criteria 0.0.1 → 0.0.3

data/README

@@ -18,20 +18,20 @@ Now, what if we wanted to then delegate to another method to add some additional
 
 All that icky SQL, not so pretty.  Depending on what you need to do, you might find a nicer way around things, but with criteria, we always stay in OO land:
 
-  c = Criteria.new(User.email.eq(email)) do |c|
-    c.and User.password.eq(password)
-  end
+  c = User.email.eq(email) & User.password.eq(password)
   c = apply_filter(c)
   u = User.find(:first, c)
 
-The important thing to notice here is that you can get a Column object by calling ActiveRecord::Base.column_name, e.g. User.email in the above example.  This Column object allows you to then express some criteria on it, in the above example we use eq() to mean this column must be equal to the value passed to it.  This in turn returns a Criterion object.  A Criteria object is a collection of AND'd and OR'd Criterion objects.
+The important thing to notice here is that you can get a Column object by calling ActiveRecord::Base.column_name, e.g. User.email in the above example.  This Column object allows you to then express some criteria on it, in the above example we use eq() to mean this column must be equal to the value passed to it.  This in turn returns a Criterion object.  A Criteria object is a collection of Criterion objects that are AND'd or OR'd depending on how the Criteria was created.
 
 As a further example, imagine we are implementing apply_filer to only allow a user to log in if their 'role' field is one of :admin, :user or :editor
 
   def apply_filter(c)
     if apply_fiter?
       c.and User.role.in([:admin, :user, :editor])
-    end
+    else
+      c
+	end
   end
 
 As you can see, appending criteria is pretty easy.
@@ -40,22 +40,22 @@ As you can see, appending criteria is pretty easy.
 
 The above was quite a simple example, and we only used ANDs and no nested boolean operations.
 
-	criteria = Criteria.new
-	criteria.and do |c|
-	  c.or User.role.eq(:admin)
-	  c.or User.active.eq(false)
-	  c.or User.created_at.gt(10.hours.ago)
+	# We create a Criteria by calling new_criteria on User.  This bind the Criteria instance to the User class
+	criteria = User.new_criteria
+	
+	# We call and() and pass it a block.  The return 
+	criteria.and do
+		User.role.eq(:admin).or(User.active.eq(false)).or(User.created_at.gt(10.hours.ago))
 	end
-	criteria.and do |c|
-	  c.or User.role.eq(:editor)
-	  c.or User.active.eq(true)
-	  c.or do |c2|
-	    c2.and User.created_at.gt(20.days.go)
-	    c2.and User.created_at.lt(10.hours.ago)
+	criteria.and
+	  c = User.role.eq(:editor)
+	  c|= User.active.eq(true)
+	  c.or do
+		User.created_at.gt(20.days.go) & User.created_at.lt(10.hours.ago)
 	  end
 	end
 	
-The above query demonstrates how to nest Criteria objects, using them as if they were Criterion, and thus nest ANDs and ORs.  If we call to_where_sql on the criteria, we would get:
+The above query demonstrates how to nest Criteria objects, using them as if they were Criterion, and thus nest ANDs and ORs. It also shows the various syntactic methods that can be used to achieve the same results.  If we call to_where_sql on the criteria, we would get:
 
   ((users.role=":admin" OR users.active=0 OR users.created_at>"2008-04-04 13:55:42") AND (users.role=":editor" OR users.active=1 OR (users.created_at>"2008-03-15 23:57:04" AND users.created_at<"2008-04-04 13:55:42")))
 

data/lib/criteria.rb

@@ -8,38 +8,75 @@ class Criteria
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
   
-  attr_accessor :limit, :offset, :default_operator
+  @@debug = false
+  
+  attr_accessor :limit, :offset #, :default_operator #, :operator
+  
+  def self.debug
+    @@debug
+  end
+  
+  def self.debug=(val)
+    @@debug=val
+  end
   
   # Create a new criteria, optionally pass in a Criterion object
   # You can also pass a block, and self will be yielded
-  def initialize(c=nil) # :yields: self
-    @and = []
-    @or = []
+  def initialize(clazz=nil, def_operator=:AND) # :yields: self
+    @associations = []
+    @criteria = []
+    @operator = def_operator
+    # @and = []
+    # @or = []
     @order_by = []
     @group_by = []
     @select = []
     @limit = nil
     @offset = nil    
     @joins = []
-    @default_operator = :or
-		self.add(c) if c.is_a? Criterion
+    # @default_operator = :or
+		@clazz = clazz if clazz.is_a? Class
+		
+		# Add the supplied criterion if it is defined
+    # add(clazz) if clazz.is_a? Criterion
+    # add(c) if c.is_a? Criterion 
 
     yield(self) if block_given?
   end
   
+  # If this Criteria was created by passing an ActiveRecord::Base subclass as the first argument
+  # to the constructor, then this will return that class.  Criteria that are bound to classes can
+  # perform additional introspection to resolve association dependencies
+  def bound_class
+    @clazz
+  end
+  
+  # Returns an unmodifiable array of all AND'd and OR'd criteria
+  def all_criteria
+    and_criteria+or_criteria
+  end
+  
   # Return a modifiable array of AND'd criteria
-  def ands
-    @and
+  def and_criteria
+    if operator==:AND
+      @criteria
+    else
+      @other_criteria.and_criteria
+    end
   end
   
-  # Returns a modifiable array of OR'd criteria
-  def ors
-    @ors
+  # Return a modifiable array of OR'd criteria
+  def or_criteria
+    if operator==:OR
+      @criteria
+    else
+      @other_criteria.or_criteria
+    end
   end
   
   # Returns an array of column's to be selected
@@ -59,12 +96,12 @@ class Criteria
 
   # AND a criterion with the existing Criteria
   def and(c=nil, &block)
-    add(c, :and, &block)
+    add(c, :AND, &block)
   end
 
   # OR a criterion with the existing Criteria
   def or(c=nil, &block)
-    add(c, :or, &block)
+    add(c, :OR, &block)
   end
   
   def <<(c)
@@ -72,19 +109,42 @@ class Criteria
     add(c)
   end
   
-  def add(c=nil, operator=self.default_operator)
-    yield(c = Criteria.new) if c.nil? and block_given?
+  def add(c=nil, operator=@operator, opts={}, &block)
+    
+    # If we are using an :or and this is an :and, or vice versa, then create a new sub-criteria to contain it
+    if operator!=@operator
+      newcriteria = Criteria.new(bound_class, @operator==:AND ? :OR : :AND)
+      newcriteria << self
+      newcriteria.add(c, operator, opts, &block)
+      return newcriteria
+    end
+    
+    # If the criterion object is nil, and there is a block given, yield a new Criteria to the block
+    c = yield(self) if c.nil? and block_given?
+    
+    raise "Supplied argument is nil" if c.nil?
       
-    # puts "#{self} << OR #{c}"
+    # puts "Criteria.add: #{self} #{operator} #{c}"
+    # If the c is a column, moan about it and refuse to continue
     if c.is_a? Column
       raise "You cannot directly #{operator.to_s.upcase} an instanceof Column, you must call some sort of expression (eq, ne, gt, ge, etc) on it."
     end
     
-    if operator==:or
-      @or << c
-    else
-      @and << c
+    # If the criterion is bound to a class and this is also bound to a class we try and find an applicable association for the criterion
+    if !c.bound_class.nil? and !@clazz.nil?
+      # puts " + #{c.bound_class} AND #{@clazz}"
+      a=@clazz.find_associations_with(c.bound_class)
+      
+      if a.size>1 and a.include? opts[:via]
+        @associations << opts[:via]
+      elsif a.size==0
+        # do nothing
+      else
+        @associations << a.first
+      end
     end
+    
+    @criteria << c
     self
   end
   
@@ -100,22 +160,12 @@ class Criteria
 
   # Convert the AND and OR statements into the WHERE SQL
   def to_where_sql
