spqr 0.1.4 → 0.2.0

data/CHANGES

@@ -1,4 +1,8 @@
-version 0.1.4
+version 0.2.0
+
+*  SPQR and Rhubarb are now separate projects.
+
+version 0.1.4 (f24baeafb0fe88e09c232acac3891d11771325a9)
 
 *  0.1.3 introduced a compatibility issue with previous versions of
    Rhubarb.  These should be resolved here.

data/TODO

@@ -1,10 +1,3 @@
-To do, overall:
-
-* packaging (partially done)
-
-
-To do for spqr:
-
 ! Event support
 * Support for map-, array-, and list-valued parameters and properties (QMF on Ruby itself does not support these at the moment)
 * Broader query support (partially done)
@@ -16,16 +9,6 @@ To do for spqr:
    - Fewer required annotations
    - Automatic decoration of certain methods
 
-
-
-To do for rhubarb:
-
-* Bring code coverage up to 100%
-* Documentation
-* Standalone examples (i.e. not just "please see the test suite")
-
-
-
 Legend:
 
 ! --> highest priority

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/examples/logservice.rb

@@ -24,7 +24,12 @@
 
 require 'spqr/spqr'
 require 'spqr/app'
-require 'rhubarb/rhubarb'
+begin
+  require 'rhubarb/rhubarb' 
+rescue LoadError
+  puts "You must have Rhubarb installed to run this example.\nTry \"gem install rhubarb\", and ensure that it is in your load path."
+  Process.exit
+end
 
 class LogService
   include SPQR::Manageable

data/test/helper.rb

@@ -9,7 +9,6 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'spqr/spqr'
 require 'spqr/app'
-require 'rhubarb/rhubarb'
 
 module QmfTestHelpers
   DEBUG = (::ENV["SPQR_TESTS_DEBUG"] and ::ENV["SPQR_TESTS_DEBUG"].downcase == "yes")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - William Benton
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-01 00:00:00 -06:00
+date: 2010-02-02 00:00:00 -06:00
 default_executable: spqr-gen.rb
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,7 +45,6 @@ files:
 - examples/codegen-schema.xml
 - examples/hello.rb
 - examples/logservice.rb
-- lib/rhubarb/rhubarb.rb
 - lib/spqr/app.rb
 - lib/spqr/codegen.rb
 - lib/spqr/constants.rb
@@ -58,7 +57,6 @@ files:
 - spqr.spec.in
 - test/example-apps.rb
 - test/helper.rb
-- test/test_rhubarb.rb
 - test/test_spqr_clicker.rb
 - test/test_spqr_dummyprop.rb
 - test/test_spqr_hello.rb
@@ -99,7 +97,6 @@ test_files:
 - test/helper.rb
 - test/test_spqr_clicker.rb
 - test/test_spqr_integerprop.rb
-- test/test_rhubarb.rb
 - test/test_spqr_hello.rb
 - examples/agent-app.rb
 - examples/examples/codegen/EchoAgent.rb

data/lib/rhubarb/rhubarb.rb

