johnbender-rquery 0.2.0 → 0.3.0

data/README.markdown

@@ -1,3 +1,4 @@
+
 RQuery
 ======
 
@@ -8,35 +9,25 @@ Currently only the ActiveRecord extension is implemented with a Sqlite adapter.
 ActiveRecord
 ------------
 
-###Setup/Config and Symbols vs Block parameters
+###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.adapter = class 
+    RQuery::Config.adapter = class 
 
 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.
 
-Also, you can choose to use symbols as the attribute names in the block or you can use an option block argument to represent an ActiveRecord object. To use the symbols make sure to add the following to your environment.rb
-
-    RQuery.use_symbols
-
-Using the block parameter instead has two benefits. 1: you won't be poluting the Symbol objects with my hackery, and 2: RQuery will tell you when you are attempting use an attribute for the object that doesn't exist. Examples of both below.
-
 ###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] }
-
-Or
-
-    @user = User.where { |user| user.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:
 
@@ -44,12 +35,6 @@ 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 |user|
         user.age.between 10..20 
     end
@@ -58,28 +43,28 @@ Both the `from` and `between` methods accept argument lists `10,20` or an array
 
 ###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 |obj|
-        obj.foo.is > 2      
-        obj.foo.is_not == 4 
+        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 |obj|
+    @obj = ActiveRecordObject.where do |obj|
         obj.foo.in "bar", "baz", "bak"
     end
     #=> conditions array: ["foo in (?)", ["bar", "baz", "bak"]]
@@ -90,8 +75,8 @@ 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:
@@ -103,7 +88,7 @@ is equivalent to the find call:
 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|
-        (mock.age.is > 20) | (mock.age.in 16,18)
+        (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" 

data/lib/rquery.rb

@@ -3,23 +3,17 @@ $: << 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/attribute.rb"
+require "rquery/operation_collector.rb"
 require "rquery/attribute_collection.rb"
 require "rquery/adapters.rb"
 require "rquery/active_record.rb"
 
 module RQuery
-  class << self 
-    attr_accessor :adapter
-
-    def use_symbols
-      Symbol.send(:include, RQuery::Declarations)
+  class Config
+    @@adapter = RQuery::Adapters::Sqlite
+    def self.adapter=(value)
+      @@adapter =  value
     end
-  
-  end  
+    def self.adapter; @@adapter end
+  end
 end
-
-##default adapter
-RQuery.adapter = RQuery::Adapters::Sqlite

data/lib/rquery/active_record/base.rb

@@ -1,26 +1,15 @@
 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
-
-        #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(RQuery::AttributeCollection.new(self.new.attribute_names))
-
-        #record altered conditions and values
-        conditions = ::RQuery::Serializers::Operations.conditions
-
-        #clear the alterations
-        RQuery::Serializers::Operations.clear
-      end
+      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

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

@@ -1,10 +1,12 @@
 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"
@@ -22,11 +24,31 @@ module RQuery
     # 	from /Users/johnbender/Projects/rquery/lib/rquery/where_clause.rb:20:in `method_missing'
     # 	from (irb):5
     def method_missing(symbol, *args)
-      if @fields.include?(symbol.to_s)
-        Attribute.new(symbol)
+      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

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

@@ -4,74 +4,71 @@ require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
 describe ActiveRecord do
 
   before(:all) do
-    RQuery.adapter = RQuery::Adapters::Sqlite
+    RQuery::Config.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::MockObject.respond_to?(:where).should == true
   end
   
-  it "should return sql with foo, the operations, and the values for mock.foo.is <operation> <value>" do
-    
+  it "should return sql with foo, the operations, and the values for mock.foo <operation> <value>" do
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is == "bar"
-    }.should == [:all, {:conditions => ["(foo = ?)", "bar"]}]  
+      mock.foo == "bar"
+      mock.foo = "bar"
+    }.should == [:all, {:conditions => ["(foo = ? and foo = ?)", "bar", "bar"]}]  
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is > 1
+      mock.foo > 1
     }.should == [:all, {:conditions => ["(foo > ?)", 1]}]
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is < 2
+      mock.foo < 2
     }.should == [:all, {:conditions => ["(foo < ?)", 2]}]
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is >= 3
+      mock.foo >= 3
     }.should == [:all, {:conditions => ["(foo >= ?)", 3]}]
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is <= 4
+      mock.foo <= 4
     }.should == [:all, {:conditions => ["(foo <= ?)", 4]}]
-
   end
 
-  it "should return sql with foo, the operations, and the values for mock.foo.is_not <operation> <value>" do
+  it "should return sql with foo, the operations, and the values for mock.foo.not_<operation> <value>" do
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is_not == "bar"
+      mock.foo.not = "bar"
     }.should == [:all, {:conditions => ["(foo <> ?)", "bar"]}]  
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is_not.in 1,2
+      mock.foo.not_in 1,2
     }.should == [:all, {:conditions => ["(foo not in (?))", [1,2]]}] 
     
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is_not.between 1..3
+      mock.foo.not_between 1..3
     }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is_not.from 1..3
+      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.is.in and mock.foo.in when used with a list of args, array, and range" do
-    
+  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.is.in 1,2,3,4
+      mock.foo.in 1,2,3,4
     }.should == resulting_conditions  
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.in [1,2,3,4]
+      mock.foo.in [1,2,3,4]
     }.should == resulting_conditions 
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.in 1..4
+      mock.foo.in 1..4
     }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
     
     ActiveRecord::MockObject.where{ |mock|
@@ -85,23 +82,21 @@ describe ActiveRecord do
     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.is.between and mock.foo.between when used with a list of args, array, and range" do
-
+  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.is.between 1,2
+      mock.foo.between 1,2
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.between [1,2]
+      mock.foo.between [1,2]
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.between 1..2
+      mock.foo.between 1..2
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
@@ -115,23 +110,21 @@ describe ActiveRecord do
     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.is.from when used with a list of args, array, and range" do
-
+  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.is.from 1,2
+      mock.foo.from 1,2
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.from [1,2]
+      mock.foo.from [1,2]
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
-      mock.foo.is.from 1..2
+      mock.foo.from 1..2
     }.should == resulting_conditions
 
     ActiveRecord::MockObject.where{ |mock|
@@ -145,72 +138,58 @@ describe ActiveRecord do
     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.is == "bar"
-      mock.foo.is_not.in 1,2,3,4,5 
+      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.is == "bar"
-      mock.foo.is_not.in 1,2,3,4,5 
+      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.is == "bar"
-      mock.foo.is_not.in 1,2,3,4,5 
-      mock.foo.is > 3
+      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.is.between "some string", "2007-01-01"
+      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.is_not.between "some string", "2007-01-01"
+      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.is.from "some string", "2007-01-01"
+      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).is == 2 }}.should raise_error(RQuery::AttributeNotFoundError)
+    lambda { ActiveRecord::MockObject.where{ |mock| mock.send(attribute) == 2 }}.should raise_error(RQuery::AttributeNotFoundError)
   end
-
 end