One place where I find the documentation lacking is in the description of urllib2’s BaseHandler class. Subclasses of this class can be passed to urllib2’s build_opener function to add functionality to your url-opening activity. Some examples of useful modifications are modifying HTTP requests (and responses) or creating support for an unsupported network protocol. Unfortunately, while the methods of interest are described, examples are sparse. Here I’ll give a couple of examples of handlers that I’ve come up with. They may not be “pythonic,” and I’d be grateful for pythonic suggestions, but they get their jobs done and demonstrate some of the features of BaseHandler.

The first example is fairly simple: a User-Agent string injector.

import urllib2

class UserAgentProcessor(urllib2.BaseHandler):
    """A handler to add a custom UA string to urllib2 requests
    """
    def __init__(self, uastring):
        self.handler_order = 100
        self.ua = uastring

    def http_request(self, request):
        request.add_header("User-Agent", self.ua)
        return request
    https_request = http_request

The __init__ method takes a string to be used as the user agent string for HTTP requests. Init also sets the handler_order attribute to 100; the default for BaseHandler subclasses is 500, but we have to set a smaller number, otherwise our UA will be overwritten with the urllib2 default UA. I’m not entirely sure why (the docs barely mention this attribute), but my experimentation as shown that it’s necessary.

The http_request (and https_request) methods are used to pre-process HTTP (and HTTPS) requests before the requests are actually made. The “request” parameter is a urllib2.Request object, which contains a wealth of editable information, including HTTP headers. Here I’ve simply aliased https_request to http_request, since https requests don’t need special handling to add a UA string.

To use this handler, we need to build an opener with it:

opener = urllib2.build_opener(UserAgentProcessor("My Useragent"))

Then we can either “install” our new opener or use it straight up:

# install and use the opener
urllib2.install_opener(opener)
urllib2.urlopen("http://whatismyuseragent.com/")

# Just use it
opener.open("http://whatismyuseragent.com/")

Another, more complex example, is to add gzip compression to urllib2.

import urllib2
from gzip import GzipFile
from StringIO import StringIO

class GZipProcessor(urllib2.BaseHandler):
    """A handler to add gzip capabilities to urllib2 requests
    """
    def http_request(self, req):
        req.add_header("Accept-Encoding", "gzip")
        return req
    https_request = http_request

    def http_response(self, req, resp):
        if resp.headers.get("content-encoding") == "gzip":
            gz = GzipFile(
                        fileobj=StringIO(resp.read()),
                        mode="r"
                      )
#            resp.read = gz.read
#            resp.readlines = gz.readlines
#            resp.readline = gz.readline
#            resp.next = gz.next
            old_resp = resp
            resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
            resp.msg = old_resp.msg
        return resp
    https_response = http_response

You can see that the GZipProcessor class uses the http_request method, like UserAgentProcessor, to add an HTTP header to the request. However, GZProcessor also uses the http_response method to pre-process the response before it is returned to whatever called urlopen().

In http_response, the “req” and “resp” parameters are urllib2.Request and urllib2.Response objects, respectively. Since the Response contains the page contents, that’s what we’re interested in. If the server responded with gzipped content, it should have set the “Content-Encoding” response HTTP header to “gzip”. If we have received gzipped content, we need to make it so that read attempts on the Response object return valid strings of text, not chunks of gzip data.

The method I’ve used here is somewhat convoluted and certainly not “pythonic”, but it gets the job done. First, the gzipped content is read from the response and stuck into a StringIO object, which offers a file-like interface to string objects. This StringIO object is then passed to GzipFile’s fileobj argument. Now, since the Response object contains info other than the page contents, we can’t simply replace it; instead, we set the read, readlines, readline, and next methods of the response to the corresponding methods of the GzipFile object. Next, we replace the incoming Response object with a new one, this one with its fp (file pointer, originally the HTTP connection socket) attribute pointing to our GZipFile object. By instantiating a new addinfourl object, we don’t have to worry about missing a relevant read method; the constructor will take care of that for us. Now, when we request a page and get gzipped contents, we can read(), readline(), etc, seamlessly, as if there were no gzipping involved. The downside is that it will take slightly longer to receive our response because the GZProcessor has to read the entire contents of the page before decoding it.

Now, granted, there are other ways to do these things. A UA string can be inserted into a manually-created Request object, which can then be passed to a raw OpenerDirector (created with urllib2.build_opener()) just fine. Same with gzip acceptance, you’ll just have to remember to un-zip the contents you get back. But the nice thing about handlers is that you can build your opener once with your custom handlers and not have to worry about the results anywhere else in your code. Also, if you install your opener with urllib2.install_opener(), you can simply use urllib2.urlopen() for every page you need to open, and your handlers will automatically be called as needed. Just plug-and-chug.

My setup runs on Apache/Linux, on a subdomain of one of my sites. I have a root SVN directory that can hold multiple repositories. While the repos are accessible via SVN, you can also browse them through a web interface (though it’s fairly simple, basically just lists of “directory” contents). The repos give anonymous access for checkouts and other “read” functions, but are login-protected for commits and other “write” functions.

The guides I came across for setting up SVN mostly want you to put your settings in the file /etc/apache2/mods-available/dav_svn.conf , but I found that it works just fine if you set it up like a regular site/subdomain. That is, as a VirtualHost entry in a file in /etc/apache2/sites-available. So here is my VHost entry for SVN:

<VirtualHost *>
        ServerName svn.eternicode.com
        <Location />
                Order allow,deny
                Allow from all
                DAV svn
                SVNParentPath /var/www/svn
                SVNListParentPath on
                AuthType Basic
                AuthName "Eternicode SVN Repo"
                AuthUserFile /etc/apache2/mods-available/dav_svn.passwd
                <LimitExcept GET PROPFIND OPTIONS REPORT>
                        Require valid-user
                </LimitExcept>
        </Location>
        ErrorLog /var/log/apache2/error_svn.log
        CustomLog /var/log/apache2/access_svn.log combined
</VirtualHost>

Most of the special, SVN-specific stuff comes inside the <Location> tags; the ServerName, ErrorLog, and CustomLog are standard Apache directives.

SVNParentPath is the “root” repo directory; your various repos will be below this directory. If you only want to host a single repo here, change the directive to just “SVNPath”. The SVNListParentPath allows web access to a listing of all available repos; if you use SVNPath, remove SVNListParentPath. If SVNListParentPath is off or omitted, users will get a 403 Forbidden error when browsing the parent directory.

AuthType, AuthName, and AuthUserFile define the login settings; the AuthUserFile is created with the htpasswd command.

The LimitExcept section is where we differentiate between anonymous reads and protected writes. For everything other than GET, PROPFIND, OPTIONS, and REPORT methods, we want to Require a valid-user; if someone wants to commit, they have to authenticate according to the AuthUserFile defined above.

One issue I ran into was that, after everything was seemingly set up properly, any svn commands would result in a “Moved Permanently” error. It turned out that I had defined the DocumentRoot to also be /var/www/svn; this would conflict with the svn settings, confuse apache, and result in the Moved error. Don’t include a DocumentRoot; the svn setup will take care of everything once you give it an SVNParentPath.

Credits: Sematopia.com has a nice little guide that takes you through steps outside of the apache configuration (though their 4-line apache config is scarily sparse). Sellersrank.com has a guide for setting up Apache-run SVN over https; though I’m not using https, this guide helped me get my settings right.

A few notes: Don’t use a DocumentRoot, only use the SVNParentPath. Make sure the parent path is owned by user and group www-data (or whatever user your apache instance uses). You can ensure this by:

$ sudo chown -R www-data.www-data /var/www/svn

While it would be extremely nice to be able to create new repositories with a simple “svn import”, it seems svn’s capabilities are restricted in that area. It wouldn’t be too difficult to set up a cron job to monitor the SVN logs and create new repos as required, but that’d be hacky and inadequate. To create a new repository, you first have to run

$ sudo svnadmin create /var/www/svn/new_repo

on the server. However, in order to not have issues with the fact that the web server owns all the svn files, I’d recommend creating new repos as the www-data user:

$ sudo su www-data -c "svnadmin create /var/ww/svn/new_repo"

Once the initial repo structure is created, you can then use “svn import” on a remote machine to import the first revision.

$ echo `printf "%05d" 3`
00003

However, this only works with numbers. Actually, it only works with integers (bash can’t handle floats, apparently). Worse, it only pads on the left with zeros. No right-padding, no “other character” padding.

$ echo `printf "%05d" -`
bash: printf: -: invalid number
00000
$ echo `printf "%05s" -`
-

Breaking out of numbers and into string concatenation, however, makes it a bit easier:

function lpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$3$word";
    done;
    echo "$word";
}
$ lpad 3 5 0
00003

“But it’s the same output!” you say? Well, for this input it happens to be, yes.

$ lpad 4 5 -
----4
$ lpad hello 11 -
------hello
$ lpad hello 11 !
!!!!!!hello

We can even pad with whitespace:

$ echo "'`lpad hello 11 \ `'"
'      hello'

Here I’ve printed single quotes around the results to show the space padding, and used the backslash to escape the space in the command, so it would be used as $3 rather than be seen as CLI whitespace (and ignored).

Of course, this function can be switched around to make an rpad function, and extended to make a cpad function:

function rpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$word$3";
    done;
    echo "$word";
}
function cpad {
    word="$1"
    while [ ${#word} -lt $2 ]; do
        word="$word$3";
        if [ ${#word} -lt $2 ]; then
            word="$3$word"
        fi;
    done;
    echo "$word";
}
$ rpad "w00t" 15 ^
w00t^^^^^^^^^^^
$ cpad "hello, world" 50 -
-------------------hello, world-------------------

Of course, these functions aren’t perfect, as they make (at least) the following assumptions:

1. Inputs $1 (word to pad), $2 (length to pad to), and $3 (padding characters) are given.
2. Input $2 is a number.
3. Input $3 is one character, and no more.

Assumption #1 means that if, for example, only $1 and $2 are given, the function will go into an infinite loop (or actually exit with an error, “bash: [: 8: unary operator expected"). This can be fixed by checking for those variables' existence, and initializing some internal variables to default values if they are not:

function lpad {
    if [ "$1" ]; then
        word="$1";
    else
        word="";
    fi;

    if [ "$2" ]; then
        len=$2;
    else
        len=${#word};
    fi;

    if [ "$3" ]; then
        padding="$3";
    else
        padding=" ";
    fi;

    while [ ${#word} -lt $len ]; do
        word="$padding$word";
    done;
    echo "$word";
}

Here, the "word" defaults to a blank string, the "length" defaults to the length of the word, and the "padding" defaults to a space. If only the word is given, the word will be returned. If word and length are given, word will be padded with spaces. If all three are given, it works fine.

Assumption #2 means that if $2 is a string containing anything other than digits 0-9, the function will exit with an error ("bash: [: <length>: integer expression expected"). This can be fixed by "filtering" any non-digit characters out of the length string:

    if [ "$2" ]; then
        len=$((`echo $2 | sed 's/[^0-9]//g'`));
    else
        len=${#word};
    fi;

This uses the sed tool, which should be available on most if not all *nix systems, to replace all non-digits ([^0-9], in regex notation) with nothing, then converts the result from a string of numbers to an actual number with $(()). This means that "5uh0oh0" will be turned into 500. We'll get a scary big string in that case, but at least we won't get errors!

Assumption #3 means that if the pad string is more than one character, the result *could* be longer than the length we wanted. For example:

$ string=`cpad hey 50 -`
$ echo ${#string}
50
$ string=`cpad hey 50 -=`
$ echo ${#string}
51

In the second example there, the length of the output string actually has one extra character. This is because the function only adds the padding while the length of the string is less than our specified length; it doesn't actually do any length-checking once we've gone beyond the "length less than" test. This is fixed slightly less simply, and requires different logic for each function:

function rpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$word$padding";
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:0:$((${#word}-1))}
    done;
    echo "$word";
}
function lpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$padding$word";
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:1:$((${#word}-1))}
    done;
    echo "$word";
}
function cpad {
    ...
    while [ ${#word} -lt $len ]; do
        word="$word$padding";
        if [ ${#word} -lt $len ]; then
            word="$padding$word"
        fi;
    done;
    while [ ${#word} -gt $len ]; do
        word=${word:0:$((${#word}-1))}
        if [ ${#word} -gt $len ]; then
            word=${word:1:$((${#word}-1))}
        fi;
    done;
    echo "$word";
}

The solution uses the bash substring notation, ${variable:start:length}, to strip off extra characters at the end/beginning when the resulting string is too long. Of course, this isn't a perfect fix; if you specify a shorter length than your input string, the string will simply be truncated to that length. Also, if you use a long string for padding with cpad, you'll get unbalanced output.

$ lpad "hello, world" 5
world
$ rpad "hello, world" 5
hello
$ cpad "hello, world" 5
lo, w
$ cpad hello 50 ---=--=---
-=--=------=--=---hello---=--=------=--=------=--=

You could easily continue to refine this function to make it obey all sorts of preconceptions, but I'm going to stop here. If you use the functions as they're meant to be used -- numerical lengths and single-character paddings, etc -- it'll all be fine.

Though if you do find a nice, concise way to make these behave "properly", feel free to share in the comments!

The files:

• Socket.php (highlighted; plaintext)
• webpage.php (highlighted; plaintext)

What good is a full-on Socket class and function, you may ask, when you can simply run file_get_contents with allow_url_fopen turned on? Well, consider that you want to send specific headers to the server, to POST data for example. Also, there are other uses for a Socket class than webpage downloading; I use this Socket implementation in a PHP-based IRC bot that I run (by the name of ecode on the Freenode network). You can use the socket to interact with many different servers.

Socket

The Socket class essentially encapsulates PHP’s socket_* functions, making it easy and straightforward to make a TCP connection with a server. The socket is given a timeout period in microseconds; while I’m not 100% sure what this means, I do know that it emulates a sort of “busy wait” while waiting for content, allowing applications to do processing while waiting for data to come in through the pipe.

To use the socket, include the Socket.php file and create a variable to hold a new Socket.

require_once("Socket.php");

$s = new Socket(1000);

The Socket will automatically set up the outgoing TCP socket for usage. The parameter passed to the new socket (1000 in this case) is the microsecond timeout — this can be left blank if you wish.

Once created, the socket can connect to any service through the connect() function. The function takes two arguments: host and port. Both parameters are optional to allow reuse of the connection; if called without parameters, the Socket will establish a new connection using a host and port from the last connection. The host is the address you would ping to see if the servers are up — for example, either google.com or 74.125.67.100, the Socket doesn’t care which as long as it’s a server it can connect to. The port is optional: if you specify a port number, that will be used; if no port number is specified, it attempts to extract a port number from the host (for example, if you used google.com:80); failing that, it will use the last port number specified (default of 80).

Once connected, you can use the send() and get() functions to — you guessed it — send() and get() data. The send function takes a string parameter, the message to be sent, sends the message through socket_write, and returns the value returned by socket_write (the number of bytes successfully sent through the socket). The get function takes an array parameter to specify fetching options: line (boolean) and length (integer). If line is set to true, then get will fetch one character at a time until a newline (\n) is encountered and return the line along with any trailing carriage returns (\r) and newlines (\n). If length is specified as greater than 0, get will fetch one character at a time until the specified number of characters have been read. If neither is specified, the function will read and return the next 512 characters. Of course, all cases will terminate if the end of data has been reached.

As a quick example, this portion uses the previously created socket to download the HTTP response headers from google.com’s homepage:

if ($s->connect("www.google.com", 80)) {
    $get;
    $s->setVerbose(false);
    $s->send("GET / HTTP/1.1");
    $s->send("Host: www.google.com");
    $s->send("");

    $response = "";
    while (strpos($response, "\r\n\r\n")===false) {
        $response .= $s->get(array("line"=>true));
    }
}

The Socket supports logging and verbosity functions. The setLog function takes a boolean (true/false for logging) and a string (filename to log to). The setVerbose function takes only a boolean (true/false — default false — for printing out extra information to the console).

Finally, when you’re finished with the connection, you can call the disconnect() function to cleanly sever the connection.

webpage()

The webpage function takes three parameters: a url, a headers array, and a “headers only” flag. The url is simple enough; this is the full url that you want to fetch, including both the host name and the file path (and, optionally, a port number after the hostname). The headers array goes two ways; you can pass in headers to send and you’ll get back any headers received. The headers only flag specifies whether or not to fetch the content of the page; if not, it saves the time of downloading that content, and leaves you with only the response headers.

The headers parameter is two-way, as I mentioned. You can pass in an associative array of header-name => header-value pairs, which will be formatted properly and sent to the server along with the HTTP request.

$h = array(
    "User-Agent" => "PHP-webscraper/1.0 php/5",
    "Authorization" => "Basic ".base64_encode("username:password")
);
$page = webpage("http://twitter.com/statuses/mentions.json", $h);

The above will send the User-Agent, for identification, and Authorization, to login, headers to the Twitter API, fetching any tweets that mention the user name “username” (using the password “password”). The response will be in JSON, and will require extra processing, but this will get you the data. For more information on HTTP headers, check out the HTTP 1.1 RFC, section 14.

Once the page is received from the server, the headers array you passed in will be overwritten by the server’s response headers, which you can then examine with external code. With this method, you can also pass in a simple empty array, which will then be populated with the response headers.

The third parameter to the webpage function is simple enough. Pass true if you want to receive only the server’s response headers, cutting off the response once those have been received; a blank string will be returned from the function. Pass false (or no third parameter) if you wish to receive the entire page, the contents of which will be returned as a string.

With these two files (and, of course, the PHP constructs they define), you can download any webpage you would have access to with your browser, provided you are able to use sockets on your server. Need to scrape some data from a page? Download that page and apply some regexes to the content. HTTP Auth required? No problem, send an extra header with your creds. The function could also be modified to POST data to a page, or even download and save images and other media; however, those functions will be left as an exercise for the reader.

Occasionally, I’ll want to keep an eye on specific processes and their resource usage, but they won’t show up in my “top” screen, no matter how I sort the fields. At this point, I have to use “ps” to find the PID (process ID) of each process I want to watch and add each PID to the end of the “top” command (using the -p switch for each PID), just to watch a few specific processes.

This little process is well-defined and repeating. Just the kind of task computers were designed to handle. I wrote a bash script which takes any number of arguments — all of them names of processes you want to watch — finds all related PIDs, and tacks them on to a top command.

#!/bin/bash

ps=""

for p in $*; do
    ps="$ps `ps -e | grep $p | awk '{print $1}' | sort -n | sed 's/^/-p /' | tr '\n' ' '`"
done

while [ `echo "$ps" | grep -c "  "` -ne 0 ]; do
    ps=`echo "$ps" | sed 's/  / /'`
done
ps=`echo "$ps" | sed 's/\(^\s*\)\|\(\s*$\)//'`

if [ -z "$ps" ]; then
    echo "No processes found."
else
    top $ps
fi

Please only use the above as a reference! The script uses a lot of single quotes, which WordPress likes to convert to “smart” quotes. To see the script as it should be, you can view the script as a text file.

The first chunk (”for p in $*…”) iterates over all the arguments, pulling out all the associated PIDs. The second block (”while…”) replaces multiple spaces with single spaces within the extracted process list, and trims any whitespace off of the beginning and end, to prepare the string for the test at the end. The last part (”if [ -z…”) checks if the process list is empty or not (if it’s all spaces, it’s “not”). If it is empty, the script alerts you and exits — you won’t get an empty top list (or full, since there are no arguments passed). If it’s not empty, we can assume we found some PIDs, so we tack that on to the top command and take you straight there.

If you want to use this, just stick it in an executable file in your path (see “echo $PATH” at the command line); I simply named mine “btm”, but it doesn’t matter what you call it. If you have any command line arguments you like to pass on to top, you can stick them between “top” and “$ps” in the “else” part of the script. Once it’s all set up, just call the script with the process names you want to watch:

$ btm rsync firefox thunderbird

Keep in mind that this will only work with processes that are currently running — once that rsync job is done, it’ll disappear from the list, but no new rsync jobs will show up unless you re-run the script.

In this case, I’ve spent the past couple days messing with Conky (yes, it is as addicting as they say). A google search will tell you what it is, and another will show you all the cool things it can do. One thing that absolutely irked me, though, was the lack of transparency under KDE4. Basically, my options were:

1. Use “own_window_type override”, which seemed to allow transparency, but conky would crash unless I set use_xft to no. So I got true transparency, but no sexy fonts.
2. Use “own_window_type normal”, and use sexy fonts with use_xft set to true, but using the “pseudo-transparency” that conky uses would use the wrong wallpaper.
3. Use #2 above, but set own_window_transparency to no, and use a solid color background.

While I was tweaking conky, I was using #3. Not the best I could hope for, but the best I could get without any help. And good enough for development.

When I asked google for help, I found out several things:

1. Conky uses the wallpaper set on the “root window” for its pseudo-transparency.
2. KDE4/Plasma uses its own desktop-drawing to draw the wallpaper.
3. KDE4/Plasma does not update the root window’s wallpaper when it updates the desktop’s wallpaper.
4. The latest and greatest KDE4 versions are phasing out DCOP support in favor of DBUS. DCOP, coupled with a program called “feh”, is what many workarounds to this issue have used.
5. The DBUS interface to KDE4 is not yet fully developed, and, as such, has no way to get the current desktop wallpaper.
6. A method has been pieced together that greps the user’s appletsrc file to get the user-set wallpaper:

   feh --bg-scale "`grep 'wallpaper=' ~/.kde4/share/config/plasma-appletsrc | tail --bytes=+11`"
   

7. Nobody seems to have hacked together anything that works for those of us who use the slideshow feature of KDE4.

Figures. Anyway, after some more digging around, I’ve created a script which fixes the problem for slideshow-users:

#!/bin/bash
# kde4bg - by Andrew Rowls <andrew@techknack.net>

SLIDEPATH=`grep slidepaths ~/.kde/share/config/plasma-appletsrc | tail --lines=1 | tail --bytes=+12`
WALL=`ls --sort=time --time=atime "$SLIDEPATH" | head --lines=1`
feh --bg-scale "$SLIDEPATH/$WALL"

Part one (SLIDEPATH) greps your appletsrc file for the directory(ies) set as your slidepath. In the appletsrc file, this is probably a comma-separated list of directories, but I only wrote the script to handle one directory. Also, you may have noticed that I used the directory ~/.kde rather than ~/.kde4. I looked at the ctimes (modification times) of those files (basically, the times KDE4 last modified them). The ctime for ~/.kde4/share/config/plasma-appletsrc was about 5 days earlier than ~/.kde/share/config/plasma-appletsrc . A little further digging, and I found that the “kde4 version” had an old path to my slideshow directory, while the “kde version” had the current (ie, correct) path. If your KDE4 installation still uses ~/.kde4, change the directory appropriately.

Part two (WALL) gets the last-accessed file in that slidepath. Basically, every time Plasma changes the wallpaper, it has to *access* the image file, read it into memory, and display it. As long as the access times (read: wallpaper switches) are at least a minute apart, the current wallpaper will bubble to the top so we can grab its name. This, of course, assumes that 1) only your slideshow images are in your slidepath directory and 2) you don’t go messing with those image files very often.

Finally, part three uses feh to set the root window’s wallpaper, giving it the full path to the image file.

Now, every time you run this script, it will find the last-accessed (presumably by Plasma itself) file and set it as the background, at which point Conky can use that image for its pseudo-transparency. Since the script has to be manually run, you could put it on cron or as a part of Conky’s updating, like this:

${texeci 3 /path/to/kde4bg}

That’ll execute the script every 3 seconds from conky. You could put it as every 1 second, but I noticed that, when I tried it, the cpu usage would get a little carried away. 3 seconds is enough to keep cpu usage down while keeping the “transparency” sufficiently up-to-date.

Quick disclaimer: This was just a quick throw-together script, written based on my needs. The main issue with it right now is it only supports one slide directory. In KDE4, you can set multiple directories, but I really don’t know what that would do to the script. Probably just confuse it, but then it wouldn’t work.

Enjoy.

$template = preg_replace(
    "#\%date(\:\s*(.*?))?\%#ei",
    "date(('\\2'!=\"\"?'\\2':\$date_format), \$timestamp)",
    $template
);

This falls on the “advanced” side of intermediate, I would think, so here’s an explanation:

This is a standard preg_replace($pattern, $replacement, $source_string). What we want to do is replace the variable %date% in $template with a date string generated from $timestamp. But %date% is too limiting; within the template, we’d like to write something like %date: F j, Y% to get a date like “March 12, 2009,” or any other format.

The regular expression is like so: #\%date(\:\s*(.*?))?\%#ei. The “hashes” (#) here act as delimiters for the regex; the e and i after the second hash turn on “eval’d replacement” and “case-insensitivty”, respectively (learn more about PCRE regex modifiers at php.net). So the regex to deal with is \%date(\:\s*(.*?))?\%. The \% are the markers for our template variables; date is the name of the variable to look for. (\:\s*(.*?))? matches zero or one instances of our “variable modifier”: a colon, followed by any amount of whitespace (including none), followed by any number of any characters (where the extra ? makes the .* “non-greedy”; it’ll stop “eating” characters when it reaches the next percent sign). For preg_replace, this will place our date() format in “\\2″ if it is present; if it is not present, “\\2″ will not be set.

The replacement is as follows: “date((’\\2′!=\”\”?’\\2′:\$date_format), \$timestamp)”. preg_replace will insert the matched date format from the regex into every occurrence of “\\2″ in the replacement string, and then run eval() on the resulting string to get the replacement value (all thanks to the e modifier in the regex). Assuming our regex matched “F j, Y” as the match, we’ll get “date((’F j, Y’!=\”\”?’F j, Y’:\$date_format), \$timestamp)”. The (’F j, Y’!=\”\”?’F j, Y’:\$date_format) part chooses the date format; if the match is not set (ie, an empty string), use whatever is in the variable $date_format; else, if the date format was matched, use it. This allows us to use %date% in the template, to default to a server-side specified format.

And there it is. You can now put “%date: F j, Y%” in your template, and it will be expanded to “March 12, 2009″ (depending on the actual date, of course ). That is, if your templating system works in the first place…

As for the most popular response, having apache run css files as php code, there are a few issues that come to mind that the article’s approach takes care of: caching, cleanliness, and portability.

Caching, as the author notes, reduces the number of CPU cycles the server must devote to php processing of the css files. The parser also implements HTTP features for determining if the file has been modified and needs reloading. Simply setting the server to parse CSS files, you may or may not lose these features, depending on your server settings.

The method is also clean; using a parsing class lets you put simple variable assignments directly in the CSS file. Associating CSS with the PHP parser requires you to use the PHP tags and all the appropriate PHP markers ( <?php $var = “whatever”; ?> ); if you miss a semicolon, a quote, a dollar sign, or any other part of the required “PHP syntax”, your css file at best will contain a php error or warning message, making the code invalid, or at worst will not display at all, giving a blank css file. The parser Jay gives, while requiring a syntax of its own, is much simpler to use.

Jay’s solution is portable; the only server configuration necessary is enabling apache’s mod_rewrite module, which should be enabled anyway. If that is done, you can move the .htaccess and enhanced_css.php files to any server, and it will work without further server config.

As commenter Pelle notes, however, if someone knows you’re using this method and they know the path to your enhanced_css.php file, they could use it maliciously. Jay responds with a quick fix that makes sure the class only parses files ending with “css”, but I believe that further security could be provided, though I’ve not taken the time to analyze the code enough to make suggestions.

Chris Pratt made a suggestion of changing the parser to hunt out CSS variables as proposed by Daniel Glazman and David Hyatt. I thought this would be a good idea; the syntax proposed in that doument is much more like the CSS3 stuff we’re slowly getting used to, such as :not() and attr().

For those interested, you could read why some think CSS variables are harmful.

Before I begin listing off links, I feel the need to put a disclaimer. I realize that the title for this post will make many laugh. It makes me laugh. Why, after all, would you want to make Windows act like Linux when you can have the real deal for free? The answer is just that: Linux is not free, not in the modern sense. The switch from windows to linux is a shift in the way your world works. It’s often a shift for the better, but the shift itself almost always takes time — time to get used to a new ideology, time to figure things out, time to make things work just the way you want them to. Time that many people don’t have.

Truth is, there is simply no way to make Windows akin to Linux in any way, shape, or form. They are two different environments, two different philosophies. However, thanks to third-party developers and a fairly open distribution platform (I’m looking at you, Apple), it’s possible to bring some functionality to the Windows desktop. You can’t change its personality, but you can change its behavior. This list is meant to bring some linux-y goodness to those without the time to jump in head first.

Now, with that out of the way, the list:

• Clipboard history: something so small, so unnoticeable until you need it, and so nice to have when you do need it. ClipX; 131K download; 252K footprint (no plugins, 25 items, text only).
• Virtual desktops: Most linux distros come with virtual desktops or workspaces. Once you learn to work with them, you can’t work without them. VirtuaWin; 385K download; 1.3M footprint (four desktops). Won’t give you the Compiz cube, but you shouldn’t be expecting that anyways .
• Window snapping: a nice feature for those who like to work with non-maximized windows in the corners of their desktops. AllSnap; 69.4K download; just over 1M footprint (portable version via startup folder, desktop snapping only)
• Systray minimization: I got used to Amarok minimizing to the systray, and I wanted Windows Media Player to do the same. TrayIt!; 327K download; just over 1M footprint (one window rule for WMP).
• Launchy/Gnome-Do/Program Launcher: I never had much luck with launchy under linux, so I ended up using Gnome-Do for app launching. Win7, however, seems to do fine with its Start Menu searchbar. No download, native footprint.
• Wallpaper rotater: while not strictly functional, it is nice to be able to choose a number of images to auto-rotate through as a wallpaper. Win7 has this built in. No download, native footprint.

Moving from a well-established Linux environment to a squeaky-clean Windows environment is bound to be a bumpy experience without first determining suitable replacements for all the programs that one uses on a daily basis. After my initial move-in, I was rather ad-hoc in finding replacements. Now that I’ve found suitable replacements for my most-used programs, perhaps this list can help those of you looking to make n experimental switch.

• BitTorrent: I do a lot of torrenting, so a good replacement for KTorrent is necessary. uTorrent has so far served my purposes for the odd torrent, while I continue to use my automated torrent system on my home server for TV shows and such.
• IM client with AIM and IRC: I sit on IRC channels all day long these days, occasionally throwing in a word or two, but mainly gleaning whatever knowledge I can from the chatter. Also, I have an AIM account that is my main real-time online point-of-access. I’ve gotten used to Kopete, but it’s lacking in just the right areas so as to make me dissatisfied with it. Recently I’ve installed Pidgin (under Kubuntu), and I’ve found that it has its own quirks that I’m dissatisfied with, perhaps more so than with Kopete. The release of kDE4-only Kubuntu 8.10 has further disappointed me: Kopete lost its IRC capabilities, and I was forced to use Konversation for IRC, but it has been an exceptional IRC program. Here on Windows, the options are rather scarce — Pidgin is available, but suffers from the aforementioned shortcomings. I’ve heard great things about Digsby, but it doesn’t seem to support IRC at the moment. However, as I was forced to split my chatting between two programs on linux, doing the same on windows isn’t too bad a compromise. I use Digsby for AIM, and YChat, which seems to be a branch of XChat, for IRC. I am not completely satisfied with YChat as a Konversation replacement, because it has no auto-login, auto-identification, or auto-join features that work on Win7 (seems to be a dll issue here), but it works well enough.
• Desktop Feed Reader: My primary feed reader for feeds of interest to me is Google Reader, and that isn’t going to change. However, I also use a desktop feed reader to toss temporary feeds like ebay and craigslist search results into. On linux I’ve grown accustomed to using Akregator, simply because it’s included with Kubuntu. Here on Windows, however, FeedDemon has taken the role quite nicely.
• Music/Video playback, a la Amarok/Kaffeine: I love my music. And I love my video, whether it be downloaded TV shows or a DVD. And I have to have some way to play them. Regarding music, my needs are not outrageous — I just need some way to organize my music, fetch album info from the net, and perhaps display album art for me. I don’t care for song ratings or anything fancy like that. Windows Media Player works well in regards to both audio and video, and even works with my Inspiron’s front-side music player controls.
• Gimp or PhotoShop: Being in web development, I do occasionally do graphics editing. For this, I need Gimp at the least, though I would like to try PhotoShop. I’m going to attempt to install PS CS4 at some point, but I’m afraid I won’t have the free disk space for it. Bummer.
• Advanced text editor: On Kubuntu, I used Kate for text editing (HTML, CSS, PHP, etc files). My requirements here are syntax highlighting, tabs, and sessions. Code collapsing is a nice feature, but not required. I will likely use Notepad++ on Windows, though I haven’t done much development lately to really test its workflow yet.
• Firefox, Thunderbird, and Sunbird: I’m sorry, there is no replacement for these three .
• Office software: On Linux, I got by fine using OpenOffice. However, since I have free access to Office 2007, I am using that. Sorry, OSS radicals.
• Filezilla: Again, no replacement.
• PDF Viewer/Printer: Another thing that comes stock with Kubuntu. Foxit is good for PDF viewing, and CutePDF works for a printer.
• File manager: Requirements in this area include all the things I’ve come to expect from Konqueror: tabbed interface (with spring-loaded tabs, no less), session management, and easy switching amongst various folder views (icons, details, etc). CubicExplorer fits the bill quite nicely, though I still find myself opening Windows Explorer for short filemanaging stints.
• SSHfs: This was rather high on my priority list, as I have my web development folders, which reside on my server, mounted locally as SSHfs shares. This means that, whenever I have internet access, I can simply open, edit, and save the files at home as if they were on my local machine. Unfortunately, no SSHfs for Windows seems to exist. I had heard things about Novell’s netdrive.exe, but it doesn’t support sftp. Dokan’s SSHfs looked promising, but, alas, would not install on a Windows 7 environment (even in Vista compatibility mode). For now, I have to resort to WinSCP for SSH-based editing, but it doesn’t come near the convenience of SSHfs.