Most window managers have some facility to arrange the visible windows. With Emacs, you cna programmatically manipulate a frame’s size and position from Lisp.

There are a few ways I like to arrange my Emacs frames. I generally use one or two – more are harder to manage – and dedicate them to specific purposes. One always has code buffers in it, and the other can have compilation buffers, IRC, w3m, unit test output, or any other variety of programming-related tools.

When I work with a single frame, I like it to be centered on my screen. When I have two, I like them to be next to each other, in the center. Since it’s hard to align by hand, I wrote some code do to it for me.

(defun screen-usable-height (&optional display)
  "Return the usable height of the display.

Some window-systems have portions of the screen which Emacs
cannot address. This function should return the height of the
screen, minus anything which is not usable."
  (- (display-pixel-height display)
     (cond ((eq window-system 'ns) 22)
           (t 0))))

(defun screen-usable-width (&optional display)
  "Return the usable width of the display.

This works like `screen-usable-height', but for the width of the display."
  (display-pixel-width display))

(defun frame-sort-ltr (frames)
  "Sort frames by their visual order, left to right.

This method takes a list of frames, and returns that list, sorted
by the visual display order. This is determined by comparing the
left position of the frames; the leftmost frames are returned
first."
  (sort frames (lambda (framea frameb)
                 (< (frame-parameter framea 'left)
                    (frame-parameter frameb 'left)))))

(defun frame-box-get-center (w h cw ch)
  "Center a box inside another box.

Returns a list of `(TOP LEFT)' representing the centered position
of the box `(w h)' inside the box `(cw ch)'."
  (list (/ (- cw w) 2) (/ (- ch h) 2)))

(defun frame-get-center (frame)
  "Return the center position of FRAME on its display."
  (frame-box-get-center (frame-pixel-width frame) (frame-pixel-height frame)
                        (screen-usable-width) (screen-usable-height)))

(defun frame-center (&optional frame)
  "Center a frame on the screen."
  (interactive)
  (apply 'set-frame-position
         `(,(or frame (selected-frame)) ,@(frame-get-center frame))))

(defun frame-tile-horizonal ()
  "Tile visible frames horizontally.

This function tiles visible frames, distributing them evenly
across the display, and centering them vertically.

It doesn't know about multi-head displays, and will probably fail
dramatically if used in such an environment."
  (interactive)
  (let ((pos)
        (offset 0)
        (vwidth (/ (screen-usable-width) (length (visible-frame-list)))))
    (dolist (frame (frame-sort-ltr (visible-frame-list)))
      (setq pos (frame-box-get-center (frame-pixel-width frame)
                                      (frame-pixel-height frame)
                                      vwidth (screen-usable-height)))
      (set-frame-position frame (+ offset (car pos)) (cadr pos))
      (incf offset vwidth))))

(defun frame-tile-center-horizonal ()
  "Tile visible frames horizontally, center-weighted.

Rather than tiling frames evenly across the available width of
the display, this function tiles them into the center of the
display, adding a 2% margin in between frames.

It doesn't know about multi-head displays, and will probably fail
dramatically if used in such an environment."
  (interactive)
  (let* ((framewidth (apply '+ (mapcar 'frame-pixel-width (visible-frame-list))))
         (margin (/ (screen-usable-width) 50)) ;; = (/ s-u-w *.02) = 2%
         (totalwidth (+ framewidth (* margin
                                      (- (length (visible-frame-list)) 1))))
         (offset (car (frame-box-get-center totalwidth 0 (screen-usable-width)
                                            (screen-usable-height)))))

    (dolist (frame (frame-sort-ltr (visible-frame-list)))
      (set-frame-position frame offset (cadr (frame-get-center frame)))
      (incf offset (+ margin (frame-pixel-width frame))))))

(defun frame-restore-defaults (frame)
  (modify-frame-parameters frame default-frame-alist))

(defun frame-default ()
  (interactive)
  (mapcar 'frame-restore-defaults (frame-list))
  (if (> (length (frame-list)) 1)
      (frame-tile-center-horizonal)
    (frame-center)))

(provide 'ime-frame)

You can also call M-x frame-tile-center-horizonal or M-x frame-center by hand, if you like.

Ordinarily, you’d use *scratch*, but it’s useful to have your scratch buffer use mode for the language you want to write code in, and *scratch* doesn’t fulfill this unless you’re hacking on emacs-lisp.

To this end, I created scratch-el, a bit of code for doing just this.

When you invoke it with M-x scratch, it gives you a scratch buffer with the same mode as your current buffer. So if you’re editing Python code, you get a *python* buffer which uses python-mode. If you’re in a shell, you get a shell-script-mode buffer, and so on.

If you invoke it with a prefix argument, as C-u M-x scratch, it will prompt you for the mode to use, which can be helpful if you want to noodle on a SQL query while editing your app code. There is tab completion support for all known major modes.

If you want to save the resulting work, it’s just a C-x C-w away.

$data = array(array('foo', 123),
              array('bar', 456),
              array('qux', 789));

This nested structure has each (key,val) pair as an array inside another array. It’s quite common in Lisp and Python, but not seen very often in PHP, since it’s more concisely expressed as an associative array.

I needed to map a function across all the keys and values in this structure, then produce an associative array. I discovered this somewhat unusual solution:

$keys = $vals = array();
foreach ($data as $pair) {
    list($keys[], $vals[]) = $pair;
}

So what happens is that list appends each new key or value to the appropriate array, leaving me with two flat arrays which I can then array_map() over, finally using array_combine() to produce my final output.

class Foo
{
    private $var = 'avalue';
    private function doStuff()
    {
    }
}

As you might expect, you can’t access $var or doStuff() from outside Foo, which is well and good. However, things get strange when you throw overloading into the mix.

class Foo
{
    private $var = 'avalue';
    private function doStuff()
    {
    }
    public function __get($var)
    {
        return $this->$var;
    }
}

$foo = new Foo;
var_dump($foo->var);

This works; if a variable isn’t accessible from the calling scope, it will invoke __get() instead. Too bad it’s not consistent:

class Foo
{
    private $var = 'avalue';
    private function doStuff()
    {
    }
    public function __get($var)
    {
        return $this->$var;
    }
    public function __call($func, array $args = array())
    {
        return call_user_func_array(array($this, $func), $args);
    }
}

$foo = new Foo;
var_dump($foo->doStuff());

This breaks with: “Fatal error: Call to private method Foo::doStuff() from context ”.”

It would be really nice if PHP followed the same rules for overloaded methods as for overloaded variables.

Better Buffer Naming

I found this code somwhere a while back, and threw in some enhancements:

1. If sql-name is set, that is used in the buffer name, e.g. “*SQL sql-name*”
2. Otherwise, the name will include the hostname of sql-server and sql-database. If sql-server is an IP address, it’s used; if it’s a DNS name, the hostname part is used. e.g. “*SQL: dbhost/dbname*” or “*SQL 192.168.0.1/dbname”

(defun sql-make-smart-buffer-name ()
  "Return a string that can be used to rename a SQLi buffer.

This is used to set `sql-alternate-buffer-name' within
`sql-interactive-mode'."
  (or (and (boundp 'sql-name) sql-name)
      (concat (if (not(string= "" sql-server))
                  (concat
                   (or (and (string-match "[0-9.]+" sql-server) sql-server)
                       (car (split-string sql-server "\\.")))
                   "/"))
              sql-database)))

(add-hook 'sql-interactive-mode-hook
          (lambda ()
            (setq sql-alternate-buffer-name (sql-make-smart-buffer-name))
            (sql-rename-buffer)))

Support for TCP Ports

At Digg, we have a lot of databases. As you may have read, we have four main pools of databases. Each of these has one write master and several slaves. We have this setup duplicated in many places for production, development, QA, and so on. While the less-stable environments don’t require the full setup, we try to balance consistency with resource usage. What we’ve settled on is one physical host running four different MySQL instance, one for each pool, each listening on a different port. Unfortunately, sql-mode has no support for this. You can set the sql-*-options variables, but this is cumbersome when you need to quickly connect to servers on different ports.

This simple advice will add sql-port into sql-mysql-options, if it’s set.

(defadvice sql-connect-mysql (around sql-mysql-port activate)
  "Add support for connecting to MySQL on other ports"
  (let ((sql-mysql-options (or (and (boundp 'sql-port) sql-port (cons (concat "-P " (or (and (numberp sql-port) (number-to-string sql-port)) sql-port)) sql-mysql-options)) sql-mysql-options)))
    ad-do-it))

Currently, this ony works for MySQL. It should be trivial to extend the support for other databases.

This doesn’t get read interactively like the other options, so you’ll have to create a new function with a let binding to connect. This isn’t such a bad thing when you throw in the next enhancement.

Support for Preset Connections

It’s not much fun to enter your connection information every time you want to connect. I had some functions which used let expressions to set the correct defaults for connections, but this was suboptimal, since you had to hit RET a bunch of times before the connection would start. This is fixed with preset connections. You define sql-connection-alist with a connection name and a list of sql variables to bind. Then you may call sql-connect-preset with the connection name, and you get your connection immediately.

Note that you can specify sql-port in the connection definition. Also, sql-name is defined to the name of the connection, so you can set the buffer name there, as well.

At some point in the future, it would be a good idea to make an interactive version of sql-connect-preset, which prompts you for one of the defined connections. For now, though, you need to define a function.

Example code:

(setq sql-connection-alist
      '((pool-a
         (sql-product 'mysql)
         (sql-server "1.2.3.4")
         (sql-user "me")
         (sql-password "mypassword")
         (sql-database "thedb")
         (sql-port 3306))
        (pool-b
         (sql-product 'mysql)
         (sql-server "1.2.3.4")
         (sql-user "me")
         (sql-password "mypassword")
         (sql-database "thedb")
         (sql-port 3307))))

(defun sql-connect-preset (name)
  "Connect to a predefined SQL connection listed in `sql-connection-alist'"
  (eval `(let ,(cdr (assoc name sql-connection-alist))
    (flet ((sql-get-login (&rest what)))
      (sql-product-interactive sql-product)))))

(defun sql-pool-a ()
  (interactive)
  (sql-connect-preset 'pool-a))

Now, you can just run sql-pool-a and get connected right away. Because the buffers have good names, you can easily fire up many connections.

I hacked it together today and submitted it back to Trac.

The changes are against r5308 of the hook, which is all well and good if you run Trac 0.11.x. Unfortunately, it’s incompatible with Trac 0.11.x. I backed out some of the changes (from r4159) which broke things, and it’s working for me.

My changes are attached to the ticket I opened.

I was hacking on some stuff recently, and needed to parse the query parameters in a URL. Python has URL parsing, but it doesn’t include querystring parsing.

This was the pleasantly easy solution:

from urlparse import urlparse
url = urlparse('http://www.google.com/search?hl=en&safe=off&q=atomized&btnG=Search')
params = dict([part.split('=') for part in url[4].split('&')])

What’s going on here

Let’s break the example down a bit.

1. from urlparse import urlparse

   This pulls in Python’s URL parser.

2. url = urlparse('http://www.google.com/search?hl=en&safe=off&q=atomized&btnG=Search')

   This passes the URL through urlparse, leaving us with a tuple of URL components.

3. url[4].split('&')

   This splits the querystring on “&” characters, leaving us with a list of “key=val” scalars. The output of this would be:

   ['hl=en', 'safe=off', 'q=atomized', 'btnG=Search']

4. [part.split('=') for part in url[4].split('&')]

   This is Python’s list mapping, also known as list comprehension. It allows us to map a function over a list – in this case, part.split('=') on the list of “key=value” pairs from the previous step. This leaves us with:

   [['hl', 'en'], ['safe', 'off'], ['q', 'atomized'], ['btnG', 'Search']]

   That is, an array of arrays, where the first member of the child array is the key and the second is the value.

5. params = dict([part.split('=') for part in url[4].split('&')])

   The last part of this is dict(), which turns the array structure above into a dictionary:

   {'q': 'atomized', 'safe': 'off', 'btnG': 'Search', 'hl': 'en'}
   

   Thix is roughly equivalent to a hash map or associative array. It allows us to access specific keys, such as params['q'].

The problem here isn’t this specific behavior, but it neatly encapsulates one of my core complaints with PHP. Which is: there’s an attitude of “do something dumb, unless the developer asks not to.” You see this over and over in the PHP world. Mangling keys unless you ask not to. Magic quotes being enabled by default. It’s lame, and stupid, and requires the developer to outsmart the language to get basic things done.

This is a problem, because developer time is expensive, and brainpower limited. When things don’t work optimally, that’s wasted developer effort and time. You have to know that there is a problem, and work around it. Or forget that there’s a problem, spend time debugging it, and get a “duh” moment when you remember. Problems like these should not rise to the level of needing attention, because developer attention is better focused on the larger problems.

It’s hard to trust the language to do the right thing for the big stuff when you have to outsmart it to get the small stuff to work.