#!/bin/sh

set -u
set -e

# non-wp tables
mysqlhotcopy --addtodest 'wordpress./^(?!wp_\d)./' /backup/

# wp tables not starting with a digit
mysqlhotcopy --addtodest 'wordpress./^wp_[^\d]/' /backup/

# tables 1-99
mysqlhotcopy --addtodest 'wordpress./^wp_\d{1,2}_/' /backup/

# tables 100-999
mysqlhotcopy --addtodest 'wordpress./^wp_\d{3}_/' /backup/

# tables 1000-1499
mysqlhotcopy --addtodest 'wordpress./^wp_1[0-4]\d{2}_/' /backup/

# tables 1500-1999
mysqlhotcopy --addtodest 'wordpress./^wp_1[5-9]\d{2}_/' /backup/

# tables 2000-2499
mysqlhotcopy --addtodest 'wordpress./^wp_2[0-4]\d{2}_/' /backup/

# tables 2500-2999
mysqlhotcopy --addtodest 'wordpress./^wp_2[5-9]\d{2}_/' /backup/

Scary.

You’ll want to have the YUI Compressor and Google Closure Compiler installed for minification of CSS and JavaScript, respectively. I installed them to my ~/bin directory, and referenced that directory in my Makefile.

Note that I’m using these two pieces of software mostly out of habit; I haven’t evaluated them or their competitors recently.

The Meat

Customizing for Your Project

To make this file useful for your own project, you’ll need to point it at your CSS and JS files.

JS_TARGETS =
CSS_TARGETS =
CLEANUP =

The first two variables define what scripts will be minified and compressed when you type “make js” or “make css,” respectively. Both of these commands will run when you type “make all” or simply “make.” CLEANUP allows you to specify additional files that will be removed when you type “make clean.”

Some sample customizations are mentioned in the file.

CSS_TARGETS = $(shell cat manifest.txt)

If you would rather organize your list of CSS or JavaScript targets into their own files, you can automatically expand that manifest file using the cat command.

CLEANUP = $(CSS_TARGETS) $(JS_TARGETS)

Some more advanced setups may combine several CSS files before minification, or use a custom target to concatenate JavaScript using the closure compiler. If you find that all your targets can be cleaned, you can simply reference them automatically as above.

concatenated.min.js: file1.js file2.js
	java -jar ~/bin/compiler.jar $(addprefix --js=,$^) >$@

The closure compiler requires a prefix for all input JavaScript files. Use the make function “addprefix” to format the argument list.

custom-concat.css: file1.css file2.css file3.css
	cat $^ >$@

Automatic variables greatly simplify most of the functionality within this makefile. To create a concatenated CSS file, simplify specify the target to the left of the colon, and its dependencies (the files to concatenate) to the right; the cat command never needs modification.

Of course, you can always define custom rules, ie. this one to fetch the newest development version of jQuery:

jquery:
	curl -o jquery.js http://code.jquery.com/jquery-git.js

Other Magic

Some other goodness happens below the “you shouldn’t need to edit past here” line. After we configure a few settings, we define how to create files based on suffixes: .min.css gets passed through YUI Compressor, .min.js through Closure, and .gz through gzip. We configure what files we care about, and make handles the rest.

.DEFAULT_GOAL := all

Set a default rule, rather than using the first rule in the file as the default.

.PHONY: css js

Prevent files named “css” or “js” from interfering with the css and js rules.

%.gz: %
	gzip -9 <$< >$@

One of three pattern rules. This enables you to compress any file (not just CSS or JS) by running “make filename.gz.” I precompress my files because I’m using gzip_static in nginx.

CSS_GZIP = $(CSS_TARGETS:.css=.css.gz)

One of several variables that modifies filenames found in $(CSS_TARGETS), changing the suffix from .css to .css.gz. Note that the colon/equals syntax is shorthand for patsubst. Given CSS_TARGETS = text.css tables.css, we would get CSS_GZIP = text.css.gz tables.css.gz, which would be sent as targets to the more general css rule, and in turn would be handled by the general-purpose %.gz rule above.

See Also

• Advanced Makefile Tricks — macros ($@ et al) and wildcard rules
• GNU make manual — functions, automatic variables, pattern rules

It’s too bad I’ve had such a hard time wrapping my head around the programmable completion toolkit, complete and compgen.

Getting There

I have a function that works like cd, but prepends a specific directory. Our web files are stored in /some/dir/webapp, and I want that directory at my fingertips at all times. Here’s the function:

wa() { cd /web/pscpages/webapp/$1 ; }

With this function, wa brings me to webapp; wa project1 brings me to webapp/project1; and so on. I just provide the full sub-path from webapp. Ideally, I would be able to tab-complete directories in webapp.

complete can pull a list of possible completions from a number of sources: “actions” (like files, directories, commands, shell keywords), command output, a wordlist separated by some whitespace, or the output of a bash function, to name a few. What you’ve typed so far (the “current word”) will be used to filter all the possible completions returned by that source. Say you’ve typed “pro” and then hit tab to autocomplete. The returned completions need to match “pro” at the start of the string, meaning you can’t match against absolute paths like /some/dir/webapp/project1.

compgen can be used to generate a list of possible completions. Matches will be output one per line, and can be piped around for transformations just like any other shell command.

Between these two tools, we have everything we need to autocomplete paths starting in a certain directory. Here’s a compgen that gives us directories matching a specified string:

compgen -d /some/dir/webapp/

Sample output:

/some/dir/webapp/.svn
/some/dir/webapp/project1
/some/dir/webapp/templates
/some/dir/webapp/images

We need to trim leading directories so “pro” matches “project1.” We should also append / to the pathnames, since we’re always matching directories:

compgen -S/ -d /some/dir/webapp/ | cut -b 18-

Playing around with compgen‘s arguments, we can further filter the completion list by appending to our string, sort of an implied glob. Use /some/dir/webapp/p, and subdirectories starting with “p” will be returned. This is exactly what we want: compgen takes care of all the filtering for us. We have access to a couple special variables to examine the word the user is expanding. For now, it’s enough just to grab ${COMP_WORDS[COMP_CWORD]} and append it to our path.

When completions are generated by a function, they’re passed back to complete by the $COMPREPLY environment variable. Pulling this all together, we can now create our completion function:

_webapp() {
    local cur
    cur=${COMP_WORDS[COMP_CWORD]}
    COMPREPLY=( $( compgen -S/ -d /some/dir/webapp/$cur | cut -b 18- ) )
}

All that’s left is to tell bash to use this function to complete our argument to wa.

complete -o nospace -F _webapp wa

The Fruits

So, that does it. Our original wrapper to cd, combined with our autocomplete functionality, looks like this:

wa() { cd /some/dir/webapp/$1 ; }
_webapp() {
    local cur
    cur=${COMP_WORDS[COMP_CWORD]}
    COMPREPLY=( $( compgen -S/ -d /some/dir/webapp/$cur | cut -b 18- ) )
}
complete -o nospace -F _webapp wa

Voila. Tab completion in a directory that’s not $PWD, and it even works with subdirectories. I hope this makes autocompletion a little clearer for others.

Let’s start at the beginning. My ~/.ssh/config file has many entries structured like so:

Host bob
    HostName robert.example.com
    User backstrom

This setup allows me to SSH to robert.example.com using the shortcut ssh bob. This shortcut could be made even shorter, though. I have a script (say, host-ssh) in my $PATH with the following content:

#!/bin/sh
HOST=$(basename $0)
ssh $HOST $@

Now I can ln -s host-ssh bob to symlink host-ssh to bob, and bob becomes a shortcut for ssh bob. At this point, the following commands work as expected:

adam@local:~$ ssh bob
backstrom@robert:~$ exit
adam@local:~$ bob
backstrom@robert:~$ exit
adam@local:~$ scp -q myfile bob:
adam@local:~$

So, onto screen. Imagine that my workstation has screen, but my remote server “bob” does not. I can mimic the functionality by running screen locally and connecting each window to bob in its own SSH session. (In the past I have done this via exec bob so I have one less exit to type during disconnects.) However, screen allows you to set a custom shell. You can leverage this to force an SSH connection to a specific server whenever a new window is created. Just launch screen with screen -s bob and every ^A-c will automatically run your new SSH shortcut. Seamless, if you have public keys set up.

More information is available on my SSH wiki page.

gs -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite \\
    -sOutputFile=collated.pdf file1.pdf file2.pdf

Today I hit several PDFs with complex table formatting. As far as I could tell, gs (and pdf2ps) were rasterizing these documents into embedded bitmaps during processing. This dramatically increased file size and processing time. Some searching brought up this page and a comment suggesting the pdftk utility.

pdftk file1.pdf file2.pdf cat output collated.pdf

pdftk ended up producing much smaller files (far closer to what I would expect based on starting file size) at very fast speeds. And watermarking, oh how I searched for a utility that could watermark.

Thanks, pdftk team.

If you’re running the Greasemonkey extension for Firefox, you’re in luck. Greasemonkey allows a surfer to install custom scripts for any site, effectively letting him customize pages as he sees fit. Remove content blocks, change colors and fonts, add text, or, drumroll: remove onmousedown events.

Here’s the script:

// By Adam Backstrom <adam@sixohthree.com>
// Public Domain, 8 August, 2005.
// Block Google's data mining on search results.

// find all paragraph tags
thePs = document.getElementsByTagName("P");

for(var i = 0; i 

    theP = thePs[i];
    theLinks = theP.getElementsByTagName("A"); // find anchors

    for(var j = 0; j < theLinks.length; j++) {
        theLinks[j].removeAttribute("onmousedown");
    }
}

Works well enough for me.

I usually resort to bc, but I use it so rarely that I can never remember the correct syntax. bash is usually a good backup with its $((1 + 1)) syntax that I can use right from the shell prompt, but this particular method doesn’t do floating point math. I did the find-a-suitable-calculator song and dance again today, but found a new partner this time: Python.

Python is a natural choice: it will return floating-point values without any additional steps, it retains a command history, and it allows for storing results in a variable. If you’re handy with printf style statements, you can even format output to your liking. As an example:

adam@shed:~$ python
Python 2.4 (#1, Jan  1 2005, 21:33:55)
[GCC 3.3.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 7 * 19
133
>>> 3 / 21.0
0.14285714285714285
>>> print "%0.2f" % (81 / 2.1)
38.57
>>>

I try to use packages when possible. Some pieces of software lend themselves to packages better than others, and Firefox is one of those packages. Firefox is available as a .tar.gz of files (as opposed to a graphical installer). The following script (download version) works nicely:

#!/bin/sh

CWD=`pwd`
PKG=/tmp/package-firefox
rm -rf $PKG

VERSION=1.0.2
ARCH=i686
BUILD=1

mkdir -p $PKG/usr/lib $PKG/usr/bin
cd $PKG/usr/lib

tar xzfv $CWD/firefox-$VERSION.tar.gz

cd $PKG/usr/bin
ln -s ../lib/firefox/firefox ./firefox

mkdir -p $PKG/usr/share/pixmaps
cp $CWD/Firefox.png $PKG/usr/share/pixmaps/Firefox.png

chown -R root:root $PKG
chown root.bin $PKG/usr/lib/firefox/firefox-bin

cd $PKG
makepkg -l y -c n ../firefox-$VERSION-$ARCH-$BUILD.tgz

Run this as root, and in no time at all you’ll have a Slackware package that can be installed, uninstalled, and upgraded. This package requires the Firefox archive as well as the following image file, all stored in the same directory:

You can download the whole package base (sans Firefox itself) if you please.

adam@aziz[0]:~$

I can immediately tell that screen is running, as well as my window number. This breaks down as soon as I SSH to DreamHost. I get a far more generic prompt:

aestus@jezebel:~$

So, what to do? Set a variable on the remote side, in a roundabout sort of way:

ssh -t jezebel.dreamhost.com 'export MYVAR=myvalue &&
      exec /bin/bash --login'

It doesn’t look like much. It took me an hour to assemble. SSH to the host, allocating a TTY with -t. Run bash on the remote side as a login shell, executing the specified command. Export a variable, and exec a sub-bash.

Yeah, that’s it.

Update 12/15/2005: Trimmed the command a bit: the outer /bin/bash call is unnecessary.