-    and_clauses = []
-    
-    if @or.size>0
-      c = @or.collect {|c| c.to_where_sql}.join(" OR ")
-      if @and.size>0
-        and_clauses << "(#{c})"
-      else
-        and_clauses << c
-      end
-    end
-    
-    if @and.size>0
-      and_clauses << @and.collect {|c| c.to_where_sql}
+    if @criteria.size>0
+      out = @criteria.collect {|c| "#{c.to_where_sql}"}.join(" #{@operator} ")
+      "(#{out})"
+    else
+      ""
     end
-    
-    and_clauses.size>0 ? "(#{and_clauses.join(" AND ")})" : ""
   end
   
   def to_order_by_sql
@@ -133,7 +183,7 @@ class Criteria
   # Return a unique list of column objects that are referenced in this query
   def columns
     columns = []
-    (@and + @or).each do |c|
+    @criteria.each do |c|
      c.columns.each do |c2|
        columns << c2
      end
@@ -148,12 +198,24 @@ class Criteria
   end
   
   def associations
-    out = []
-    (@and + @or).each do |c| 
+    out = @associations
+    @criteria.each do |c| 
       out+=c.associations
     end
     out
   end
+    
+  def list
+    @clazz.find(:all, self)
+  end
+  
+  def count
+    @clazz.count(self)
+  end
+  
+  def first
+    @clazz.find(:first, self)
+  end
   
   # def list
   #   @clazz.find(:all, self.to_hash)
@@ -202,6 +264,13 @@ class Criteria
     "Criteria(#{to_hash.inspect})"
   end
   
+  def inspect(indent=0)
+    indent_str = " " * indent
+    "(\n" + @criteria.collect do |c| 
+      "#{" " * (indent+1)}#{@operator} #{c.inspect(indent+1)}"
+    end.join("\n") + "\n#{indent_str})"
+  end
+  
   # This class reprsents an ordering by a particular column.  The normal way to retreive and instance of 
   # this object is by calling the direction on the Column instance, e.g. User.email.asc
   class Order
@@ -228,7 +297,8 @@ class Criteria
   end
   
   class Column 
-    def initialize(clazz, column, adapter=ActiveRecord::Base.connection)
+    def initialize(clazz, column, options={}, adapter=ActiveRecord::Base.connection)
+      @options = {}
       @adapter = adapter
       if clazz.is_a? Class
         @clazz = clazz
@@ -237,6 +307,10 @@ class Criteria
       end
       @column = (column.is_a? String) ? column.intern : column
     end
+    
+    def bound_class
+      @clazz if @clazz.is_a? Class
+    end
   
     def column_name
       (@column.is_a? Symbol) ? @column : @column.name.intern
@@ -319,7 +393,20 @@ class Criteria
     end
   
     def to_sql_name
-      "#{@adapter.quote_table_name(table_name)}.#{@adapter.quote_column_name(column_name)}"
+      out = ""
+      if @adapter.methods.include? "quote_table_name"
+        # puts @adapter.method(:quote_table_name).inspect
+        out+="#{@adapter.quote_table_name(table_name)}"
+      else
+        out+="#{table_name}"
+      end
+      out+="."
+      if @adapter.methods.include? "quote_column_name"
+        out+="#{@adapter.quote_column_name(column_name)}"
+      else
+        out+="#{column_name}"
+      end
+      out
     end
     
     def to_s
@@ -430,6 +517,10 @@ class Criteria
       @opts = opts
     end
     
+    def bound_class
+      @column.bound_class
+    end
+    
     def associations
       if @column.is_a? Association
         [@column.association_name]
@@ -445,22 +536,35 @@ class Criteria
     # AND this with another criterion
     def &(criterion)
       if !criterion.nil?
-        c = Criteria.new
-        c.and self
-        c.and criterion
-        c
+        to_criteria(:AND).and(criterion)
       end
     end
     
     # OR this with another criterion
     def |(criterion)
       if !criterion.nil?
