itrigga-param_fu 0.4.0 → 0.4.1

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/trigga/param_fu/param_fu.rb

@@ -106,9 +106,11 @@ module Trigga
       
       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] << ( definition[:operator] =~ /\blike\b/i ? opts[param_name].to_active_record_condition : opts[param_name] )
+        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] || '='} (?) )" 
+            c[:values] << ( definition[:operator] =~ /\blike\b/i ? opts[param_name].to_active_record_condition : opts[param_name] )
+          end
         end
         c
       end

data/spec/param_fu_spec.rb

@@ -172,86 +172,104 @@ describe ::Trigga::ParamFu 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
+          context "and the param value is not empty" do
           
-          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*$/
+            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 "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\..*/
+          
+            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
-              
-              context "When the definition has a :fieldname" do
+            
+              describe "inside the brackets" 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')
+                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 given param_name converted to a string as the field name" do
-                  @inside_the_brackets.should =~ /\s*[^\.]+\.param_1.*/
+                  it "should use the :fieldname" do
+                    @inside_the_brackets.should =~ /\s*[^\.]+\.field_name.*/
+                  end
                 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
+                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 :operator" do
-                  @inside_the_brackets.should =~ /.*\bmy_operator\b.*/
+                  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
-              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')
+                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*[^=]+/
+                  it "should use = as the :operator" do
+                    @inside_the_brackets.should =~ /[^=]+\s*=\s*[^=]+/
+                  end
                 end
-              end
               
-              it "should end with (?)" do
-                @inside_the_brackets.should =~ /\(\?\)\s*$/
+                it "should end with (?)" do
+                  @inside_the_brackets.should =~ /\(\?\)\s*$/
+                end
               end
             end
-          end
           
-          context "when the given :operator matches 'like'" do
-            before(:each) do 
-              @definition[:operator] = " LIKE "
-            end
+            context "when the given :operator matches 'like'" do
+              before(:each) do 
+                @definition[:operator] = " LIKE "
+              end
             
-            it "should add the corresponding value, converted to a like condition, to the :values key" do
-              Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should == ['%param_1%value%']
+              it "should add the corresponding value, converted to a like condition, to the :values key" do
+                Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should == ['%param_1%value%']
+              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
           
-          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']
+          context "when the given value is empty" do
+            before(:each) do
+              @params = {:param_1=>'', :param_2=>'dave'}
+              @param_name = :param_1
+            end
+            
+            it "should not add the key to the where clause" do
+              Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:where].should be_empty
+            end
+            
+            it "should not add the value to the :values key" do
+              Tester.parse_field_definition( @params, @model_class, @param_name, @definition )[:values].should_not include('')
+            end
           end
         end
       end

metadata

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