criteria 0.0.1

data/README

@@ -0,0 +1,101 @@
+= Criteria for ActiveRecord
+
+== What is it?
+
+Users of Hibernate, Torque (in Java) and Propel (in PHP) will be familiar with the concept of criteria as a method of building, in an object orientated manner, complex queries for the underlying Object Relational Mapping (ORM) framework.
+
+== Example
+
+Imagine you have an ActiveRecord class User, and it has the following columns/fields: email, password, name, createdAt, role, active.  When a user logs in, we want to find the correct user object for the email provided and confirm that the password is correct:
+
+  u = User.find_by_email_and_password(email, password)
+ 
+Now, what if we wanted to then delegate to another method to add some additional criteria?  We may end up doing something like this:
+
+  where = "email = '#{email}' AND password = '#{password}'"
+  where = apply_filter(where)
+  u = User.find(:first, :where => where)
+
+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 = 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.
+
+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
+  end
+
+As you can see, appending criteria is pretty easy.
+
+== Complex Boolean
+
+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)
+	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)
+	  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:
+
+  ((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")))
+
+== Chaining
+
+Most methods on Criteria or Criterion return self, so you can chain calls together:
+
+ u = User.email.eq(email).and(User.password.eq(password))
+
+
+== Alternative Syntax
+
+Alternatively, rather than express the column constraint like this:
+
+  User.createdAt.gt(20.days.ago)
+
+We can use a more natural ruby language approach
+
+  User.createdAt > 20.days.ago
+
+Rather than return a boolean true or false, this will return the same Criterion as would be returned in the above statement.  When writing lots of criteria, you can see how much nicer this looks
+
+  c.and( User.createAt > 20.days.ago )
+
+We can go further and then express AND and OR in a similar way:
+
+  (User.createdAt < 10.hours.ago) & (User.createdAt > 20.days.ago)
+
+The above will return a Criteria object populated with the two statements ANDed together.
+
+So, in fact, you could query for the User's email and password like this:
+
+  User.find((User.email == email) & (User.password == password))
+
+Although this looks nicer, it might be removed as it breaks the semantics of the language.  Normally you would expect an == or <= to return a boolean value and such comparisons would no longer be possible with these objects.
+
+== Joins
+
+ActiveRecord does much of the heavy lifting for us, so joins, etc, are made pretty simple.  By virtue of including a criterion for a particular column in a particular table, that table will be added to the list of included tables.  It is then delegated to your model hierarchy (via belongs_to, has_many, etc) to determine how these relationships are actually manifest in terms of JOINs in the SQL
+
+== More info
+
+Please see the rdoc for more information on the API

data/lib/criteria.rb

@@ -0,0 +1,603 @@
+require 'rubygems'
+require 'activerecord'
+
+# Criteria is a collection of Criterion as well as additional constraints regarding the order, limit and offset
+#
+# see the readme for usage examples.
+class Criteria
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+  
+  attr_accessor :limit, :offset, :default_operator
+  
+  # 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 = []
+    @order_by = []
+    @group_by = []
+    @select = []
+    @limit = nil
+    @offset = nil    
+    @joins = []
+    @default_operator = :or
+		self.add(c) if c.is_a? Criterion
+
+    yield(self) if block_given?
+  end
+  
+  # Return a modifiable array of AND'd criteria
+  def ands
+    @and
+  end
+  
+  # Returns a modifiable array of OR'd criteria
+  def ors
+    @ors
+  end
+  
+  # Returns an array of column's to be selected
+  def select
+    @select
+  end
+  
+  # Get the collection of columns to group by
+  def group_by
+    @group_by
+  end
+
+  # Get the collection of Order objects to order by
+  def order_by
+    @order_by
+  end
+
+  # AND a criterion with the existing Criteria
+  def and(c=nil, &block)
+    add(c, :and, &block)
+  end
+
+  # OR a criterion with the existing Criteria
+  def or(c=nil, &block)
+    add(c, :or, &block)
+  end
+  
+  def <<(c)
+    raise "<< does not accept a block, perhaps you were trying to pass it to Criteria.new?" if block_given?
+    add(c)
+  end
+  
+  def add(c=nil, operator=self.default_operator)
+    yield(c = Criteria.new) if c.nil? and block_given?
+      
+    # puts "#{self} << OR #{c}"
+    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
+    end
+    self
+  end
+  
+  # AND this with another criterion
+  def &(criterion)
+    self.and(criterion)
+  end
+  
+  # OR this with another criterion
+  def |(criterion)
+    self.or(criterion)
+  end
+
+  # 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}
+    end
+    
+    and_clauses.size>0 ? "(#{and_clauses.join(" AND ")})" : ""
+  end
+  
+  def to_order_by_sql
+    @order_by.size>0 ? @order_by.collect {|o| o.to_s}.join(",") : nil
+  end
+
+  def to_group_by_sql
+    @group_by.size>0 ? @group_by.collect {|g| g.to_s}.join(",") : nil
+  end
+  
+  def to_select_sql
+    @select.size>0 ? @select.collect{|s| s.to_s}.join(",") : nil
+  end
+  
+  # Return a unique list of column objects that are referenced in this query
+  def columns
+    columns = []
+    (@and + @or).each do |c|
+     c.columns.each do |c2|
+       columns << c2
+     end
+    end 
+    columns.uniq
+  end
+  
+  # Get a read-only array of all the table names that will be included in 
+  # this query
+  def tables
+    columns.collect {|c| c.table_name }.uniq
+  end
+  
+  def associations
+    out = []
+    (@and + @or).each do |c| 
+      out+=c.associations
+    end
+    out
+  end
+  
+  # def list
+  #   @clazz.find(:all, self.to_hash)
+  # end
+  # 
+  # def count
+  #   h = self.to_hash
+  #   h.delete :order
+  #   h.delete :group
+  #   @clazz.count(h)
+  # end
+  
+  # def [](key)
+  #   if key==:include
+  #     self.tables
+  #   elsif key==:conditions
+  #     self.to_where_sql
+  #   elsif key==:limit
+  #     self.limit
+  #   elsif key==:offset
+  #     self.offset
+  #   elsif key==:order
+  #     self.to_order_by_sql
+  #   elsif key==:group
+  #     self.to_group_by_sql
+  #   elsif key==:select
+  #     self.to_select_sql
+  #   end
+  # end
+
+  # FIXME: this returns a list of table names in :include, whereas it should contain the
+  # relationship names
+  def to_hash
+    {
+      :include => self.associations,
+      :conditions => self.to_where_sql,
+      :limit => self.limit,
+      :offset => self.offset,
+      :order => self.to_order_by_sql,
+      :group => self.to_group_by_sql,
+      :select => self.to_select_sql
+    }
+  end
+  
+  def to_s
+    "Criteria(#{to_hash.inspect})"
+  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
+    attr_reader :dir, :column
+    ASC = "ASC"
+    DESC = "DESC"
+    
+    def initialize(column, dir = ASC)
+      @column = column
+      @dir = dir
+    end
+    
+    def to_s
+      "#{@column.to_sql_name} #{@dir}"
+    end
+    
+    def self.asc(col)
+      Order.new(col, ASC)
+    end
+    
+    def self.desc(col)
+      Order.new(col, DESC)
+    end
+  end
+  
+  class Column 
+    def initialize(clazz, column, adapter=ActiveRecord::Base.connection)
+      @adapter = adapter
+      if clazz.is_a? Class
+        @clazz = clazz
+      else
+        @clazz = (clazz.is_a? Symbol) ? clazz : clazz.intern
+      end
+      @column = (column.is_a? String) ? column.intern : column
+    end
+  
+    def column_name
+      (@column.is_a? Symbol) ? @column : @column.name.intern
+    end
+
+    def quote_value(val)
+      @adapter.quote(val, (@column.is_a? Symbol) ? nil : @column)
+    end
+    
+    def adapter
+      @adapter
+    end
+
+    def table_name
+      if @clazz.is_a? Class
+        @clazz.table_name.intern
+      else
+        @clazz
+      end
+    end
+    
+    def asc
+      Order.asc(self)
+    end
+    
+    def desc
+      Order.desc(self)
+    end
+  
+    def not_in(values)
+      create_criterion(Criterion::NOT_IN, values)
+    end
+  
+    def in(values)
+      create_criterion(Criterion::IN, values)
+    end
+  
+    def ne(value)
+      create_criterion(Criterion::NOT_EQUAL, value)
+    end
+  
+    def eq(value)
+      create_criterion(Criterion::EQUAL, value)
+    end
+  
+    def gt(value)
+      create_criterion(Criterion::GREATER_THAN, value)
+    end
+  
+    def ge(value)
+      create_criterion(Criterion::GREATER_THAN_OR_EQUAL, value)
+    end
+
+    def lt(value)
+      create_criterion(Criterion::LESS_THAN, value)
+    end
+  
+    def le(value)
+      create_criterion(Criterion::LESS_THAN_OR_EQUAL, value)
+    end
+    
+    def ==(value)
+      eq(value)
+    end
+    
+    def >(value)
+      gt(value)
+    end
+    
+    def >=(value)
+      ge(value)
+    end
+    
+    def <(value)
+      lt(value)
+    end
+    
+    def <=(value)
+      le(value)
+    end
+  
+    def to_sql_name
+      "#{@adapter.quote_table_name(table_name)}.#{@adapter.quote_column_name(column_name)}"
+    end
+    
+    def to_s
+      self.to_sql_name
+    end
+    
+    protected
+    
+    def create_criterion(operator, value)
+      Criterion.new(self, operator, value)
+    end
+  end
+  
+  # Association can be treated like a Column, except that values should be an 
+  # instance of the associated class
+  class Association < Column
+    def association_name
+      @column
+    end
+  end
+  
+  class OneToManyAssociation < Association
+    # This is a special case and can only be applied to OneToManyAssociation
+    def contains(value)
+      create_criterion(Criterion::EQUAL, value)
+    end  
+    
+    protected 
+    
+    # We flip the association round once we know who we are associating with
+    # def create_criterion(operator, value)
+    #   a = OneToManyAssociation.new(value.class, @column)
+    #   a.create_criterion(operator, self)
+    # end
+    
+    def column_name
+      "id"
+    end
+    
+    def table_name
+      @column
+    end
+  end
+  
+  class ManyToOneAssociation < Association
+    def column_name
+      "#{@column}_id"
+    end
+  end
+  
+  # module SqlUtil
+  #   # RESERVED_WORDS = ["table", "column", "type"]
+  #   def self.escape_name(name)
+  #     # if !name =~/[^a-zA-Z0-9_]/
+  #       # "`#{name}`"
+  #     # else
+  #       name
+  #     # end
+  #   end
+  #   
+  #   def self.value_to_sql(column, v)
+  #     if column.is_a? Association and v.is_a? ActiveRecord::Base
+  #       # Special case, we need to extract the object's PK and add make sure the association is in the 
+  #       # criteria
+  #       v = v.id
+  #     end
+  #     
+  #     if v.is_a? Array
+  #       "(" + v.collect {|value| value_to_sql(value)}.join(",") + ")"
+  #     elsif v.is_a? String
+  #       "'#{v}'"
+  #     elsif v.is_a? TrueClass
+  #       "1"
+  #     elsif v.is_a? FalseClass
+  #       "0"
+  #     elsif v.is_a? Time
+  #       "'#{v.to_s(:db)}'"
+  #     elsif v.is_a? Symbol
+  #       "':#{v}'"
+  #     else
+  #       v
+  #     end
+  #   end
+  # end
+  
+  
+  class Criterion
+    attr_accessor :value
+    attr_reader :column, :operator
+    
+    NOT_EQUAL = "<>"
+    EQUAL = "="
+    GREATER_THAN = ">"
+    GREATER_THAN_OR_EQUAL = ">="
+    LESS_THAN = "<"
+    LESS_THAN_OR_EQUAL = "<="
+    IN = "IN"
+    NOT_IN = "NOT IN"
+    
+    # Create a new criteria.  Generally, you will not call this directly, rather create it via 
+    # the Column instance.
+    # 
+    # The constructor takes a Column instance, an operator string and an optional value
+    def initialize(column, operator=nil, value=nil, opts={})
+      @column = column
+      @operator = operator
+      @value = value
+      @opts = opts
+    end
+    
+    def associations
+      if @column.is_a? Association
+        [@column.association_name]
+      else
+        []
+      end
+    end
+    
+    def not
+      NotCriterion.new(self)
+    end
+    
+    # AND this with another criterion
+    def &(criterion)
+      if !criterion.nil?
+        c = Criteria.new
+        c.and self
+        c.and criterion
+        c
+      end
+    end
+    
+    # OR this with another criterion
+    def |(criterion)
+      if !criterion.nil?
+        c = Criteria.new
+        c.or self
+        c.or criterion
+        c
+      end
+    end
+  
+    # Return a list of columns associated with this criterion, always an array with one element
+    def columns
+      [@column]
+    end    
+    
+    # Convert this criterion into WHERE SQL
+    def to_where_sql 
+      "#{@column.to_sql_name} #{@operator} #{@column.quote_value(@value)}"
+    end
+    
+    def to_hash
+      {
+        :include => self.associations,
+        :conditions => to_where_sql
+      }
+    end
+    
+    def to_s
+      "#{self.class}(#{to_where_sql})"
+    end
+    
+  end
+  
+  class NotCriterion < Criterion
+    attr_accessor :criterion
+    def initialize(c)
+      @criterion = c
+    end
+    
+    def not
+      @criterion
+    end
+    
+    def columns
+      @criterion.colums
+    end
+    
+    def to_where_sql 
+      "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)
+    
+    # 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
+    
+    if @@critera_columns.has_key? column.to_s
+      @@critera_columns[column.to_s]
+    else
+      nil
+    end
+  end
+  
+  def self.many_to_one_associations
+    @@many_to_one_associations
+  end
+  
+  def self.one_to_many_associations
+    @@one_to_many_associations
+  end
+  
+  def self.__criteria_method_missing(*a)
+    # puts a.inspect
+    self[a[0]] || __ar_method_missing(*a)
+  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)
+  end
+    
+  class << self
+    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
+      else
+        arg
+      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_active_record.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class ActiveRecordTest < Test::Unit::TestCase
+  
+  def test_find
+    u = User.find(1)
+    c = (User.email == "test@example.com") & (User.password=="password")
+    c.order_by << User.email.asc
+    # c.select << User.email
+    # c.select << User.password
+    # c.select << User.role
+    c.limit = 1
+    c.offset = 0
+    # puts c.to_hash.inspect
+    # puts c.to_hash.inspect
+    # puts User.find_by_email_and_password("test@example.com", "password")
+    u2 = User.find(:first, c)
+    assert_equal u.email, u2.email
+    assert_equal u.password, u2.password
+    assert_equal u.id, u2.id
+  end      
+  
+end

data/test/test_associations.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class AssociationTest < Test::Unit::TestCase
+  
+  def test_many_to_one
+    u = User.find(1)
+    c = Receipt.user.eq(u)
+    assert c.column.is_a? Criteria::ManyToOneAssociation
+    assert_equal "receipts.\"user_id\" = 1", c.to_where_sql
+    assert c.associations.include? :user
+    
+    r = Receipt.find(:all, c)
+    assert_equal 2, r.size
+    assert_equal Receipt.find(1), r[0]
+    assert_equal Receipt.find(2), r[1]
+  end    
+  
+  def test_one_to_many
+    r = Receipt.find(1)
+    c = User.receipts.contains(r)
+    
+    assert c.column.is_a? Criteria::OneToManyAssociation
+    assert_equal "receipts.\"id\" = 1", c.to_where_sql
+    puts c.associations.inspect
+    assert c.associations.include? :receipts
+    
+    u = User.find(:first, c)
+    assert_equal User.find(1), u
+    assert u.receipts.include? r
+  end
+  
+  # If we perform a query from the User context, then the associations should be named from
+  # the user's perspective
+  def test_context
+    
+  end
+
+end

data/test/test_column.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class ColumnTest < Test::Unit::TestCase
+  
+  def test_create_from_symbols
+    c = Criteria::Column.new(:some_table, :a_column)
+    assert_equal :some_table, c.table_name
+    assert_equal :a_column, c.column_name
+  end    
+  
+  def test_create_from_strings
+    c = Criteria::Column.new("some_table", "a_column")
+    assert_equal :some_table, c.table_name
+    assert_equal :a_column, c.column_name
+  end
+  
+  def test_create_from_class
+    c = Criteria::Column.new(SomeTable, "a_column")
+    assert_equal :some_table, c.table_name
+    assert_equal :a_column, c.column_name
+  end
+  
+  def test_escaped
+    c = Criteria::Column.new(SomeTable, "a_column")
+    assert_equal quote("some_table.a_column"), c.to_sql_name
+  end
+  
+  class SomeTable
+    def self.table_name
+      "some_table"
+    end
+  end
+
+end

data/test/test_criteria.rb

@@ -0,0 +1,83 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/criteria.rb"
+require "test/mock_classes.rb"
+
+class CriteriaTest < Test::Unit::TestCase
+  
+  def test_order_by
+    c = Criteria.new
+    assert_equal nil, c.to_order_by_sql
+    c.order_by << User.email
+    assert_equal "#{quote("users.email")}", c.to_order_by_sql
+    c.order_by << User.password
+    assert_equal "#{quote("users.email")},#{quote("users.password")}", c.to_order_by_sql
+    c.order_by << :id
+    assert_equal "#{quote("users.email")},#{quote("users.password")},id", c.to_order_by_sql
+  end
+  
+  def test_group_by
+    c = Criteria.new
+    assert_equal nil, c.to_group_by_sql
+    c.group_by << User.email
+    assert_equal "#{quote("users.email")}", c.to_group_by_sql
+    c.group_by << User.password
+    assert_equal "#{quote("users.email")},#{quote("users.password")}", c.to_group_by_sql
+    c.group_by << :id
+    assert_equal "#{quote("users.email")},#{quote("users.password")},id", c.to_group_by_sql
+  end
+
+  def test_select
+    c = Criteria.new
+    c.select << User.email
+    c.select << :id
+    c.select << "password"
+    
+    assert_equal "#{quote("users.email")},id,password", c.to_select_sql
+  end
+  
+  def test_include
+    c = Criteria.new
+    c.and User.email.eq("test@example.com")
+    c.and User.password.eq("blah")
+    assert_equal "#{quote("users.email")}", c.columns[0].to_s
+    assert_equal "#{quote("users.password")}", c.columns[1].to_s
+    assert_equal [:users], c.tables
+    c.and Criteria::Column.new("another_table", "foo").eq("bar")
+    
+    assert_equal "#{quote("users.email")}", c.columns[0].to_s
+    assert_equal "#{quote("users.password")}", c.columns[1].to_s
+    assert_equal "#{quote("another_table.foo")}", c.columns[2].to_s
+    assert_equal [:users, :another_table], c.tables
+  end
+
+  def test_limit
+    c = Criteria.new
+    assert_equal nil, c.limit
+    assert_equal nil, c.to_hash[:limit]
+    c.limit = 1
+    assert_equal 1, c.limit
+    assert_equal 1, c.to_hash[:limit]
+    c.limit = 1000
+    assert_equal 1000, c.limit
+    assert_equal 1000, c.to_hash[:limit]
+    c.limit = nil
+    assert_equal nil, c.limit
+    assert_equal nil, c.to_hash[:limit]
+  end
+  
+  def test_offset
+    c = Criteria.new
+    assert_equal nil, c.offset
+    assert_equal nil, c.to_hash[:offset]
+    c.offset = 1
+    assert_equal 1, c.offset
+    assert_equal 1, c.to_hash[:offset]
+    c.offset = 1000
+    assert_equal 1000, c.offset
+    assert_equal 1000, c.to_hash[:offset]
+    c.offset = nil
+    assert_equal nil, c.offset
+    assert_equal nil, c.to_hash[:offset]
+  end
+  
+end

data/test/test_criterion.rb

@@ -0,0 +1,83 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class CriterionTest < Test::Unit::TestCase
+  
+  def test_eq
+    a = User.email == "test@example.com"
+    b = User.email.eq("test@example.com")
+    assert_equal quote("users.email") + " = 'test@example.com'", a.to_where_sql
+    assert_equal quote("users.email") + " = 'test@example.com'", b.to_where_sql
+  end    
+  
+  def test_ne
+    a = User.email.ne("test@example.com")
+    assert_equal quote("users.email") + " <> 'test@example.com'", a.to_where_sql
+  end
+  
+  def test_not
+    a = User.email.eq("test@example.com")
+    b = a.not
+    c = b.not
+    assert_equal quote("users.email") + " = 'test@example.com'", a.to_where_sql
+    assert_equal "NOT (#{quote("users.email")} = 'test@example.com')", b.to_where_sql
+    assert_equal quote("users.email") + " = 'test@example.com'", c.to_where_sql
+  end
+  
+  def test_time
+    time = Time.now
+    a = User.created_at > time
+    assert_equal quote("users.created_at") + " > '#{time.to_s(:db)}'", a.to_where_sql
+  end
+  
+  def test_symbol
+    a = User.role == :admin
+    assert_equal "#{quote("users.role")} = '--- :admin\n'", a.to_where_sql
+  end
+  
+  def test_string
+    a = User.role == "admin"
+    assert_equal "#{quote("users.role")} = 'admin'", a.to_where_sql
+  end
+    
+  def test_float
+    a = User.number > 1.3122
+    assert_equal "#{quote("users.number")} > 1.3122", a.to_where_sql
+  end  
+  
+  def test_int
+    a = User.number > 1234
+    assert_equal "#{quote("users.number")} > 1234", a.to_where_sql
+  end
+  
+  def test_nested
+    a = User.email == "test@example.com"
+    b = User.password == "secure password"
+    c = User.active == true
+    d = ((User.email == "test@example.com") | (User.password == "secure password")) & (User.active == true)
+    assert d.is_a?(Criteria)
+    assert_equal "((#{quote("users.email")} = 'test@example.com' OR #{quote("users.password")} = 'secure password') AND #{quote("users.active")} = 't')", d.to_where_sql
+    assert_equal ((a|b)&c).to_where_sql, d.to_where_sql
+  end
+  
+  def test_or
+    a = User.email == "test@example.com"
+    b = User.password == "secure password"
+    c = (User.email == "test@example.com") | (User.password == "secure password")
+    assert c.is_a?(Criteria)
+    assert_equal "(#{quote("users.email")} = 'test@example.com' OR #{quote("users.password")} = 'secure password')", c.to_where_sql
+    # assert_equal "(users.email = 'test@example.com' OR users.password = 'secure password')", c.to_where_sql
+    assert_equal (a|b).to_where_sql, c.to_where_sql
+  end
+  
+  def test_and
+    a = User.email == "test@example.com"
+    b = User.password == "secure password"
+    c = (User.email == "test@example.com") & (User.password == "secure password")
+    assert c.is_a?(Criteria)
+    assert_equal "(#{quote("users.email")} = 'test@example.com' AND #{quote("users.password")} = 'secure password')", c.to_where_sql
+    # assert_equal "(users.email = 'test@example.com' AND users.password = 'secure password')", c.to_where_sql
+    assert_equal (a&b).to_where_sql, c.to_where_sql
+  end
+end

data/test/test_examples.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+# Test examples given in docs
+class ExamplesTest < Test::Unit::TestCase
+  TIME1=10.hours.ago
+  TIME2=20.days.ago
+  EXPECTED_HASH = {
+    :select => nil,
+    :order => nil,
+    :group => nil,
+    :include => [],
+    :offset => nil,
+    :limit => nil,
+    :conditions => "((users.\"role\" = '--- :admin\n' OR users.\"active\" = 'f' OR users.\"created_at\" > '#{TIME2.to_s(:db)}') AND (users.\"role\" = '--- :editor\n' OR users.\"active\" = 't' OR (users.\"created_at\" > '#{TIME1.to_s(:db)}' AND users.\"created_at\" < '#{TIME2.to_s(:db)}')))"
+  }
+  def test_big_terse
+    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))
+    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)
+    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)
+      end
+    end
+    
+    assert_equal EXPECTED_HASH, criteria.to_hash
+    EXPECTED_HASH.each do |k,v|
+      assert_equal EXPECTED_HASH[k], criteria.to_hash[k]
+    end
+  end
+end