-        c = Criteria.new
-        c.or self
-        c.or criterion
-        c
+        to_criteria(:OR).or(criterion)
       end
     end
+    
+    # Convert this lone Criterion into a proper Criteria object.  This is used by the following first(), list() and count() methods to 
+    # provide a shortcut to the Criteria behaviour
+    def to_criteria(operator=:AND)
+      bound_class.new_criteria(self, operator)
+    end
+    
+    # Allow Criteria-esque calls directly on this Criterion
+    def first
+      to_criteria.first
+    end
+    
+    def list
+      to_criteria.list
+    end
+    
+    def count
+      to_criteria.count
+    end
   
     # Return a list of columns associated with this criterion, always an array with one element
     def columns
@@ -483,6 +587,10 @@ class Criteria
       "#{self.class}(#{to_where_sql})"
     end
     
+    def inspect(indent=0)
+      to_s
+    end
+    
   end
   
   class NotCriterion < Criterion
@@ -503,101 +611,205 @@ class Criteria
       "NOT (#{@criterion.to_where_sql})"
     end
   end
-end
 
-class ActiveRecord::Base 
-  @@one_to_many_associations = []
-  @@many_to_one_associations = []
-  @@critera_columns = {}
-  
-  # Access the column object by using the class as a hash.  This is useful if there are other
-  # static methods that have the same name as your field, or the field name is not, for some reason,
-  # allowed as a ruby method name
-  # 
-  # Usually, you can just call Class.column_name to access this column object
-  def self.[](column)
+  class ClassHeirarchyContext
+    def initialize()
+      @vars = {}
+    end
+    def get(cl, var, default=nil)
+      @vars[cl]||={}
+      out = @vars[cl][var]
+    
+      # search up the inheretence heirarchy
+      clazz = cl
+      while !clazz.nil? and out.nil?
+        out = (@vars[clazz]||{})[var]
+        clazz = clazz.superclass
+      end
     
-    # First check to see if there is a column on this class 
-    if self.columns.collect {|c| c.name }.include? column.to_s
-      col = self.columns.reject {|c| c.name!=column.to_s }.first
-      @@critera_columns[column.to_s] = Criteria::Column.new(self, col, self.connection)
-      
-    # No?  well lets check if there is an association on this class
-    # FIXME: this is very prone to error, we need a way of confirming this
-    elsif self.one_to_many_associations.include? column.to_s.intern
-      @@critera_columns[column.to_s] = Criteria::OneToManyAssociation.new(self, column, self.connection)
-    elsif self.many_to_one_associations.include? column.to_s.intern
-      @@critera_columns[column.to_s] = Criteria::ManyToOneAssociation.new(self, column, self.connection)
-    end
+      # set default if no value was found
+      if out.nil? and !default.nil?
+        @vars[cl][var] = default
+        out = @vars[cl][var]
+      end
     
-    if @@critera_columns.has_key? column.to_s
-      @@critera_columns[column.to_s]
-    else
-      nil
+      out
     end
-  end
   
-  def self.many_to_one_associations
-    @@many_to_one_associations
-  end
+    def unset(cl, var)
+      @vars[cl].delete var
+    end
   
-  def self.one_to_many_associations
-    @@one_to_many_associations
+    def set(cl,var, value)
+      @vars[cl]||={}
+      @vars[cl][var] = value
+    end
   end
+end
+
+class Class
+  @@static = Criteria::ClassHeirarchyContext.new
   
-  def self.__criteria_method_missing(*a)
-    # puts a.inspect
-    self[a[0]] || __ar_method_missing(*a)
+  def static_get(key, default=nil)
+    @@static.get(self, key, default)
   end
   
-  # Provide the ability to search by criteria using the normal find() syntax.  Basically we 
-  # just turn the criteria object into a normal query hash (:conditions, :order, :limit, etc)
-  #
-  # Since this can come as the first or second argument in the find() method, we just scan for 
-  # any instances of Criteria and then call to_hash
-  def self.__criteria_find(*a)
-    a = rewrite_criteria_in_args(a)
-    # puts a.inspect
-    __ar_find(*a)
+  def static_set(name, value)
+    @@static.set(self, name, value)
   end
