johnbender-rquery 0.1.2 → 0.2.0

data/lib/rquery.rb

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

data/spec/active_record_base_spec_attribute_collection.rb

@@ -0,0 +1,216 @@
+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
+  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
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is == "bar"
+    }.should == [:all, {:conditions => ["(foo = ?)", "bar"]}]  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is > 1
+    }.should == [:all, {:conditions => ["(foo > ?)", 1]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is < 2
+    }.should == [:all, {:conditions => ["(foo < ?)", 2]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is >= 3
+    }.should == [:all, {:conditions => ["(foo >= ?)", 3]}]
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is <= 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
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is_not == "bar"
+    }.should == [:all, {:conditions => ["(foo <> ?)", "bar"]}]  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is_not.in 1,2
+    }.should == [:all, {:conditions => ["(foo not in (?))", [1,2]]}] 
+    
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is_not.between 1..3
+    }.should == [:all, {:conditions => ["(foo not between ? and ?)", 1, 3]}] 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.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 mock.foo.is.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
+    }.should == resulting_conditions  
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.in [1,2,3,4]
+    }.should == resulting_conditions 
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.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.is.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
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.between [1,2]
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.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.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{ |mock|
+      mock.foo.is.from 1,2
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.from [1,2]
+    }.should == resulting_conditions
+
+    ActiveRecord::MockObject.where{ |mock|
+      mock.foo.is.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.is == "bar"
+      mock.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){ |mock|
+      mock.foo.is == "bar"
+      mock.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){ |mock| 
+      mock.foo.is == "bar"
+      mock.foo.is_not.in 1,2,3,4,5 
+      mock.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{ |mock|
+      mock.foo.is.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"
+    }.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"
+    }.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)
+  end
+
+end

data/spec/active_record_base_spec_symbols.rb

@@ -0,0 +1,214 @@
+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

data/spec/declarations_spec.rb

@@ -11,7 +11,7 @@ describe RQuery::Declarations do
         RQuery::Serializers::Operations.clear
     end
 
-    it "any Object should respond to is, is_not, in, between, from, and contains methods" do
+    it "any symbol 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
@@ -20,28 +20,4 @@ describe RQuery::Declarations do
         :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/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::Serializers::Operations do
+
+  before(:all) do
+    RQuery.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)
+    }.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.is == 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.is == 2) & (mock.foo.in 1,2,3)
+      mock.foo.is > 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.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]]}]
+    
+  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")
+    }.should == [:all, {:conditions => ["((foo = ? or (foo in (?) and foo like '%' || ? || '%')))", 2, [1,2,3], "george"]}]
+    
+
+  end
+
+end

data/spec/serializers_spec.rb

@@ -3,28 +3,32 @@ 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
+  before(:all) do
+    RQuery.use_symbols
+  end
+
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: johnbender-rquery
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - John bender
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2000-03-16 00:00:00 -08:00
+date: 2000-04-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,19 +24,25 @@ 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
-- spec/active_record_base_spec.rb
-- spec/serializers_spec.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: true
+has_rdoc: false
 homepage: http://nickelcode.com/rquery/
 post_install_message: 
 rdoc_options: []