@@ -1,545 +0,0 @@
-# Rhubarb is a simple persistence layer for Ruby objects and SQLite.
-# For now, see the test cases for example usage.
-#
-# Copyright (c) 2009 Red Hat, Inc.
-#
-# Author:  William Benton (willb@redhat.com)
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-require 'rubygems'
-require 'set'
-require 'time'
-require 'sqlite3'
-
-module Rhubarb
-
-module SQLBUtil
-  def self.timestamp(tm=nil)
-    tm ||= Time.now.utc
-    (tm.tv_sec * 1000000) + tm.tv_usec
-  end
-end
-    
-
-module Persistence
-  class DbCollection < Hash
-    alias orig_set []=
-    
-    def []=(k,v)
-      v.results_as_hash = true if v
-      v.type_translation = true if v
-      orig_set(k,v)
-    end
-  end
-  
-  @@dbs = DbCollection.new
-  
-  def self.open(filename, which=:default)
-    dbs[which] = SQLite3::Database.new(filename)
-  end
-
-  def self.close(which=:default)
-    if dbs[which]
-      dbs[which].close
-      dbs.delete(which)
-    end
-  end
-
-  def self.db
-    dbs[:default]
-  end
-  
-  def self.db=(d)
-    dbs[:default] = d
-  end
-
-  def self.dbs
-    @@dbs
-  end
-end
-
-class Column
-  attr_reader :name
-
-  def initialize(name, kind, quals)
-    @name, @kind = name, kind
-    @quals = quals.map {|x| x.to_s.gsub("_", " ") if x.class == Symbol}
-    @quals.map 
-  end
-  
-  def to_s
-    qualifiers = @quals.join(" ")
-    if qualifiers == ""
-      "#@name #@kind"
-    else
-      "#@name #@kind #{qualifiers}"
-    end
-  end
-end
-
-class Reference
-  attr_reader :referent, :column, :options
-
-  # Creates a new Reference object, modeling a foreign-key relationship to another table.  +klass+ is a class that includes Persisting; +options+ is a hash of options, which include
-  # +:column => + _name_::  specifies the name of the column to reference in +klass+ (defaults to row id)
-  # +:on_delete => :cascade+:: specifies that deleting the referenced row in +klass+ will delete all rows referencing that row through this reference
-  def initialize(klass, options={})
-    @referent = klass
-    @options = options
-    @options[:column] ||= "row_id"
-    @column = options[:column]
-  end
-
-  def to_s
-    trigger = ""
-    trigger = " on delete cascade" if options[:on_delete] == :cascade
-    "references #{@referent}(#{@column})#{trigger}"
-  end
-
-  def managed_ref?
-    # XXX?
-    return false if referent.class == String
-    referent.ancestors.include? Persisting
-  end
-end
-
-
-# Methods mixed in to the class object of a persisting class
-module PersistingClassMixins 
-  # Returns the name of the database table modeled by this class.
-  # Defaults to the name of the class (sans module names)
-  def table_name
-    @table_name ||= self.name.split("::").pop.downcase  
-  end
-  
-  # Enables setting the table name to a custom name
-  def declare_table_name(nm)
-    @table_name = nm
-  end
-
-  # Models a foreign-key relationship. +options+ is a hash of options, which include
-  # +:column => + _name_::  specifies the name of the column to reference in +klass+ (defaults to row id)
-  # +:on_delete => :cascade+:: specifies that deleting the referenced row in +klass+ will delete all rows referencing that row through this reference
-  def references(table, options={})
-    Reference.new(table, options)
-  end
-
-  # Models a CHECK constraint.
-  def check(condition)
-    "check (#{condition})"
-  end
-  
-  # Returns an object corresponding to the row with the given ID, or +nil+ if no such row exists.
-  def find(id)
-    tup = self.find_tuple(id)
-    return self.new(tup) if tup
-    nil
-  end
-  
-  alias find_by_id find
-
-  def find_by(arg_hash)
-    arg_hash = arg_hash.dup
-    valid_cols = self.colnames.intersection arg_hash.keys
-    select_criteria = valid_cols.map {|col| "#{col.to_s} = #{col.inspect}"}.join(" AND ")
-    arg_hash.each {|k,v| arg_hash[k] = v.row_id if v.respond_to? :row_id}
-
-    self.db.execute("select * from #{table_name} where #{select_criteria} order by row_id", arg_hash).map {|tup| self.new(tup) }
-  end
-
-  # args contains the following keys
-  #  * :group_by maps to a list of columns to group by (mandatory)
-  #  * :select_by maps to a hash mapping from column symbols to values (optional)
-  #  * :version maps to some version to be considered "current" for the purposes of this query; that is, all rows later than the "current" version will be disregarded (optional, defaults to latest version)
-  def find_freshest(args)
-    args = args.dup
-    
-    args[:version] ||= SQLBUtil::timestamp
-    args[:select_by] ||= {}
-    
-    query_params = {}
-    query_params[:version] = args[:version]
-    
-    select_clauses = ["created <= :version"]
-
-    valid_cols = self.colnames.intersection args[:select_by].keys
-
-    valid_cols.map do |col|
-      select_clauses << "#{col.to_s} = #{col.inspect}"
-      val = args[:select_by][col]
-      val = val.row_id if val.respond_to? :row_id
-      query_params[col] = val
-    end
-
-    group_by_clause = "GROUP BY " + args[:group_by].join(", ")
-    where_clause = "WHERE " + select_clauses.join(" AND ")
-    projection = self.colnames - [:created]
-    join_clause = projection.map do |column|
-      "__fresh.#{column} = __freshest.#{column}"
-    end
-
-    projection << "MAX(created) AS __current_version"
-    join_clause << "__fresh.__current_version = __freshest.created"
-
-    query = "
-SELECT __freshest.* FROM (
-  SELECT #{projection.to_a.join(', ')} FROM (
-    SELECT * from #{table_name} #{where_clause}
-  ) #{group_by_clause}
-) as __fresh INNER JOIN #{table_name} as __freshest ON
-  #{join_clause.join(' AND ')}
-  ORDER BY row_id
-"
-
-    self.db.execute(query, query_params).map {|tup| self.new(tup) }
-  end
-
-  # Does what it says on the tin.  Since this will allocate an object for each row, it isn't recomended for huge tables.
-  def find_all
-    self.db.execute("SELECT * from #{table_name}").map {|tup| self.new(tup)}
-  end
-
-  def delete_all
-    self.db.execute("DELETE from #{table_name}")
-  end
-
-  # Declares a query method named +name+ and adds it to this class.  The query method returns a list of objects corresponding to the rows returned by executing "+SELECT * FROM+ _table_ +WHERE+ _query_" on the database.
-  def declare_query(name, query)
-    klass = (class << self; self end)
-    klass.class_eval do
-      define_method name.to_s do |*args|
-        # handle reference parameters
-        args = args.map {|x| (x.row_id if x.class.ancestors.include? Persisting) or x}
-        
-        res = self.db.execute("select * from #{table_name} where #{query}", args)
-        res.map {|row| self.new(row)}        
-      end
-    end
-  end
-
-  # Declares a custom query method named +name+, and adds it to this class.  The custom query method returns a list of objects corresponding to the rows returned by executing +query+ on the database.  +query+ should select all fields (with +SELECT *+).  If +query+ includes the string +\_\_TABLE\_\_+, it will be expanded to the table name.  Typically, you will want to use +declare\_query+ instead; this method is most useful for self-joins.
-  def declare_custom_query(name, query)
-    klass = (class << self; self end)
-    klass.class_eval do
-      define_method name.to_s do |*args|
-        # handle reference parameters
-        args = args.map {|x| (x.row_id if x.class.ancestors.include? Persisting) or x}
-        
-        res = self.db.execute(query.gsub("__TABLE__", "#{self.table_name}"), args)
-        # XXX:  should freshen each row?
-        res.map {|row| self.new(row) }        
-      end
-    end
-  end
-  
-  def declare_index_on(*fields)
-    @creation_callbacks << Proc.new do
-      idx_name = "idx_#{self.table_name}__#{fields.join('__')}__#{@creation_callbacks.size}"
-      creation_cmd = "create index #{idx_name} on #{self.table_name} (#{fields.join(', ')})"
-      self.db.execute(creation_cmd)
-    end if fields.size > 0
-  end
-
-  # Adds a column named +cname+ to this table declaration, and adds the following methods to the class:
-  # * accessors for +cname+, called +cname+ and +cname=+
-  # * +find\_by\_cname+ and +find\_first\_by\_cname+ methods, which return a list of rows and the first row that have the given value for +cname+, respectively
-  # If the column references a column in another table (given via a +references(...)+ argument to +quals+), then add triggers to the database to ensure referential integrity and cascade-on-delete (if specified)
-  def declare_column(cname, kind, *quals)
-    ensure_accessors
-    
-    find_method_name = "find_by_#{cname}".to_sym
-    find_first_method_name = "find_first_by_#{cname}".to_sym
-    
-    get_method_name = "#{cname}".to_sym
-    set_method_name = "#{cname}=".to_sym
-    
-    # does this column reference another table?
-    rf = quals.find {|q| q.class == Reference}
-    if rf
-      self.refs[cname] = rf
-    end
-
-    # add a find for this column (a class method)
-    klass = (class << self; self end)
-    klass.class_eval do 
-      define_method find_method_name do |arg|
-        res = self.db.execute("select * from #{table_name} where #{cname} = ?", arg)
-        res.map {|row| self.new(row)}
-      end
-
-      define_method find_first_method_name do |arg|
-        res = self.db.execute("select * from #{table_name} where #{cname} = ?", arg)
-        return self.new(res[0]) if res.size > 0
-        nil
-      end
-    end
-
-    self.colnames.merge([cname])
-    self.columns << Column.new(cname, kind, quals)
-    
-    # add accessors
-    define_method get_method_name do
-      freshen
-      return @tuple["#{cname}"] if @tuple
-      nil
-    end
-    
-    if not rf
-      define_method set_method_name do |arg|
-        @tuple["#{cname}"] = arg
-        update cname, arg
-      end      
-    else
-      # this column references another table; create a set 
-      # method that can handle either row objects or row IDs
-      define_method set_method_name do |arg|
-        freshen
-        
-        arg_id = nil
-
-        if arg.class == Fixnum
-          arg_id = arg
-          arg = rf.referent.find arg_id
-        else
-          arg_id = arg.row_id
-        end
-        @tuple["#{cname}"] = arg
-        
-        update cname, arg_id
-      end
-      
-      # Finally, add appropriate triggers to ensure referential integrity.
-      # If rf has an on_delete trigger, also add the necessary
-      # triggers to cascade deletes. 
-      # Note that we do not support update triggers, since the API does 
-      # not expose the capacity to change row IDs.
-      
-      self.creation_callbacks << Proc.new do   
-        @ccount ||= 0
-
-        insert_trigger_name = "ri_insert_#{self.table_name}_#{@ccount}_#{rf.referent.table_name}"
-        delete_trigger_name = "ri_delete_#{self.table_name}_#{@ccount}_#{rf.referent.table_name}"
-        
-        self.db.execute_batch("CREATE TRIGGER #{insert_trigger_name} BEFORE INSERT ON \"#{self.table_name}\" WHEN new.\"#{cname}\" IS NOT NULL AND NOT EXISTS (SELECT 1 FROM \"#{rf.referent.table_name}\" WHERE new.\"#{cname}\" == \"#{rf.column}\") BEGIN SELECT RAISE(ABORT, 'constraint #{insert_trigger_name} (#{rf.referent.table_name} missing foreign key row) failed'); END;")
-
-        self.db.execute_batch("CREATE TRIGGER #{delete_trigger_name} BEFORE DELETE ON \"#{rf.referent.table_name}\" WHEN EXISTS (SELECT 1 FROM \"#{self.table_name}\" WHERE old.\"#{rf.column}\" == \"#{cname}\") BEGIN DELETE FROM \"#{self.table_name}\" WHERE \"#{cname}\" = old.\"#{rf.column}\"; END;") if rf.options[:on_delete] == :cascade
-
-        @ccount = @ccount + 1
-      end
-    end
-  end
-  
-  # Declares a constraint.  Only check constraints are supported; see
-  # the check method.
-  def declare_constraint(cname, kind, *details)
-    ensure_accessors
-    info = details.join(" ")
-    @constraints << "constraint #{cname} #{kind} #{info}"
-  end
-  
-  # Creates a new row in the table with the supplied column values.
-  # May throw a SQLite3::SQLException.
-  def create(*args)
-    new_row = args[0]
-    new_row[:created] = new_row[:updated] = SQLBUtil::timestamp
-    
-    cols = colnames.intersection new_row.keys
-    colspec = (cols.map {|col| col.to_s}).join(", ")
-    valspec = (cols.map {|col| col.inspect}).join(", ")
-    res = nil
-
-    # resolve any references in the args
-    new_row.each do |k,v|
-      new_row[k] = v.row_id if v.class.ancestors.include? Persisting
-    end
-
-    self.db.transaction do |db|
-      stmt = "insert into #{table_name} (#{colspec}) values (#{valspec})"
-#      p stmt
-      db.execute(stmt, new_row)
-      res = find(db.last_insert_row_id)
-    end
-    res
-  end
-  
-  # Returns a string consisting of the DDL statement to create a table
-  # corresponding to this class. 
-  def table_decl
-    cols = columns.join(", ")
-    consts = constraints.join(", ")
-    if consts.size > 0
-      "create table #{table_name} (#{cols}, #{consts});"
-    else
-      "create table #{table_name} (#{cols});"
-    end
-  end
-  
-  # Creates a table in the database corresponding to this class.
-  def create_table(dbkey=:default)
-    self.db = Persistence::dbs[dbkey]
-    self.db.execute(table_decl)
-    @creation_callbacks.each {|func| func.call}
-  end
-
-  def db
-    @db || Persistence::db
-  end
-
-  def db=(d)
-    @db = d
-  end
-
-  # Ensure that all the necessary accessors on our class instance are defined 
-  # and that all metaclass fields have the appropriate values
-  def ensure_accessors
-    # Define singleton accessors
-    if not self.respond_to? :columns
-      class << self
-        # Arrays of columns, column names, and column constraints.
-        # Note that colnames does not contain id, created, or updated.
-        # The API purposefully does not expose the ability to create a
-        # row with a given id, and created and updated values are
-        # maintained automatically by the API.
-        attr_accessor :columns, :colnames, :constraints, :dirtied, :refs, :creation_callbacks
-      end
-    end
-
-    # Ensure singleton fields are initialized
-    self.columns ||= [Column.new(:row_id, :integer, [:primary_key]), Column.new(:created, :integer, []), Column.new(:updated, :integer, [])]
-    self.colnames ||= Set.new [:created, :updated]
-    self.constraints ||= []
-    self.dirtied ||= {}
-    self.refs ||= {}
-    self.creation_callbacks ||= []
-  end
-
-  # Returns the number of rows in the table backing this class
-  def count
-    result = self.db.execute("select count(row_id) from #{table_name}")[0]
-    result[0].to_i
-  end
-
-  def find_tuple(id)
-    res = self.db.execute("select * from #{table_name} where row_id = ?", id)
-    if res.size == 0
-      nil
-    else
-      res[0]
-    end
-  end
-end
-
-module Persisting
-  def self.included(other)
-    class << other
-      include PersistingClassMixins
-    end
-
-    other.class_eval do
-      attr_reader :row_id
-      attr_reader :created
-      attr_reader :updated
-    end
-  end
-  
-  def db
-    self.class.db
-  end
-  
-  # Returns true if the row backing this object has been deleted from the database
-  def deleted?
-    freshen
-    not @tuple
-  end
-  
-  # Initializes a new instance backed by a tuple of values.  Do not call this directly. 
-  # Create new instances with the create or find methods.
-  def initialize(tup)
-    @backed = true
-    @tuple = tup
-    mark_fresh
-    @row_id = @tuple["row_id"]
-    @created = @tuple["created"]
-    @updated = @tuple["updated"]
-    resolve_referents
-    self.class.dirtied[@row_id] ||= @expired_after
-    self
-  end
-  
-  # Deletes the row corresponding to this object from the database; 
-  # invalidates =self= and any other objects backed by this row
-  def delete
-    self.db.execute("delete from #{self.class.table_name} where row_id = ?", @row_id)
-    mark_dirty
-    @tuple = nil
-    @row_id = nil
-  end
-
-  ## Begin private methods
-
-  private
-  
-  # Fetches updated attribute values from the database if necessary
-  def freshen
-    if needs_refresh?
-      @tuple = self.class.find_tuple(@row_id)
-      if @tuple
-        @updated = @tuple["updated"]
-      else
-        @row_id = @updated = @created = nil
-      end
-      mark_fresh
-      resolve_referents
-    end
-  end
-  
-  # True if the underlying row in the database is inconsistent with the state 
-  # of this object, whether because the row has changed, or because this object has no row id
-  def needs_refresh?
-    if not @row_id 
-      @tuple != nil
-    else
-      @expired_after < self.class.dirtied[@row_id]
-    end
-  end
-  
-  # Mark this row as dirty so that any other objects backed by this row will 
-  # update from the database before their attributes are inspected
-  def mark_dirty
-    self.class.dirtied[@row_id] = SQLBUtil::timestamp
-  end
-  
-  # Mark this row as consistent with the underlying database as of now
-  def mark_fresh
-    @expired_after = SQLBUtil::timestamp
-  end
-  
-  # Helper method to update the row in the database when one of our fields changes
-  def update(attr_name, value)
-    mark_dirty
-    self.db.execute("update #{self.class.table_name} set #{attr_name} = ?, updated = ? where row_id = ?", value, SQLBUtil::timestamp, @row_id)
-  end
-  
-  # Resolve any fields that reference other tables, replacing row ids with referred objects
-  def resolve_referents
-    refs = self.class.refs
-
-    refs.each do |c,r|
-      c = c.to_s
-      if r.referent == self.class and @tuple[c] == row_id
-        @tuple[c] = self
-      else
-        row = r.referent.find @tuple[c]
-        @tuple[c] = row if row
-      end
-    end
-  end
-
-end
-
-end

