rquery 0.1.2

data/README.markdown

@@ -0,0 +1,87 @@
+RQuery
+======
+
+RQuery is a small DSL inspired by RSpec for building text queries in languages like SQL. It is meant to be concise, easy to read, and expressive about what the query will be asking for.
+
+Currently only the ActiveRecord extension is implemented with a Sqlite adapter. Mysql should follow shortly, and then support for Grove + JSON queries to Mnesia.
+
+ActiveRecord
+------------
+
+RQuery extend ActiveRecord to provide the `where` method. `where` accepts a single optional argument and a block that represents the query statements
+
+###Example compared with `find`
+
+In a given UsersController your `show` action might find the User like so:
+
+    @user = User.find(params[:id])
+
+Using RQuery:
+
+    @user = User.where { :id.is == params[:id] }
+
+
+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:
+
+    @users = User.find(:all, conditions => ["age between ? and ?", 10 , 20])
+
+RQuery:
+
+    @users = User.where do 
+        :age.from 10..20 
+    end
+
+Or:
+
+    @users = User.where do 
+        :age.between 10..20 
+    end
+
+Both the `from` and `between` methods accept argument lists `10,20` or an array `[10,20]`. 
+
+
+###Other Examples 
+
+RQuery supports most of the common SQL operations: =, <>, >, <, >=, <=  as well as in, like (see below for specifics), and between. `:column.is_not` works for `.in`, `.between`, `.contains`, and `==`. All operations are anded as of the current version.
+
+Operators:
+
+    @obj = ActiveRecordObject.where do
+        :foo.is > 2      
+        :foo.is_not == 4 
+    end 
+    #=> conditions array: ["foo > ? and foo <> ?", 2, 4]
+
+Contains:
+
+    @obj = ActiveRecordObject.where do
+        :foo.contains "bar"
+    end
+    #=> conditions array: ["foo like '%' || ? || '%'", "bar"]
+    #using the default sqlite adapter
+
+In:
+
+   @obj = ActiveRecordObject.where do
+        :foo.in "bar", "baz", "bak"
+    end
+    #=> conditions array: ["foo in (?)", ["bar", "baz", "bak"]]
+    #using the default sqlite adapter
+
+
+You can also limit the results returned in a similar manner to the `find` method by passing a symbol argument to the where method. The default is `:all`, when no option is specified.
+
+First:
+
+    @obj = ActiveRecordObject.where(:first) do
+        :foo.is == "bar"
+    end
+
+is equivalent to the find call:
+
+    @obj = ActiveRecordObject.find(:first, conditions => ["foo = ?", "bar"])
+
+
+
+
+    

data/lib/rquery/active_record/base.rb

@@ -0,0 +1,35 @@
+module RQuery
+    module ActiveRecord
+        @@where_mutex = Mutex.new
+        def where(*args, &block)
+
+            #establish scope for conditions
+            conditions = nil
+
+            #make sure only one thread at a time is altering the class
+            #variables inside RQuery::Serializers::Operations
+            @@where_mutex.synchronize do
+
+                #yielding the block will alter the Operations class
+                yield
+
+                #record altered conditions and values
+                conditions = ::RQuery::Serializers::Operations.conditions
+
+                #clear the alterations
+                ::RQuery::Serializers::Operations.clear
+            end
+
+            #limit the records returned (:first, :all, :last)
+            limit = args.first ? args.first : :all
+
+            #call find with the conditions and values provided by the block
+            find(limit, :conditions => conditions)
+        end
+    end
+end
+
+#extend ActiveRecord::Base with the where method 
+if Object.const_defined?(:ActiveRecord)
+    ActiveRecord::Base.send :extend, RQuery::ActiveRecord
+end

data/lib/rquery/active_record.rb

@@ -0,0 +1 @@
+require "rquery/active_record/base.rb"

data/lib/rquery/adapters/sql.rb