-    
+  def static_unset(name)
+    @@static.unset(self, name)
+  end
+end
+
+# FIXME: Argh! ruby's class variables are not per-class... so setting a class variable in a subclass overrides the
+# parent class...  in order to get around this, we need to store the associations per class, and then iterate over a classes
+# parent classes to find all applicable associations
+class ActiveRecord::Base
+  
+  def self.new_criteria(c=nil, operator=:AND)
+    if c==:AND or c==:OR
+      Criteria.new(self, c)
+    else
+      crit = Criteria.new(self, operator)
+      crit << c if !c.nil?
+      crit
+    end
+  end
+  
   class << self
+    # alias_method :__ar_inherited, :inherited
     alias_method :__ar_method_missing, :method_missing
-    alias_method :method_missing, :__criteria_method_missing
     alias_method :__ar_find, :find
-    alias_method :find, :__criteria_find
-  end
-  
-  protected
-  
-  def self.rewrite_criteria_in_args(args)
-    args.collect do |arg|
-      if arg.is_a? Criteria or arg.is_a? Criteria::Criterion
-        arg.to_hash
+    alias_method :__ar_count, :count
+    alias_method :__ar_belongs_to, :belongs_to  
+    alias_method :__ar_has_many, :has_many
+    
+    # Provide the ability to search by criteria using the normal find() syntax.  Basically we 
+    # just turn the criteria object into a normal query hash (:conditions, :order, :limit, etc)
+    #
+    # Since this can come as the first or second argument in the find() method, we just scan for 
+    # any instances of Criteria and then call to_hash
+    def find(*a)
+      a = rewrite_criteria_in_args(a)
+      __ar_find(*a)
+    end
+
+    def count(*a)
+      a = rewrite_criteria_in_args(a)
+      __ar_count(*a)
+    end
+    
+    def method_missing(*a)
+      puts "seeking method #{a[0]}: #{criteria_columns[a[0]]}" if Criteria.debug
+      if !criteria_columns[a[0].to_s].nil?
+        criteria_columns[a[0].to_s]
       else
-        arg
+        __ar_method_missing(*a)
       end
     end
+    
+    # protected
+
+    def rewrite_criteria_in_args(args)
+      args.collect do |arg|
+        if arg.is_a? Criteria or arg.is_a? Criteria::Criterion
+          # puts "#{arg.to_hash.inspect}"
+          arg.to_hash
+        else
+          arg
+        end
+      end
+    end
+  # end
+  #  
+  #  def self.inherited(clazz)
+  #    __ar_inherited(clazz)
+  #    
+  #    puts "Enhance #{clazz} < #{clazz.superclass}"
+  # 
+  #    class << clazz
+      # puts "enhancing #{self} < #{self.superclass}"
+      # @@one_to_many_associations = {}
+      # @@many_to_one_associations = {}
+      # @@criteria_columns = nil
+      
+      def criteria_columns
+        if static_get(:criteria_columns).nil?
+          static_set(:criteria_columns, {})
+          # do some more initialization
+          self.columns.each do |c|
+            static_get(:criteria_columns)[c.name.to_s] = Criteria::Column.new(self, c, {}, self.connection)
+          end
+          self.one_to_many_associations.each do |k,v|
+            puts "found 1->m #{k} => #{v.inspect}" if Criteria.debug
+            static_get(:criteria_columns)[k.to_s] = Criteria::OneToManyAssociation.new(self, k, v, self.connection)
+          end
+          self.many_to_one_associations.each do |k,v|
+            puts "found m->1 #{k} => #{v.inspect}" if Criteria.debug
+            static_get(:criteria_columns)[k.to_s] = Criteria::ManyToOneAssociation.new(self, k, v, self.connection)
+          end
+          
+        end
+        puts "call criteria_columns on #{self} (#{static_get(:criteria_columns).keys.inspect})" if Criteria.debug
+        static_get(:criteria_columns)
+      end
+      
+      def one_to_many_associations
+        static_get(:one_to_many_associations, {})
+      end
+      
+      def many_to_one_associations
+        static_get(:many_to_one_associations, {})
+      end
+  
+      # Access the column object by using the class as a hash.  This is useful if there are other
+      # static methods that have the same name as your field, or the field name is not, for some reason,
+      # allowed as a ruby method name
+      # 
+      # Usually, you can just call Class.column_name to access this column object
+      def [](column)
+        criteria_columns[column.to_s]
+      end
+
+      # Search the associations defined on this class for one that would map to the given class
+      # This returns an array of symbols which are equal to the symbols used in the has_many and
+      # belongs_to definitions
+      def find_associations_with(clazz)
+        associations = []
+        pluralized = Inflector.pluralize(clazz.table_name.to_s).intern
+        singularized = clazz.table_name.to_s.singularize.intern
+        puts "does #{self} 1->m #{one_to_many_associations.inspect} contain #{pluralized}" if Criteria.debug
+        if !one_to_many_associations[pluralized].nil?
+          associations << pluralized
+          associations << one_to_many_associations[pluralized][:through] if !one_to_many_associations[pluralized][:through].nil?
+        end
+        puts "does #{self} m->1 #{many_to_one_associations.inspect} contain #{singularized}" if Criteria.debug
+        if !many_to_one_associations[singularized].nil?
+          associations << singularized
+          # associations << many_to_one_associations[singularized][:through] if !many_to_one_associations[singularized][:through].nil?
+        end
+        associations #+clazz.find_associations_with(self)
+      end
+    
+      def belongs_to(id, opts={})
+        # self.__criteria_enhance
+        puts "#{self} belongs to #{id} with #{opts.inspect}" if Criteria.debug
+        many_to_one_associations[id] = opts
+        __ar_belongs_to(id, opts)
+      end
+
+      def has_many(id, opts={}, &block)
+        # self.__criteria_enhance
+        puts "#{self} has many #{id} with #{opts.inspect}" if Criteria.debug
+        puts "#{self.one_to_many_associations.inspect}" if Criteria.debug
+        one_to_many_associations[id] = opts
+        puts "#{self.one_to_many_associations.inspect}" if Criteria.debug
+        __ar_has_many(id, opts, &block)
+      end
+    # end
   end
 end
 
-
 module ActiveRecord::Associations::ClassMethods
-  def __criteria_belongs_to(id, opts={})
-    # puts "#{self} belongs to #{id} with #{opts.inspect}"
-    self.many_to_one_associations << id
-    __ar_belongs_to(id, opts)
-  end
-  
-  alias_method :__ar_belongs_to, :belongs_to
-  alias_method :belongs_to, :__criteria_belongs_to
-  
-  def __criteria_has_many(id, opts={}, &block)
-    # puts "#{self} has many #{id} with #{opts.inspect}"
-    self.one_to_many_associations << id
-    __ar_has_many(id, opts, &block)
-  end
-  
-  alias_method :__ar_has_many, :has_many
-  alias_method :has_many, :__criteria_has_many
 end

data/test/test_associations.rb

@@ -4,6 +4,20 @@ require 'test/mock_classes.rb'
 
 class AssociationTest < Test::Unit::TestCase
   
+  def test_associations_from_subject
+    u = User.find(1)
+    c = Criteria.new(User).and Receipt.title.eq("Receipt1")
+    u2 = c.first
+    assert_equal u, u2
+  end
+  
+  def test_associations_from_subject_through_another
+    u = User.find(1)
+    c = Criteria.new(User).and Query.created_at.lt(Time.now)
+    u2 = c.first
+    assert_equal u, u2
+  end
+  
   def test_many_to_one
     u = User.find(1)
     c = Receipt.user.eq(u)

data/test/test_class_heirarchy.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class ClassHeirarchyTest < Test::Unit::TestCase
+  
+  def test_inherit_class_vars
+    ActiveRecord::Base.static_set("hello", :world)
+    assert_equal :world, ActiveRecord::Base.static_get("hello")
+    assert_equal :world, User.static_get("hello")
+    ActiveRecord::Base.static_set("hello", :world_again)
+    assert_equal :world_again, ActiveRecord::Base.static_get("hello")
+    assert_equal :world_again, User.static_get("hello")
+    
+    # Define the same variable at the child level
+    User.static_set("hello", :mondo)
+    assert_equal :mondo, User.static_get("hello")    
+    
+    # Unsetting the User-level static var should revert to the parent ActiveRecord::Base-level var
+    User.static_unset("hello")
+    assert_equal :world_again, User.static_get("hello")
+  end
+  
+  def test_no_overwrite
+    User.static_set("foo", "bar")
+    Class.static_set("foo", "baz")
+    ActiveRecord::Base.static_set("foo", "bum")
+    assert_equal "bar", User.static_get("foo")
+    assert_equal "baz", Class.static_get("foo")
+    assert_equal "bum", ActiveRecord::Base.static_get("foo")
+  end
+
+end

data/test/test_criteria.rb

@@ -4,6 +4,13 @@ require "test/mock_classes.rb"
 
 class CriteriaTest < Test::Unit::TestCase
   
+  def test_bind_to_class
+    u = User.find(1)
+    c = User.new_criteria(Query.created_at < Time.now)
+    puts c.to_hash.inspect
+    assert_equal u, c.first
+  end
+    
   def test_order_by
     c = Criteria.new
     assert_equal nil, c.to_order_by_sql
@@ -80,4 +87,4 @@ class CriteriaTest < Test::Unit::TestCase
     assert_equal nil, c.to_hash[:offset]
   end
   
-end
+end

data/test/test_examples.rb

@@ -19,22 +19,20 @@ class ExamplesTest < Test::Unit::TestCase
     a = (User.role == :admin) | (User.active == false) | (User.created_at > TIME2)
     b = (User.role==:editor) | (User.active==true)
     b|= ((User.created_at>TIME1) & (User.created_at<TIME2))
+    puts (a&b).inspect
     assert_equal EXPECTED_HASH, (a&b).to_hash
   end    
   
   def test_big_full
-    criteria = Criteria.new
-    criteria.and do |c|
-      c.or User.role.eq(:admin)
-      c.or User.active.eq(false)
-      c.or User.created_at.gt(TIME2)
+    criteria = User.new_criteria
+    criteria.and do
+      User.role.eq(:admin) | User.active.eq(false) | User.created_at.gt(TIME2)
     end
-    criteria.and do |c|
-      c.or User.role.eq(:editor)
-      c.or User.active.eq(true)
-      c.or do |c2|
-        c2.and User.created_at.gt(TIME1)
-        c2.and User.created_at.lt(TIME2)
+    criteria.and do
+      c = User.role.eq(:editor)
+      c|= User.active.eq(true)
+      c.or do
+        User.created_at.gt(TIME1) & User.created_at.lt(TIME2)
       end
     end
     

data/test/test_suite.rb

@@ -1,3 +1,9 @@
 require 'test/unit'
 require 'test/test_criterion.rb'
-require 'test/test_criteria.rb'
+require 'test/test_criteria.rb'
+require 'test/test_order.rb'
+require 'test/test_examples.rb'
+require 'test/test_column.rb'
+require 'test/test_class_heirarchy.rb'
+require 'test/test_associations.rb'
+require 'test/test_active_record.rb'

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: criteria
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2008-04-08 00:00:00 +10:00
+  version: 0.0.3
+date: 2008-06-10 00:00:00 +10:00
 summary: Object-orientated Criteria for ActiveRecord
 require_paths: 
 - lib
@@ -34,6 +34,7 @@ files:
 test_files: 
 - test/test_active_record.rb
 - test/test_associations.rb
+- test/test_class_heirarchy.rb
 - test/test_column.rb
 - test/test_criteria.rb
 - test/test_criterion.rb