data/test/test_rhubarb.rb

@@ -1,632 +0,0 @@
-# Test cases for Rhubarb, which is is a simple persistence layer for
-# Ruby objects and SQLite.
-#
-# Copyright (c) 2009 Red Hat, Inc.
-#
-# Author:  William Benton (willb@redhat.com)
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-require 'rhubarb/rhubarb'
-require 'test/unit'
-
-class TestClass 
-  include Rhubarb::Persisting  
-  declare_column :foo, :integer
-  declare_column :bar, :string
-end
-
-module RhubarbNamespace
-  class NMTC
-    include Rhubarb::Persisting  
-    declare_column :foo, :integer
-    declare_column :bar, :string
-  end
-
-  class NMTC2
-    include Rhubarb::Persisting  
-    declare_column :foo, :integer
-    declare_column :bar, :string
-    declare_table_name('namespacetestcase')
-  end
-end
-
-class TestClass2 
-  include Rhubarb::Persisting  
-  declare_column :fred, :integer
-  declare_column :barney, :string
-  declare_index_on :fred
-end
-
-class TC3 
-  include Rhubarb::Persisting  
-  declare_column :ugh, :datetime
-  declare_column :yikes, :integer
-  declare_constraint :yikes_pos, check("yikes >= 0")
-end
-
-class TC4 
-  include Rhubarb::Persisting  
-  declare_column :t1, :integer, references(TestClass)
-  declare_column :t2, :integer, references(TestClass2)
-  declare_column :enabled, :boolean, :default, :true
-end
-
-class SelfRef 
-  include Rhubarb::Persisting  
-  declare_column :one, :integer, references(SelfRef)
-end
-
-class CustomQueryTable 
-  include Rhubarb::Persisting  
-  declare_column :one, :integer
-  declare_column :two, :integer
-  declare_query :ltcols, "one < two"
-  declare_query :ltvars, "one < ? and two < ?"
-  declare_custom_query :cltvars, "select * from __TABLE__ where one < ? and two < ?"
-end
-
-class ToRef 
-  include Rhubarb::Persisting  
-  declare_column :foo, :string
-end
-
-class FromRef 
-  include Rhubarb::Persisting 
-  declare_column :t, :integer, references(ToRef, :on_delete=>:cascade)
-end
-
-class FreshTestTable 
-  include Rhubarb::Persisting
-  declare_column :fee, :integer
-  declare_column :fie, :integer
-  declare_column :foe, :integer
-  declare_column :fum, :integer
-end
-
-class BackendBasicTests < Test::Unit::TestCase
-  def setup
-    Rhubarb::Persistence::open(":memory:")
-    klasses = []
-    klasses << TestClass
-    klasses << TestClass2
-    klasses << TC3
-    klasses << TC4
-    klasses << SelfRef
-    klasses << CustomQueryTable
-    klasses << ToRef
-    klasses << FromRef
-    klasses << FreshTestTable
-    klasses << RhubarbNamespace::NMTC
-    klasses << RhubarbNamespace::NMTC2
-
-    klasses.each { |klass| klass.create_table }
-
-    @flist = []
-  end
-
-  def teardown
-    Rhubarb::Persistence::close()
-  end
-
-  def test_persistence_setup
-    assert Rhubarb::Persistence::db.type_translation, "type translation not enabled for db"
-    assert Rhubarb::Persistence::db.results_as_hash, "rows-as-hashes not enabled for db"
-  end
-
-  def test_reference_ctor_klass
-    r = Rhubarb::Reference.new(TestClass)
-    assert(r.referent == TestClass, "Referent of managed reference instance incorrect")
-    assert(r.column == "row_id", "Column of managed reference instance incorrect")
-    assert(r.to_s == "references TestClass(row_id)", "string representation of managed reference instance incorrect")
-    assert(r.managed_ref?, "managed reference should return true for managed_ref?")
-  end
-
-  def test_namespace_table_name
-    assert_equal "nmtc", RhubarbNamespace::NMTC.table_name
-  end
-
-  def test_set_table_name
-    assert_equal "namespacetestcase", RhubarbNamespace::NMTC2.table_name
-  end
-
-  def test_reference_ctor_string
-    r = Rhubarb::Reference.new("TestClass")
-    assert(r.referent == "TestClass", "Referent of string-backed reference instance incorrect")
-    assert(r.column == "row_id", "Column of string-backed reference instance incorrect")
-    assert(r.to_s == "references TestClass(row_id)", "string representation of string-backed reference instance incorrect")
-    assert(r.managed_ref? == false, "unmanaged reference should return false for managed_ref?")
-  end
-
-  def test_instance_methods
-    ["foo", "bar"].each do |prefix|
-      ["#{prefix}", "#{prefix}="].each do |m|
-        assert TestClass.instance_methods.include?(m), "#{m} method not declared in TestClass"
-      end
-    end
-  end
-
-  def test_instance_methods2
-    ["fred", "barney"].each do |prefix|
-      ["#{prefix}", "#{prefix}="].each do |m|
-        assert TestClass2.instance_methods.include?(m), "#{m} method not declared in TestClass2"
-      end
-    end
-  end
-
-  def test_instance_methods_neg
-    ["fred", "barney"].each do |prefix|
-      ["#{prefix}", "#{prefix}="].each do |m|
-        bogus_include = TestClass.instance_methods.include? m
-        assert(bogus_include == false, "#{m} method declared in TestClass; shouldn't be")
-      end
-    end
-  end
-
-  def test_instance_methods_dont_include_class_methods
-    ["foo", "bar"].each do |prefix|
-      ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
-        bogus_include = TestClass.instance_methods.include? m
-        assert(bogus_include == false, "#{m} method declared in TestClass; shouldn't be")
-      end
-    end
-  end
-
-  def test_class_methods
-    ["foo", "bar"].each do |prefix|
-      ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
-        klass = class << TestClass; self end
-        assert klass.instance_methods.include?(m), "#{m} method not declared in TestClass' eigenclass"
-      end
-    end
-  end
-  
-  def test_class_methods2
-    ["fred", "barney"].each do |prefix|
-      ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
-        klass = class << TestClass2; self end
-        assert klass.instance_methods.include?(m), "#{m} method not declared in TestClass2's eigenclass"
-      end
-    end
-  end
-    
-  def test_table_class_methods_neg
-    ["foo", "bar", "fred", "barney"].each do |prefix|
-      ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
-        klass = Class.new
-
-        klass.class_eval do
-          include Rhubarb::Persisting
-        end
-
-        bogus_include = klass.instance_methods.include?(m)
-        assert(bogus_include == false, "#{m} method declared in eigenclass of class including Rhubarb::Persisting; shouldn't be")
-      end
-    end
-  end
-
-  def test_class_methods_neg
-    ["fred", "barney"].each do |prefix|
-      ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
-        klass = class << TestClass; self end
-        bogus_include = klass.instance_methods.include?(m)
-        assert(bogus_include == false, "#{m} method declared in TestClass' eigenclass; shouldn't be")
-      end
-    end
-  end
-
-  def test_column_size
-    assert(TestClass.columns.size == 5, "TestClass has wrong number of columns")
-  end
-
-  def test_tc2_column_size
-    assert(TestClass2.columns.size == 5, "TestClass2 has wrong number of columns")
-  end
-
-  def test_table_column_size
-    klass = Class.new
-    klass.class_eval do
-      include Rhubarb::Persisting
-    end
-    if klass.respond_to? :columns
-      assert(Frotz.columns.size == 0, "A persisting class with no declared columns has the wrong number of columns")
-    end
-  end
-
-  def test_constraints_size
-    k = Class.new
-    
-    k.class_eval do
-      include Rhubarb::Persisting
-    end
-    
-    {k => 0, TestClass => 0, TestClass2 => 0, TC3 => 1}.each do |klass, cts|
-      if klass.respond_to? :constraints
-        assert(klass.constraints.size == cts, "#{klass} has wrong number of constraints")
-      end
-    end
-  end
-
-  def test_cols_and_constraints_understood
-    [TestClass, TestClass2, TC3, TC4].each do |klass|
-      assert(klass.respond_to?(:constraints), "#{klass} should have accessor for constraints")
-      assert(klass.respond_to?(:columns), "#{klass} should have accessor for columns")
-    end
-  end
-
-  def test_column_contents
-    [:row_id, :foo, :bar].each do |col|
-      assert(TestClass.columns.map{|c| c.name}.include?(col), "TestClass doesn't contain column #{col}")
-    end
-  end
-  
-  def test_create_proper_type
-    tc = TestClass.create(:foo => 1, :bar => "argh")
-    assert(tc.class == TestClass, "TestClass.create should return an instance of TestClass")
-  end
-
-  def test_create_multiples
-    tc_list = [nil]
-    1.upto(9) do |num|
-      tc_list.push TestClass.create(:foo => num, :bar => "argh#{num}")
-    end
-
-    1.upto(9) do |num|
-      assert(tc_list[num].foo == num, "multiple TestClass.create invocations should return records with proper foo values")
-      assert(tc_list[num].bar == "argh#{num}", "multiple TestClass.create invocations should return records with proper bar values")
-
-      tmp = TestClass.find(num)
-
-      assert(tmp.foo == num, "multiple TestClass.create invocations should add records with proper foo values to the db")
-      assert(tmp.bar == "argh#{num}", "multiple TestClass.create invocations should add records with proper bar values to the db")
-    end
-  end
-
-  def test_delete
-    range = []
-    1.upto(9) do |num|
-      range << num
-      TestClass.create(:foo => num, :bar => "argh#{num}")
-    end
-    
-    assert(TestClass.count == range.size, "correct number of rows inserted prior to delete")
-
-    TestClass.find(2).delete
-
-    assert(TestClass.count == range.size - 1, "correct number of rows inserted after delete")
-  end
-
-  def test_delete_2
-    TestClass.create(:foo => 42, :bar => "Wait, what was the question?")
-    tc1 = TestClass.find_first_by_foo(42)
-    tc2 = TestClass.find_first_by_foo(42)
-    
-    [tc1,tc2].each do |obj|
-      assert obj
-      assert_kind_of TestClass, obj
-      assert_equal false, obj.instance_eval {needs_refresh?}
-    end
-    
-    [:foo, :bar, :row_id].each do |msg|
-      assert_equal tc1.send(msg), tc2.send(msg)
-    end
-    
-    tc1.delete
-    
-    tc3 = TestClass.find_by_foo(42)
-    assert_equal [], tc3
-
-    tc3 = TestClass.find_first_by_foo(42)
-    assert_equal nil, tc3
-    
-    [tc1, tc2].each do |obj|
-      assert obj.deleted?
-      [:foo, :bar, :row_id].each do |msg|
-        assert_equal nil, obj.send(msg)
-      end
-    end
-  end
-
-  def test_count_base
-    assert(TestClass.count == 0, "a new table should have no rows")
-  end
-
-  def test_count_inc
-    1.upto(9) do |num|
-      TestClass.create(:foo => num, :bar => "argh#{num}")
-      assert(TestClass.count == num, "table row count should increment after each row create")
-    end
-  end
-
-  def test_create_proper_values
-    vals = {:foo => 1, :bar => "argh"}
-    tc = TestClass.create(vals)
-    assert(tc.foo == 1, "tc.foo (newly-created) should have the value 1")
-    assert(tc.bar == "argh", "tc.bar (newly-created) should have the value \"argh\"")
-  end
-  
-  def test_create_and_find_by_id
-    vals = {:foo => 2, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc = TestClass.find(1)
-    assert(tc.foo == 2, "tc.foo (found by id) should have the value 2")
-    assert(tc.bar == "argh", "tc.bar (found by id) should have the value \"argh\"")
-  end
-
-  def test_find_by_id_bogus
-    tc = TestClass.find(1)
-    assert(tc == nil, "TestClass table should be empty")
-  end
-
-  def test_create_and_find_by_foo
-    vals = {:foo => 2, :bar => "argh"}
-    TestClass.create(vals)
-    
-    result = TestClass.find_by_foo(2)
-    tc = result[0]
-    assert(result.size == 1, "TestClass.find_by_foo(2) should return exactly one result")
-    assert(tc.foo == 2, "tc.foo (found by foo) should have the value 2")
-    assert(tc.bar == "argh", "tc.bar (found by foo) should have the value \"argh\"")
-  end
-
-  def test_create_and_find_first_by_foo
-    vals = {:foo => 2, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc = (TestClass.find_first_by_foo(2))
-    assert(tc.foo == 2, "tc.foo (found by foo) should have the value 2")
-    assert(tc.bar == "argh", "tc.bar (found by foo) should have the value \"argh\"")
-  end
-
-  def test_create_and_find_by_bar
-    vals = {:foo => 2, :bar => "argh"}
-    TestClass.create(vals)
-    result = TestClass.find_by_bar("argh")
-    tc = result[0]
-    assert(result.size == 1, "TestClass.find_by_bar(\"argh\") should return exactly one result")
-    assert(tc.foo == 2, "tc.foo (found by bar) should have the value 2")
-    assert(tc.bar == "argh", "tc.bar (found by bar) should have the value \"argh\"")
-  end
-  
-  def test_create_and_find_first_by_bar
-    vals = {:foo => 2, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc = (TestClass.find_first_by_bar("argh"))
-    assert(tc.foo == 2, "tc.foo (found by bar) should have the value 2")
-    assert(tc.bar == "argh", "tc.bar (found by bar) should have the value \"argh\"")
-  end
-  
-  def test_create_and_update_modifies_object
-    vals = {:foo => 1, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc = TestClass.find(1)
-    tc.foo = 2
-    assert("#{tc.foo}" == "2", "tc.foo should have the value 2 after modifying object")
-  end
-  
-  def test_create_and_update_modifies_db
-    vals = {:foo => 1, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc = TestClass.find(1)
-    tc.foo = 2
-    
-    tc_fresh = TestClass.find(1)
-    assert(tc_fresh.foo == 2, "foo value in first row of db should have the value 2 after modifying tc object")
-  end
-  
-  def test_create_and_update_freshen
-    vals = {:foo => 1, :bar => "argh"}
-    TestClass.create(vals)
-    
-    tc_fresh = TestClass.find(1)    
-    tc = TestClass.find(1)
-    
-    tc.foo = 2
-    
-    assert(tc_fresh.foo == 2, "object backed by db row isn't freshened")
-  end
-  
-  def test_reference_tables
-    assert(TC4.refs.size == 2, "TC4 should have 2 refs, instead has #{TC4.refs.size}")
-  end
-
-  def test_reference_classes
-    t_vals = []
-    t2_vals = []
-    
-    1.upto(9) do |n| 
-      t_vals.push({:foo => n, :bar => "item-#{n}"})
-      TestClass.create t_vals[-1]
-    end
-
-    9.downto(1) do |n| 
-      t2_vals.push({:fred => n, :barney => "barney #{n}"})
-      TestClass2.create t2_vals[-1]
-    end
-
-    1.upto(9) do |n|
-      m = 10-n
-      k = TC4.create(:t1 => n, :t2 => m)
-      assert(k.t1.class == TestClass, "k.t1.class is #{k.t1.class}; should be TestClass")
-      assert(k.t2.class == TestClass2, "k.t2.class is #{k.t2.class}; should be TestClass2")
-      assert(k.enabled)
-      k.enabled = false
-      assert(k.enabled==false)
-    end
-  end
-
-  def test_references_simple
-    t_vals = []
-    t2_vals = []
-    
-    1.upto(9) do |n| 
-      t_vals.push({:foo => n, :bar => "item-#{n}"})
-      TestClass.create t_vals[-1]
-    end
-
-    9.downto(1) do |n| 
-      t2_vals.push({:fred => n, :barney => "barney #{n}"})
-      TestClass2.create t2_vals[-1]
-    end
-
-    1.upto(9) do |n|
-      k = TC4.create(:t1 => n, :t2 => (10 - n))
-      assert(k.t1.foo == k.t2.fred, "references don't work")
-    end
-  end
-
-  def test_references_sameclass
-    SelfRef.create :one => nil
-    1.upto(3) do |num|
-      SelfRef.create :one => num
-    end
-    4.downto(2) do |num|
-      sr = SelfRef.find num
-      assert(sr.one.class == SelfRef, "SelfRef with row ID #{num} should have a one field of type SelfRef; is #{sr.one.class} instead")
-      assert(sr.one.row_id == sr.row_id - 1, "SelfRef with row ID #{num} should have a one field with a row id of #{sr.row_id - 1}; is #{sr.one.row_id} instead")
-    end
-  end
-  
-  def test_references_circular_id
-    sr = SelfRef.create :one => nil
-    sr.one = sr.row_id
-    assert(sr == sr.one, "self-referential rows should work; instead #{sr} isn't the same as #{sr.one}")
-  end
-
-  def test_references_circular_obj
-    sr = SelfRef.create :one => nil
-    sr.one = sr
-    assert(sr == sr.one, "self-referential rows should work; instead #{sr} isn't the same as #{sr.one}")
-  end
-
-  def test_referential_integrity
-    assert_raise SQLite3::SQLException do 
-      FromRef.create(:t => 42)
-    end
-    
-    assert_nothing_thrown do
-      1.upto(20) do |x|
-        ToRef.create(:foo => "#{x}")
-        FromRef.create(:t => x)
-        assert_equal ToRef.count, FromRef.count
-      end
-    end
-    
-    20.downto(1) do |x|
-      ct = ToRef.count
-      tr = ToRef.find(x)
-      tr.delete
-      assert_equal ToRef.count, ct - 1
-      assert_equal ToRef.count, FromRef.count
-    end
-  end
-
-  def test_custom_query
-    colresult = 0
-    varresult = 0
-    
-    1.upto(20) do |i|
-      1.upto(20) do |j|
-        CustomQueryTable.create(:one => i, :two => j)
-        colresult = colresult.succ if i < j
-        varresult = varresult.succ if i < 5 && j < 7
-      end
-    end
-
-    f = CustomQueryTable.ltcols
-    assert(f.size() == colresult, "f.size() should equal colresult, but #{f.size()} != #{colresult}")
-    f.each {|r| assert(r.one < r.two, "#{r.one}, #{r.two} should only be in ltcols custom query if #{r.one} < #{r.two}") }
-
-    f = CustomQueryTable.ltvars 5, 7
-    f2 = CustomQueryTable.cltvars 5, 7
-    
-    [f,f2].each do |obj|
-      assert(obj.size() == varresult, "query result size should equal varresult, but #{obj.size()} != #{varresult}")
-      obj.each {|r| assert(r.one < 5 && r.two < 7, "#{r.one}, #{r.two} should only be in ltvars/cltvars custom query if #{r.one} < 5 && #{r.two} < 7") }
-    end
-    
-  end
-
-  def freshness_query_fixture
-    @flist = []
-    
-    0.upto(99) do |x|
-      @flist << FreshTestTable.create(:fee=>x, :fie=>(x%7), :foe=>(x%11), :fum=>(x%13))
-    end
-  end
-
-  def test_freshness_query_basic
-    freshness_query_fixture
-    # basic test
-    basic = FreshTestTable.find_freshest(:group_by=>[:fee])
-    
-    assert_equal(@flist.size, basic.size)
-    0.upto(99) do |x|
-      [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
-        assert_equal(@flist[x].send(msg), basic[x].send(msg))
-      end
-    end
-  end
-
-  def test_freshness_query_basic_restricted
-    freshness_query_fixture
-    # basic test
-
-    basic = FreshTestTable.find_freshest(:group_by=>[:fee], :version=>@flist[30].created, :debug=>true)
-    
-    assert_equal(31, basic.size)
-    0.upto(30) do |x|
-      [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
-        assert_equal(@flist[x].send(msg), basic[x].send(msg))
-      end
-    end
-  end
-
-  def test_freshness_query_basic_select
-    freshness_query_fixture
-    # basic test
-
-    basic = FreshTestTable.find_freshest(:group_by=>[:fee], :select_by=>{:fie=>0}, :debug=>true)
-
-    expected_ct = 99/7 + 1;
-
-    assert_equal(expected_ct, basic.size)
-
-    0.upto(expected_ct - 1) do |x|
-      [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
-        assert_equal(@flist[x*7].send(msg), basic[x].send(msg))
-      end
-    end
-  end
-
-  def test_freshness_query_group_single
-    freshness_query_fixture
-    # more basic tests
-    pairs = {:fie=>7,:foe=>11,:fum=>13}
-    pairs.each do |col,ct|
-      basic = FreshTestTable.find_freshest(:group_by=>[col])
-      assert_equal(ct,basic.size)
-
-      expected_objs = {}
-
-      99.downto(99-ct+1) do |x|
-        expected_objs[x%ct] = @flist[x]
-      end
-
-      basic.each do |row|
-        res = expected_objs[row.send(col)]
-        [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
-          assert_equal(res.send(msg), row.send(msg))
-        end
-      end
-    end
-  end
-end