clean-bitmask-attribute 2.0.0

data/lib/bitmask_attribute.rb

@@ -0,0 +1,162 @@
+require 'bitmask_attribute/value_proxy'
+require 'bitmask_attribute/attribute'
+require 'bitmask_attribute/core_ext/hash_with_indifferent_access' unless defined?(HashWithIndifferentAccess)
+require 'bitmask_attribute/core_ext/returning' unless Object.respond_to?(:returning)
+require 'bitmask_attribute/core_ext/blank' unless Object.respond_to?(:blank?)
+
+module BitmaskAttribute
+  
+  class Definition
+    
+    attr_reader :attribute, :values, :extension
+    def initialize(attribute, values=[], &extension)
+      @attribute = attribute
+      @values = values
+      @extension = extension
+    end
+    
+    def install_on(model)
+      validate_for model
+      generate_bitmasks_on model
+      override model
+      create_convenience_class_method_on(model)
+      create_convenience_instance_methods_on(model)
+      create_named_scopes_on(model) if defined?(ActiveRecord::Base) && model.respond_to?(scope_method)
+    end
+    
+    #######
+    private
+    #######
+
+    def validate_for(model)
+      unless (model.columns.detect { |col| col.name == attribute.to_s } rescue true)
+        raise ArgumentError, "`#{attribute}' is not an attribute of `#{model}'"
+      end
+    end
+    
+    def generate_bitmasks_on(model)
+      model.bitmasks[attribute] = returning HashWithIndifferentAccess.new do |mapping|
+        values.each_with_index do |value, index|
+          mapping[value] = 0b1 << index
+        end
+      end
+    end
+    
+    def override(model)
+      override_getter_on(model)
+      override_setter_on(model)
+    end
+    
+    def override_getter_on(model)
+      model.class_eval %(
+        def #{attribute}
+          @#{attribute} ||= BitmaskAttribute::ValueProxy.new(self, :#{attribute}, &self.class.bitmask_definitions[:#{attribute}].extension)
+        end
+      )
+    end
+    
+    def override_setter_on(model)
+      model.class_eval %(
+        def #{attribute}=(raw_value)
+          values = raw_value.kind_of?(Array) ? raw_value : [raw_value]
+          self.#{attribute}.replace(values.reject(&:blank?))
+        end
+      )
+    end
+    
+    def create_convenience_class_method_on(model)
+      model.class_eval %(
+        def self.bitmask_for_#{attribute}(*values)
+          values.inject(0) do |bitmask, value|
+            unless (bit = bitmasks[:#{attribute}][value])
+              raise ArgumentError, "Unsupported value for #{attribute}: \#{value.inspect}"
+            end
+            bitmask | bit
+          end
+        end
+      )
+    end
+
+
+    def create_convenience_instance_methods_on(model)
+      values.each do |value|
+        model.class_eval %(
+          def #{attribute}_for_#{value}?                  
+            self.#{attribute}?(:#{value})
+          end
+        )
+      end
+      model.class_eval %(
+        def #{attribute}?(*values)
+          if !values.blank?
+            values.all? do |value|
+              self.#{attribute}.include?(value.to_sym)
+            end
+          else
+            self.#{attribute}.present?
+          end
+        end
+      )
+    end
+
+    def scope_method
+      ActiveRecord::VERSION::STRING >= "3" ? :scope : :named_scope
+    end
+
+    def create_named_scopes_on(model)
+      model.class_eval %(
+        #{scope_method} :with_#{attribute},
+          proc { |*values|
+            if values.blank?
+              {:conditions => '#{attribute} > 0 OR #{attribute} IS NOT NULL'}
+            else
+              sets = values.map do |value|
+                mask = #{model}.bitmask_for_#{attribute}(value)
+                "#{attribute} & \#{mask} <> 0"
+              end
+              {:conditions => sets.join(' AND ')}
+            end
+          }
+        #{scope_method} :without_#{attribute}, :conditions => "#{attribute} == 0 OR #{attribute} IS NULL"
+        #{scope_method} :no_#{attribute},      :conditions => "#{attribute} == 0 OR #{attribute} IS NULL"
+      )
+      values.each do |value|
+        model.class_eval %(
+          #{scope_method} :#{attribute}_for_#{value},
+                          :conditions => ['#{attribute} & ? <> 0', #{model}.bitmask_for_#{attribute}(:#{value})]
+        )
+      end      
+    end
+    
+  end
+
+  def self.included(model)
+    model.extend ClassMethods
+    # Include basic attributes support for clean class
+    # TODO improve attributes detection
+    model.send(:include, BitmaskAttribute::Attribute) unless model.included_modules.detect{|m| m.to_s.include? 'AttributeMethods'}
+  end
+
+  module ClassMethods
+    
+    def bitmask(attribute, options={}, &extension)
+      unless options[:as] && options[:as].kind_of?(Array)
+        raise ArgumentError, "Must provide an Array :as option"
+      end
+      bitmask_definitions[attribute] = BitmaskAttribute::Definition.new(attribute, options[:as].to_a, &extension)
+      bitmask_definitions[attribute].install_on(self)
+    end
+    
+    def bitmask_definitions
+      @bitmask_definitions ||= {}
+    end
+    
+    def bitmasks
+      @bitmasks ||= {}
+    end
+      
+  end
+  
+end
+
+ActiveRecord::Base.send :include, BitmaskAttribute if defined? ActiveRecord::Base

data/rails/init.rb

@@ -0,0 +1,3 @@
+ActiveRecord::Base.instance_eval do
+  include BitmaskAttribute
+end

data/test/bitmask_attribute_test.rb

@@ -0,0 +1,223 @@
+require 'test_helper'
+
+class BitmaskAttributeTest < Test::Unit::TestCase
+  
+  context "Campaign" do
+
+    teardown do
+      Company.destroy_all
+      Campaign.destroy_all
+    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
+
+    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
+
+    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
+      assert_equal 1, campaign.medium.select { |value| value == :phone }.size
+    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 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 add custom behavor to value proxies during bitmask definition" do
+      campaign = Campaign.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
+
+    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 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 "hash of values is with indifferent access" do
+      string_bit = nil
+      assert_nothing_raised do
+        assert (string_bit = Campaign.bitmask_for_medium('web', 'print'))
+      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 "ignore blanks fed as values" do
+      campaign = Campaign.new(:medium => [:web, :print, ''])
+      assert_stored campaign, :web, :print
+    end
+    
+    should "convert values passed as strings to symbols" do
+      campaign = Campaign.new
+      campaign.medium << "web"
+      assert_equal [:web], campaign.medium
+      assert_equal true, campaign.medium?("web")
+    end
+        
+    context "checking" do
+
+      setup { @campaign = Campaign.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
+
+    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] 
+      end
+
+      should "support retrieval by any value" do
+        assert_equal [@campaign1, @campaign3], @company.campaigns.with_medium
+      end
+
+      should "support retrieval by one matching value" do
+        assert_equal [@campaign1], @company.campaigns.with_medium(:print)
+      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)
+      end
+
+      should "support retrieval for no values" do
+        assert_equal [@campaign2], @company.campaigns.without_medium
+      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 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.all, Campaign.medium_for_print.medium_for_web.all
+      
+      assert_equal [], Campaign.medium_for_email
+      assert_equal [], Campaign.medium_for_web.medium_for_email
+    end
+
+    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
+
+    #######
+    private
+    #######
+
+    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
+
+end

data/test/clean_bitmask_attribute_test.rb

@@ -0,0 +1,155 @@
+require 'clean_test_helper'
+
+class CleanBitmaskAttributeTest < Test::Unit::TestCase
+  
+  context "CleanCampaign" do
+
+    should "can assign single value to bitmask" do
+      assert_stored CleanCampaign.new(:medium => :web), :web
+    end
+
+    should "can assign multiple values to bitmask" do
+      assert_stored CleanCampaign.new(:medium => [:web, :print]), :web, :print
+    end
+
+    should "can add single value to bitmask" do
+      campaign = CleanCampaign.new(:medium => [:web, :print])
+      assert_stored campaign, :web, :print
+      campaign.medium << :phone
+      assert_stored campaign, :web, :print, :phone
+    end
+
+    should "ignores duplicate values added to bitmask" do
+      campaign = CleanCampaign.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
+      assert_equal 1, campaign.medium.select { |value| value == :phone }.size
+    end
+
+    should "can assign new values at once to bitmask" do
+      campaign = CleanCampaign.new(:medium => [:web, :print])
+      assert_stored campaign, :web, :print
+      campaign.medium = [:phone, :email]
+      assert_stored campaign, :phone, :email
+    end
+
+    should "can add custom behavor to value proxies during bitmask definition" do
+      campaign = CleanCampaign.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
+
+    should "cannot use unsupported values" do
+      assert_unsupported { CleanCampaign.new(:medium => [:web, :print, :this_will_fail]) }
+      campaign = CleanCampaign.new(:medium => :web)
+      assert_unsupported { campaign.medium << :this_will_fail_also }
+      assert_unsupported { campaign.medium = [:so_will_this] }
+    end
+
+    should "can determine bitmasks using convenience method" do
+      assert CleanCampaign.bitmask_for_medium(:web, :print)
+      assert_equal(
+        CleanCampaign.bitmasks[:medium][:web] | CleanCampaign.bitmasks[:medium][:print],
+        CleanCampaign.bitmask_for_medium(:web, :print)
+      )
+    end
+    
+    should "assert use of unknown value in convenience method will result in exception" do
+      assert_unsupported { CleanCampaign.bitmask_for_medium(:web, :and_this_isnt_valid)  }
+    end
+
+    should "hash of values is with indifferent access" do
+      string_bit = nil
+      assert_nothing_raised do
+        assert (string_bit = CleanCampaign.bitmask_for_medium('web', 'print'))
+      end
+      assert_equal CleanCampaign.bitmask_for_medium(:web, :print), string_bit
+    end
+
+    should "save bitmask with non-standard attribute names" do
+      campaign = CleanCampaign.new(:Legacy => [:upper, :case])
+      assert_equal [:upper, :case], campaign.Legacy
+    end
+
+    should "ignore blanks fed as values" do
+      campaign = CleanCampaign.new(:medium => [:web, :print, ''])
+      assert_stored campaign, :web, :print
+    end
+    
+    should "convert values passed as strings to symbols" do
+      campaign = CleanCampaign.new
+      campaign.medium << "web"
+      assert_equal [:web], campaign.medium
+      assert_equal true, campaign.medium?("web")
+    end
+        
+    context "checking" do
+
+      setup { @campaign = CleanCampaign.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 "can check if at least one value is set" do
+      campaign = CleanCampaign.new(:medium => [:web, :print])
+      
+      assert campaign.medium?
+      
+      campaign = CleanCampaign.new
+      
+      assert !campaign.medium?
+    end
+
+    #######
+    private
+    #######
+
+    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 | CleanCampaign.bitmasks[:medium][value]
+      end
+      assert_equal full_mask, record.medium.to_i
+    end
+
+  end
+
+end

data/test/clean_test_helper.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+begin
+  require 'redgreen'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bitmask-attribute'
+require File.dirname(__FILE__) + '/../rails/init'
+
+# Pseudo model for testing purposes
+class CleanCampaign
+  include BitmaskAttribute
+  bitmask :medium, :as => [:web, :print, :email, :phone]
+  bitmask :misc, :as => %w(some useless values) do
+    def worked?
+      true
+    end
+  end
+  bitmask :Legacy, :as => [:upper, :case]
+end
+
+class Test::Unit::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

data/test/test_helper.rb

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'active_record'
+
+begin
+  require 'redgreen'
+  require 'active_support/hash_with_indifferent_access'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bitmask-attribute'
+require File.dirname(__FILE__) + '/../rails/init'
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Schema.define do 
+  create_table :campaigns do |t|
+    t.integer :company_id
+    t.integer :medium, :misc, :Legacy
+  end
+  create_table :companies do |t|
+    t.string :name
+  end
+end
+
+class Company < ActiveRecord::Base
+  has_many :campaigns
+end
+
+# Pseudo model for testing purposes
+class Campaign < ActiveRecord::Base
+  belongs_to :company
+  bitmask :medium, :as => [:web, :print, :email, :phone]
+  bitmask :misc, :as => %w(some useless values) do
+    def worked?
+      true
+    end
+  end
+  bitmask :Legacy, :as => [:upper, :case]
+end
+
+class Test::Unit::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