bitmask_attributes 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.markdown
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+\#*
+.#*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@bitmask_attributes --create --install

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gemspec
+
+if RUBY_VERSION < '1.9'
+  gem "ruby-debug", ">= 0.10.3"
+end
+
+gem 'shoulda'
+gem 'sqlite3'
+gem 'turn'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    bitmask_attributes (0.1.0)
+      activerecord (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.9)
+    ansi (1.3.0)
+    arel (2.0.10)
+    builder (2.1.2)
+    i18n (0.5.0)
+    shoulda (2.11.3)
+    sqlite3 (1.3.3)
+    turn (0.8.2)
+      ansi (>= 1.2.2)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bitmask_attributes!
+  shoulda
+  sqlite3
+  turn

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2009 Bruce Williams & 2011 Joel Moss
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+BitmaskAttributes
+=================
+
+Transparent manipulation of bitmask attributes for ActiveRecord, based on
+the bitmask-attribute gem, which has been dormant since 2009. This updated
+gem work with Rails 3 and up (including Rails 3.1).
+
+Installation
+------------
+
+The best way to install is with RubyGems:
+
+    $ [sudo] gem install bitmask_attributes
+    
+Or better still, just add it to your Gemfile:
+
+    gem 'bitmask_attributes'
+
+Example
+-------
+
+Simply declare an existing integer column as a bitmask with its possible
+values.
+
+    class User < ActiveRecord::Base
+      bitmask :roles, :as => [:writer, :publisher, :editor, :proofreader] 
+    end
+    
+You can then modify the column using the declared values without resorting
+to manual bitmasks.
+    
+    user = User.create(:name => "Bruce", :roles => [:publisher, :editor])
+    user.roles
+    # => [:publisher, :editor]
+    user.roles << :writer
+    user.roles
+    # => [:publisher, :editor, :writer]
+    
+It's easy to find out if a record has a given value:
+
+    user.roles?(:editor)
+    # => true
+    
+You can check for multiple values (uses an `and` boolean):
+
+    user.roles?(:editor, :publisher)
+    # => true
+    user.roles?(:editor, :proofreader)
+    # => false
+
+Or, just check if any values are present:
+
+    user.roles?
+    # => true
+
+Named Scopes
+------------
+
+A couple useful named scopes are also generated when you use
+`bitmask`:
+
+    User.with_roles
+    # => (all users with roles)
+    User.with_roles(:editor)
+    # => (all editors)
+    User.with_roles(:editor, :writer)
+    # => (all users who are BOTH editors and writers)
+
+Later we'll support an `or` boolean; for now, do something like:
+
+    User.with_roles(:editor) + User.with_roles(:writer)
+    # => (all users who are EITHER editors and writers)
+
+Find records without any bitmask set:
+
+    User.without_roles
+    # => (all users without a role)
+
+Later we'll support finding records without a specific bitmask.
+
+Adding Methods
+--------------
+
+You can add your own methods to the bitmasked attributes (similar to
+named scopes):
+
+    bitmask :other_attribute, :as => [:value1, :value2] do
+      def worked?
+        true
+      end
+    end
+
+    user = User.first
+    user.other_attribute.worked?
+    # => true
+
+
+Warning: Modifying possible values
+----------------------------------
+
+IMPORTANT: Once you have data using a bitmask, don't change the order
+of the values, remove any values, or insert any new values in the `:as`
+array anywhere except at the end.  You won't like the results.
+
+Contributing
+------------
+
+1. Fork it.
+2. Create a branch (`git checkout -b new-feature`)
+3. Make your changes
+4. Run the tests (`bundle install` then `bundle exec rake`)
+5. Commit your changes (`git commit -am "Created new feature"`)
+6. Push to the branch (`git push origin new-feature`)
+7. Create a [Pull Request](http://help.github.com/pull-requests/) from your branch.
+8. Promote it. Get others to drop in and +1 it.
+
+Credits
+-------
+
+Thanks to [Bruce Williams](https://github.com/bruce) and the following contributors
+of the bitmask-attribute plugin:
+
+* [Jason L Perry](http://github.com/ambethia)
+* [Nicolas Fouché](http://github.com/nfo)
+
+Copyright
+---------
+
+Copyright (c) 2007-2009 Bruce Williams & 2011 Joel Moss. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/bitmask_attributes.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bitmask_attributes/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "bitmask_attributes"
+  gem.summary       = %Q{Simple bitmask attribute support for ActiveRecord}
+  gem.description   = %Q{Simple bitmask attribute support for ActiveRecord}
+  gem.email         = "joel@developwithstyle.com"
+  gem.homepage      = "http://github.com/joelmoss/bitmask_attributes"
+  gem.authors       = ['Joel Moss']
+  
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ['lib']
+  gem.version       = BitmaskAttributes::VERSION
+  
+  gem.add_dependency 'activerecord', '~> 3.0'
+end

data/lib/bitmask_attributes.rb

@@ -0,0 +1,26 @@
+require 'bitmask_attributes/definition'
+require 'bitmask_attributes/value_proxy'
+
+module BitmaskAttributes
+  extend ActiveSupport::Concern
+
+  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] = 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, BitmaskAttributes

data/lib/bitmask_attributes/definition.rb

@@ -0,0 +1,122 @@
+module BitmaskAttributes
+  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_scopes_on model
+    end
+    
+    private
+
+      def validate_for(model)
+        # The model cannot be validated if it is preloaded and the attribute/column is not in the
+        # database (the migration has not been run).  This usually
+        # occurs in the 'test' and 'production' environments.
+        return if defined?(Rails) && Rails.configuration.cache_classes
+
+        unless model.columns.detect { |col| col.name == attribute.to_s }
+          raise ArgumentError, "`#{attribute}' is not an attribute of `#{model}'"
+        end
+      end
+    
+      def generate_bitmasks_on(model)
+        model.bitmasks[attribute] = HashWithIndifferentAccess.new.tap 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} ||= BitmaskAttributes::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)
+              end
+            else
+              self.#{attribute}.present?
+            end
+          end
+        )
+      end
+    
+      def create_scopes_on(model)
+        model.class_eval %(
+          scope :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 :without_#{attribute}, :conditions => "#{attribute} == 0 OR #{attribute} IS NULL"
+          scope :no_#{attribute},      :conditions => "#{attribute} == 0 OR #{attribute} IS NULL"
+        )
+        values.each do |value|
+          model.class_eval %(
+            scope :#{attribute}_for_#{value},
+                        :conditions => ['#{attribute} & ? <> 0', #{model}.bitmask_for_#{attribute}(:#{value})]
+          )
+        end      
+      end
+  end
+end

data/lib/bitmask_attributes/value_proxy.rb

@@ -0,0 +1,68 @@
+module BitmaskAttributes
+  class ValueProxy < Array
+      
+    def initialize(record, attribute, &extension)
+      @record = record
+      @attribute = attribute
+      find_mapping
+      instance_eval(&extension) if extension
+      super(extract_values)
+    end
+    
+    # =========================
+    # = OVERRIDE TO SERIALIZE =
+    # =========================
+    
+    %w(push << delete replace reject! select!).each do |override|
+      class_eval(<<-EOEVAL)
+        def #{override}(*args)
+          (super).tap do
+            updated!
+          end
+        end
+      EOEVAL
+    end
+    
+    def to_i
+      inject(0) { |memo, value| memo | @mapping[value] }
+    end
+  
+    private
+    
+      def validate!
+        each do |value|
+          if @mapping.key? value
+            true
+          else
+            raise ArgumentError, "Unsupported value for `#{@attribute}': #{value.inspect}"
+          end
+        end
+      end
+    
+      def updated!
+        validate!
+        uniq!
+        serialize!
+      end
+    
+      def serialize!
+        @record.send(:write_attribute, @attribute, to_i)
+      end
+  
+      def extract_values
+        stored = [@record.send(:read_attribute, @attribute) || 0, 0].max
+        @mapping.inject([]) do |values, (value, bitmask)|
+          values.tap do
+            values << value.to_sym if (stored & bitmask > 0)
+          end
+        end        
+      end
+    
+      def find_mapping
+        unless (@mapping = @record.class.bitmasks[@attribute])
+          raise ArgumentError, "Could not find mapping for bitmask attribute :#{@attribute}"
+        end
+      end
+      
+  end
+end

data/lib/bitmask_attributes/version.rb

@@ -0,0 +1,3 @@
+module BitmaskAttributes
+  VERSION = "0.1.0"
+end

data/test/bitmask_attributes_test.rb

@@ -0,0 +1,205 @@
+require 'test_helper'
+
+class BitmaskAttributesTest < ActiveSupport::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
+    
+    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.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
+
+    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/support/helpers.rb

@@ -0,0 +1,17 @@
+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

data/test/support/models.rb

@@ -0,0 +1,26 @@
+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

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require 'bundler/setup'
+
+require 'test/unit'
+begin; require 'turn'; rescue LoadError; end
+require 'shoulda'
+
+require 'active_record'
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require 'bitmask_attributes'
+
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: bitmask_attributes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joel Moss
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-04 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+description: Simple bitmask attribute support for ActiveRecord
+email: joel@developwithstyle.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .document
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bitmask_attributes.gemspec
+- lib/bitmask_attributes.rb
+- lib/bitmask_attributes/definition.rb
+- 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
+has_rdoc: true
+homepage: http://github.com/joelmoss/bitmask_attributes
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.9.1
+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