rquery 0.1.2 → 0.3.0

data/README.markdown

@@ -1,25 +1,33 @@
+
 RQuery
 ======
 
 RQuery is a small DSL inspired by RSpec for building text queries in languages like SQL. It is meant to be concise, easy to read, and expressive about what the query will be asking for.
 
-Currently only the ActiveRecord extension is implemented with a Sqlite adapter. Mysql should follow shortly, and then support for Grove + JSON queries to Mnesia.
+Currently only the ActiveRecord extension is implemented with a Sqlite adapter. Mysql should be trivial to implement, and I'm hoping to get to supporting my own project Grove.
 
 ActiveRecord
 ------------
 
-RQuery extend ActiveRecord to provide the `where` method. `where` accepts a single optional argument and a block that represents the query statements
+###Setup/Config
+
+In you're rails environment file simply require rquery. The default adapter is the included Sqlite adapter but you can created and set your own with
+
+    RQuery::Config.adapter = class 
 
-###Example compared with `find`
+You can view both Sql and Sqlite in the adapters directory if you are interested in writing your own (mysql?). As a side note it would be nice at some point to decide the adapter based on the db chosen for a given environment.
+
+###Examples
+
+RQuery extend ActiveRecord to provide the `where` method. `where` accepts a single optional argument and a block that represents the query statements
 
 In a given UsersController your `show` action might find the User like so:
 
-    @user = User.find(params[:id])
+    @user = User.find(params[:age])
 
 Using RQuery:
 
-    @user = User.where { :id.is == params[:id] }
-
+    @user = User.where { |user| user.age == params[:age] }
 
 In the above case, RQuery doesn't provide much of an improvement over the traditional `find` method, but as the query becomes more complex its expressiveness begins to shine through:
 
@@ -27,43 +35,37 @@ In the above case, RQuery doesn't provide much of an improvement over the tradit
 
 RQuery:
 
-    @users = User.where do 
-        :age.from 10..20 
-    end
-
-Or:
-
-    @users = User.where do 
-        :age.between 10..20 
+    @users = User.where do |user|
+        user.age.between 10..20 
     end
 
 Both the `from` and `between` methods accept argument lists `10,20` or an array `[10,20]`. 
 
-
 ###Other Examples 
 
-RQuery supports most of the common SQL operations: =, <>, >, <, >=, <=  as well as in, like (see below for specifics), and between. `:column.is_not` works for `.in`, `.between`, `.contains`, and `==`. All operations are anded as of the current version.
+RQuery supports most of the common SQL operations: =, <>, >, <, >=, <=  as well as in, like (see below for specifics), and between. `obj.foo.not_<operation>` works for `.in` and  `.between` with the negation of == being `obj.foo.not = ` and the negation of `obj.foo.contains` as `obj.foo.without`.
 
 Operators:
 
-    @obj = ActiveRecordObject.where do
-        :foo.is > 2      
-        :foo.is_not == 4 
+    @obj = ActiveRecordObject.where do |obj|
+        obj.foo > 2      
+        obj.foo.not = 4 
     end 
+
     #=> conditions array: ["foo > ? and foo <> ?", 2, 4]
 
 Contains:
 
-    @obj = ActiveRecordObject.where do
-        :foo.contains "bar"
+    @obj = ActiveRecordObject.where do |obj|
+        obj.foo.contains "bar"
     end
     #=> conditions array: ["foo like '%' || ? || '%'", "bar"]
     #using the default sqlite adapter
 
 In:
 
-   @obj = ActiveRecordObject.where do
-        :foo.in "bar", "baz", "bak"
+    @obj = ActiveRecordObject.where do |obj|
+        obj.foo.in "bar", "baz", "bak"
     end
     #=> conditions array: ["foo in (?)", ["bar", "baz", "bak"]]
     #using the default sqlite adapter
@@ -73,14 +75,44 @@ You can also limit the results returned in a similar manner to the `find` method
 
 First:
 
-    @obj = ActiveRecordObject.where(:first) do
-        :foo.is == "bar"
+    @obj = ActiveRecordObject.where(:first) do |obj|
+        obj.foo == "bar"
     end
 
 is equivalent to the find call:
 
     @obj = ActiveRecordObject.find(:first, conditions => ["foo = ?", "bar"])
 
+###Complex queries
+
+RQuery supports relatively complex queries including | and & operation groupings. All operations need to be on the same line and in parens and either the | operator or the & operator can be used on a singel line
+
+    User.where do |user|
+        (user.age > 20) | (user.age.in 16,18)
+    end
+
+In the following example the & takes precedence and will be grouped with the contains "Alice" which will be or'd with the contains "George" 
+
+    #=> name contains "George" or (name contains "Alice and age from 20 to 30)
+    User.where do |user|
+        (user.name.contains "George") | (user.name.contains "Alice") & (use.age.from 20..30)
+    end
+
+To correct the above to the more intuitive version add parens to force precedence of the contains operations 
+    
+    #=> (name contains "George" or name contains "Alice) and age from 20 to 30
+    User.where do |user|
+        ((user.name.contains "George") | (user.name.contains "Alice")) & (use.age.from 20..30)
+    end
+
+In this sutation it would be cleaner and easier to just move the and'd statement down a line as all seperate lines are and'd and lines have precedence from top to bottom
+    
+    User.where do |user|
+        (user.name.contains "George") | (user.name.contains "Alice")
+        use.age.from 20..30
+    end
+
+
 
 
 

data/lib/rquery.rb

@@ -2,24 +2,18 @@ $: << File.expand_path(File.dirname(__FILE__) + "/../lib/")
 
 #RQuery is a small DSL for building queries in query languages like SQL. It is meant to be concise, easy to read
 #and expressive.
-#
 
-
-require "rquery/serializers.rb"
-require "rquery/declarations.rb"
+require "rquery/operation_collector.rb"
+require "rquery/attribute_collection.rb"
 require "rquery/adapters.rb"
 require "rquery/active_record.rb"
 
 module RQuery
+  class Config
     @@adapter = RQuery::Adapters::Sqlite
-    
-    #Allows for the runtime alteration of the adapter being used
-    #to convert the "rqueries" into the adapters query language
-    def RQuery.adapter=(val)
-        @@adapter = val
-    end
-    def RQuery.adapter
-        @@adapter
+    def self.adapter=(value)
+      @@adapter =  value
     end
+    def self.adapter; @@adapter end
+  end
 end
-

data/lib/rquery/active_record/base.rb

@@ -1,35 +1,26 @@
 module RQuery
-    module ActiveRecord
-        @@where_mutex = Mutex.new
-        def where(*args, &block)
-
-            #establish scope for conditions
-            conditions = nil
-
-            #make sure only one thread at a time is altering the class
-            #variables inside RQuery::Serializers::Operations
-            @@where_mutex.synchronize do
-
-                #yielding the block will alter the Operations class
-                yield
-
-                #record altered conditions and values
-                conditions = ::RQuery::Serializers::Operations.conditions
-
-                #clear the alterations
-                ::RQuery::Serializers::Operations.clear
-            end
-
-            #limit the records returned (:first, :all, :last)
-            limit = args.first ? args.first : :all
-
-            #call find with the conditions and values provided by the block
-            find(limit, :conditions => conditions)
-        end
+  module ActiveRecord
+    def where(*args, &block)
+      collector = RQuery::AttributeCollection.new(self.new.attribute_names)
+      
+      #Passes a new AttributeCollection object to the block
+      #if RQuery.use_symbols has been called it may not be used
+      #but otherwise will take the form attr_coll_object.attribute.is ...
+      yield(collector)
+
+      #record altered conditions and values
+      conditions = collector.clauses.to_conditions
+
+      #limit the records returned (:first, :all, :last)
+      limit = args.first ? args.first : :all
+
+      #call find with the conditions and values provided by the block
+      find(limit, :conditions => conditions)
     end
+  end
 end
 
 #extend ActiveRecord::Base with the where method 
 if Object.const_defined?(:ActiveRecord)
-    ActiveRecord::Base.send :extend, RQuery::ActiveRecord
+  ActiveRecord::Base.send :extend, RQuery::ActiveRecord
 end

data/lib/rquery/adapters/sql.rb

@@ -31,9 +31,13 @@ module RQuery
                 def contains
                     "like '%' + ? + '%'"
                 end
+                
+                def and_group(ops)
+                  "(#{ops.join(" and ")})"
+                end
 
-                def join(ops)
-                    ops.join(" and ")
+                def or_group(ops)
+                  "(#{ops.join(" or ")})"
                 end
 
                 [:>, :>=, :<, :<=].each do |operator|
@@ -41,6 +45,8 @@ module RQuery
                         "#{operator} ?"
                     end
                 end
+
+                alias :join :and_group
             end
         end
     end

data/lib/rquery/adapters/sqlite.rb

@@ -5,7 +5,7 @@ module RQuery
             def self.contains
                 "like '%' || ? || '%'"
             end
-            def self.not_contains
+            def self.without
                 "not #{contains}"
             end
         end

data/lib/rquery/attribute_collection.rb

@@ -0,0 +1,57 @@
+module RQuery
+  class AttributeCollection
+    attr_reader :clauses
+
+    def initialize(fields)
+      @fields = fields.map{ |x| x.to_s }
+      @clauses = OperationCollector.new
+    end
+
+    #if the field was added upon initialization its a valid call
+    #otherwise report to the user it is invalid. Reports errors at the ruby level
+    #instead of the data store level with something like "column doesn't exist"
+    #
+    #example
+    #
+    # >> user = RQuery::FieldCollection.new([:age, :name])
+    # => #<RQuery::FieldCollection:0x1a2c21c @fields=[:age, :name]>
+    # >> user.age
+    # => #<RQuery::Field:0x1a2b240 @name=:age>
+    # >> user.name
+    # => #<RQuery::Field:0x1a2a390 @name=:name>
+    # >> user.weight
+    # ArgumentError: The field 'weight' doesn't exist for this object
+    # 	from /Users/johnbender/Projects/rquery/lib/rquery/where_clause.rb:20:in `method_missing'
+    # 	from (irb):5
+    def method_missing(symbol, *args)
+      attr_str = symbol.to_s
+      eq_str = attr_str.gsub(/=/, '')
+
+      if @fields.include?(attr_str) #if the method is part of the attributes 
+        add_clause(attr_str)
+      elsif @fields.include?(eq_str) #if the method sans '=' is part of the attributes
+        add_clause(eq_str)
+        eq(*args)
+      else
+        raise AttributeNotFoundError, "The field '#{symbol.to_s}' doesn't exist for this object" 
+      end
+
+      #explicit return of OperationCollector, same instance returned by methods of Operation collector
+      #but included here for clarity
+      @clauses
+    end
+
+
+    private
+    def add_clause(str)
+      @clauses.add_operation(str)
+    end
+    
+    def eq(*args)
+      @clauses.send(:==, *args)
+    end
+
+  end
+
+  class AttributeNotFoundError < ArgumentError; end
+end

data/lib/rquery/operation_collector.rb

@@ -0,0 +1,175 @@
+module RQuery
+  class OperationCollector
+    NOT_PREFIX = 'not_'
+    NIL_PREFIX = ''
+
+    def initialize
+      # @name, @prefix = optns[:name], optns[:prefix]
+      @operations = []
+      @values = []
+    end
+
+    def to_s
+      RQuery::Config.adapter.join(@operations)
+    end
+    
+    #return a conditions array for use with ActiveRecord.find
+    def to_conditions
+      [to_s] + @values
+    end
+    
+    #add and operation to the @operations array which will be popped
+    #and pushed depending on the operations sequence and arrangement
+    def add_operation(val)
+      @operations << val.to_s
+      self
+    end
+    
+    #grouping is done by using the | and & operators between multiple operations
+    #objects on a single line.
+    #
+    #This works because each operation ie (user.age.is == 2) is
+    #evaluated before these two operators thus pushing
+    #the equivelant operation string onto the @operations array (ie 'age = ?'). 
+    #When an operation is evaluated it returns the Operations class which can be compared
+    #using the aforementioned operators. Those operators call the group method
+    #popping the last two arguments off the stack and dealing with them in one of two ways
+    #
+    #1. if the second object popped is a string both objects should be
+    #   added to a new OperationGroup which is then put back onto the stack
+    #
+    #2. if the second object popped is an OperationGroup the firest belongs to this group as
+    #   well (it was on the same line). It is added to the OperationGroup and put back on the
+    #   stack
+    #
+    #TODO requires refactoring
+    def group(type)
+      second_op, first_op = @operations.pop, @operations.pop
+      
+      #if the previous operation on the stack is an Operation Group we need to add to it
+      #and push it back on the @operations stack
+      if first_op.class == OperationsGroup
+        if first_op.type == type
+          first_op.ops << second_op
+          @operations << first_op
+        else
+          @operations << OperationsGroup.new(first_op.to_s, second_op, type)
+        end
+      else
+        @operations << OperationsGroup.new(first_op, second_op, type)
+      end
+
+      self
+    end
+    
+    #used to group operations for anding on a single line
+    #example with sqlite adapter
+    #(user.age.in [1,2,3]) | (user.name.contains "foo")
+    #=>(age in (?) and name like '%' || 'foo' || '%')
+    def &(second)
+      group :and
+    end
+    
+    def |(second)
+      group :or
+    end
+
+    def in(*args)
+      call_in(NIL_PREFIX, *args)
+    end
+    
+    def not_in(*args)
+      call_in(NOT_PREFIX, *args)
+    end
+    
+    def between(*args)
+      call_between(NIL_PREFIX, *args)
+    end
+    
+    def not_between(*args)
+      call_between(NOT_PREFIX, *args)
+    end
+
+    def contains(str)
+      @values << str
+      chain :contains
+    end
+
+    def without(str)
+      @values << str
+      chain :without
+    end
+
+    def not=(arg)
+      @values << arg
+      chain :neq
+    end
+
+    [:==, :>, :>=, :<, :<=, :neq].each do |operator|                    
+      define_method(operator) do |val|
+        @values << val
+        chain operator
+      end
+    end
+    
+    #allows for is.from
+    #examples:
+    #
+    #:id.is.from 1,2
+    #:is.is.from 2..10
+    alias :from :between
+    alias :not_from :not_between
+
+    private 
+    def chain(method)
+      @operations[@operations.length-1] += " #{RQuery::Config.adapter.send(method)}"
+      self
+    end
+
+    def call_in(prefix=nil, *args)
+      #flatten our args to prevent having to check for an array first arg
+      args.flatten!
+      
+      #if a range is passed as the first argument 
+      #use it alone, otherwise use the args array 
+      #examples:
+      #ruby => args.flatten! => stored values
+      #:id.between 1..100 => [1..100] => 1..100
+      #:id.between [1, 2, 3] => [1, 2, 3] => [1, 2, 3]
+      #:id.between 1, 2 => [1, 2] => [1, 2] 
+      @values << (args.first.class == Range ? args.first : args)
+      chain :"#{prefix}in"
+    end
+
+    def call_between(prefix=nil, *args)      
+      #flatten our args to prevent having to check for an array first arg
+      args.flatten!
+      
+      #if a range is passed use its first/last element 
+      #otherwise use the first and last element of the flattened args array
+      #examples:
+      #ruby => args.flatten! => stored values
+      #:id.between 1..100 => [1..100] => 1 100
+      #:id.between [1, 2, 3] => [1, 2, 3] => 1 3
+      #:id.between 1, 2 => [1, 2] => 1 2 
+ 
+      @values += (args.first.class == Range ? [args.first.first, args.first.last] : [args.first, args.last])
+      chain :"#{prefix}between"
+    end
+  end
+  
+  class OperationsGroup
+    attr_accessor :ops, :type
+    
+    def initialize(left, right, type)
+      @ops = Array.new
+      @ops << left
+      @ops << right
+      @type = type
+    end
+    
+    def to_s
+      RQuery::Config.adapter.send("#{type.to_s}_group", @ops)
+    end
+  end
+end

data/rakefile.rb

@@ -3,5 +3,6 @@ require 'spec/rake/spectask'
 
 desc "Run all specs"
 Spec::Rake::SpecTask.new('specs') do |t|
-      t.spec_files = FileList['spec/*.rb']
+  t.spec_files = FileList['spec/*.rb']
+  t.rcov = true
 end

data/spec/active_record_base_spec_attribute_collection.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.dirname(__FILE__) + "/mock_active_record.rb")
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+
+describe ActiveRecord do
+
+  before(:all) do
+    RQuery::Config.adapter = RQuery::Adapters::Sqlite
+  end
+
+  it "should set up a where method" do
+    ActiveRecord::MockObject.respond_to?(:where).should == true
+  end
+  
+  it "should return sql with foo, the operations, and the values for mock.foo <operation> <value>" do
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo == "bar"
+      mock.foo = "bar"
+    }.should == [:all, {:conditions => ["(foo = ? and foo = ?)", "bar", "bar"]}]  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo > 1
+    }.should == [:all, {:conditions => ["(foo > ?)", 1]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo < 2
+    }.should == [:all, {:conditions => ["(foo < ?)", 2]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo >= 3
+    }.should == [:all, {:conditions => ["(foo >= ?)", 3]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo <= 4
+    }.should == [:all, {:conditions => ["(foo <= ?)", 4]}]
+  end
+
+  it "should return sql with foo, the operations, and the values for mock.foo.not_<operation> <value>" do
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.not = "bar"
+    }.should == [:all, {:conditions => ["(foo <> ?)", "bar"]}]  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.not_in 1,2
+    }.should == [:all, {:conditions => ["(foo not in (?))", [1,2]]}] 
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.not_between 1..3
+    }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.not_from 1..3
+    }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
+    
+     ActiveRecord::MockObject.where{ |mock|
+      mock.foo.without "bar"
+    }.should == [:all, {:conditions => ["(foo not like '%' || ? || '%')", "bar"]}]
+  end
+
+  it "should return sql with foo, the operations, and values for mock.foo.in and mock.foo.in when used with a list of args, array, and range" do
+    resulting_conditions = [:all, {:conditions => ["(foo in (?))", [1,2,3,4]]}] 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in 1,2,3,4
+    }.should == resulting_conditions  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in [1,2,3,4]
+    }.should == resulting_conditions 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in 1..4
+    }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in 1,2,3,4
+    }.should == resulting_conditions  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in [1,2,3,4]
+    }.should == resulting_conditions 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in 1..4
+    }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
+  end
+
+  it "should return sql with foo, operations, and values for mock.foo.between and mock.foo.between when used with a list of args, array, and range" do
+    resulting_conditions = [:all, {:conditions => ["(foo between ? and ?)", 1, 2]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between 1,2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between [1,2]
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between 1..2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between 1,2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between [1,2]
+    }.should == resulting_conditions
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between 1..2
+    }.should == resulting_conditions
+  end
+
+  it "should return sql with foo, operations, and values for mock.foo.from when used with a list of args, array, and range" do
+    resulting_conditions = [:all, {:conditions => ["(foo between ? and ?)", 1, 2]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from 1,2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from [1,2]
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from 1..2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from 1,2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from [1,2]
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from 1..2
+    }.should == resulting_conditions
+  end
+
+  it "should return sql with foo, operations, and values for mock.foo.contains when used with a range, array, and list" do
+    resulting_conditions = [:all, {:conditions => ["(foo like '%' || ? || '%')", "bar"]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.contains "bar"
+    }.should == resulting_conditions
+  end
+
+  it "should return return the correct group of joined sql after multiple operations" do
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo == "bar"
+      mock.foo.not_in 1,2,3,4,5 
+    }.should == [:all, {:conditions => ["(foo = ? and foo not in (?))", "bar", [1,2,3,4,5]]}]
+  end
+
+  it "should return return the correct limit value passed" do
+    ActiveRecord::MockObject.where(:first){ |mock|
+      mock.foo == "bar"
+      mock.foo.not_in 1,2,3,4,5 
+    }.should == [:first, {:conditions => ["(foo = ? and foo not in (?))", "bar", [1,2,3,4,5]]}]
+  end
+
+  it "should have the correct 'not' keywords in alternating operations" do
+    ActiveRecord::MockObject.where(:first){ |mock| 
+      mock.foo == "bar"
+      mock.foo.not_in 1,2,3,4,5 
+      mock.foo > 3
+    }.should == [:first, {:conditions => ["(foo = ? and foo not in (?) and foo > ?)", "bar", [1,2,3,4,5], 3]}]
+  end
+
+  it "should return return strings as arguments when passed to between, in, and from (used for date strings)" do
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.between "some string", "2007-01-01"
+    }.should == [:all, {:conditions => ["(foo between ? and ?)", "some string", "2007-01-01"]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.not_between "some string", "2007-01-01"
+    }.should == [:all, {:conditions => ["(foo not between ? and ?)", "some string", "2007-01-01"]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.from "some string", "2007-01-01"
+    }.should == [:all, {:conditions => ["(foo between ? and ?)", "some string", "2007-01-01"]}]
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.in "some string", "2007-01-01"
+    }.should == [:all, {:conditions => ["(foo in (?))", ["some string", "2007-01-01"]]}]
+  end
+
+  it "should throw and exception when trying to use a field not in the objects attributes" do    
+    attribute = "arbitrary_attribute_name"
+    lambda { ActiveRecord::MockObject.where{ |mock| mock.send(attribute) == 2 }}.should raise_error(RQuery::AttributeNotFoundError)
+  end
+end

data/spec/mock_active_record.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  class Base
+    def Base.find(limit, conditions)
+      [limit, conditions]
+    end
+  end
+  
+  class MockObject < Base
+    def attribute_names
+      ["foo"]
+    end
+  end
+end

data/spec/or_and_operations_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + "/mock_active_record.rb")
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+
+describe RQuery::OperationCollector do
+
+  before(:all) do
+    RQuery::Config.adapter = RQuery::Adapters::Sqlite
+  end
+
+  it "should group two operations on the same line with parens and the 'or' keyword when the | operator is used" do
+
+    ActiveRecord::MockObject.where{ |mock|
+      (mock.foo == 2) | (mock.foo.in 1,2,3)
+    }.should == [:all, {:conditions => ["((foo = ? or foo in (?)))", 2, [1,2,3]]}]
+
+  end
+
+  it "should group two operations on the same line with parns and the 'and' keyword when the & operator is used" do
+    
+    ActiveRecord::MockObject.where{ |mock|
+      (mock.foo == 2) & (mock.foo.in 1,2,3)
+    }.should == [:all, {:conditions => ["((foo = ? and foo in (?)))", 2, [1,2,3]]}]
+    
+  end
+
+  it "should group two operations on the same line and continue to add subsequent operations" do
+
+    ActiveRecord::MockObject.where{ |mock|
+      (mock.foo == 2) & (mock.foo.in 1,2,3)
+      mock.foo > 3
+    }.should == [:all, {:conditions => ["((foo = ? and foo in (?)) and foo > ?)", 2, [1,2,3], 3]}]
+    
+  end
+
+  it "should properly group multiple nested groupings on the same line" do
+
+    ActiveRecord::MockObject.where{ |mock|
+      (mock.foo == 2) | (mock.foo.in 1,2,3) | (mock.foo.contains "george")
+      mock.foo > 3
+      (mock.foo == 2) & (mock.foo.in 1,2,3)
+    }.should == [:all, {:conditions => ["((foo = ? or foo in (?) or foo like '%' || ? || '%') and foo > ? and (foo = ? and foo in (?)))", 2, [1,2,3], "george", 3, 2, [1,2,3]]}]
+    
+  end
+
+  it "& should have precedence when evaluating multiple operation group types on a single line" do
+    
+     ActiveRecord::MockObject.where{ |mock|
+      (mock.foo == 2) | (mock.foo.in 1,2,3) & (mock.foo.contains "george")
+    }.should == [:all, {:conditions => ["((foo = ? or (foo in (?) and foo like '%' || ? || '%')))", 2, [1,2,3], "george"]}]
+    
+
+  end
+
+end

data/spec/sqlite_adapter_spec.rb

@@ -15,7 +15,7 @@ describe RQuery::Adapters::Sqlite do
         @adapter.not_between.should == "not " + @adapter.between
         @adapter.neq.should == "<> ?"
         @adapter.contains.should == "like '%' || ? || '%'"
-        @adapter.not_contains.should == "not " + @adapter.contains 
+        @adapter.without.should == "not " + @adapter.contains 
     end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rquery
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors: 
 - John bender
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2000-03-16 00:00:00 -05:00
+date: 2009-08-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,19 +25,21 @@ files:
 - README.markdown
 - rakefile.rb
 - lib/rquery.rb
-- lib/rquery/declarations.rb
-- lib/rquery/serializers.rb
+- lib/rquery/attribute_collection.rb
 - lib/rquery/active_record.rb
 - lib/rquery/active_record/base.rb
 - lib/rquery/adapters.rb
 - lib/rquery/adapters/sql.rb
 - lib/rquery/adapters/sqlite.rb
-- spec/active_record_base_spec.rb
-- spec/serializers_spec.rb
-- spec/declarations_spec.rb
+- lib/rquery/operation_collector.rb
+- spec/active_record_base_spec_attribute_collection.rb
+- spec/mock_active_record.rb
+- spec/or_and_operations_spec.rb
 - spec/sqlite_adapter_spec.rb
 has_rdoc: true
-homepage: http://nickelcode.com/rquery/
+homepage: http://github.com/johnbender/rquery
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -58,9 +60,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
-summary: A ruby DSL for building data queries in SQL and other query languages.
+specification_version: 3
+summary: An ActiveRecord extension providing a DSL replacement for complex find queries.
 test_files: []
 

data/lib/rquery/declarations.rb

@@ -1,39 +0,0 @@
-
-module RQuery
-    module Declarations
-        def is
-            ::RQuery::Serializers::IsOperations.add_operation(self)
-            ::RQuery::Serializers::IsOperations.prefix = nil
-            ::RQuery::Serializers::IsOperations
-        end
-
-        def is_not
-            ::RQuery::Serializers::IsNotOperations.add_operation(self)
-            ::RQuery::Serializers::IsNotOperations.prefix = "not_"
-            ::RQuery::Serializers::IsNotOperations
-        end
-
-        def in(*args)
-            ::RQuery::Serializers::IsOperations.add_operation(self)
-            ::RQuery::Serializers::IsOperations.prefix = nil
-            ::RQuery::Serializers::IsOperations.in(*args)
-        end
-
-        def between(*args)
-            ::RQuery::Serializers::IsOperations.add_operation(self)
-            ::RQuery::Serializers::IsOperations.prefix = nil
-            ::RQuery::Serializers::IsOperations.between(*args)
-        end
-
-        def contains(val)
-            ::RQuery::Serializers::IsOperations.add_operation(self)
-            ::RQuery::Serializers::IsOperations.prefix = nil
-            ::RQuery::Serializers::IsOperations.contains(val)
-        end
-
-        alias :from :between
-    end
-end
-
-Symbol.send :include, RQuery::Declarations
-

data/lib/rquery/serializers.rb

@@ -1,118 +0,0 @@
-module RQuery
-    module Serializers
-        #The Operations serializer, handles the limiting factors imposed
-        #by a given query. The methods in this class apply to both is and is_not
-        #operations. An example in sql would look like:
-        #
-        #where foo = bar and foo > 2
-        #
-        #This class is a gateway to the selected RQuery.adapter methods.
-        #Calls to methods here, will be passed on to the selected adapter 
-        class Operations
-        
-            @@prefix = nil
-            @@ops = []
-            @@values = []
-
-            class << self
-                def prefix=(val)
-                    @@prefix = val
-                end
-
-                def to_s
-                    RQuery.adapter.join(@@ops)
-                end
-
-                def conditions
-                    [to_s] + @@values
-                end
-
-                def add_operation(val)
-                    @@ops << val.to_s
-                end
-
-                def clear
-                    @@ops.clear
-                    @@values.clear
-                end
-
-                def in(*args)
-                    #flatten our args to prevent having to check for an array first arg
-                    args.flatten!
-                    
-                    #if a range is passed as the first argument 
-                    #use it alone, otherwise use the args array 
-                    #examples:
-                    #ruby => args.flatten! => stored values
-                    #:id.between 1..100 => [1..100] => 1..100
-                    #:id.between [1, 2, 3] => [1, 2, 3] => [1, 2, 3]
-                    #:id.between 1, 2 => [1, 2] => [1, 2] 
-                    #
-                    @@values << (args.first.class == Range ? args.first : args)
-                    @@ops[@@ops.length-1] += " #{RQuery.adapter.send("#{@@prefix}in")}"
-                end
-
-                def between(*args)
-                    #flatten our args to prevent having to check for an array first arg
-                    args.flatten!
-                    
-                    #if a range is passed use its first/last element 
-                    #otherwise use the first and last element of the flattened args array
-                    #examples:
-                    #ruby => args.flatten! => stored values
-                    #:id.between 1..100 => [1..100] => 1 100
-                    #:id.between [1, 2, 3] => [1, 2, 3] => 1 3
-                    #:id.between 1, 2 => [1, 2] => 1 2 
-                    #
-                    @@values += (args.first.class == Range ? [args.first.first, args.first.last] : [args.first, args.last])
-                    @@ops[@@ops.length-1] += " #{RQuery.adapter.send("#{@@prefix}between")}"
-                end
-
-                def contains(str)
-                    @@values << str
-                    @@ops[@@ops.length-1] += " #{RQuery.adapter.send("#{@@prefix}contains")}"
-                end
-
-                #allows for is.from
-                #examples:
-                #
-                #:id.is.from 1,2
-                #:is.is.from 2..10
-                alias :from :between
-
-            end
-
-        end
-
-        #The IsOpertaions serializer defines only methods that apply to the .is operator
-        #that is added to the Symbol class in the Declarations module.
-        class IsOperations < Operations
-
-            #define the normal operators for is to call the adapter for the equivelant sql
-            class << self
-                [:==, :>, :>=, :<, :<=].each do |operator|                    
-                    define_method(operator) do |val|
-                        @@values << val
-                        @@ops[@@ops.length-1] += " #{RQuery.adapter.send(operator)}"
-                    end
-                end
-            end
-        end
-
-        #The IsNotOperations serializer defines only methods that apply to the .is_not operator
-        #that is added to the symbol class in the declarations module. Specifically, == as 
-        #ruby does not allow for the overloading of !=
-        class IsNotOperations < Operations
-
-            #define the == value for is_not to call the adapter for the equivelant sql
-            class << self
-                define_method(:==) do |val|
-                    @@values << val
-                    @@ops[@@ops.length-1] += " #{RQuery.adapter.send(:neq)}"
-                end
-            end
-
-        end
-    
-    end
-end

data/spec/active_record_base_spec.rb

@@ -1,220 +0,0 @@
-module ActiveRecord
-    class Base
-        def Base.find(limit, conditions)
-           return [limit, conditions]
-        end
-    end
-end
-
-require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
-
-describe ActiveRecord do
-
-    before(:all) do
-        RQuery.adapter = RQuery::Adapters::Sqlite
-    end
-
-    #should really set up the find method defined above to use the ruby db libraries and 
-    #create the final sql string
-    #all run with default adapter
-
-    it "should set up a where method" do
-        ActiveRecord::Base.respond_to?(:where).should == true
-    end
-
-    it "should return sql with foo, the operations, and the values for :foo.is <operation> <value>" do
-        
-        ActiveRecord::Base.where{
-            :foo.is == "bar"
-        }.should == [:all, {:conditions => ["foo = ?", "bar"]}]  
-
-        ActiveRecord::Base.where{
-            :foo.is > 1
-        }.should == [:all, {:conditions => ["foo > ?", 1]}]
-
-        ActiveRecord::Base.where{
-            :foo.is < 2
-        }.should == [:all, {:conditions => ["foo < ?", 2]}]
-
-        ActiveRecord::Base.where{
-            :foo.is >= 3
-        }.should == [:all, {:conditions => ["foo >= ?", 3]}]
-
-        ActiveRecord::Base.where{
-            :foo.is <= 4
-        }.should == [:all, {:conditions => ["foo <= ?", 4]}]
-
-    end
-
-    it "should return sql with foo, the operations, and the values for :foo.is_not <operation> <value>" do
-         ActiveRecord::Base.where{
-            :foo.is_not == "bar"
-        }.should == [:all, {:conditions => ["foo <> ?", "bar"]}]  
-
-        ActiveRecord::Base.where{
-            :foo.is_not.in 1,2
-        }.should == [:all, {:conditions => ["foo not in (?)", [1,2]]}] 
-       
-        ActiveRecord::Base.where{
-            :foo.is_not.between 1..3
-        }.should == [:all, {:conditions => ["foo not between ? and ?", 1, 3]}] 
-
-        ActiveRecord::Base.where{
-            :foo.is_not.from 1..3
-        }.should == [:all, {:conditions => ["foo not between ? and ?", 1, 3]}] 
-
-    end
-
-    it "should return sql with foo, the operations, and values for :foo.is.in and :foo.in when used with a list of args, array, and range" do
-        
-        resulting_conditions = [:all, {:conditions => ["foo in (?)", [1,2,3,4]]}] 
-
-        ActiveRecord::Base.where{
-            :foo.is.in 1,2,3,4
-        }.should == resulting_conditions  
-
-        ActiveRecord::Base.where{
-            :foo.is.in [1,2,3,4]
-        }.should == resulting_conditions 
-
-        ActiveRecord::Base.where{
-            :foo.is.in 1..4
-        }.should == [:all, {:conditions => ["foo in (?)", 1..4]}]  
- 
-        ActiveRecord::Base.where{
-            :foo.in 1,2,3,4
-        }.should == resulting_conditions  
-
-        ActiveRecord::Base.where{
-            :foo.in [1,2,3,4]
-        }.should == resulting_conditions 
-
-        ActiveRecord::Base.where{
-            :foo.in 1..4
-        }.should == [:all, {:conditions => ["foo in (?)", 1..4]}]  
-
-    end
-
-    it "should return sql with foo, operations, and values for :foo.is.between and :foo.between when used with a list of args, array, and range" do
-
-        resulting_conditions = [:all, {:conditions => ["foo between ? and ?", 1, 2]}]
-
-        ActiveRecord::Base.where{
-            :foo.is.between 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.is.between [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.is.between 1..2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.between 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.between [1,2]
-        }.should == resulting_conditions
-        
-        ActiveRecord::Base.where{
-            :foo.between 1..2
-        }.should == resulting_conditions
-
-    end
-
-    it "should return sql with foo, operations, and values for :foo.is.from when used with a list of args, array, and range" do
-
-        resulting_conditions = [:all, {:conditions => ["foo between ? and ?", 1, 2]}]
-
-        ActiveRecord::Base.where{
-            :foo.is.from 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.is.from [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.is.from 1..2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.from 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.from [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::Base.where{
-            :foo.from 1..2
-        }.should == resulting_conditions
-
-
-    end
-
-    it "should return sql with foo, operations, and values for :foo.contains when used with a range, array, and list" do
-
-        resulting_conditions = [:all, {:conditions => ["foo like '%' || ? || '%'", "bar"]}]
-
-        ActiveRecord::Base.where{
-            :foo.contains "bar"
-        }.should == resulting_conditions
-
-    end
-
-
-    it "should return return the correct group of joined sql after multiple operations" do
-    
-        ActiveRecord::Base.where{
-            :foo.is == "bar"
-            :foo.is_not.in 1,2,3,4,5 
-        }.should == [:all, {:conditions => ["foo = ? and foo not in (?)", "bar", [1,2,3,4,5]]}]
-
-    end
-
-    it "should return return the correct limit value passed" do
-    
-        ActiveRecord::Base.where(:first){
-            :foo.is == "bar"
-            :foo.is_not.in 1,2,3,4,5 
-        }.should == [:first, {:conditions => ["foo = ? and foo not in (?)", "bar", [1,2,3,4,5]]}]
-
-    end
-
-    it "should have the correct 'not' keywords in alternating operations" do
-
-        ActiveRecord::Base.where(:first){
-            :foo.is == "bar"
-            :foo.is_not.in 1,2,3,4,5 
-            :foo.is > 3
-        }.should == [:first, {:conditions => ["foo = ? and foo not in (?) and foo > ?", "bar", [1,2,3,4,5], 3]}]
-
-    end
-
-    it "should return return strings as arguments when passed to between, in, and from (used for date strings)" do
-    
-        ActiveRecord::Base.where{
-            :foo.is.between "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["foo between ? and ?", "some string", "2007-01-01"]}]
-
-        ActiveRecord::Base.where{
-             :foo.is_not.between "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["foo not between ? and ?", "some string", "2007-01-01"]}]
-
-        ActiveRecord::Base.where{
-           :foo.is.from "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["foo between ? and ?", "some string", "2007-01-01"]}]
-    
-        ActiveRecord::Base.where{
-           :foo.in "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["foo in (?)", ["some string", "2007-01-01"]]}]
-
-    end
-
-    
-
-end

data/spec/declarations_spec.rb

@@ -1,47 +0,0 @@
-
-require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
-
-describe RQuery::Declarations do
-
-    before(:all) do
-        RQuery.adapter = RQuery::Adapters::Sqlite
-    end
-
-    after(:each) do
-        RQuery::Serializers::Operations.clear
-    end
-
-    it "any Object should respond to is, is_not, in, between, from, and contains methods" do
-        :foo.respond_to?(:is).should == true
-        :foo.respond_to?(:is_not).should == true
-        :foo.respond_to?(:in).should == true
-        :foo.respond_to?(:from).should == true
-        :foo.respond_to?(:between).should == true
-        :foo.respond_to?(:from).should == true
-    end
-
-    it "should return an Serializer Class when is, is_not are called" do
-        :foo.is.class.should == Class
-        :foo.is_not.class.should == Class
-    end 
-
-    it "should add an Operation for each call to is, is_not, and in" do
-        :foo.is
-        :bar.is
-        RQuery::Serializers::Operations.conditions.should == ["foo and bar"]    
-    end
-
-    it "should add an Operation and the arguments for each call to from, contain, and between" do
-        :foo.between 1,2
-        RQuery::Serializers::Operations.conditions.should == ["foo between ? and ?", 1 , 2]
-        RQuery::Serializers::Operations.clear 
-        :bar.from 1,2 
-        RQuery::Serializers::Operations.conditions.should == ["bar between ? and ?", 1 , 2]
-        RQuery::Serializers::Operations.clear 
-        :baz.contains "something" 
-        RQuery::Serializers::Operations.conditions.should == ["baz like '%' || ? || '%'", "something"]
-        RQuery::Serializers::Operations.clear 
-    end
-
-
-end

data/spec/serializers_spec.rb

@@ -1,30 +0,0 @@
-
-require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
-
-describe RQuery::Serializers do
-
-    it "Object.is should define ==, <, <=, >, >=, in, and between" do
-        :foo.is.respond_to?(:==).should == true
-        :foo.is.respond_to?(:<).should == true
-        :foo.is.respond_to?(:<=).should == true
-        :foo.is.respond_to?(:>).should == true
-        :foo.is.respond_to?(:>=).should == true
-        :foo.is.respond_to?(:in).should == true
-        :foo.is.respond_to?(:between).should == true
-    end
-
-    it "Object.is_not should define == and in" do
-        :foo.is_not.respond_to?(:==).should == true
-        :foo.is_not.respond_to?(:in).should == true
-        :foo.is_not.respond_to?(:between).should == true
-    end
-
-    it "Object.is_not should not redefine <, <=, >, >= in the same way that .is did" do
-        lambda {:foo.is_not.send(:<)}.should raise_error(ArgumentError)
-        lambda {:foo.is_not.send(:<=)}.should raise_error(ArgumentError)
-        lambda {:foo.is_not.send(:>)}.should raise_error(ArgumentError)
-        lambda {:foo.is_not.send(:>=)}.should raise_error(ArgumentError)
-    end
-
-
-end