The trick was to encode the file exactly correctly, and then post it with the correct headers. I wrote a simple post_file method to do this.

  def post_file(url, param_name, file_path, content_type)
    file_name = File.basename(file_path)
    boundary = "AaB03x"
    data = "--#{boundary}\r\n" +
           "Content-Disposition: form-data; name=\"#{param_name}\"; filename=\"#{file_name}\"\r\n" +
           "Content-Type: #{content_type}\r\n" +
           "\r\n" +
           "#{File.read(file_path)}\r\n" +
           "--#{boundary}--\r\n" +
           "\r\n"
    post(url, {}, {
      "CONTENT_TYPE" => "multipart/form-data, boundary=\"#{boundary}\"",
      "CONTENT_LENGTH" => data.length, :input => data })
  end

I call it from my test like this:

...
post_file("/my_app/upload", "uploaded_image", "../test-images/originals/loki.jpg", "image/jpeg")
...

and my app reads it like this:

...
request = Rack::Request.new(env)
...
uploaded_image = request.params["uploaded_image"][:tempfile]
...

MySQL

I had already downloaded and installed MySQL, so I didn’t have to do anything. If I remember, installing MySQL was straightforward.

Apache

Apache comes pre-installed on Mac OS X, but I had to turn it on in System Preferences > Sharing > Web Sharing.

PHP

PHP 5 comes pre-installed on Mac OS X, but I had to enable it in Apache by editing the conf file:

sudo vi /etc/apache2/httpd.conf

and uncommenting the line:

LoadModule php5_module

WordPress

I downloaded WordPress and extracted it into:

~/Sites/wordpress

I followed the installation instructions, but I had to use “Localhost” instead of “localhost” as my database host name.

I created a symlink from the directory where I was editing my theme to the WordPress themes directory:

ln -s ~/Development/my-theme ~/Sites/wordpress/wp-content/themes/my-theme

Apache wasn’t set up to follow symlinks in my user directory, so I had to edit my personal conf file:

sudo vi /private/etc/apache2/users/ehanson.conf

and set the options line to:

Options Indexes MultiViews FollowSymLinks

Then I logged into the WordPress admin console at http://localhost/~ehanson/wordpress/wp-admin, set the theme to my new theme, and everything worked.

Also, I wanted to be able to view any test page so I could debug the tests with Firebug (as explained here).

I also didn’t want to run a web server all the time, so I wanted a script that would create a static HTML file.

Here’s what I came up with. It’s not configurable, so you’ll have to modify it for your own needs.

JsUnitSuiteBuilder.rb

FireBug has a nice debugger, but I couldn’t get it to work with the JsUnit test runner. I could set breakpoints in JsUnit itself, but any breakpoints in my test would be ignored.

And then it hit me: ditch the test runner. I opened my test page directly in Firefox, opened FireBug, clicked the Debugger tab, and chose my test from the “Scripts” menu. Here’s a simplified version:

function testUpdate() {
  var listPanel = new ListPanel();
  listPanel.update(["one", "two", "three"]);

  var children = $("content").childNodes;
  assertEquals("one", children[0]);
  assertEquals("two", children[1]);
  assertEquals("three", children[2]);
}

I put a breakpoint at the first assertEquals and switched to the Console tab and typed testUpdate(). I saw the ListPanel getting drawn in the browser (something you don’t see in the JsUnit test runner) and in the Debugger tab I could inspect all my variables.

But even better, I could go back to the Console tab and start evaluating Javascript.

>>> children.length
3

Good.

>>> children[0]
div

Bad.

>>> children[0].firstChild
[Text] "one"

Better.

>>> children[0].firstChild.nodeValue
"one"

Perfect.

PS1='\h:\w \u\$ '

The code for starting a font and color change is \e[. The code for bold red is 1;31. The code for closing the starting code for a font and color tag is m. The closing code for a font and color change is \e[m. Bash thinks that these color commands will increase the length of the prompt, which will cause odd line wrapping behavior. The solution is to wrap all the color codes in brackets (\[ and \]).

So, the entire prompt looks like this:

PS1='\[\e[1;31m\]\h:\w \u\$\[\e[m\] '

Eeech. Add that to your .bashrc file and you’re all set. If you don’t want the red, the prompt would be:

PS1='\[\e[1m\]\h:\w \u\$\[\e[m\] '

More colors are listed at the bottom of this page.

Update: Somewhere along the way, all the backslashes got replaced by double backslashes. I’ve fixed that.

Creating the join table

Starting with tables foos and bars, I created a join table bars_foos. (Rails expects the join table’s name to be a concatenation of the two table names in alphabetical order).

Reading attributes

I added an attribute baz to bars_foos. I had originally tried to access it with:

myFoo.baz

but that didn’t work. It turns out that I needed to force Rails to do the join before accessing the attribute, which makes sense when you think about it (but it took me a while before my little brain thought about it correctly):

myFoo.bars.baz

Adding attributes

Use the well-documented push_with_attributes method:

myFoo.bars.push_with_attributes(bar, :baz => "fez")

Updating attributes

Apparently you can’t. Luckily, in my app the attribute is immutable. Other people have suggested deleting and re-inserting the row which I imagine shouldn’t be a problem for most applications.

Recently, I was trying to pass some info from my Javascript into my XSL stylesheet. Here’s how I finally did it:

(Quick note: in real life, I don’t name variables "myThis" and "myThat"; I’m just doing it here to make it clear what is my code and what is part of XSL, AJAXSLT, Javascript, etc.)

The XSL

<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:param name="myParam" select="'myDefault'"/>
  <xsl:template match="/">
    myParam: <xsl:value-of select="$myParam"/>
  </xsl:template>
</xsl:stylesheet>

The Javascript

var myContext = new ExprContext(myXml);
myContext.setVariable("myParam",
    new StringValue("the value for myParam"));
xsltProcessContext(myContext, myXsl, myRootElement);

The Trick

So the big trick, which I figured out after reading lots of the AJAXSLT code, was to set the parameter to a StringValue, rather than a regular Javascript String. StringValue is part of AJAXSLT. Update: Will, in the comments below, mentions that there are four total types: StringValue, NumberValue, BooleanValue and NodeSetValue.

Troubleshooting

Don’t forget to declare your parameter with <xsl:param.../> before using it with <xsl:value-of select="$..."/>, otherwise Ajaxslt will blow up in the middle of rendering.

It took a bit of playing to get it to work. Here’s some sample code. (I forgot to write it up when I did it, so I might have left something out.)

Setup

First, include the scripts. Note: make sure to have a closing </script> tag rather than doing <script ... /> because that silently fails on some browsers (yay!).

<!-- AJAXSLT -->
<script src="/ajaxslt/misc.js"
    type="text/javascript"></script>

<script src="/ajaxslt/dom.js"
    type="text/javascript"></script>

<script src="/ajaxslt/xpath.js"
    type="text/javascript"></script>

<script src="/ajaxslt/xslt.js"
    type="text/javascript"></script>

<script src="/ajaxslt/xpathdebug.js"
    type="text/javascript"></script>

Using Ajaxslt for XSL Transformation

For XSL transformation, you’ll need three things: some XML, some XSL, and a node (or DocumentFragment presumably) to place the result in. One way to get the XML and XSL is to load them through an XmlHttpRequest. Ajaxslt also provides a couple of handy functions to convert between text and XML:

var myText = "...";
var myXml = xmlParse(myText);
var myTextAgain = xmlText(myXml);

Once you’ve got the XML and XSL, you’re ready to do the transformation:

var myNode = document.getElementById("myId");
xsltProcessContext(new ExprContext(myXml), myXsl, myNode);

Your node should now contain the result of the transformation.

Using Ajaxslt for XPath

You can also use Ajaxslt for XPath evaluation, which is really handy when writing tests on your rendered document:

var expr = xpathParse(myXpathString);
var result = expr.evaluate(new ExprContext(myXmlDocument));
var resultAsString = result.stringValue();

Troublshooting

The order of the JavaScript include statements matters: if Ajaxslt is giving strange errors, make sure the scripts are included in the exact same order as in the Setup section of this page.

Make sure you know what you’re passing to Ajaxslt: if you’re sending request.responseXML to a method, don’t look at request.responseText to see what you’re passing; use xmlText(request.responseXML).

The root element isn’t selectable: if your XML is <foo id="myId">...</foo>, then you don’t select foo’s id with /foo/@id but rather with just @id.

Case matters in xpath: If you’re evaluating an xpath expression on an HTML DOM, note that the node names are most likely uppercase. So do /HTML/BODY instead of /html/body

One big problem is that it can’t run all your tests. So we wrote a test suite class that runs all tests and can be run from Test::Unit:

require 'test/unit'

Dir.chdir("test")
@@test_files = Dir.glob("**/*_test.rb")
@@test_files.each {|x| require x} 

class TestSuite
  def self.suite
    suite = Test::Unit::TestSuite.new

    @@test_files.each do |filename|
      File.open(filename) do |file|
        file.each_line do |line|
          if match = (/class\s+(\w+Test)/).match(line)
           suite << eval(match[1] + ".suite")
          end
        end
      end
    end

    return suite

  end
end

Here’s what ended up working for me. It’s based on the instructions on Jamie’s Blogomatic.

1. Install the XCode tools from the Tiger DVD.

2. Download and run the Ruby on Rails installer from: http://users.tpg.com.au/aarnold/Ruby%20on%20Rails.zip.

3. Download and run the MySQL installer (I used version 4.1.11): http://dev.mysql.com/downloads/index.html.

4. Start mysql: bash$ sudo /usr/local/mysql/bin/mysqld_safe

5. Put mysql into the background: ctrl-z and then bash$ bg

6. Update gems: bash$ sudo gem update

7. Install the mysql gem from the remote source: bash$ sudo gem install -r mysql -- --with-mysql-dir=/usr/local/mysql

8. Compile and install the MySQL API module from here: http://www.tmtm.org/en/mysql/ruby/.

9. All done!