rquery 0.3.0 → 0.3.5

data/README.markdown

@@ -17,6 +17,20 @@ In you're rails environment file simply require rquery. The default adapter is t
 
 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.
 
+###Sniper Scopes
+
+Its now extremely easy to use rquery's dsl as named scopes. For example
+
+    class User < ActiveRecord::Base
+      sniper_scope :with_name do |user, passed_name|
+        user.name == passed_name
+      end
+    end
+
+    User.with_name('George')
+   
+The first parameter will be an object representing the user and the rest will be the parameters passed when the method is called. Since this functionality makes use of the named_scope method it can be chained with other sniper_scopes and named_scopes. If the name seems a bit odd, I'm open to other suggestions :D
+
 ###Examples
 
 RQuery extend ActiveRecord to provide the `where` method. `where` accepts a single optional argument and a block that represents the query statements

data/lib/rquery.rb

@@ -1,8 +1,6 @@
 $: << 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/operations_group.rb"
 require "rquery/operation_collector.rb"
 require "rquery/attribute_collection.rb"
 require "rquery/adapters.rb"

data/lib/rquery/active_record/base.rb

@@ -1,26 +1,36 @@
 module RQuery
   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)
+    module ClassMethods
+      def where(*args, &block)
+        collector = AttributeCollection.new(columns.map {|x| x.name })
+        
+        #Passes a new AttributeCollection object to the block, which will in turn
+        #instantiate a OperationCollector to be used for each expression
+        yield(collector)
 
-      #record altered conditions and values
-      conditions = collector.clauses.to_conditions
+        #record altered conditions and values
+        conditions = collector.clauses.to_conditions
 
-      #limit the records returned (:first, :all, :last)
-      limit = args.first ? args.first : :all
+        #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)
+        #call find with the conditions and values provided by the block
+        find(limit, :conditions => conditions)
+      end
+
+      def sniper_scope(name, &block)
+        #rescope self
+        klass = self
+        named_scope name, lambda { |*args|
+          collector = AttributeCollection.new(klass.columns.map {|x| x.name })
+          block.call(collector, *args)
+          { :conditions => collector.clauses.to_conditions }
+        }
+      end
     end
   end
 end
 
 #extend ActiveRecord::Base with the where method 
-if Object.const_defined?(:ActiveRecord)
-  ActiveRecord::Base.send :extend, RQuery::ActiveRecord
-end
+ActiveRecord::Base.send :extend, RQuery::ActiveRecord::ClassMethods
+

data/lib/rquery/attribute_collection.rb

@@ -3,45 +3,23 @@ module RQuery
     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" 
+      # For each field define it and its setter to add the appropriate clause
+      fields.each do |field|
+        self.class.send(:define_method, field) do |*args|
+          add_clause(field)
+          @clauses
+        end
+
+        self.class.send(:define_method, (field + '=')) do |*args|
+          add_clause(field)
+          eq(*args)
+          @clauses
+        end
       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)
@@ -50,8 +28,5 @@ module RQuery
     def eq(*args)
       @clauses.send(:==, *args)
     end
-
   end
-
-  class AttributeNotFoundError < ArgumentError; end
 end

data/lib/rquery/operation_collector.rb

@@ -25,53 +25,21 @@ module RQuery
       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' || '%')
+    #
+    # note that second is not used in this case because it should
+    # have been collected into the @operations array earlier
     def &(second)
-      group :and
+      @operations << AndOperationsGroup.new(tail_ops!(2))
+      self
     end
     
     def |(second)
-      group :or
+      @operations << OrOperationsGroup.new(tail_ops!(2))
+      self
     end
 
     def in(*args)
@@ -120,13 +88,17 @@ module RQuery
     alias :from :between
     alias :not_from :not_between
 
-    private 
+    private
+    def tail_ops!(num)
+      @operations.slice!(@operations.length-2, num)
+    end
+    
     def chain(method)
       @operations[@operations.length-1] += " #{RQuery::Config.adapter.send(method)}"
       self
     end
 
-    def call_in(prefix=nil, *args)
+    def call_in(prefix, *args)
       #flatten our args to prevent having to check for an array first arg
       args.flatten!
       
@@ -141,7 +113,7 @@ module RQuery
       chain :"#{prefix}in"
     end
 
-    def call_between(prefix=nil, *args)      
+    def call_between(prefix, *args)      
       #flatten our args to prevent having to check for an array first arg
       args.flatten!
       
@@ -157,19 +129,4 @@ module RQuery
       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/lib/rquery/operations_group.rb

@@ -0,0 +1,32 @@
+module RQuery
+  class OperationsGroup
+    attr_accessor :operations
+    
+    def initialize(args)
+      @operations = []
+      #if the two args passed are strings make a new group
+      #otherwise add the second arg to the previous operation group
+      #
+      # NOTE coupling by type assumption here
+      @operations = args[0].instance_of?(String) ? args[0,2] : (args[0].operations << args[1])
+    end
+    
+    def to_s
+      RQuery::Config.adapter.send("#{@type.to_s}_group", @operations)
+    end
+  end
+
+  class OrOperationsGroup < OperationsGroup 
+    def initialize(args)
+      super(args)
+      @type = :or 
+    end
+  end
+
+  class AndOperationsGroup < OperationsGroup 
+    def initialize(args)
+      super(args)
+      @type = :and 
+    end
+  end
+end

data/spec/{active_record_base_spec_attribute_collection.rb → active_record_base_attribute_collection_spec.rb}

@@ -1,5 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/mock_active_record.rb")
-require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 
 describe ActiveRecord do
 
@@ -8,50 +7,57 @@ describe ActiveRecord do
   end
 
   it "should set up a where method" do
-    ActiveRecord::MockObject.respond_to?(:where).should == true
+    MockObject.respond_to?(:where).should == true
+  end
+
+  it "should behave properly when using the id method" do
+    MockObject.where { |mock|
+      mock.id == 1
+    }.should == [:all, {:conditions => ['(id = ?)', 1]}]
   end
   
   it "should return sql with foo, the operations, and the values for mock.foo <operation> <value>" do
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo == "bar"
       mock.foo = "bar"
     }.should == [:all, {:conditions => ["(foo = ? and foo = ?)", "bar", "bar"]}]  
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo > 1
     }.should == [:all, {:conditions => ["(foo > ?)", 1]}]
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo < 2
     }.should == [:all, {:conditions => ["(foo < ?)", 2]}]
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo >= 3
     }.should == [:all, {:conditions => ["(foo >= ?)", 3]}]
 
-    ActiveRecord::MockObject.where{ |mock|
+    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|
+    MockObject.where{ |mock|
       mock.foo.not = "bar"
     }.should == [:all, {:conditions => ["(foo <> ?)", "bar"]}]  
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.not_in 1,2
     }.should == [:all, {:conditions => ["(foo not in (?))", [1,2]]}] 
     
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.not_between 1..3
     }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
 
-    ActiveRecord::MockObject.where{ |mock|
+
+    MockObject.where{ |mock|
       mock.foo.not_from 1..3
     }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
     
-     ActiveRecord::MockObject.where{ |mock|
+     MockObject.where{ |mock|
       mock.foo.without "bar"
     }.should == [:all, {:conditions => ["(foo not like '%' || ? || '%')", "bar"]}]
   end
@@ -59,27 +65,27 @@ describe ActiveRecord 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|
+    MockObject.where{ |mock|
       mock.foo.in 1,2,3,4
     }.should == resulting_conditions  
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.in [1,2,3,4]
     }.should == resulting_conditions 
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.in 1..4
     }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
     
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.in 1,2,3,4
     }.should == resulting_conditions  
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.in [1,2,3,4]
     }.should == resulting_conditions 
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.in 1..4
     }.should == [:all, {:conditions => ["(foo in (?))", 1..4]}]  
   end
@@ -87,27 +93,27 @@ describe ActiveRecord 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|
+    MockObject.where{ |mock|
       mock.foo.between 1,2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.between [1,2]
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.between 1..2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.between 1,2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.between [1,2]
     }.should == resulting_conditions
     
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.between 1..2
     }.should == resulting_conditions
   end
@@ -115,27 +121,27 @@ describe ActiveRecord 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|
+    MockObject.where{ |mock|
       mock.foo.from 1,2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.from [1,2]
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.from 1..2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.from 1,2
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.from [1,2]
     }.should == resulting_conditions
 
-    ActiveRecord::MockObject.where{ |mock|
+    MockObject.where{ |mock|
       mock.foo.from 1..2
     }.should == resulting_conditions
   end
@@ -143,27 +149,27 @@ describe ActiveRecord do
   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|
+    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|
+    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|
+    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| 
+    MockObject.where(:first){ |mock| 
       mock.foo == "bar"
       mock.foo.not_in 1,2,3,4,5 
       mock.foo > 3
@@ -171,25 +177,25 @@ describe ActiveRecord do
   end
 
   it "should return return strings as arguments when passed to between, in, and from (used for date strings)" do
-    ActiveRecord::MockObject.where{ |mock|
+    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|
+    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|
+    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|
+    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)
+    lambda { MockObject.where{ |mock| mock.send(attribute) == 2 }}.should raise_error(NoMethodError)
   end
 end

data/spec/or_and_operations_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/mock_active_record.rb")
-require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 
 describe RQuery::OperationCollector do
 
@@ -9,7 +8,7 @@ describe RQuery::OperationCollector do
 
   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|
+    MockObject.where{ |mock|
       (mock.foo == 2) | (mock.foo.in 1,2,3)
     }.should == [:all, {:conditions => ["((foo = ? or foo in (?)))", 2, [1,2,3]]}]
 
@@ -17,7 +16,7 @@ describe RQuery::OperationCollector 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|
+    MockObject.where{ |mock|
       (mock.foo == 2) & (mock.foo.in 1,2,3)
     }.should == [:all, {:conditions => ["((foo = ? and foo in (?)))", 2, [1,2,3]]}]
     
@@ -25,7 +24,7 @@ describe RQuery::OperationCollector do
 
   it "should group two operations on the same line and continue to add subsequent operations" do
 
-    ActiveRecord::MockObject.where{ |mock|
+    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]}]
@@ -34,7 +33,7 @@ describe RQuery::OperationCollector do
 
   it "should properly group multiple nested groupings on the same line" do
 
-    ActiveRecord::MockObject.where{ |mock|
+    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)
@@ -44,10 +43,9 @@ describe RQuery::OperationCollector do
 
   it "& should have precedence when evaluating multiple operation group types on a single line" do
     
-     ActiveRecord::MockObject.where{ |mock|
+     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
 

data/spec/sniper_scope_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper.rb")
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+
+describe ActiveRecord do
+
+  before :all do
+    RQuery::Config.adapter = RQuery::Adapters::Sqlite
+    MockObject.sniper_scope :baz do  |object, foo_val|
+      object.foo == foo_val
+    end
+  end
+  
+  it "should proved a named scope on the active record object when sniper_scope is defined" do
+    MockObject.respond_to?(:baz).should == true
+  end
+
+  it "should set the named scope conditions properly when the sniper_scope is defined" do
+    result = MockObject.baz('bar').proxy_options
+    result.should == {:conditions => ['(foo = ?)', 'bar']}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'active_record'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+
+class MockObject < ActiveRecord::Base
+  def self.find(limit, conditions)
+    [limit, conditions]
+  end
+  
+  def initialize
+  end
+  
+  def self.columns
+    [Column.new("foo"), Column.new("id")]
+  end
+end
+
+class Column 
+  attr_accessor :name
+  def initialize(n)
+    @name = n
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rquery
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.5
 platform: ruby
 authors: 
 - John bender
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-22 00:00:00 -07:00
+date: 2010-01-14 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -32,10 +32,12 @@ files:
 - lib/rquery/adapters/sql.rb
 - lib/rquery/adapters/sqlite.rb
 - lib/rquery/operation_collector.rb
-- spec/active_record_base_spec_attribute_collection.rb
-- spec/mock_active_record.rb
+- lib/rquery/operations_group.rb
+- spec/active_record_base_attribute_collection_spec.rb
 - spec/or_and_operations_spec.rb
 - spec/sqlite_adapter_spec.rb
+- spec/sniper_scope_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/johnbender/rquery
 licenses: []
@@ -60,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: An ActiveRecord extension providing a DSL replacement for complex find queries.

data/spec/mock_active_record.rb

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