@@ -0,0 +1,47 @@
+module RQuery
+    module Adapters
+        class Sql
+
+            class << self
+                def in
+                    "in (?)" 
+                end
+
+                def not_in
+                    #using send because 'in' is a keyword
+                    "not #{send(:in)}"   
+                end
+
+                def between
+                    "between ? and ?"
+                end
+                
+                def not_between
+                    "not #{between}"
+                end
+
+                def neq
+                    "<> ?"
+                end
+
+                def ==
+                    "= ?"
+                end
+
+                def contains
+                    "like '%' + ? + '%'"
+                end
+
+                def join(ops)
+                    ops.join(" and ")
+                end
+
+                [:>, :>=, :<, :<=].each do |operator|
+                    define_method(operator) do 
+                        "#{operator} ?"
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/rquery/adapters/sqlite.rb

@@ -0,0 +1,13 @@
+
+module RQuery
+    module Adapters
+        class Sqlite < Sql
+            def self.contains
+                "like '%' || ? || '%'"
+            end
+            def self.not_contains
+                "not #{contains}"
+            end
+        end
+    end
+end

data/lib/rquery/adapters.rb

@@ -0,0 +1,2 @@
+require "rquery/adapters/sql.rb"
+require "rquery/adapters/sqlite.rb"

data/lib/rquery/declarations.rb

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

data/lib/rquery/serializers.rb

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

data/lib/rquery.rb

@@ -0,0 +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/adapters.rb"
+require "rquery/active_record.rb"
+
+module RQuery
+    @@adapter = RQuery::Adapters::Sqlite
+    
+    #Allows for the runtime alteration of the adapter being used
+    #to convert the "rqueries" into the adapters query language
+    def RQuery.adapter=(val)
+        @@adapter = val
+    end
+    def RQuery.adapter
+        @@adapter
+    end
+end
+

data/rakefile.rb

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

data/spec/active_record_base_spec.rb

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

data/spec/declarations_spec.rb

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

data/spec/serializers_spec.rb

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

data/spec/sqlite_adapter_spec.rb

@@ -0,0 +1,31 @@
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rquery.rb")
+
+describe RQuery::Adapters::Sqlite do
+
+    before(:each) do
+        #define the adapter with the new left operand
+        @adapter = RQuery::Adapters::Sqlite
+    end
+
+    it "should return the correct sql for comparing :foo with non operator methods" do
+        @adapter.in.should == "in (?)"
+        @adapter.not_in.should == "not in (?)"
+        @adapter.between.should == "between ? and ?"
+        @adapter.not_between.should == "not " + @adapter.between
+        @adapter.neq.should == "<> ?"
+        @adapter.contains.should == "like '%' || ? || '%'"
+        @adapter.not_contains.should == "not " + @adapter.contains 
+    end
+
+
+    it "should return the correct sql for comparing :foo with operators" do
+        @adapter.send(:==).should == "= ?"
+        @adapter.send(:>).should == "> ?"
+        @adapter.send(:>=).should == ">= ?"
+        @adapter.send(:<).should == "< ?"
+        @adapter.send(:<=).should == "<= ?"
+    end
+
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rquery
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- John bender
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2000-03-16 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: john.m.bender@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- rakefile.rb
+- lib/rquery.rb
+- lib/rquery/declarations.rb
+- lib/rquery/serializers.rb
+- lib/rquery/active_record.rb
+- lib/rquery/active_record/base.rb
+- lib/rquery/adapters.rb
+- lib/rquery/adapters/sql.rb
+- lib/rquery/adapters/sqlite.rb
+- spec/active_record_base_spec.rb
+- spec/serializers_spec.rb
+- spec/declarations_spec.rb
+- spec/sqlite_adapter_spec.rb
+has_rdoc: true
+homepage: http://nickelcode.com/rquery/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A ruby DSL for building data queries in SQL and other query languages.
+test_files: []
+