rhubarb 0.2.7 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.7
+0.3.0

data/lib/rhubarb/classmixins.rb

@@ -19,8 +19,14 @@ module Rhubarb
     PCM_OUTPUT_TRANSFORMERS = {:object=>Util.deswizzle_object_proc, :zblob=>Util.dezblobify_proc, }
     # Returns the name of the database table modeled by this class.
     # Defaults to the name of the class (sans module names)
-    def table_name
+    def table_name(quoted=false)
       @table_name ||= self.name.split("::").pop.downcase  
+      @quoted_table_name ||= "'#{@table_name}'"
+      quoted ? @quoted_table_name : @table_name
+    end
+
+    def quoted_table_name
+      table_name(true)
     end
 
     # Enables setting the table name to a custom name
@@ -56,19 +62,19 @@ module Rhubarb
       valid_cols = self.colnames.intersection arg_hash.keys
       select_criteria = valid_cols.map {|col| "#{col.to_s} = #{col.inspect}"}.join(" AND ")
       arg_hash.each {|key,val| arg_hash[key] = val.row_id if val.respond_to? :row_id}
-      db.do_query("select * from #{table_name} where #{select_criteria} order by row_id", arg_hash) {|tup| results << self.new(tup) }
+      db.do_query("select * from #{quoted_table_name} where #{select_criteria} order by row_id", arg_hash) {|tup| results << self.new(tup) }
       results
     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
       results = []
-      db.do_query("SELECT * from #{table_name}") {|tup| results << self.new(tup)}
+      db.do_query("SELECT * from #{quoted_table_name}") {|tup| results << self.new(tup)}
       results
     end
 
     def delete_all
-      db.do_query("DELETE from #{table_name}")
+      db.do_query("DELETE from #{quoted_table_name}")
     end
 
     def delete_where(arg_hash)
@@ -76,7 +82,7 @@ module Rhubarb
       valid_cols = self.colnames.intersection arg_hash.keys
       select_criteria = valid_cols.map {|col| "#{col.to_s} = #{col.inspect}"}.join(" AND ")
       arg_hash.each {|key,val| arg_hash[key] = val.row_id if val.respond_to? :row_id}
-      db.do_query("DELETE FROM #{table_name} WHERE #{select_criteria}", arg_hash)
+      db.do_query("DELETE FROM #{quoted_table_name} WHERE #{select_criteria}", arg_hash)
     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.
@@ -87,7 +93,7 @@ module Rhubarb
     # 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)
-      processed_query = query.gsub("__TABLE__", "#{self.table_name}")
+      processed_query = query.gsub("__TABLE__", "#{self.quoted_table_name}")
       
       klass.class_eval do
         define_method name.to_s do |*args|
@@ -113,7 +119,7 @@ module Rhubarb
     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(', ')})"
+        creation_cmd = "create index #{idx_name} on #{self.quoted_table_name} (#{fields.join(', ')})"
         self.db.execute(creation_cmd)
       end if fields.size > 0
     end
@@ -127,7 +133,7 @@ module Rhubarb
 
       find_method_name = "find_by_#{cname}".to_sym
       find_first_method_name = "find_first_by_#{cname}".to_sym
-      find_query = "select * from #{table_name} where #{cname} = ? order by row_id"
+      find_query = "select * from #{quoted_table_name} where \"#{cname}\" = ? order by row_id"
 
       get_method_name = "#{cname}".to_sym
       set_method_name = "#{cname}=".to_sym
@@ -173,8 +179,9 @@ module Rhubarb
         xform = PCM_INPUT_TRANSFORMERS[kind]
         
         define_method set_method_name do |arg|
-          @tuple["#{cname}"] = xform ? xform.call(arg) : arg
-          update cname, arg
+          new_val = xform ? xform.call(arg) : arg
+          @tuple["#{cname}"] = new_val
+          update cname, new_val
         end      
       else
         # this column references another table; create a set 
@@ -202,15 +209,16 @@ module Rhubarb
         # not expose the capacity to change row IDs.
         
         rtable = rf.referent.table_name
+        qrtable = rf.referent.quoted_table_name
 
         self.creation_callbacks << Proc.new do   
           @ccount ||= 0
 
           insert_trigger_name, delete_trigger_name = %w{insert delete}.map {|op| "ri_#{op}_#{self.table_name}_#{@ccount}_#{rtable}" } 
 
-          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 \"#{rtable}\" WHERE new.\"#{cname}\" == \"#{rf.column}\") BEGIN SELECT RAISE(ABORT, 'constraint #{insert_trigger_name} (#{rtable} missing foreign key row) failed'); END;")
+          self.db.execute_batch("CREATE TRIGGER #{insert_trigger_name} BEFORE INSERT ON #{quoted_table_name} WHEN new.\"#{cname}\" IS NOT NULL AND NOT EXISTS (SELECT 1 FROM #{qrtable} WHERE new.\"#{cname}\" == \"#{rf.column}\") BEGIN SELECT RAISE(ABORT, 'constraint #{insert_trigger_name} (#{rtable} missing foreign key row) failed'); END;")
 
-          self.db.execute_batch("CREATE TRIGGER #{delete_trigger_name} BEFORE DELETE ON \"#{rtable}\" 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
+          self.db.execute_batch("CREATE TRIGGER #{delete_trigger_name} BEFORE DELETE ON #{qrtable} WHEN EXISTS (SELECT 1 FROM #{quoted_table_name} WHERE old.\"#{rf.column}\" == \"#{cname}\") BEGIN DELETE FROM #{quoted_table_name} WHERE \"#{cname}\" = old.\"#{rf.column}\"; END;") if rf.options[:on_delete] == :cascade
 
           @ccount = @ccount + 1
         end
@@ -230,8 +238,8 @@ module Rhubarb
       new_row = args[0]
       new_row[:created] = new_row[:updated] = Util::timestamp
 
-      cols = colnames.intersection new_row.keys
-      colspec, valspec = [:to_s, :inspect].map {|msg| (cols.map {|col| col.send(msg)}).join(", ")}
+      colspec, valspec = cvspecs[new_row.keys]
+
       res = nil
 
       # resolve any references in the args
@@ -240,7 +248,7 @@ module Rhubarb
         new_row[column] = xform ? xform.call(value) : Util::rhubarb_fk_identity(value)
       end
 
-      create_text = "insert into #{table_name} (#{colspec}) values (#{valspec})"
+      create_text = "insert into #{quoted_table_name} (#{colspec}) values (#{valspec})"
       db.do_query(create_text, new_row)
       
       res = find(db.last_insert_row_id)
@@ -252,11 +260,12 @@ module Rhubarb
     # corresponding to this class. 
     def table_decl
       ddlspecs = [columns.join(", "), constraints.join(", ")].reject {|str| str.size==0}.join(", ")
-      "create table #{table_name} (#{ddlspecs});"
+      "create table #{quoted_table_name} (#{ddlspecs});"
     end
 
     # Creates a table in the database corresponding to this class.
     def create_table(dbkey=:default)
+      ensure_accessors
       self.db ||= Persistence::dbs[dbkey] unless @explicitdb
       self.db.execute(table_decl)
       @creation_callbacks.each {|func| func.call}
@@ -298,16 +307,23 @@ module Rhubarb
 
     # Returns the number of rows in the table backing this class
     def count
-      self.db.get_first_value("select count(row_id) from #{table_name}").to_i
+      self.db.get_first_value("select count(row_id) from #{quoted_table_name}").to_i
     end
 
     def find_tuple(tid)
-      ft_text = "select * from #{table_name} where row_id = ?"
+      ft_text = "select * from #{quoted_table_name} where row_id = ?"
       result = nil
       db.do_query(ft_text, tid) {|tup| result = tup; break}
       result
     end
     
+    def cvspecs
+      @cvspecs ||= Hash.new do |h,new_row_keys|
+        cols = colnames.intersection new_row_keys
+        h[new_row_keys] = [Proc.new {|f| f.to_s.inspect}, Proc.new {|f| f.inspect}].map {|p| (cols.map {|col| p.call(col)}).join(", ")}
+      end
+    end
+    
     include FindFreshest
     
   end

data/lib/rhubarb/column.rb

@@ -23,9 +23,9 @@ module Rhubarb
     def to_s
       qualifiers = @quals.join(" ")
       if qualifiers == ""
-        "#@name #@kind"
+        "'#@name' #@kind"
       else
-        "#@name #@kind #{qualifiers}"
+        "'#@name' #@kind #{qualifiers}"
       end
     end
   end

data/lib/rhubarb/mixins/freshness.rb

@@ -51,9 +51,9 @@ module Rhubarb
       query = "
   SELECT __freshest.* FROM (
     SELECT #{projection.to_a.join(', ')} FROM (
-      SELECT * from #{table_name} #{where_clause}
+      SELECT * from #{quoted_table_name} #{where_clause}
     ) #{group_by_clause}
-  ) as __fresh INNER JOIN #{table_name} as __freshest ON #{join_clause} ORDER BY row_id"
+  ) as __fresh INNER JOIN #{quoted_table_name} as __freshest ON #{join_clause} ORDER BY row_id"
       self.db.execute(query, query_params).map {|tup| self.new(tup) }
     end
   end

data/lib/rhubarb/persisting.rb

@@ -23,6 +23,10 @@ module Rhubarb
         attr_reader :created
         attr_reader :updated
       end
+      
+      other.instance_eval do
+        private_class_method :ensure_accessors
+      end
     end
 
     def db
@@ -62,7 +66,7 @@ module Rhubarb
     # Deletes the row corresponding to this object from the database; 
     # invalidates =self= and any other objects backed by this row
     def delete
-      db.do_query("delete from #{self.class.table_name} where row_id = ?", @row_id)
+      db.do_query("delete from #{self.class.quoted_table_name} where row_id = ?", @row_id)
       mark_dirty
       @tuple = nil
       @row_id = nil
@@ -119,7 +123,7 @@ module Rhubarb
     def update(attr_name, value)
       mark_dirty
 
-      db.do_query("update #{self.class.table_name} set #{attr_name} = ?, updated = ? where row_id = ?", value, Util::timestamp, @row_id)
+      db.do_query("update #{self.class.quoted_table_name} set '#{attr_name}' = ?, updated = ? where row_id = ?", value, Util::timestamp, @row_id)
     end
 
     # Resolve any fields that reference other tables, replacing row ids with referred objects

data/ruby-rhubarb.spec.in

@@ -1,5 +1,5 @@
 %{!?ruby_sitelib: %global ruby_sitelib %(ruby -rrbconfig -e 'puts Config::CONFIG["sitelibdir"] ')}
-%define rel 1.0
+%define rel 1
 
 Summary: Simple versioned object-graph persistence layer
 Name: ruby-rhubarb
@@ -48,6 +48,10 @@ rm -rf %{buildroot}
 %{ruby_sitelib}/rhubarb/persistence.rb
 
 %changelog
+* Wed Sep 15 2010 willb <willb@redhat> - 0.2.7-1
+- Updated to version 0.2.7
+- fixed problems with hash-valued params in custom queries
+
 * Wed Apr 28 2010 willb <willb@redhat> - 0.2.6-1.0
 - Updated to version 0.2.6
 

data/test/test_rhubarb.rb

@@ -119,6 +119,25 @@ class ObjectTestTable
   declare_column :obj, :object
 end
 
+class NoColumnsTestTable
+  include Rhubarb::Persisting
+end
+
+class Create
+  include Rhubarb::Persisting
+  declare_column :name, :string
+end
+
+class Group
+  include Rhubarb::Persisting
+  declare_column :other, :int, references(Create, :on_delete=>:cascade)
+end
+
+class Order
+  include Rhubarb::Persisting
+  declare_column :group, :int
+end
+
 class PreparedStmtBackendTests < Test::Unit::TestCase  
   def dbfile
     ENV['RHUBARB_TEST_DB'] || ":memory:"
@@ -159,6 +178,44 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     Rhubarb::Persistence::close()
   end
 
+  def test_reserved_word_table
+    assert_nothing_raised do
+      Create.create_table
+      Create.create(:name=>"bar")
+      c = Create.find_first_by_name("bar")
+      c.name = "blah"
+      c.name = "bar"
+      assert(c.name == "bar")
+      c.delete
+    end
+  end
+  
+  def test_reserved_word_column
+    assert_nothing_raised do
+      Order.create_table
+      Order.create(:group=>42)
+      o = Order.find_first_by_group(42)
+      o.group = 37
+      assert(o.group == 37)
+    end
+  end
+
+  def test_reserved_word_fk_table
+    assert_nothing_raised do
+      Create.create_table
+      Group.create_table
+      Create.create(:name=>"bar")
+      Group.create(:other=>Create.create(:name=>"blah"))
+      assert(Group.find_all[0].other.name=="blah")
+    end
+  end
+
+  def test_no_columns_table
+    assert_nothing_raised do
+      NoColumnsTestTable.create_table      
+    end
+  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"
@@ -833,6 +890,42 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     assert_equal(text, Zlib::Inflate.inflate(cbtrow.info))
   end
 
+  def test_mutable_object_data
+    things = []
+    
+    words = %w{It is a truth universally acknowledged that a single man in possession of a good fortune must be in want of a wife}
+    
+    100.times do
+      things << words.sort_by {rand}
+    end
+    
+    things.each_with_index do |thing, idx|
+      ObjectTestTable.create(:otype=>thing.class.name.to_s, :obj=>thing)
+    end
+    
+    otts = ObjectTestTable.find_all
+    
+    assert_equal otts.size, things.size
+    
+    things.zip(otts) do |thing, ott|
+      assert_equal thing.class.name.to_s, ott.otype
+      assert_equal thing, ott.obj      
+    end
+    
+    otts.each_with_index do |ott, i|
+      obj = ott.obj.reverse
+      ott.obj = obj.dup
+      assert_equal obj, ott.obj
+      assert_equal obj, ObjectTestTable.find(ott.row_id).obj
+      things[i].reverse!
+    end
+    
+    things.zip(otts) do |thing, ott|
+      assert_equal thing.class.name.to_s, ott.otype
+      assert_equal thing, ott.obj      
+    end
+  end
+
 
   def test_object_data
     things = []

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rhubarb
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - William Benton
@@ -9,29 +15,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-31 00:00:00 -05:00
+date: 2011-02-15 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 2
+        - 2
         version: 1.2.2
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: Rhubarb is a simple object-graph persistence library implemented as a mixin.  It also works with the SPQR library for straightforward object publishing over QMF.
 email: willb@redhat.com
 executables: []
@@ -72,21 +90,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: "Rhubarb:  object graph persistence, easy as pie"