do you want there to be a smooth changeover from the previous version of the results to a new version, with no rollbacks or lock timeouts ?

activerecord_worm_table allows an ActiveRecord model to be backed by several database tables, an active table, a working table and one or more historical tables. data is loaded into the working table, and when finished the working table becomes the active table. the old active table becomes a historical table, and any active queries continue using that table

it’s available from gemcutter :

gem install activerecord_worm_table

and it’s easy to use :

class Foo < ActiveRecord::Base
  include ActiveRecord::WormTable
end
Foo.connection.execute( "insert into #{Foo.working_table_name} values ('foofoo')" )
Foo.advance_version
Foo.first

( MySQL support only for now )

regexes can concatenate character classes, so you can do things like match against “all unicode whitespace except newlines” thus :

/[[^\n]&&[:space:]]+/

there are plenty of low-level stream parsers around e.g. in rexml, but they stop some way short of allowing the solution to be expressed in a natural way

here‘s a parser, which sits atop rexml’s pull parser, and allows you to formulate your parse in ruby blocks which straightforwardly process xml elements. what you keep and how you convert is completely specified by those blocks, so you can happily parse an unending document in constant memory

<people>
  <person name="alice">likes cheese</person>
  <person name="bob">likes music</person>
  <person name="charles">likes alice</person>
</people>

can be parsed with :

require 'rubygems'
require 'xml_stream_parser'

people = {}
XmlStreamParser.new.parse_dsl(doc) do
  element "people"  do |name,attrs|
    elements "person" do |name, attrs|
      people[attrs["name"]] = text
    end
  end
end

a plainer api is also supported, allowing a parse to be split over multiple methods [ since parse_dsl uses instance_exec to call blocks, and loses context ]

people = {}
XmlStreamParser.new.parse(doc) do |p|
  p.element( "people" ) do |name,attrs|
    p.elements( "person" ) do |name, attrs|
      people[attrs["name"]] = p.text
    end
  end
end

features are

• run ack within emacs
• clickable results
• ecb source path sensitive : searches current project
• alternatives to search sub-projects of current project, for large projects

u get

• jruby spec running [ requires a "jspec" script ] in addition to cruby
• results in ecb compile window
• following of results as they are output
• automatic scroll-to-bottom of results after completion

active-record-jdbc-mysql-master-slave

(re-posted from work)

_why helped some, but i still wasn’t completely clear

i undertook an investigation, with ruby 1.8.6 ( mri and jruby 1.1.4 ), and ruby 1.9 ( mri )

the two 1.8.6 rubys are consistent with each other, but different from ruby 1.9. method resolution seems to function similarly in both 1.8.6 and 1.9, but eigenclasses are referenced differently

this diagram captures what i found

relationships between ruby objects, classes and eigenclasses

(pdf: ruby objects, classes and eigenclasses )