data/test/test_order.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/criteria.rb'
+require 'test/mock_classes.rb'
+
+class OrderTest < Test::Unit::TestCase
+  
+  def test_order_asc
+    a = User.email.asc
+    assert_equal "#{quote("users.email")} ASC", a.to_s
+    assert_equal "ASC", a.dir
+    assert_equal User.email, a.column
+  end    
+  
+  def test_order_desc
+    a = User.email.desc
+    assert_equal "#{quote("users.email")} DESC", a.to_s
+    assert_equal "DESC", a.dir
+    assert_equal User.email, a.column
+  end
+end

data/test/test_suite.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'test/test_criterion.rb'
+require 'test/test_criteria.rb'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: Object-orientated Criteria for ActiveRecord
+require_paths: 
+- lib
+email: ray@wirestorm.net
+homepage: http://criteria.rubyforge.org
+rubyforge_project: 
+description: An object-orientated approach to assembling complex criteria for querying ActiveRecord.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ray Hilton
+files: 
+- lib/criteria.rb
+- README
+test_files: 
+- test/test_active_record.rb
+- test/test_associations.rb
+- test/test_column.rb
+- test/test_criteria.rb
+- test/test_criterion.rb
+- test/test_examples.rb
+- test/test_order.rb
+- test/test_suite.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: