itrigga-param_fu 0.2.0 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/trigga/param_fu/param_fu.rb

@@ -1,11 +1,11 @@
 module Trigga
   module ParamFu
     def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
+      base.extend(AllMethods)
+      base.send(:include, AllMethods)
     end
     
-    module ClassMethods
+    module AllMethods
       def require_obj_or_id(opts, key)
         obj_or_id(opts,key)
         raise ArgumentError.new("#{key} or #{key_with_id(key)} are required") unless opts[key_with_id(key)]
@@ -47,24 +47,70 @@ module Trigga
         condition
       end
       
+      
       # fallback when we don't have ActiveSupport's pluralize method available
       def to_plural(s)
         (s.match(/[aeiou]$/i) ? s + 's' : s + 'es' )
       end
-    end
-    
-    module InstanceMethods
-      def require_obj_or_id(opts,key)
-        self.class.require_obj_or_id(opts, key)
-      end
-      def obj_or_id(opts, key)
-        self.class.obj_or_id(opts, key)
+      
+      # Give this a hash per model in the format:
+      # Model class => { param_name => { :operator=>(db operator - defaults to '='), 
+      # =>                              :field_name=>(field_name in the database - defaults to param_name) 
+      # =>                            }
+      # =>             }
+      # and it will return an ActiveRecord finder :conditions clause using any params which are present in the given :params
+      # e.g. if you have params = { :created_date_from=>'2011-10-09 00:01:02', :status=>'A', :click_url=>'items.html' }
+      # then calling:
+      # 
+      # params_to_conditions( :params=>params, :models=>{
+      #  Click => {:click_url=>{ :operator=>"like", :field_name=>'request_path' }, 
+      #            :status => {},
+      #            :http_referer=>{:operator=>'like'},
+      #            :created_date_from => {:operator=> ">=", :field_name=>'timestamp'}
+      #            }
+      # })
+      #
+      #
+      # will generate:
+      #
+      # [ 'clicks.request_path like (?) AND clicks.status = ? AND clicks.created_date_from >= ?', '%items.html%', 'A', '2011-10-09 00:01:02' ]
+      #
+      # It will ignore any criteria given which are NOT in the given :params hash
+      #
+      def params_to_conditions( opts={} )
+        require_param(opts, :params, :models) 
+        
+        conds = { :where=>[], :values=>[] }
+
+        puts "<br />opts = #{opts.inspect}<br />"
+        opts[:models].each { |model_class, field_defs|
+          puts "model_class = #{model_class.inspect}"
+          parsed_model_conditions = model_conditions( opts[:params], model_class, field_defs )
+          puts "parsed_model_conditions = #{parsed_model_conditions.inspect}"
+          conds[:where]  += parsed_model_conditions[:where]
+          conds[:values] += parsed_model_conditions[:values]
+        }
+       
+        [ conds[:where].join(" AND ") ] + conds[:values]
       end
-      def require_param(opts, *keys)
-        self.class.require_param(opts, *keys)
+      
+      def model_conditions( opts, model_class, field_defs )
+        h = {:where=>[], :values=>[]}
+        field_defs.each{ |field_name, definition|
+          parsed_field_def = parse_field_definition( opts, model_class, field_name, definition )
+          h[:where] += parsed_field_def[:where]
+          h[:values] += parsed_field_def[:values]
+        }
+        h
       end
-      def require_one_of( opts, *keys )
-        self.class.require_one_of( opts, *keys )
+      
+      def parse_field_definition( opts, model_class, param_name, definition )
+        c = {:where=>[], :values=>[]}
+        if opts[param_name]
+          c[:where] << "( #{model_class.table_name}.#{definition[:field_name] || param_name.to_s} #{definition[:operator] || '='} (?) )" 
+          c[:values] << opts[param_name] 
+        end
+        c
       end
     end
   end

data/spec/param_fu_spec.rb

@@ -145,21 +145,284 @@ describe ::Trigga::ParamFu do
         end
       end
     end
-  end
-  
-  describe "instance_methods" do
-    describe "require_obj_or_id" do
-      it "should call the class method require_obj_or_id" do
-        Tester.should_receive(:require_obj_or_id).with( {:key=>'val'}, :key )
-        @t.require_obj_or_id( {:key=>'val'}, :key )
+    
+    describe "parse_field_definition" do
+      before(:each) do
+        @params = { :param_1 => 'param_1 value' }
+        @model_class = mock("model class")
+        @model_class.stub!(:table_name).and_return( 'model_class_table_name' )
+        @param_name = :param_name
+        @definition = { :operator=>'=', :field_name=>'field_name'}
+      end
+      
+      it "should return a Hash" do
+        Tester.parse_field_definition( @params, @model_class, @param_name, @definition ).should be_a(Hash)
+      end
+      
+      describe "returned Hash" do
+        it "should have a key for :where" do
+          Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].should_not be_nil
+        end
+        it "should have a key for :values" do
+          Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should_not be_nil
+        end
+        
+        context "when the given opts has a key matching the given param_name" do
+          before(:each) do
+            @param_name = :param_1
+          end
+          
+          it "should add an element to the :where key" do
+            Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].size.should == 1
+          end
+          
+          describe "where clause" do
+            it "should be wrapped in brackets" do
+              Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].should =~ /^\s*\(.*\)\s*$/
+            end
+            
+            describe "inside the brackets" do
+              before(:each) do
+                @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1')
+              end
+              
+              it "should start with the model_class's table name as a scope" do
+                @inside_the_brackets.should =~ /\s*model_class_table_name\..*/
+              end
+              
+              context "When the definition has a :fieldname" do
+                before(:each) do
+                  @definition[:field_name] = 'field_name'
+                  @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1')
+                end
+                    
+                it "should use the :fieldname" do
+                  @inside_the_brackets.should =~ /\s*[^\.]+\.field_name.*/
+                end
+              end
+              
+              context "When the definition has no :fieldname" do
+                before(:each) do
+                  @definition[:field_name] = nil
+                  @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1')
+                end
+                    
+                it "should use the given param_name converted to a string as the field name" do
+                  @inside_the_brackets.should =~ /\s*[^\.]+\.param_1.*/
+                end
+              end
+              
+              context "When the definition has a :operator" do
+                before(:each) do
+                  @definition[:operator] = 'my_operator'
+                  @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1')
+                end
+                    
+                it "should use the :operator" do
+                  @inside_the_brackets.should =~ /.*\bmy_operator\b.*/
+                end
+              end
+              
+              context "When the definition has no :operator" do
+                before(:each) do
+                  @definition[:operator] = nil
+                  @inside_the_brackets = Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].gsub(/^\s*\((.*)\)\s*$/, '\1')
+                end
+                    
+                it "should use = as the :operator" do
+                  @inside_the_brackets.should =~ /[^=]+\s*=\s*[^=]+/
+                end
+              end
+              
+              it "should end with (?)" do
+                @inside_the_brackets.should =~ /\(\?\)\s*$/
+              end
+            end
+          end
+          
+          it "should add the corresponding value to the :values key" do
+            Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should == ['param_1 value']
+          end
+        end
       end
     end
     
-    describe "obj_or_id" do
-      it "should call the class method obj_or_id" do
-        Tester.should_receive(:obj_or_id).with( {:key=>'val'}, :key )
-        @t.obj_or_id( {:key=>'val'}, :key )
+    describe "model_conditions" do
+      before(:each) do
+        @params = { :param_1 => 'param_1 value' }
+        @model_class = mock("model class")
+        @mock_parsed_field_def_1 = {:where=>['where 1'], :values=>['values 1']}
+        @mock_parsed_field_def_2 = {:where=>['where 2'], :values=>['values 2']}
+        Tester.stub!(:parse_field_definition).and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 )
+        @definitions = { :key=>'=', :field_name=>'field_name'}
+      end
+      
+      it "should return a Hash" do
+        Tester.model_conditions( @params, @model_class, @definitions ).should be_a(Hash)
+      end
+      
+      describe "returned Hash" do
+        it "should have a key for :where" do
+          Tester.model_conditions( @params, @model_class, @definitions )[:where].should_not be_nil
+        end
+        it "should have a key for :values" do
+          Tester.model_conditions( @params, @model_class, @definitions )[:values].should_not be_nil
+        end
+      end
+      
+      context "for each given field_def" do
+        before(:each) do
+          @definitions = { :field_name_1 => (@mock_definition_1={}), :field_name_2 => (@mock_definition_2={}) } 
+        end
+        
+        it "should call parse_field_definition" do
+          Tester.should_receive(:parse_field_definition).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 )
+          Tester.model_conditions( @params, @model_class, @definitions )
+        end
+        
+        describe "parse_field_definition call params" do
+          it "should pass the given opts" do
+            Tester.should_receive(:parse_field_definition).with( @params, anything, anything, anything ).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 )
+            Tester.model_conditions( @params, @model_class, @definitions )
+          end
+          
+          it "should pass the given model class" do
+            Tester.should_receive(:parse_field_definition).with( anything, @model_class, anything, anything ).twice.and_return( @mock_parsed_field_def_1, @mock_parsed_field_def_2 )
+            Tester.model_conditions( @params, @model_class, @definitions )
+          end
+          
+          it "should pass each field_name" do
+            Tester.should_receive(:parse_field_definition) do |args|
+              args[2].should == :field_name_1
+              @mock_parsed_field_def_1 
+            end
+            Tester.should_receive(:parse_field_definition) do |args|
+              args[2].should == :field_name_2
+              @mock_parsed_field_def_2
+            end
+            Tester.model_conditions( @params, @model_class, @definitions )
+          end
+          
+          it "should pass the field_name's definition" do
+            Tester.should_receive(:parse_field_definition) do |args|
+              args[3].should == @mock_definition_1
+              @mock_parsed_field_def_1 
+            end
+            Tester.should_receive(:parse_field_definition) do |args|
+              args[3].should == @mock_definition_2
+              @mock_parsed_field_def_2
+            end
+            Tester.model_conditions( @params, @model_class, @definitions )
+          end
+          
+        end
+        
+        it "should add the :where key from the parsed field definition to the :where key of the return hash " do
+          Tester.model_conditions( @params, @model_class, @definitions )[:where].should == ['where 1', 'where 2']
+        end
+        
+        it "should add the :values key from the parsed field definition to the :values key of the return hash " do
+          Tester.model_conditions( @params, @model_class, @definitions )[:values].should == ['values 1', 'values 2']
+        end
+      end
+    end
+    
+    
+    describe "params_to_conditions" do
+      before(:each) do
+        @mock_params = mock('params')
+        @model_class_1 = "model class 1"
+        @model_class_2 = "model class 2"
+        @models = { @model_class_1 => 'model class def 1', @model_class_2 => 'model class def 2' }
+        @mock_parsed_model_def_1 = {:where=>['where 1'], :values=>['values 1']}
+        @mock_parsed_model_def_2 = {:where=>['where 2'], :values=>['values 2']}
+        Tester.stub!(:model_conditions).and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 )
+      end
+      
+      context "when not given a :params key" do
+        it "should raise an ArgumentError" do
+          lambda{ Tester.params_to_conditions(:blart=>'flange', :models=>'models')  }.should raise_error(ArgumentError)
+        end
       end
+      context "when not given a :models key" do
+        it "should raise an ArgumentError" do
+          lambda{ Tester.params_to_conditions(:blart=>'flange', :params=>'params')  }.should raise_error(ArgumentError)
+        end
+      end
+      
+      context "for each given model" do
+        before(:each) do
+          
+        end
+        
+        it "should call model_conditions" do
+          Tester.should_receive(:model_conditions).twice.and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 )
+          Tester.params_to_conditions( :params=>@mock_params, :models=>@models )
+        end
+        
+        describe "model_conditions_call_params" do
+          it "should pass on the given :params" do
+            Tester.should_receive(:model_conditions).with(@mock_params, anything, anything).twice.and_return( @mock_parsed_model_def_1, @mock_parsed_model_def_2 )
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )
+          end
+          
+          it "should pass each model class" do
+            Tester.should_receive(:model_conditions) do |args|
+              args[1].should == 'model class 1'
+              @mock_parsed_model_def_1 
+            end
+            Tester.should_receive(:model_conditions) do |args|
+              args[1].should == 'model class 2'
+              @mock_parsed_model_def_2
+            end
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )
+          end
+          
+          it "should pass the models field definitions" do
+            Tester.should_receive(:model_conditions) do |args|
+              args[2].should == 'model class def 1'
+              @mock_parsed_model_def_1 
+            end
+            Tester.should_receive(:model_conditions) do |args|
+              args[2].should == 'model class def 2'
+              @mock_parsed_model_def_2
+            end
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )
+          end
+        end
+      end
+      
+      describe "returned value" do
+        it "should be an array" do
+          Tester.params_to_conditions( :params=>@mock_params, :models=>@models ).should be_a(Array)
+        end
+        
+        describe "first element" do
+          it "should be a string" do
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[0].should be_a(String)
+          end
+          
+          it "should have the :where keys from the parsed model definitions joined with AND " do
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[0].should == "where 1 AND where 2"
+          end
+        end
+        
+        describe "subsequent elements" do
+          it "should be the values from the parsed model definitions" do
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[1].should == 'values 1'
+            Tester.params_to_conditions( :params=>@mock_params, :models=>@models )[2].should == 'values 2'
+          end
+        end
+      end
+      
+    end
+  end
+  
+  describe "instance_methods" do
+    it "should not raise an error" do
+      lambda {
+        @t.require_obj_or_id( {:key=>'val'}, :key )
+      }.should_not raise_error
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: itrigga-param_fu
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Al Davidson
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-03 00:00:00 +00:00
+date: 2011-11-10 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency