I have relatively high hopes for TextMate 2 as well, since I expect that the Rails stuff will be very well cared for there, but at the moment, it’s too rough around the edges for me, and even it doesn’t act in the manner I’ve gotten accustomed to. There are plenty of annoying things about TextMate 1, but on balance, I’m going to have to wait for a middle beta I think before I jump over to TextMate 2.

So, all it really took was a quick ln -s to re-establish that symbolic link, and then the preference pane was able to turn mysql on, and rails s brought my local server right up. Not bad. Here’s hoping my TeX install survived in as good a shape.

But I’ve become still more famous, as Some Guy From Canada, in Nick Sutterer and Kevin Triplett’s presentation at Lonestar RubyConf 2010.

I have recently gotten back into working on making Apotomo and jqGrid work together in a nice widget plugin. And this time, I’m doing it in Rails 3 and much more cleanly.

The current state of it is demoed on github in grid_widget_example, the plugin itself lives at grid_widget. It does maybe 70% of what I want it to do now. We’ll see whether I can keep it up to date and improve it over the next 12 months.

So, I installed mysql using the official 64-bit package installer, moved my data into the new mysql directory, everything you’re supposed to do.

But even after much banging of head and gnashing of teeth get the mysql gem to install. The magic command is supposed to be this:

sudo env ARCHFLAGS="-arch x86_64" gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config

But it just can’t find my mysql libraries. I look at the output and it didn’t even try, there’s no mention of the contents of the –with-mysql-config parameter.

For whatever reason, it wasn’t picking this up. I poked around a little bit in the gem configuration source code, and, although I didn’t figure out what the problem was, I did at least find something that allowed me to compile the thing: be sure that mysql_config is on the path. In retrospect, perhaps something should have happened to put mysql on the path anyway, but this is what I did:

PATH=/usr/local/mysql/bin:$PATH
sudo env ARCHFLAGS="-arch x86_64" gem install mysql

And it worked, mostly. The documentation install spouted a bunch of errors, but I think the gem at least is installed. Maybe someday I’ll come back and worry about the documentation, though I actually think that’s kind of unlikely.

However, it’s working. I can continue, I’ll come back and clean up later.

What I decided to do in the end was to make the jqGrid datatype be a function that requests not JSON but rather Javascript commands, and then I set up a caching system. When a jqGrid is initially wired in, I push an empty JSON structure onto the cache, so that when the jqGrid initially requests its data, it doesn’t do an AJAX call but just loads up this cached empty recordset. Then, when the topmost parent is finally rendered, it sends Javascript instructions to populate its own cache, as well as the caches of all of its children, and tells them all to reload. That way, only a single HTTP request is made, populating the entire page (which, in my test case, contains 8 different jqGrids). Eventually, I’ll put the plugin on github. For now, here’s the Javascript bit, which could be useful even without apotomo.

// The following functions implement a pre-cache for JSON requests, which allow for
// the parent widget to send data updates for itself and all children at once to minimize
// AJAX requests.  It is hooked into jQGrid as a function datatype, with an option like this:
// datatype: function(pdata) { retrieveJSON('table_id_selector','url/to/retrieve',pdata); }
// Cached data will be passed back, or, if there is nothing cached, then data is requested.
var pendingJSON = new Array();
function retrieveJSON(table,purl,pdata) {
	var ts = jQuery(table)[0],
	loadComplete = jQuery.isFunction(ts.p.loadComplete) ? ts.p.loadComplete : false;
	if (pendingJSON[table] == null) {
		indicateReq(table);
		jQuery.getScript(purl+'&'+jQuery.param(pdata));
	} else {
		ts.addJSONData(eval("("+pendingJSON[table]+")"));
		if(loadComplete) loadComplete(pendingJSON[table],'success');
		delete pendingJSON[table];
	}
}
function pushJSON(table,json) {
  pendingJSON[table] = json;
}
// jQGrid's "loading" UI behavior is hidden away as a private function, so I duplicated
// the basic essence of its beginReq() function here.  It is used to send the UI for child
// tables into the "loading" state while the parent loads. The table is expanded when this
// happens, in order for the "loading..." message to appear in a sensible place.
// I also ditched the beforeRequest and the check for initial collapsed status.
function indicateReq(table) {
  var ts = jQuery(table)[0];
	openTable(table);
	switch(ts.p.loadui) {
		case "disable":
			break;
		case "enable":
			jQuery("#load_"+ts.p.id).show();
			break;
		case "block":
			jQuery("#lui_"+ts.p.id).show();
			jQuery("#load_"+ts.p.id).show();
			break;
	}
}
// The hideTable and openTable functions provide a way to "click on the collapse icon" programmatically.
function hideTable(table) {
	if (jQuery(table).getGridParam('gridstate') == 'visible') {
		jQuery(table).closest('.ui-jqgrid-view').find('.ui-jqgrid-titlebar-close').trigger('click');
	}
}
function openTable(table) {
	if (jQuery(table).getGridParam('gridstate') == 'hidden') {
		jQuery(table).closest('.ui-jqgrid-view').find('.ui-jqgrid-titlebar-close').trigger('click');
	}
}

As for how I use it, I have a couple of helper methods in my cell controller that can illustrate it. Apotomo has a kind of cascading rendering process, which emits the rendered output of a widget together with its child widgets, so I just have each individual widget hit the database for the JSON data, and then emit Javascript using these functions, e.g., js_push_json_to_cache(load_records) + js_reload_jqgrid, or, to push an empty recordset, js_push_json_to_cache(empty_json).

...
  include ActionView::Helpers::JavaScriptHelper 
...
  def empty_json
    '{"rows": [], "records": 0, "page": 0, "total": 0}'
  end
  
  def js_reload_jqgrid(jqgrid_id = @jqgrid_id)
    return <<-JS
    jQuery('##{jqgrid_id}').trigger('reloadGrid');
    JS
  end
  
  def js_push_json_to_cache(raw_json_data)
    json_data = escape_javascript(raw_json_data)
    return <<-JS
    pushJSON('##{@jqgrid_id}', "#{json_data}");
    JS
  end

...

log/*.log
.DS_Store
tmp/**/*
db/*.sqlite3
doc/api
doc/app
doc/plugins

...
:order => (ford = (sopt = 1)),
...
:order => (ford = (sopt = 1) + ford),
:options => (Degree.find(:all).map {|x| [x.id, {:name => x.name, :order => (sopt += 1)}]}).inject({}) {|h, (k, v)| h[k] = v; h},
...

There might be another way to do this, I’m a bit of a Ruby novice, but this was complex enough that I thought it worth noting down.

git rm --cached vendor/plugin/submodule (no trailing slash)

This will cause git to forget the submodule is there (though it’s still mentioned in .git/config and .gitmodules, may want to remove it from there as well). It does not delete the submodule. I just moved it to the trash rather than exercising my sudo privileges with rm, but in any event it’s safe to remove at that point.