itrigga-param_fu 0.4.1 → 0.4.2

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2

data/lib/trigga/param_fu/param_fu.rb

@@ -57,10 +57,12 @@ module Trigga
       end
       
       # 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:
@@ -78,8 +80,41 @@ module Trigga
       #
       # [ '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
       #
+      # Table Names
+      # ===========
+      # By default each field given in a model class key is automatically scoped by the table name - e.g.
+      #
+      # Person => { :status=>{} }
+      #
+      # results in a where clause of
+      #
+      # 'people.status = (?)' 
+      #
+      # Sometimes you need to scope a field by another table name  - e.g. when you have a joined table, or an aliased table 
+      # If your fieldname contains a dot ('.') it will NOT be scoped by the table name, it will be left as given
+      #
+      # e.g.
+      #
+      # Writer => { :interested_in => { :operator => 'LIKE', :field_name=>['writer_interests.interest_notes'] }}
+      #
+      # gives
+      #
+      # 'writer_interests.interest_notes LIKE (?)'
+      #
+      # ORs
+      # ===
+      # You can combine two different fields into an OR on the same value by passing :fieldname=>[ "fieldname_1", "fieldname_2" ]
+      # e.g.
+      #
+      # Click => { :click_url_pattern=> {:operator=>"like", :field_name=>['request_path', 'http_referer']}}
+      #
+      # will generate:
+      #
+      # ['( clicks.request_path LIKE (?) OR clicks.http_referrer LIKE (?) )']
+      #
       def params_to_conditions( opts={} )
         require_param(opts, :params, :models) 
         
@@ -96,7 +131,8 @@ module Trigga
       
       def model_conditions( opts, model_class, field_defs )
         h = {:where=>[], :values=>[]}
-        field_defs.each{ |field_name, definition|
+
+        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]
@@ -108,12 +144,20 @@ module Trigga
         c = {:where=>[], :values=>[]}
         if opts[param_name] 
           unless opts[param_name].to_s.empty?
-            c[:where] << "( #{model_class.table_name}.#{definition[:field_name] || param_name.to_s} #{definition[:operator] || '='} (?) )" 
+            ors = Array(definition[:field_name] || param_name.to_s).map{ |field|  scoped_field_name( model_class, field ) + " " + (definition[:operator] || '=') + " (?)" }
+            
+            clause = "( " + ors.join(' OR ') + " )"
+#             "( #{ scoped_field_name( model_class, (definition[:field_name] || param_name.to_s) ) } #{definition[:operator] || '='} (?) )" 
+            c[:where] << clause
             c[:values] << ( definition[:operator] =~ /\blike\b/i ? opts[param_name].to_active_record_condition : opts[param_name] )
           end
         end
         c
       end
+      
+      def scoped_field_name( model_class, field_name )
+        field_name.include?('.') ? field_name : "#{model_class.table_name}.#{field_name}"
+      end
     end
   end
 end

data/spec/param_fu_spec.rb

@@ -188,32 +188,72 @@ describe ::Trigga::ParamFu 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\..*/
+                it "should call scoped_field_name " do
+                  Tester.should_receive(:scoped_field_name).and_return('blart')
+                  Tester.parse_field_definition( @params, @model_class, @param_name, @definition )
                 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')
+                
+                describe "scoped_field_name args" do
+                  it "should start with the model class" do
+                    Tester.should_receive(:scoped_field_name) do |args|
+                      args[0].should == @model_class
+                      'blart'
+                    end
+                    Tester.parse_field_definition( @params, @model_class, @param_name, @definition )
                   end
+                  
+                  context "When the definition has a :fieldname" do
+                    before(:each) do
+                      @definition[:field_name] = 'field_name'
+                    end
                     
-                  it "should use the :fieldname" do
-                    @inside_the_brackets.should =~ /\s*[^\.]+\.field_name.*/
+                    it "should pass the given :field_name as the second arg" do
+                      Tester.should_receive(:scoped_field_name) do |args|
+                        args[1].should == 'field_name'
+                        'blart'
+                      end
+                      Tester.parse_field_definition( @params, @model_class, @param_name, @definition )
+                    end
                   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')
+                  
+                  context "When the definition has no :fieldname" do
+                    before(:each) do
+                      @definition[:field_name] = nil
+                    end
+                    
+                    it "should pass the given param_name converted to a string as the second arg" do
+                      Tester.should_receive(:scoped_field_name) do |args|
+                        args[1].should == 'param_1'
+                        'blart'
+                      end
+                      Tester.parse_field_definition( @params, @model_class, @param_name, @definition )
+                    end
                   end
+                  
+                  context "when the definitions fieldname is an array" do
+                    before(:each) do
+                      @definition[:field_name] = ["field_name_1", "other_table.field_name_2"]
+                    end
                     
-                  it "should use the given param_name converted to a string as the field name" do
-                    @inside_the_brackets.should =~ /\s*[^\.]+\.param_1.*/
+                    it "should call scoped_field_name with each element" do
+                      Tester.should_receive(:scoped_field_name) do |args|
+                        args[1].should == 'field_name_1'
+                        'blart'
+                      end
+                      Tester.should_receive(:scoped_field_name) do |args|
+                        args[1].should == 'other_table.field_name_2'
+                        'blart'
+                      end
+                      Tester.parse_field_definition( @params, @model_class, @param_name, @definition )
+                    end
+                    
+                    it "should join the fieldname conditions together with OR" do
+                      Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where][0].should == "( model_class_table_name.field_name_1 = (?) OR other_table.field_name_2 = (?) )"
+                    end
                   end
+                  
                 end
-              
+                
                 context "When the definition has a :operator" do
                   before(:each) do
                     @definition[:operator] = 'my_operator'
@@ -275,6 +315,28 @@ describe ::Trigga::ParamFu do
       end
     end
     
+    describe "scoped_field_name" do
+      before do
+        @model_class = mock("model class")
+        @model_class.stub!(:table_name).and_return( 'model_class_table_name' )
+      end
+      
+      context "when the given field_name contains a ." do
+        it "should just return the given field_name" do
+          Tester.scoped_field_name(@model_class, 'blart.flange').should == 'blart.flange'
+        end
+      end
+      context "when the given field_name does not contain a ." do
+        it "should call table_name on the model_class" do
+          @model_class.should_receive(:table_name).and_return( 'model_class_table_name' )
+          Tester.scoped_field_name(@model_class, 'blart')
+        end
+        it "should return the given field_name" do
+          Tester.scoped_field_name(@model_class, 'flange').should == 'model_class_table_name.flange'
+        end
+      end
+    end
+    
     describe "model_conditions" do
       before(:each) do
         @params = { :param_1 => 'param_1 value' }
@@ -320,14 +382,15 @@ describe ::Trigga::ParamFu do
           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.should_receive(:parse_field_definition) do |args|
+              args[2].should == :field_name_1
+              @mock_parsed_field_def_1 
+            end
             Tester.model_conditions( @params, @model_class, @definitions )
           end
           

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: itrigga-param_fu
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 4
-  - 1
-  version: 0.4.1
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - Al Davidson
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-18 00:00:00 +00:00
+date: 2011-12-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency