bitmask_attributes 0.2.4 → 0.3.0

data/.gitignore

@@ -6,4 +6,5 @@ pkg
 \#*
 .#*
 *.gem
-/nbproject
+/nbproject
+.idea/

data/.travis.yml

@@ -0,0 +1,4 @@
+script: 'bundle exec rake test'
+language: ruby
+rvm:
+  - 1.9.3

data/CHANGELOG.rdoc

@@ -1,14 +1,67 @@
+=== Version 0.3.0 - 2012-04-30 21:36:18 +0100
+
+Aaron Hamid (1):
+* wrap two scopes in procs to fix migration/startup issues
+
+Andre Duffeck (1):
+* fix values_for
+
+Ivan Buiko (1):
+* Adding retrieval by exact value
+
+Joel Moss (9):
+* Merge pull request #6 from incandescent/fix-scope-proc
+* Merge pull request #4 from SUSE/fix_values_for
+* Bundle update
+* Adding retrieval by exact value
+* Merge branch 'retrieval-by-exact-value'
+* Resolved merge conflict
+* Merge pull request #9 from numerex/master
+* Merge pull request #13 from spemmons/master
+* Merge pull request #16 from spemmons/master
+
+Sebastian Borrazas (1):
+* Not raising exception when the bitmask column is not found, since its adding it on a migration
+
+spemmons (22):
+* detect whether or not nulls are possible with an attribute and remove OR conditions checking if it is null or not
+* ignore RubyMine info
+* merge changes with joel moss for scopes
+* check for model not being ready when creating scopes
+* support nulls with an explicit attribute, not by inspecting the model due to preloading issues
+* add documentation for the :null option
+* support multiple values in the "without_..." scope that excludes match for of any of the bits; previously 2nd and following values were ignored
+* update documentation to reflect support for multiple arguments to "without_..."
+* update documentation to reflect support for multiple arguments to "without_..."
+* update documentation to reflect support for multiple arguments to "without_..."
+* added tests to verify the validity of zykadelic's complaint that "with_" scopes were improperly including "OR IS NOT NULL" and fixed the code by removing the condition in this case
+* DRY-up scope expressions, standardizing on "no_" and "bitmask_for_...(*values)" instead of repeating more complex calculations; also found another example of zykadelic's complaint with "with_any_" that is fixed and has tests
+* add travis configuration file
+* follow buffpojken in forcing string-interpolated model to work in global scope
+* Merge branch 'master' of github.com:spemmons/bitmask_attributes
+* remove out-dated helpers that, although no longer used, were being loaded by Travis-CI and failing
+* clarify travis config to fix failing CI build that works locally
+* apparently 1.9.2 doesn't work... will figure out why later
+* add :zero option and tests
+* check for a string match instead of a symbol to allow values arriving from web forms and services to match properly
+* added documentation for the :zero attribute
+* rename :zero to :zero_value for clarity
+
+steve emmons (3):
+* Merge pull request #1 from numerex/master
+* Merge pull request #2 from numerex/master
+* Merge pull request #15 from spemmons/master
+
+
 === Version 0.2.4 - 2011-11-23 09:37:50 +0000
 
 Ivan Buiko (3):
-* add netbeans project files to .gitignore
-* latest versions in Gemfile.lock
-* don't validate attribute during creating table
+* No longer validates attribute during migrations
 
 Joel Moss (3):
-* Merge pull request #3 from IvanBuiko/master
-* Added changeling tasks
-* Created docs
+* Added changeling tasks for help with gem releases
+* Created docs using sdoc
+
 
 
 

data/Gemfile

@@ -2,12 +2,8 @@ source "http://rubygems.org"
 
 gemspec
 
-if RUBY_VERSION < '1.9'
-  gem "ruby-debug", ">= 0.10.3"
-end
-
 gem 'sdoc'
 gem 'rake'
 gem 'shoulda'
-gem 'sqlite3', '>=1.3.4'
-gem 'turn'
+gem 'sqlite3', '>=1.3.5'
+gem 'turn'

data/Gemfile.lock

@@ -1,40 +1,40 @@
 PATH
   remote: .
   specs:
-    bitmask_attributes (0.2.3)
+    bitmask_attributes (0.2.4)
       activerecord (~> 3.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.3)
-      activesupport (= 3.1.3)
+    activemodel (3.2.2)
+      activesupport (= 3.2.2)
       builder (~> 3.0.0)
-      i18n (~> 0.6)
-    activerecord (3.1.3)
-      activemodel (= 3.1.3)
-      activesupport (= 3.1.3)
-      arel (~> 2.2.1)
+    activerecord (3.2.2)
+      activemodel (= 3.2.2)
+      activesupport (= 3.2.2)
+      arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.1.3)
+    activesupport (3.2.2)
+      i18n (~> 0.6)
       multi_json (~> 1.0)
-    ansi (1.4.1)
-    arel (2.2.1)
+    ansi (1.4.2)
+    arel (3.0.2)
     builder (3.0.0)
     i18n (0.6.0)
-    json (1.6.1)
-    multi_json (1.0.3)
+    json (1.6.5)
+    multi_json (1.1.0)
     rake (0.9.2.2)
-    rdoc (3.11)
+    rdoc (3.12)
       json (~> 1.4)
     sdoc (0.3.16)
       json (>= 1.1.3)
       rdoc (~> 3.10)
     shoulda (2.11.3)
-    sqlite3 (1.3.4)
+    sqlite3 (1.3.5)
     turn (0.8.3)
       ansi
-    tzinfo (0.3.31)
+    tzinfo (0.3.32)
 
 PLATFORMS
   ruby
@@ -44,5 +44,5 @@ DEPENDENCIES
   rake
   sdoc
   shoulda
-  sqlite3 (>= 1.3.4)
+  sqlite3 (>= 1.3.5)
   turn

data/README.rdoc

@@ -71,6 +71,10 @@ A couple useful named scopes are also generated when you use
     # => (all users who are BOTH editors and writers)
     User.with_any_roles(:editor, :writer)
     # => (all users who are editors OR writers)
+    User.with_exact_roles(:writer)
+    # => (all users who are ONLY writers)
+    User.with_exact_roles(:writer, :editor)
+    # => (all users who are BOTH editors and writers and nothing else)
 
 Find records without any bitmask set:
 
@@ -79,12 +83,16 @@ Find records without any bitmask set:
     User.no_roles
     # => (all users without a role)
 
-Find records without a specific attribute.
+Find records without specific attributes:
 
     User.without_roles(:editor)
     # => (all users who are not editors)
 
-Note that "without_" only supports a single attribute argument, and the "no_" method does not support arguments.
+    User.without_roles(:writer, :editor)
+    # => (all users who are NEITHER writers nor editors)
+
+Note that "without_" supports one or more attribute arguments, and the "no_" method does not support arguments.
+And "with_exact_" without arguments is alias for "no_"
 
 
 === Adding Methods
@@ -102,6 +110,58 @@ named scopes):
     user.other_attribute.worked?
     # => true
 
+=== Handling null values
+
+By default, bitmasks support the potential for the underlying integer value to be null. However, if you have created
+a field that is guaranteed never to be null, you can simplify the SQL query conditions by declaring ":null => false"
+in the definition:
+
+     bitmask :never_null_attributes,:as => [:value1, :value2], :null => false
+
+=== Allowing for a "zero" value
+
+It is common to use web forms to set bitmask bits using checkboxes. If the various bits each are represented by a
+checkbox and the user unchecks them all, the resulting "params" posted to the controller will be missing. When this
+happens, a controller will need to ensure that a "params" hash entry has an empty array or a call to "update_attributes"
+will not change the attribute. For example:
+
+    In model...
+        class SomeModel < ActiveRecord::Base
+            bitmask :some_attribute, :as => [:value1, :value2]
+        end
+
+    In view...
+        <input type="checkbox" name="some_model[some_attribute][]" value="value1"/>
+        <input type="checkbox" name="some_model[some_attribute][]" value="value2"/>
+
+    In controller...
+        def update
+            @some_model = SomeModel.find(params[:id])
+            params[:some_attribute] ||= []
+            @some_model.update_attributes(params)
+        end
+
+As an alternative, you may provide a special symbol representing "zero":
+
+    In model...
+        class SomeModel < ActiveRecord::Base
+            bitmask :some_attribute, :as => [:value1, :value2], :zero_value => :none
+        end
+
+    In view...
+        <input type="checkbox" name="some_model[some_attribute][]" value="value1"/>
+        <input type="checkbox" name="some_model[some_attribute][]" value="value2"/>
+        <input type="hidden"   name="some_model[some_attribute][]" value="none"/>
+
+    In controller...
+        def update
+            @some_model = SomeModel.find(params[:id])
+            @some_model.update_attributes(params)
+        end
+
+This technique can be particularly useful for both forms and web services where setting the attribute in question may
+be optionally included or not such that the controller setting of an empty array in the first example would not be
+correct.
 
 === Warning: Modifying possible values
 

data/lib/bitmask_attributes.rb

@@ -9,7 +9,7 @@ module BitmaskAttributes
       unless options[:as] && options[:as].kind_of?(Array)
         raise ArgumentError, "Must provide an Array :as option"
       end
-      bitmask_definitions[attribute] = Definition.new(attribute, options[:as].to_a, &extension)
+      bitmask_definitions[attribute] = Definition.new(attribute, options[:as].to_a,options[:null].nil? || options[:null],options[:zero_value],&extension)
       bitmask_definitions[attribute].install_on(self)
     end
     

data/lib/bitmask_attributes/definition.rb

@@ -1,11 +1,13 @@
 module BitmaskAttributes
   class Definition
-    attr_reader :attribute, :values, :extension
+    attr_reader :attribute, :values, :allow_null, :zero_value, :extension
     
-    def initialize(attribute, values=[], &extension)
+    def initialize(attribute, values=[],allow_null = true,zero_value = nil, &extension)
       @attribute = attribute
       @values = values
       @extension = extension
+      @allow_null = allow_null
+      @zero_value = zero_value
     end
     
     def install_on(model)
@@ -17,7 +19,7 @@ module BitmaskAttributes
       create_scopes_on model
       create_attribute_methods_on model
     end
-    
+
     private
 
       def validate_for(model)
@@ -25,9 +27,9 @@ module BitmaskAttributes
         # database (the migration has not been run) or table doesn't exist. This usually
         # occurs in the 'test' and 'production' environment or during migration.
         return if defined?(Rails) && Rails.configuration.cache_classes || !model.table_exists?
-       
+
         unless model.columns.detect { |col| col.name == attribute.to_s }
-          raise ArgumentError, "`#{attribute}' is not an attribute of `#{model}'"
+          Rails.logger.warn "WARNING: `#{attribute}' is not an attribute of `#{model}'. But, it's ok if it happens during migrations and your \"bitmasked\" attribute is still not created."
         end
       end
     
@@ -56,7 +58,7 @@ module BitmaskAttributes
         model.class_eval %(
           def #{attribute}=(raw_value)
             values = raw_value.kind_of?(Array) ? raw_value : [raw_value]
-            self.#{attribute}.replace(values.reject(&:blank?))
+            self.#{attribute}.replace(values.reject{|value| #{eval_string_for_zero('value')}})
           end
         )
       end
@@ -74,7 +76,9 @@ module BitmaskAttributes
         model.class_eval %(
           def self.bitmask_for_#{attribute}(*values)
             values.inject(0) do |bitmask, value|
-              unless (bit = bitmasks[:#{attribute}][value])
+              if #{eval_string_for_zero('value')}
+                bit = 0
+              elsif (bit = bitmasks[:#{attribute}][value]).nil?
                 raise ArgumentError, "Unsupported value for #{attribute}: \#{value.inspect}"
               end
               bitmask | bit
@@ -105,50 +109,60 @@ module BitmaskAttributes
       end
     
       def create_scopes_on(model)
+        or_is_null_condition = " OR #{attribute} IS NULL" if allow_null
+
         model.class_eval %(
           scope :with_#{attribute},
             proc { |*values|
               if values.blank?
-                where('#{attribute} > 0 OR #{attribute} IS NOT NULL')
+                where('#{attribute} > 0')
               else
                 sets = values.map do |value|
-                  mask = #{model}.bitmask_for_#{attribute}(value)
+                  mask = ::#{model}.bitmask_for_#{attribute}(value)
                   "#{attribute} & \#{mask} <> 0"
                 end
                 where(sets.join(' AND '))
               end
             }
           scope :without_#{attribute}, 
-            proc { |value| 
-              if value
-                mask = #{model}.bitmask_for_#{attribute}(value)
-                where("#{attribute} IS NULL OR #{attribute} & ? = 0", mask)
+            proc { |*values|
+              if values.blank?
+                no_#{attribute}
               else
-                where("#{attribute} IS NULL OR #{attribute} = 0")
-              end              
-              }                    
-          
-          scope :no_#{attribute}, where("#{attribute} = 0 OR #{attribute} IS NULL")
+                where("#{attribute} & ? = 0#{or_is_null_condition}", ::#{model}.bitmask_for_#{attribute}(*values))
+              end
+            }
+
+          scope :with_exact_#{attribute},
+            proc { | *values|
+              if values.blank?
+                no_#{attribute}
+              else
+                where("#{attribute} = ?", ::#{model}.bitmask_for_#{attribute}(*values))
+              end
+            }
           
+          scope :no_#{attribute}, proc { where("#{attribute} = 0#{or_is_null_condition}") }
+
           scope :with_any_#{attribute},
             proc { |*values|
               if values.blank?
-                where('#{attribute} > 0 OR #{attribute} IS NOT NULL')
+                where('#{attribute} > 0')
               else
-                sets = values.map do |value|
-                  mask = #{model}.bitmask_for_#{attribute}(value)
-                  "#{attribute} & \#{mask} <> 0"
-                end
-                where(sets.join(' OR '))
+                where("#{attribute} & ? <> 0", ::#{model}.bitmask_for_#{attribute}(*values))
               end
             }
         )
         values.each do |value|
           model.class_eval %(
             scope :#{attribute}_for_#{value},
-                  where('#{attribute} & ? <> 0', #{model}.bitmask_for_#{attribute}(:#{value}))
+                  proc { where('#{attribute} & ? <> 0', ::#{model}.bitmask_for_#{attribute}(:#{value})) }
           )
         end      
       end
+
+      def eval_string_for_zero(value_string)
+        zero_value ? "#{value_string}.blank? || #{value_string}.to_s == '#{zero_value}'" : "#{value_string}.blank?"
+      end
   end
-end
+end

data/lib/bitmask_attributes/version.rb

@@ -1,3 +1,3 @@
 module BitmaskAttributes
-  VERSION = "0.2.4".freeze
+  VERSION = "0.3.0".freeze
 end

data/test/bitmask_attributes_test.rb

@@ -1,219 +1,275 @@
 require 'test_helper'
 
 class BitmaskAttributesTest < ActiveSupport::TestCase
-  
-  context "Campaign" do
-    teardown do
-      Company.destroy_all
-      Campaign.destroy_all
-    end
-
-    should "return all defined values of a given bitmask attribute" do
-      assert_equal Campaign.values_for_medium, [:web, :print, :email, :phone]
-    end
-
-    should "can assign single value to bitmask" do
-      assert_stored Campaign.new(:medium => :web), :web
-    end
 
-    should "can assign multiple values to bitmask" do
-      assert_stored Campaign.new(:medium => [:web, :print]), :web, :print
-    end
+  def self.context_with_classes(label,campaign_class,company_class)
+    context label do
+      setup do
+        @campaign_class = campaign_class
+        @company_class = company_class
+      end
 
-    should "can add single value to bitmask" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert_stored campaign, :web, :print
-      campaign.medium << :phone
-      assert_stored campaign, :web, :print, :phone
-    end
+      teardown do
+        @company_class.destroy_all
+        @campaign_class.destroy_all
+      end
 
-    should "ignores duplicate values added to bitmask" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert_stored campaign, :web, :print
-      campaign.medium << :phone
-      assert_stored campaign, :web, :print, :phone
-      campaign.medium << :phone
-      assert_stored campaign, :web, :print, :phone
-      campaign.medium << "phone"
-      assert_stored campaign, :web, :print, :phone
-      assert_equal 1, campaign.medium.select { |value| value == :phone }.size
-      assert_equal 0, campaign.medium.select { |value| value == "phone" }.size
-    end
+      should "return all defined values of a given bitmask attribute" do
+        assert_equal @campaign_class.values_for_medium, [:web, :print, :email, :phone]
+      end
 
-    should "can assign new values at once to bitmask" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert_stored campaign, :web, :print
-      campaign.medium = [:phone, :email]
-      assert_stored campaign, :phone, :email
-    end
+      should "can assign single value to bitmask" do
+        assert_stored @campaign_class.new(:medium => :web), :web
+      end
 
-    should "can save bitmask to db and retrieve values transparently" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert_stored campaign, :web, :print
-      assert campaign.save
-      assert_stored Campaign.find(campaign.id), :web, :print
-    end
+      should "can assign multiple values to bitmask" do
+        assert_stored @campaign_class.new(:medium => [:web, :print]), :web, :print
+      end
 
-    should "can add custom behavor to value proxies during bitmask definition" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert_raises NoMethodError do
-        campaign.medium.worked?
+      should "can add single value to bitmask" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert_stored campaign, :web, :print
+        campaign.medium << :phone
+        assert_stored campaign, :web, :print, :phone
       end
-      assert_nothing_raised do
-        campaign.misc.worked?
+
+      should "ignores duplicate values added to bitmask" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert_stored campaign, :web, :print
+        campaign.medium << :phone
+        assert_stored campaign, :web, :print, :phone
+        campaign.medium << :phone
+        assert_stored campaign, :web, :print, :phone
+        campaign.medium << "phone"
+        assert_stored campaign, :web, :print, :phone
+        assert_equal 1, campaign.medium.select { |value| value == :phone }.size
+        assert_equal 0, campaign.medium.select { |value| value == "phone" }.size
       end
-      assert campaign.misc.worked?
-    end
 
-    should "cannot use unsupported values" do
-      assert_unsupported { Campaign.new(:medium => [:web, :print, :this_will_fail]) }
-      campaign = Campaign.new(:medium => :web)
-      assert_unsupported { campaign.medium << :this_will_fail_also }
-      assert_unsupported { campaign.medium = [:so_will_this] }
-    end
+      should "can assign new values at once to bitmask" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert_stored campaign, :web, :print
+        campaign.medium = [:phone, :email]
+        assert_stored campaign, :phone, :email
+      end
 
-    should "can determine bitmasks using convenience method" do
-      assert Campaign.bitmask_for_medium(:web, :print)
-      assert_equal(
-        Campaign.bitmasks[:medium][:web] | Campaign.bitmasks[:medium][:print],
-        Campaign.bitmask_for_medium(:web, :print)
-      )
-    end
-    
-    should "assert use of unknown value in convenience method will result in exception" do
-      assert_unsupported { Campaign.bitmask_for_medium(:web, :and_this_isnt_valid)  }
-    end
+      should "can save bitmask to db and retrieve values transparently" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert_stored campaign, :web, :print
+        assert campaign.save
+        assert_stored @campaign_class.find(campaign.id), :web, :print
+      end
 
-    should "hash of values is with indifferent access" do
-      string_bit = nil
-      assert_nothing_raised do
-        assert (string_bit = Campaign.bitmask_for_medium('web', 'print'))
+      should "can add custom behavor to value proxies during bitmask definition" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert_raises NoMethodError do
+          campaign.medium.worked?
+        end
+        assert_nothing_raised do
+          campaign.misc.worked?
+        end
+        assert campaign.misc.worked?
       end
-      assert_equal Campaign.bitmask_for_medium(:web, :print), string_bit
-    end
 
-    should "save bitmask with non-standard attribute names" do
-      campaign = Campaign.new(:Legacy => [:upper, :case])
-      assert campaign.save
-      assert_equal [:upper, :case], Campaign.find(campaign.id).Legacy
-    end
+      should "cannot use unsupported values" do
+        assert_unsupported { @campaign_class.new(:medium => [:web, :print, :this_will_fail]) }
+        campaign = @campaign_class.new(:medium => :web)
+        assert_unsupported { campaign.medium << :this_will_fail_also }
+        assert_unsupported { campaign.medium = [:so_will_this] }
+      end
 
-    should "ignore blanks fed as values" do
-      campaign = Campaign.new(:medium => [:web, :print, ''])
-      assert_stored campaign, :web, :print
-    end
-    
-    context "checking" do
-      setup { @campaign = Campaign.new(:medium => [:web, :print]) }
+      should "can determine bitmasks using convenience method" do
+        assert @campaign_class.bitmask_for_medium(:web, :print)
+        assert_equal(
+          @campaign_class.bitmasks[:medium][:web] | @campaign_class.bitmasks[:medium][:print],
+          @campaign_class.bitmask_for_medium(:web, :print)
+        )
+      end
 
-      context "for a single value" do
-        should "be supported by an attribute_for_value convenience method" do
-          assert @campaign.medium_for_web?
-          assert @campaign.medium_for_print?
-          assert !@campaign.medium_for_email?
-        end
-        
-        should "be supported by the simple predicate method" do
-          assert @campaign.medium?(:web)
-          assert @campaign.medium?(:print)
-          assert !@campaign.medium?(:email)
-        end
+      should "assert use of unknown value in convenience method will result in exception" do
+        assert_unsupported { @campaign_class.bitmask_for_medium(:web, :and_this_isnt_valid)  }
       end
-      
-      context "for multiple values" do
-        should "be supported by the simple predicate method" do
-          assert @campaign.medium?(:web, :print)
-          assert !@campaign.medium?(:web, :email)
+
+      should "hash of values is with indifferent access" do
+        string_bit = nil
+        assert_nothing_raised do
+          assert (string_bit = @campaign_class.bitmask_for_medium('web', 'print'))
         end
+        assert_equal @campaign_class.bitmask_for_medium(:web, :print), string_bit
       end
-    end
 
-    context "named scopes" do
-      setup do
-        @company = Company.create(:name => "Test Co, Intl.")
-        @campaign1 = @company.campaigns.create :medium => [:web, :print]        
-        @campaign2 = @company.campaigns.create
-        @campaign3 = @company.campaigns.create :medium => [:web, :email] 
+      should "save bitmask with non-standard attribute names" do
+        campaign = @campaign_class.new(:Legacy => [:upper, :case])
+        assert campaign.save
+        assert_equal [:upper, :case], @campaign_class.find(campaign.id).Legacy
       end
 
-      should "support retrieval by any value" do
-        assert_equal [@campaign1, @campaign3], @company.campaigns.with_medium
+      should "ignore blanks fed as values" do
+        assert_equal 0b11,@campaign_class.bitmask_for_medium(:web, :print, '')
+        campaign = @campaign_class.new(:medium => [:web, :print, ''])
+        assert_stored campaign, :web, :print
       end
 
-      should "support retrieval by one matching value" do
-        assert_equal [@campaign1], @company.campaigns.with_medium(:print)
-      end
-      
-      should "support retrieval by any matching value (OR)" do
-        assert_equal [@campaign1, @campaign3], @company.campaigns.with_any_medium(:print, :email)
+      context "checking" do
+        setup { @campaign = @campaign_class.new(:medium => [:web, :print]) }
+
+        context "for a single value" do
+          should "be supported by an attribute_for_value convenience method" do
+            assert @campaign.medium_for_web?
+            assert @campaign.medium_for_print?
+            assert !@campaign.medium_for_email?
+          end
+
+          should "be supported by the simple predicate method" do
+            assert @campaign.medium?(:web)
+            assert @campaign.medium?(:print)
+            assert !@campaign.medium?(:email)
+          end
+        end
+
+        context "for multiple values" do
+          should "be supported by the simple predicate method" do
+            assert @campaign.medium?(:web, :print)
+            assert !@campaign.medium?(:web, :email)
+          end
+        end
       end
-      
-      should "support retrieval by all matching values" do
-        assert_equal [@campaign1], @company.campaigns.with_medium(:web, :print)
-        assert_equal [@campaign3], @company.campaigns.with_medium(:web, :email)
+
+      context "named scopes" do
+        setup do
+          @company = @company_class.create(:name => "Test Co, Intl.")
+          @campaign1 = @company.campaigns.create :medium => [:web, :print]
+          @campaign2 = @company.campaigns.create
+          @campaign3 = @company.campaigns.create :medium => [:web, :email]
+          @campaign4 = @company.campaigns.create :medium => [:web]
+          @campaign5 = @company.campaigns.create :medium => [:web, :print, :email]
+          @campaign6 = @company.campaigns.create :medium => [:web, :print, :email, :phone]
+          @campaign7 = @company.campaigns.create :medium => [:email, :phone]
+        end
+
+        should "support retrieval by any value" do
+          assert_equal [@campaign1, @campaign3, @campaign4, @campaign5, @campaign6, @campaign7], @company.campaigns.with_medium
+        end
+
+        should "support retrieval by one matching value" do
+          assert_equal [@campaign1, @campaign5, @campaign6], @company.campaigns.with_medium(:print)
+        end
+
+        should "support retrieval by any matching value (OR)" do
+          assert_equal [@campaign1, @campaign3, @campaign5, @campaign6, @campaign7], @company.campaigns.with_any_medium(:print, :email)
+        end
+
+        should "support retrieval by all matching values" do
+          assert_equal [@campaign1, @campaign5, @campaign6], @company.campaigns.with_medium(:web, :print)
+          assert_equal [@campaign3, @campaign5, @campaign6], @company.campaigns.with_medium(:web, :email)
+        end
+
+        should "support retrieval for no values" do
+          assert_equal [@campaign2], @company.campaigns.without_medium
+          assert_equal [@campaign2], @company.campaigns.no_medium
+        end
+
+        should "support retrieval without a specific value" do
+          assert_equal [@campaign2, @campaign3, @campaign4, @campaign7], @company.campaigns.without_medium(:print)
+          assert_equal [@campaign2, @campaign7], @company.campaigns.without_medium(:web, :print)
+          assert_equal [@campaign2, @campaign3, @campaign4], @company.campaigns.without_medium(:print, :phone)
+        end
+        
+        should "support retrieval by exact value" do
+          assert_equal [@campaign4], @company.campaigns.with_exact_medium(:web)
+          assert_equal [@campaign1], @company.campaigns.with_exact_medium(:web, :print)
+          assert_equal [@campaign2], @company.campaigns.with_exact_medium
+        end
+
+        should "not retrieve retrieve a subsequent zero value for an unqualified with scope " do
+          assert_equal [@campaign1, @campaign3, @campaign4, @campaign5, @campaign6, @campaign7], @company.campaigns.with_medium
+          @campaign4.medium = []
+          @campaign4.save
+          assert_equal [@campaign1, @campaign3, @campaign5, @campaign6, @campaign7], @company.campaigns.with_medium
+          assert_equal [@campaign1, @campaign3, @campaign5, @campaign6, @campaign7], @company.campaigns.with_any_medium
+        end
+
+        should "not retrieve retrieve a subsequent zero value for a qualified with scope " do
+          assert_equal [@campaign1, @campaign3, @campaign4, @campaign5, @campaign6], @company.campaigns.with_medium(:web)
+          @campaign4.medium = []
+          @campaign4.save
+          assert_equal [@campaign1, @campaign3, @campaign5, @campaign6], @company.campaigns.with_medium(:web)
+          assert_equal [@campaign1, @campaign3, @campaign5, @campaign6], @company.campaigns.with_any_medium(:web)
+        end
       end
 
-      should "support retrieval for no values" do
-        assert_equal [@campaign2], @company.campaigns.without_medium
-        assert_equal [@campaign2], @company.campaigns.no_medium
+      should "can check if at least one value is set" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert campaign.medium?
+
+        campaign = @campaign_class.new
+        assert !campaign.medium?
       end
-      
-      should "support retrieval without a specific value" do
-        assert_equal [@campaign2, @campaign3], @company.campaigns.without_medium(:print)
+
+      should "find by bitmask values" do
+        campaign = @campaign_class.new(:medium => [:web, :print])
+        assert campaign.save
+
+        assert_equal(
+          @campaign_class.find(:all, :conditions => ['medium & ? <> 0', @campaign_class.bitmask_for_medium(:print)]),
+          @campaign_class.medium_for_print
+        )
+
+        assert_equal @campaign_class.medium_for_print.first, @campaign_class.medium_for_print.medium_for_web.first
+
+        assert_equal [], @campaign_class.medium_for_email
+        assert_equal [], @campaign_class.medium_for_web.medium_for_email
       end
-    end
 
-    should "can check if at least one value is set" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert campaign.medium?
-      
-      campaign = Campaign.new
-      assert !campaign.medium?
-    end
+      should "find no values" do
+        campaign = @campaign_class.create(:medium => [:web, :print])
+        assert campaign.save
 
-    should "find by bitmask values" do
-      campaign = Campaign.new(:medium => [:web, :print])
-      assert campaign.save
-      
-      assert_equal(
-        Campaign.find(:all, :conditions => ['medium & ? <> 0', Campaign.bitmask_for_medium(:print)]),
-        Campaign.medium_for_print
-      )
-      
-      assert_equal Campaign.medium_for_print.first, Campaign.medium_for_print.medium_for_web.first
-      
-      assert_equal [], Campaign.medium_for_email
-      assert_equal [], Campaign.medium_for_web.medium_for_email
-    end
+        assert_equal [], @campaign_class.no_medium
 
-    should "find no values" do
-      campaign = Campaign.create(:medium => [:web, :print])
-      assert campaign.save
-      
-      assert_equal [], Campaign.no_medium
-      
-      campaign.medium = []
-      assert campaign.save
-      
-      assert_equal [campaign], Campaign.no_medium
-    end
+        campaign.medium = []
+        assert campaign.save
+
+        assert_equal [campaign], @campaign_class.no_medium
+      end
 
+      should "allow zero in values without changing result" do
+        assert_equal 0,@campaign_class.bitmask_for_allow_zero(:none)
+        assert_equal 0b111,@campaign_class.bitmask_for_allow_zero(:one,:two,:three,:none)
 
-    private
+        campaign = @campaign_class.new(:allow_zero => :none)
+        assert campaign.save
+        assert_equal [],campaign.allow_zero
 
-      def assert_unsupported(&block)
-        assert_raises(ArgumentError, &block)
+        campaign.allow_zero = :none
+        assert campaign.save
+        assert_equal [],campaign.allow_zero
+
+        campaign.allow_zero = [:one,:none]
+        assert campaign.save
+        assert_equal [:one],campaign.allow_zero
       end
 
-      def assert_stored(record, *values)
-        values.each do |value|
-          assert record.medium.any? { |v| v.to_s == value.to_s }, "Values #{record.medium.inspect} does not include #{value.inspect}"
+
+      private
+
+        def assert_unsupported(&block)
+          assert_raises(ArgumentError, &block)
         end
-        full_mask = values.inject(0) do |mask, value|
-          mask | Campaign.bitmasks[:medium][value]
+
+        def assert_stored(record, *values)
+          values.each do |value|
+            assert record.medium.any? { |v| v.to_s == value.to_s }, "Values #{record.medium.inspect} does not include #{value.inspect}"
+          end
+          full_mask = values.inject(0) do |mask, value|
+            mask | @campaign_class.bitmasks[:medium][value]
+          end
+          assert_equal full_mask, record.medium.to_i
         end
-        assert_equal full_mask, record.medium.to_i
-      end
 
+    end
   end
+
+  context_with_classes 'Campaign with null attributes',CampaignWithNull,CompanyWithNull
+  context_with_classes 'Campaign without null attributes',CampaignWithoutNull,CompanyWithoutNull
 end

data/test/support/models.rb

@@ -1,26 +1,50 @@
 ActiveRecord::Schema.define do 
-  create_table :campaigns do |t|
+  create_table :campaign_with_nulls do |t|
     t.integer :company_id
-    t.integer :medium, :misc, :Legacy
+    t.integer :medium, :allow_zero, :misc, :Legacy
   end
-  create_table :companies do |t|
+  create_table :company_with_nulls do |t|
+    t.string :name
+  end
+  create_table :campaign_without_nulls do |t|
+    t.integer :company_id
+    t.integer :medium, :allow_zero, :misc, :Legacy, :null => false, :default => 0
+  end
+  create_table :company_without_nulls do |t|
     t.string :name
   end
 end
 
+# Pseudo models for testing purposes
 
-class Company < ActiveRecord::Base
-  has_many :campaigns
+class CompanyWithNull < ActiveRecord::Base
+  has_many :campaigns,:class_name => 'CampaignWithNull',:foreign_key => 'company_id'
 end
 
-# Pseudo model for testing purposes
-class Campaign < ActiveRecord::Base
-  belongs_to :company
+class CampaignWithNull < ActiveRecord::Base
+  belongs_to :company,:class_name => 'CompanyWithNull'
   bitmask :medium, :as => [:web, :print, :email, :phone]
+  bitmask :allow_zero, :as => [:one, :two, :three], :zero_value => :none
   bitmask :misc, :as => %w(some useless values) do
     def worked?
       true
     end
   end
   bitmask :Legacy, :as => [:upper, :case]
+end
+
+class CompanyWithoutNull < ActiveRecord::Base
+  has_many :campaigns,:class_name => 'CampaignWithoutNull',:foreign_key => 'company_id'
+end
+
+class CampaignWithoutNull < ActiveRecord::Base
+  belongs_to :company,:class_name => 'CompanyWithoutNull'
+  bitmask :medium, :as => [:web, :print, :email, :phone], :null => false
+  bitmask :allow_zero, :as => [:one, :two, :three], :zero_value => :none, :null => false
+  bitmask :misc, :as => %w(some useless values), :null => false do
+    def worked?
+      true
+    end
+  end
+  bitmask :Legacy, :as => [:upper, :case], :null => false
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitmask_attributes
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-23 00:00:00.000000000 Z
+date: 2012-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70229913138200 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,12 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70229913138200
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: 
 email: joel@developwithstyle.com
 executables: []
@@ -31,6 +36,7 @@ files:
 - .document
 - .gitignore
 - .rvmrc
+- .travis.yml
 - CHANGELOG.rdoc
 - Gemfile
 - Gemfile.lock
@@ -75,7 +81,6 @@ files:
 - lib/bitmask_attributes/value_proxy.rb
 - lib/bitmask_attributes/version.rb
 - test/bitmask_attributes_test.rb
-- test/support/helpers.rb
 - test/support/models.rb
 - test/test_helper.rb
 homepage: http://github.com/joelmoss/bitmask_attributes
@@ -98,12 +103,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple bitmask attribute support for ActiveRecord
 test_files:
 - test/bitmask_attributes_test.rb
-- test/support/helpers.rb
 - test/support/models.rb
 - test/test_helper.rb

data/test/support/helpers.rb

@@ -1,17 +0,0 @@
-class ActiveSupport::TestCase
-  
-  def assert_unsupported(&block)
-    assert_raises(ArgumentError, &block)
-  end
-  
-  def assert_stored(record, *values)
-    values.each do |value|
-      assert record.medium.any? { |v| v.to_s == value.to_s }, "Values #{record.medium.inspect} does not include #{value.inspect}"
-    end
-    full_mask = values.inject(0) do |mask, value|
-      mask | Campaign.bitmasks[:medium][value]
-    end
-    assert_equal full_mask, record.medium.to_i
-  end
-  
-end