johnbender-rquery 0.2.0 → 0.3.0

data/spec/or_and_operations_spec.rb

@@ -1,16 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + "/mock_active_record.rb")
 require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
 
-describe RQuery::Serializers::Operations do
+describe RQuery::OperationCollector do
 
   before(:all) do
-    RQuery.adapter = RQuery::Adapters::Sqlite
+    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.is == 2) | (mock.foo.in 1,2,3)
+      (mock.foo == 2) | (mock.foo.in 1,2,3)
     }.should == [:all, {:conditions => ["((foo = ? or foo in (?)))", 2, [1,2,3]]}]
 
   end
@@ -18,7 +18,7 @@ describe RQuery::Serializers::Operations do
   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.is == 2) & (mock.foo.in 1,2,3)
+      (mock.foo == 2) & (mock.foo.in 1,2,3)
     }.should == [:all, {:conditions => ["((foo = ? and foo in (?)))", 2, [1,2,3]]}]
     
   end
@@ -26,8 +26,8 @@ describe RQuery::Serializers::Operations do
   it "should group two operations on the same line and continue to add subsequent operations" do
 
     ActiveRecord::MockObject.where{ |mock|
-      (mock.foo.is == 2) & (mock.foo.in 1,2,3)
-      mock.foo.is > 3
+      (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
@@ -35,17 +35,17 @@ describe RQuery::Serializers::Operations do
   it "should properly group multiple nested groupings on the same line" do
 
     ActiveRecord::MockObject.where{ |mock|
-      (mock.foo.is == 2) & (mock.foo.in 1,2,3) | (mock.foo.contains "george")
-      mock.foo.is > 3
-      (mock.foo.is == 2) & (mock.foo.in 1,2,3)
-    }.should == [:all, {:conditions => ["(((foo = ? and foo in (?)) or foo like '%' || ? || '%') and foo > ? and (foo = ? and foo in (?)))", 2, [1,2,3], "george", 3, 2, [1,2,3]]}]
+      (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.is == 2) | (mock.foo.in 1,2,3) & (mock.foo.contains "george")
+      (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"]}]
     
 

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: johnbender-rquery
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - John bender
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2000-04-27 00:00:00 -07:00
+date: 2009-08-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,26 +24,21 @@ extra_rdoc_files: []
 files: 
 - README.markdown
 - rakefile.rb
-- examples/user.rb
 - lib/rquery.rb
-- lib/rquery/declarations.rb
-- lib/rquery/serializers.rb
-- lib/rquery/attribute.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
+- lib/rquery/operation_collector.rb
 - spec/active_record_base_spec_attribute_collection.rb
-- spec/active_record_base_spec_symbols.rb
-- spec/declarations_spec.rb
 - spec/mock_active_record.rb
 - spec/or_and_operations_spec.rb
-- spec/serializers_spec.rb
 - spec/sqlite_adapter_spec.rb
 has_rdoc: false
-homepage: http://nickelcode.com/rquery/
+homepage: http://github.com/johnbender/rquery
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -64,9 +59,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
-summary: A ruby DSL for building data queries in SQL and other query languages.
+summary: An ActiveRecord extension providing a DSL replacement for complex find queries.
 test_files: []
 

data/examples/user.rb

@@ -1,49 +0,0 @@
-#All operations need to be on the same line and in parens
-#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)
-end
-
-#the & takes precedence here 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
-#additionaly operations on seperate lines don't need parens
-User.where do |user|
- (user.name.contains "George") | (user.name.contains "Alice")
- use.age.from 20..30
-end
-
-#should you attempt to use and attribute that doesn't exist for a given model
-#rquery will tell you before it's sent to the db
-User.where do |user|
-  user.ssn.is == 123-45-6789
-end
-# RQuery::AttributeNotFoundError: The field 'ssn' doesn't exist for this object
-# 	from /Users/johnbender/Projects/rquery/lib/rquery/attribute_collection.rb:28:in `method_missing'
-# 	from (irb):24
-# 	from /Users/johnbender/Projects/rquery/lib/rquery/active_record/base.rb:16:in `where'
-# 	from /Users/johnbender/Projects/rquery/lib/rquery/active_record/base.rb:11:in `synchronize'
-# 	from /Users/johnbender/Projects/rquery/lib/rquery/active_record/base.rb:11:in `where'
-# 	from (irb):23
-
-#environment config
-RQuery.use_symbols
-
-#example of using symbols, you can see more at the RQuery page on my site.
-User.where do |user|
- (:name.contains "George") | (:name.contains "Alice")
- :age.from 20..30
-end

data/lib/rquery/attribute.rb

@@ -1,14 +0,0 @@
-module RQuery
-  class Attribute
-    #adds is, is_not, between, in, contains, and from (alias)
-    include RQuery::Declarations
-
-    #define name for the Declarations included methods
-    #as it needs to be different than the default
-    attr_accessor :name
-
-    def initialize(field_name)
-      @name = field_name
-    end
-  end
-end

data/lib/rquery/declarations.rb

@@ -1,34 +0,0 @@
-module RQuery
-  module Declarations
-    #Allows the methods below to be included in 
-    #the Field class and the Symbol class but remain
-    #the same in implementation
-    #!name is redefined as an attr_accessor in the Field class!
-    def name
-      self.to_s if @name == nil
-    end
-    
-    def is
-      Serializers::IsOperations.add_operation(name)
-      Serializers::IsOperations.prefix = nil
-      Serializers::IsOperations
-    end
-    
-    def is_not
-      Serializers::IsNotOperations.add_operation(name)
-      Serializers::IsNotOperations.prefix = "not_"
-      Serializers::IsNotOperations
-    end
-    
-    [:in, :between, :contains].each do |m|
-      define_method(m) do |*args|
-        Serializers::IsOperations.add_operation(name)
-        Serializers::IsOperations.prefix = nil
-        Serializers::IsOperations.send(m, *args)
-      end
-    end
-    
-    alias :from :between
-  end
-end
-

data/lib/rquery/serializers.rb

@@ -1,184 +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
-        
-        #return a conditions array for use with ActiveRecord.find
-        def conditions
-          [to_s] + @@values
-        end
-        
-        #add and operation to the @@ops array which will be popped
-        #and pushed depending on the operations sequence and arrangement
-        def add_operation(val)
-          @@ops << val.to_s
-        end
-
-        #clean out the Operations singleton class variables
-        def clear
-          @@ops.clear
-          @@values.clear
-        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 @@ops 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
-        def group(type)
-          second_op, first_op = @@ops.pop, @@ops.pop
-          
-          #if the previous operation on the stack is an Operation Group we need to add to it
-          if first_op.class == RQuery::Serializers::OperationsGroup
-            if first_op.type == type
-              first_op.ops << second_op
-              @@ops << first_op
-            else
-              @@ops << OperationsGroup.new(first_op.to_s, second_op, type)
-            end
-          else
-            @@ops << OperationsGroup.new(first_op, second_op, type)
-          end
-        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)
-          self.group(:and)
-          self
-        end
-        
-        def |(second)
-          self.group(:or)
-          self
-        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")}"
-          self
-        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")}"
-          self
-        end
-        
-        def contains(str)
-          @@values << str
-          @@ops[@@ops.length-1] += " #{RQuery.adapter.send("#{@@prefix}contains")}"
-          self
-        end
-        
-        #allows for is.from
-        #examples:
-        #
-        #:id.is.from 1,2
-        #:is.is.from 2..10
-        alias :from :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.adapter.send("#{type.to_s}_group", @ops)
-      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)}"
-            self
-          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
-        def ==(val) 
-          @@values << val
-          @@ops[@@ops.length-1] += " #{RQuery.adapter.send(:neq)}"
-          self
-        end
-      end
-
-    end  
-
-  end
-end

data/spec/active_record_base_spec_symbols.rb

@@ -1,214 +0,0 @@
-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.adapter = RQuery::Adapters::Sqlite
-        RQuery.use_symbols
-    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 :foo.is <operation> <value>" do
-        
-        ActiveRecord::MockObject.where{
-            :foo.is == "bar"
-        }.should == [:all, {:conditions => ["(foo = ?)", "bar"]}]  
-
-        ActiveRecord::MockObject.where{
-            :foo.is > 1
-        }.should == [:all, {:conditions => ["(foo > ?)", 1]}]
-
-        ActiveRecord::MockObject.where{
-            :foo.is < 2
-        }.should == [:all, {:conditions => ["(foo < ?)", 2]}]
-
-        ActiveRecord::MockObject.where{
-            :foo.is >= 3
-        }.should == [:all, {:conditions => ["(foo >= ?)", 3]}]
-
-        ActiveRecord::MockObject.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::MockObject.where{
-            :foo.is_not == "bar"
-        }.should == [:all, {:conditions => ["(foo <> ?)", "bar"]}]  
-
-        ActiveRecord::MockObject.where{
-            :foo.is_not.in 1,2
-        }.should == [:all, {:conditions => ["(foo not in (?))", [1,2]]}] 
-       
-        ActiveRecord::MockObject.where{
-            :foo.is_not.between 1..3
-        }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
-
-        ActiveRecord::MockObject.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::MockObject.where{
-            :foo.is.in 1,2,3,4
-        }.should == resulting_conditions  
-
-        ActiveRecord::MockObject.where{
-            :foo.is.in [1,2,3,4]
-        }.should == resulting_conditions 
-
-        ActiveRecord::MockObject.where{
-            :foo.is.in 1..4
-        }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
- 
-        ActiveRecord::MockObject.where{
-            :foo.in 1,2,3,4
-        }.should == resulting_conditions  
-
-        ActiveRecord::MockObject.where{
-            :foo.in [1,2,3,4]
-        }.should == resulting_conditions 
-
-        ActiveRecord::MockObject.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::MockObject.where{
-            :foo.is.between 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.is.between [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.is.between 1..2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.between 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.between [1,2]
-        }.should == resulting_conditions
-        
-        ActiveRecord::MockObject.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::MockObject.where{
-            :foo.is.from 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.is.from [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.is.from 1..2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.from 1,2
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.where{
-            :foo.from [1,2]
-        }.should == resulting_conditions
-
-        ActiveRecord::MockObject.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::MockObject.where{
-            :foo.contains "bar"
-        }.should == resulting_conditions
-
-    end
-
-
-    it "should return return the correct group of joined sql after multiple operations" do
-    
-        ActiveRecord::MockObject.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::MockObject.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::MockObject.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::MockObject.where{
-            :foo.is.between "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["(foo between ? and ?)", "some string", "2007-01-01"]}]
-
-        ActiveRecord::MockObject.where{
-             :foo.is_not.between "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["(foo not between ? and ?)", "some string", "2007-01-01"]}]
-
-        ActiveRecord::MockObject.where{
-           :foo.is.from "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["(foo between ? and ?)", "some string", "2007-01-01"]}]
-    
-        ActiveRecord::MockObject.where{
-           :foo.in "some string", "2007-01-01"
-        }.should == [:all, {:conditions => ["(foo in (?))", ["some string", "2007-01-01"]]}]
-
-    end
-
-    
-
-end