rhubarb 0.2.6 → 0.2.7

data/CHANGES

@@ -1,3 +1,8 @@
+version 0.2.7
+
+*  Fix for reference-valued hash-style positional parameters in 
+   custom queries.  Fix for Red Hat BZ 618493.
+
 version 0.2.6
 
 *  Rhubarb now supports starting arbitrary Ruby objects to fields 

data/Rakefile

@@ -109,6 +109,7 @@ end
 Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.libs << 'lib' << 'spec'
   spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov_opts << "-x" << "/usr/lib" << "-x" << ".gem"
   spec.rcov = true
 end
 
@@ -127,6 +128,7 @@ begin
   Rcov::RcovTask.new do |test|
     test.libs << 'test'
     test.pattern = 'test/**/test_*.rb'
+    test.rcov_opts << "-x" << "/usr/lib" << "-x" << ".gem"
     test.verbose = true
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.2.6
+0.2.7

data/lib/rhubarb/classmixins.rb

@@ -55,7 +55,7 @@ module Rhubarb
       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}
+      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) }
       results
     end
@@ -75,7 +75,7 @@ module Rhubarb
       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}
+      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)
     end
 
@@ -92,7 +92,16 @@ module Rhubarb
       klass.class_eval do
         define_method name.to_s do |*args|
           # handle reference parameters
-          args = args.map {|arg| Util::rhubarb_fk_identity(arg)}
+          if args.size == 1 && args[0].is_a?(Hash)
+            args[0].each do |k,v|
+              args[0][k] = Util::rhubarb_fk_identity(v)
+            end
+          else
+            args = args.map do |arg| 
+              raise RuntimeError.new("Hash-valued positional parameters may only appear as named positional parameters.") if arg.is_a?(Hash)
+              Util::rhubarb_fk_identity(arg)
+            end
+          end
           
           results = []
           db.do_query(processed_query, args) {|tup| results << self.new(tup)}
@@ -124,7 +133,7 @@ module Rhubarb
       set_method_name = "#{cname}=".to_sym
 
       # does this column reference another table?
-      rf = quals.find {|q| q.class == Reference}
+      rf = quals.find {|qual| qual.class == Reference}
       if rf
         self.refs[cname] = rf
       end
@@ -154,7 +163,8 @@ module Rhubarb
       define_method get_method_name do
         freshen
         return nil unless @tuple
-        out_xform ? out_xform.call(@tuple[cname.to_s]) : @tuple[cname.to_s]
+        result = @tuple[cname.to_s]
+        out_xform ? out_xform.call(result) : result
       end
 
       if not rf

data/lib/rhubarb/mixins/freshness.rb

@@ -39,24 +39,22 @@ module Rhubarb
       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|
+      join_criteria = projection.map do |column|
         "__fresh.#{column} = __freshest.#{column}"
       end
 
       projection << "MAX(created) AS __current_version"
-      join_clause << "__fresh.__current_version = __freshest.created"
+      join_criteria << "__fresh.__current_version = __freshest.created"
 
+      join_clause = join_criteria.join(' AND ')
+      
       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
-  "
-
+  ) as __fresh INNER JOIN #{table_name} as __freshest ON #{join_clause} ORDER BY row_id"
       self.db.execute(query, query_params).map {|tup| self.new(tup) }
     end
   end
-end
+end

data/lib/rhubarb/util.rb

@@ -27,43 +27,35 @@ module Rhubarb
       (object.row_id if object.class.ancestors.include? Persisting) || object
     end
     
-    def self.blobify(obj)
-      blobify_proc.call(obj)
-    end
-    
     def self.blobify_proc
-      @blobify_proc ||= Proc.new {|x| x.is_a?(SQLite3::Blob) ? x : SQLite3::Blob.new(x)}
+      @blobify_proc ||= Proc.new {|obj| obj.is_a?(SQLite3::Blob) ? obj : SQLite3::Blob.new(obj)}
     end
     
     def self.zblobify_proc
-      @zblobify_proc ||= Proc.new {|x| x.is_a?(SQLite3::Blob) ? x : SQLite3::Blob.new(Zlib::Deflate.deflate(x))}
+      @zblobify_proc ||= Proc.new {|obj| obj.is_a?(SQLite3::Blob) ? obj : SQLite3::Blob.new(Zlib::Deflate.deflate(obj))}
     end
     
     def self.dezblobify_proc
-      @dezblobify_proc ||= Proc.new do |x| 
-        return nil if x.nil? || x == ""
-        Zlib::Inflate.inflate(x)
+      @dezblobify_proc ||= Proc.new do |obj| 
+        return nil if obj.nil? || obj == ""
+        Zlib::Inflate.inflate(obj)
       end
     end
     
     def self.swizzle_object_proc
-      @swizzle_object_proc ||= Proc.new do |x| 
-        yamlrepr = x.to_yaml
+      @swizzle_object_proc ||= Proc.new do |obj| 
+        yamlrepr = obj.to_yaml
         SQLite3::Blob.new(Zlib::Deflate.deflate(yamlrepr, Zlib::BEST_COMPRESSION))
       end
     end
 
     def self.deswizzle_object_proc
-      @deswizzle_object_proc ||= Proc.new do |x|
-        return nil if x.nil? || x == ""
+      @deswizzle_object_proc ||= Proc.new do |zy_obj|
+        return nil if zy_obj.nil? || zy_obj == ""
         
-        z = YAML.load(Zlib::Inflate.inflate(x))
-        z.freeze
+        obj = YAML.load(Zlib::Inflate.inflate(zy_obj))
+        obj.freeze
       end
     end
-
-    def self.identity_proc
-      @identity ||= Proc.new {|x| x}
-    end
   end
 end

data/test/test_rhubarb.rb

@@ -78,9 +78,11 @@ class ToRef
   declare_column :foo, :string
 end
 
-class FromRef 
+class FromRef
   include Rhubarb::Persisting 
   declare_column :t, :integer, references(ToRef, :on_delete=>:cascade)
+  declare_query :to_is, "t = ?"
+  declare_query :to_is_hash, "t = :t"
 end
 
 class FreshTestTable 
@@ -89,6 +91,16 @@ class FreshTestTable
   declare_column :fie, :integer
   declare_column :foe, :integer
   declare_column :fum, :integer
+  declare_column :foo, :integer
+  declare_column :bar, :integer
+  
+  def <=>(other)
+    [:fie,:foe,:fum,:foo,:bar].each do |msg|
+      tmpresult = self.send(msg) <=> other.send(msg)
+      return tmpresult unless tmpresult == 0
+    end
+    return 0
+  end
 end
 
 class BlobTestTable 
@@ -641,6 +653,10 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     assert_equal(tc1, tc1)         # equality is reflexive
     assert_equal(tc1p, tc1)        # even after find operations
     assert_equal(tc1, tc1p)        # ... and it should be symmetric
+
+    assert_equal(tc1.hash, tc1p.hash)
+    assert_not_equal(tc2.hash, tc1p.hash)
+
     assert_not_equal(tc1, tc2)     # these are not identical
     assert_not_equal(tc1p, tc2)    # even after find operations
     assert_not_equal(tc2, tc1p)    # ... and it should be symmetric
@@ -653,10 +669,29 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
 
   def freshness_query_fixture
     @flist = []
-    
-    0.upto(99) do |x|
-      @flist << FreshTestTable.create(:fee=>x, :fie=>(x%7), :foe=>(x%11), :fum=>(x%13))
+    @fresh_fields = [:fee,:fie,:foe,:fum,:foo,:bar,:created,:updated,:row_id]
+    @ffcounts = {:fie=>2, :foe=>3, :fum=>4, :foo=>5, :bar=>6}  
+    
+    x = 0
+    
+    2.times do
+      @ffcounts[:fie].times do |fie|
+        @ffcounts[:foe].times do |foe|
+          @ffcounts[:fum].times do |fum|
+            @ffcounts[:foo].times do |foo|
+              @ffcounts[:bar].times do |bar|
+                row = FreshTestTable.create(:fee=>@flist.size, :fie=>fie, :foe=>foe, :fum=>fum, :foo=>foo, :bar=>bar)
+                assert(row != nil)
+                @flist << row
+              end
+            end
+          end
+        end
+      end
     end
+    
+    @fcount = @flist.size
+    @ffcounts[:fee] = @fcount
   end
 
   def test_freshness_query_basic
@@ -665,8 +700,8 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     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|
+    0.upto(@fcount - 1) do |x|
+      @fresh_fields.each do |msg|
         assert_equal(@flist[x].send(msg), basic[x].send(msg))
       end
     end
@@ -680,7 +715,7 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     
     assert_equal(31, basic.size)
     0.upto(30) do |x|
-      [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
+      @fresh_fields.each do |msg|
         assert_equal(@flist[x].send(msg), basic[x].send(msg))
       end
     end
@@ -690,15 +725,18 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
     freshness_query_fixture
     # basic test
 
-    basic = FreshTestTable.find_freshest(:group_by=>[:fee], :select_by=>{:fie=>0}, :debug=>true)
+    ffc = @ffcounts[:fie]
 
-    expected_ct = 99/7 + 1;
+    basic = FreshTestTable.find_freshest(:group_by=>[:fee], :select_by=>{:fie=>0}, :debug=>true).sort_by {|x| x.fee}
+
+    expected_ct = @fcount/ffc
+    expected_rows = @flist.select{|tup| tup.fie == 0}.sort_by{|tup| tup.fee}
 
     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))
+      @fresh_fields.each do |msg|
+        assert_equal(expected_rows[x].send(msg), basic[x].send(msg))
       end
     end
   end
@@ -706,26 +744,56 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
   def test_freshness_query_group_single
     freshness_query_fixture
     # more basic tests
-    pairs = {:fie=>7,:foe=>11,:fum=>13}
+    pairs = @ffcounts.dup
+    pairs.delete(:fee)
+    
     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]
+      needed_vals = Set[*(0..ct).to_a]
+
+      @flist.reverse_each do |row|
+        break if needed_vals.empty?
+        
+        colval = row.send(col)
+        if needed_vals.include? colval
+          expected_objs[colval] = row
+          needed_vals.delete(colval)
+        end
       end
 
       basic.each do |row|
         res = expected_objs[row.send(col)]
-        [:fee,:fie,:foe,:fum,:created,:updated,:row_id].each do |msg|
+        puts expected_objs.keys.inspect if res.nil?
+        @fresh_fields.each do |msg|
           assert_equal(res.send(msg), row.send(msg))
         end
       end
     end
   end
   
+  def test_freshness_query_group_powerset
+    freshness_query_fixture
+    # more basic tests
+    
+    pairs = @ffcounts.dup
+    pairs.delete(:fee)
+    pairs_powerset = pairs.to_a.inject([[]]){|c,y|r=[];c.each{|i|r<<i;r<<i+[y]};r}.map {|h| h.transpose}
+    pairs_powerset.shift
+    
+    pairs_powerset.each do |cols,cts|
+      expected_ct = cts.inject(1){|x,acc| acc * x}
+      basic = FreshTestTable.find_freshest(:group_by=>cols)
+      
+      assert_equal(expected_ct,basic.size)
+
+      # XXX:  test identities, too
+    end
+  end
+  
   def test_blob_data
     words = %w{the quick brown fox jumps over a lazy dog now is time for all good men to come aid party jackdaws love my big sphinx of quartz}
     text = ""
@@ -799,6 +867,25 @@ class PreparedStmtBackendTests < Test::Unit::TestCase
       assert_equal thing, ott.obj      
     end
   end
+  
+  [true, false].each do |create_uses_rowid|
+    [true, false].each do |lookup_uses_rowid|
+      [true, false].each do |to_is_hash|
+  
+        define_method("test_reference_params_in_#{to_is_hash ? "hashed_" : ""}custom_queries_#{create_uses_rowid ? "createUsesRowID" : "createUsesObject"}_#{lookup_uses_rowid ? "lookupUsesRowID" : "lookupUsesObject"}".to_sym) do
+          to_refs = %w{foo bar blah}.map {|s| ToRef.create(:foo=>s)}
+          to_refs.each {}
+          to_refs.each {|tr| FromRef.create(:t=>create_uses_rowid ? tr.row_id : tr)}
+  
+          to_refs.each do |tr|
+            frs = to_is_hash ? FromRef.to_is_hash(:t=>lookup_uses_rowid ? tr.row_id : tr) : FromRef.to_is(lookup_uses_rowid ? tr.row_id : tr)
+            assert_equal frs.size, 1
+            assert_equal frs[0].t, tr
+          end
+        end
+      end
+    end
+  end
 end
 
 class NoPreparedStmtBackendTests < PreparedStmtBackendTests  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rhubarb
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - William Benton
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 -05:00
+date: 2010-08-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency