acts_as_bits 0.2.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [maiha@wota.jp]
+
+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

@@ -0,0 +1,73 @@
+ActsAsBits
+==========
+
+ActiveRecord plugin that maintains massive flags in one column
+
+
+Table Definition
+================
+
+Add "string" column into your model table.
+
+  ALTER TABLE users ADD operations varchar(255);
+
+
+Model Definition
+================
+
+  class User < ActiveRecord::Base
+    acts_as_bits :operations, %w( create read update delete )
+  end
+
+
+Usage
+=====
+
+  user = User.new
+  user.create?        # => false
+  user.create = true
+  user.delete = true
+  user.operations     # => "1001"
+  user.create?        # => true
+
+  User.create!(:update => true, :read=>false)
+
+
+Search
+======
+
+Finding methods work only on PostgreSQL, MySQL and SQL Server because we use "substring" function
+
+  User.find(:all, :conditions=>{:read=>true})
+
+
+Advanced
+========
+
+"(column_name)=" enables to fill up values with argument that is true/false.
+This is useful for initial setting like all allow/deny.
+
+  user = User.new
+  user.operations     # => "0000"
+
+  # set all green
+  user.operations = true
+  user.operations     # => "1111"
+
+  # set all red
+  user.operations = false
+  user.operations     # => "0000"
+
+
+Environment
+===========
+
+  tested on
+
+  * Rails 1.2.6-2.3.2
+
+
+Author
+======
+
+moriq and maiha

data/Rakefile

@@ -0,0 +1,74 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_bits plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_bits plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsBits'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+######################################################################
+### for gem
+
+require 'rubygems'
+require 'rake/gempackagetask'
+
+GEM_NAME = "acts_as_bits"
+AUTHOR = "maiha"
+EMAIL = "maiha@wota.jp"
+HOMEPAGE = "http://github.com/maiha/acts_as_bits"
+SUMMARY = "ActiveRecord plugin that maintains massive flags in one column"
+GEM_VERSION = "0.2.1"
+
+spec = Gem::Specification.new do |s|
+#  s.rubyforge_project = 'merb'
+  s.name             = GEM_NAME
+  s.version          = GEM_VERSION
+  s.platform         = Gem::Platform::RUBY
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.summary          = SUMMARY
+  s.description      = s.summary
+  s.author           = AUTHOR
+  s.email            = EMAIL
+  s.homepage         = HOMEPAGE
+  s.require_path     = 'lib'
+  s.files            = %w(LICENSE README Rakefile) + Dir.glob("{core_ext,lib,spec,tasks,test}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install the gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+

data/lib/acts_as_bits.rb

@@ -0,0 +1,198 @@
+require 'active_record'
+
+# ActsAsBits
+module ActsAsBits
+  def self.rails2?
+    ActiveRecord::Base.respond_to?(:sanitize_sql_hash_for_conditions)
+  end
+
+  def self.append_features(base)
+    base.extend ClassMethods
+    base.extend(rails2? ? Rails2x : Rails1x)
+    base.class_eval do
+      def self.sanitize_sql_hash(*args)
+        sanitize_sql_hash_with_aab(*args)
+      end
+
+      def self.sanitize_sql_hash_for_conditions(*args)
+        sanitize_sql_hash_with_aab(*args)
+      end
+    end
+  end
+
+  module Rails1x
+    def sanitize_sql_hash_with_aab(attrs)
+      values = []
+      conditions = attrs.map do |attr, value|
+        if bit_column = bit_columns_hash[attr.to_s]
+          flag = ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+          "#{bit_column} %s '1'" % (flag ? '=' : '<>')
+        else
+          values << value
+          prefix = "#{table_name}." rescue ''
+          "#{prefix}#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+        end
+      end.join(' AND ')
+      replace_bind_variables(conditions, expand_range_bind_variables(values))
+    end
+  end
+
+  module Rails2x
+    def sanitize_sql_hash_with_aab(attrs)
+      values = []
+      conditions = attrs.keys.map do |key|
+        value = attrs[key]
+        attr  = key.to_s
+
+        # Extract table name from qualified attribute names.
+        if attr.include?('.')
+          table_name, attr = attr.split('.', 2)
+          table_name = connection.quote_table_name(table_name)
+        else
+          table_name = quoted_table_name
+        end
+
+        if bit_column = bit_columns_hash[attr]
+          flag = ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+          "#{bit_column} %s '1'" % (flag ? '=' : '<>')
+        else
+          values << value
+          case ActiveRecord::Base.method(:attribute_condition).arity
+          when 1                # Rails 2.0-2.2
+            "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+          when 2                # Rails 2.3-
+            attribute_condition("#{table_name}.#{connection.quote_column_name(attr)}", value)
+          else
+            raise NotImplementedError, "unknown AR::Base#attribute_condition type"
+          end
+        end
+      end.join(' AND ')
+      replace_bind_variables(conditions, expand_range_bind_variables(values))
+    end
+  end
+
+  module ClassMethods
+    def bit_columns_hash
+      @bit_columns_hash ||= {}
+    end
+
+    def acts_as_bits(part_id, bit_names, options = {})
+      composed_name = part_id.id2name
+      singular_name = composed_name.singularize
+
+      delegate "#{singular_name}_names", :to=>"self.class"
+
+      if options[:prefix]
+        bit_names = bit_names.map do |(name, label)|
+          name = "%s_%s" % [singular_name, name]
+          [name, label]
+        end
+      end
+
+      # true/false fills all values by itself
+      module_eval <<-end_eval
+        def #{composed_name}=(value)
+          case value
+          when true  then super("1"*#{singular_name}_names.size)
+          when false then super("0"*#{singular_name}_names.size)
+          else            super
+          end
+        end
+      end_eval
+
+      bit_names.each_with_index do |(name, label), index|
+        next if name.blank?
+
+        # register bit column
+        column_name = "COALESCE(SUBSTRING(%s.%s,%d,1),'')" % [table_name, connection.quote_column_name(composed_name), index+1]
+        (@bit_columns_hash ||= {})[name.to_s] = column_name
+
+        module_eval <<-end_eval
+              def #{name}
+                #{name}?
+              end
+
+              unless label.blank?
+                def self.#{name}_label
+                  #{label.inspect}
+                end
+              end
+
+              def #{name}?
+                #{composed_name}.to_s[#{index}] == ?1
+              end
+
+              def #{name}=(v)
+                v = ActiveRecord::ConnectionAdapters::Column.value_to_boolean(v) ? ?1 : ?0
+
+                # expand target string automatically
+                if #{composed_name}.size < #{singular_name}_names.size
+                   #{composed_name} << "0" * (#{singular_name}_names.size - #{composed_name}.size)
+                end
+
+                value = #{composed_name}.dup
+                value[#{index}] = v
+                write_attribute("#{composed_name}", value)
+                return v
+              end
+        end_eval
+
+        compacted_bit_names = bit_names.select{|(i,)| !i.blank?}
+        column_names = compacted_bit_names.map{|(i,)| i.to_s}
+        label_names  = compacted_bit_names.map{|(n,i)| i.to_s}
+
+        module_eval <<-end_eval
+            def self.#{singular_name}_names
+              #{column_names.inspect}
+            end
+
+          if options[:prefix]
+
+            def #{singular_name}?(name = nil)
+              if name
+                __send__ "#{singular_name}_" + name.to_s
+              else
+                #{composed_name}.to_s.include?('1')
+              end
+            end
+
+          else
+
+            def #{singular_name}?(name = nil)
+              if name
+                __send__ name
+              else
+                #{composed_name}.to_s.include?('1')
+              end
+            end
+
+          end
+
+            def #{composed_name}
+              self.#{composed_name} = "0" * #{column_names.size} if super.blank?
+              super
+            end
+
+            def #{composed_name}_hash
+              HashWithIndifferentAccess[*#{singular_name}_names.map{|i| [i,__send__(i)]}.flatten]
+            end
+        end_eval
+
+        module_eval <<-end_eval
+            def self.#{singular_name}_labels
+              #{label_names.inspect}
+            end
+
+            def self.#{singular_name}_names_with_labels
+              #{bit_names.inspect}
+            end
+        end_eval
+      end
+    end
+  end # ClassMethods
+end
+
+ActiveRecord::Base.class_eval do
+  include ActsAsBits
+end
+

data/tasks/acts_as_bits_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_bits do
+#   # Task goes here
+# end

data/test/acts_as_bits_test.rb

@@ -0,0 +1,153 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ActsAsBitsTest < Test::Unit::TestCase
+  fixtures :mixins
+
+  def test_respond
+    m = mixins(:bits_00)
+
+    assert_respond_to m, :admin
+    assert_respond_to m, :admin?
+    assert_respond_to m, :admin=
+
+    assert_respond_to m, :composer
+    assert_respond_to m, :composer?
+    assert_respond_to m, :composer=
+  end
+
+  def test_reader_00
+    m = mixins(:bits_00)
+
+    assert ! m.admin?
+    assert ! m.composer?
+  end
+
+  def test_writer_01
+    m = mixins(:bits_01)
+
+    m.admin = true
+    m.composer = false
+
+    # save?
+
+    assert m.admin?
+    assert ! m.composer?
+  end
+
+  def test_reader_to_new_object
+    m = Mixin.new
+
+    assert_equal false, m.admin?
+    assert_equal false, m.composer?
+  end
+
+  def test_names
+    assert_equal %w( top right bottom left ), Mixin.position_names
+  end
+
+  def test_labels
+    assert_equal "TOP",    Mixin.top_label
+    assert_equal "RIGHT",  Mixin.right_label
+    assert_equal "BOTTOM", Mixin.bottom_label
+    assert_equal "LEFT",   Mixin.left_label
+
+    assert_equal %w( TOP RIGHT BOTTOM LEFT ), Mixin.position_labels
+  end
+
+  def test_names_with_labels
+    expected = [
+                [:top,    "TOP"],
+                [:right,  "RIGHT"],
+                [:bottom, "BOTTOM"],
+                [:left,   "LEFT"],
+               ]
+    assert_equal expected, Mixin.position_names_with_labels
+  end
+
+  def test_nil_means_blank_column
+    assert_equal %w( flag1 flag3 ), Mixin.blank_flag_names
+
+    assert_equal false, mixins(:bits_00).flag1
+    assert_equal false, mixins(:bits_00).flag3
+    assert_equal true , mixins(:bits_10).flag1
+    assert_equal false, mixins(:bits_10).flag3
+
+    assert_equal "0000",  Mixin.new.positions
+
+    assert_equal "00",  Mixin.new.blank_flags
+    assert_equal false, Mixin.new.flag1
+    assert_equal false, Mixin.new.flag3
+  end
+
+  def test_referer_to_out_of_index
+    Mixin.delete_all
+    mixin = Mixin.create!(:positions=>"11")
+    assert_equal true,  mixin.top?
+    assert_equal true,  mixin.right?
+    assert_equal false, mixin.bottom?
+    assert_equal false, mixin.left?
+  end
+
+  def test_subscribe_to_out_of_index
+    Mixin.delete_all
+    mixin = Mixin.create!(:positions=>"11")
+
+    assert_nothing_raised do
+      mixin.left = true
+    end
+
+    assert_equal true, mixin.left?
+  end
+
+  def test_functional_accessor
+    mixin = Mixin.create!(:positions=>"1010")
+    assert_equal true,  mixin.position?(:top)
+    assert_equal false, mixin.position?(:right)
+    assert_equal true,  mixin.position?(:bottom)
+    assert_equal false, mixin.position?(:left)
+  end
+
+  def test_functional_accessor_without_args
+    mixin = Mixin.create!(:positions=>"0001")
+    assert_equal true,  mixin.position?
+
+    mixin = Mixin.create!(:positions=>"0000")
+    assert_equal false, mixin.position?
+
+    mixin = Mixin.create!(:positions=>"1111")
+    assert_equal true,  mixin.position?
+  end
+
+  def test_sanitize_sql_hash
+    expected = ["COALESCE(SUBSTRING(mixins.positions,1,1),'') = '1'", "COALESCE(SUBSTRING(mixins.positions,4,1),'') <> '1'"]
+    executed = Mixin.__send__(:sanitize_sql_hash, {:top => true, :left => false})
+    executed = executed.delete('`"').split(/ AND /).sort
+
+    assert_equal expected, executed
+  end
+
+  def test_search
+    conditions = {:top=>true}
+    assert_equal 1, Mixin.count(:conditions=>conditions)
+    assert_equal 1, Mixin.find(:all, :conditions=>conditions).size
+
+    conditions = {:top=>false, :right=>false, :bottom=>false, :left=>false}
+    assert_equal 2, Mixin.count(:conditions=>conditions)
+    assert_equal 2, Mixin.find(:all, :conditions=>conditions).size
+
+    conditions = {:top=>true, :right=>true, :bottom=>true, :left=>true}
+    assert_equal 1, Mixin.count(:conditions=>conditions)
+    assert_equal 1, Mixin.find(:all, :conditions=>conditions).size
+  end
+
+  def test_set_all
+    obj = Mixin.new
+    assert_equal "00", obj.flags
+
+    obj.flags = true
+    assert_equal "11", obj.flags
+
+    obj.flags = false
+    assert_equal "00", obj.flags
+  end
+end

data/test/database.yml

@@ -0,0 +1,22 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: acts_as_bits_plugin_test.sqlite.db
+
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: acts_as_bits_plugin_test.sqlite3.db
+
+postgresql:
+  :adapter: postgresql
+  :username: maiha
+  :password: 
+  :database: test
+  :min_messages: ERROR
+
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: acts_as_bits_plugin_test
+

data/test/dirty_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ActsAsBits do
+  describe " should mark dirty" do
+    before(:each) do
+      @obj = Mixin.create!(:flags=>"00")
+    end
+
+    it "when value is changed by setter" do
+      @obj.flags                 # create string object first
+      @obj.changed?.should == false
+      @obj.admin = true
+      @obj.changed?.should == true
+      @obj.changes.should == {"flags"=>["00", "10"]}
+    end
+
+    it "when massive assignment" do
+      @obj.flags                 # create string object first
+      @obj.changed?.should == false
+      @obj.attributes = {:admin => true}
+      @obj.changed?.should == true
+      @obj.changes.should == {"flags"=>["00", "10"]}
+    end
+  end
+end

data/test/fixtures/mixin.rb

@@ -0,0 +1,10 @@
+class Mixin < ActiveRecord::Base
+  acts_as_bits :flags, %w( admin composer )
+  acts_as_bits :positions, [
+                            [:top,    "TOP"],
+                            [:right,  "RIGHT"],
+                            [:bottom, "BOTTOM"],
+                            [:left,   "LEFT"],
+                           ]
+  acts_as_bits :blank_flags, [:flag1, nil, :flag3]
+end

data/test/fixtures/mixins.yml

@@ -0,0 +1,20 @@
+bits_00:
+  id: 1
+  flags: "00"
+  positions: "0000"
+  blank_flags: "0 0"
+bits_01:
+  id: 2
+  flags: "01"
+  positions: "1111"
+  blank_flags: "0 1"
+bits_10:
+  id: 3
+  flags: "10"
+  positions: "0101"
+  blank_flags: "1 0"
+bits_11:
+  id: 4
+  flags: "11"
+  positions: ""
+  blank_flags: "1 1"

data/test/prefix_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PrefixTest < Test::Unit::TestCase
+  class User < ActiveRecord::Base
+    set_table_name :mixins
+    acts_as_bits :flags, %w( login show ), :prefix=>true
+  end
+
+  def test_not_respond_to_native_name
+    user = User.new
+
+    assert ! user.respond_to?(:login)
+    assert ! user.respond_to?(:show)
+  end
+
+  def test_respond_to_prefixed_name
+    user = User.new
+
+    assert_respond_to user, :flag_login?
+    assert_respond_to user, :flag_login=
+    assert_respond_to user, :flag_login
+    assert_respond_to user, :flag_show?
+    assert_respond_to user, :flag_show=
+    assert_respond_to user, :flag_show
+  end
+
+  def test_respond_to_prefix_method
+    user = User.new
+    assert_respond_to user, :flag?
+  end
+
+  def test_setter
+    user = User.new
+    assert_equal false, user.flag_login?
+    user.flag_login = true
+    assert_equal true , user.flag_login?
+  end
+
+  def test_prefix_method
+    user = User.new
+    assert_equal false, user.flag?(:login)
+    assert_equal false, user.flag?(:show)
+    assert_equal false, user.flag?("login")
+    assert_equal false, user.flag?("show")
+
+    user.flag_login = true
+    assert_equal true,  user.flag?(:login)
+    assert_equal false, user.flag?(:show)
+    assert_equal true,  user.flag?("login")
+    assert_equal false, user.flag?("show")
+  end
+end

data/test/schema.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :mixins, :force => true do |t|
+    t.column :flags,       :string
+    t.column :positions,   :string
+    t.column :blank_flags, :string
+  end
+
+end

data/test/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'spec'
+require 'active_record'
+
+__DIR__ = File.dirname(__FILE__)
+config = YAML::load_file(__DIR__ + '/database.yml')
+ActiveRecord::Base.configurations = config
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'postgresql')
+load(__DIR__ + "/schema.rb")
+
+$:.unshift __DIR__ + "/../lib"
+require 'acts_as_bits'
+
+require File.join(__DIR__, "fixtures/mixin")

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+def __DIR__; File.dirname(__FILE__); end
+
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_record'
+require 'active_record/fixtures'
+
+config = YAML::load_file(__DIR__ + '/database.yml')
+ActiveRecord::Base.logger = Logger.new(__DIR__ + "/debug.log")
+ActiveRecord::Base.colorize_logging = false
+ActiveRecord::Base.configurations = config
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'postgresql')
+
+$:.unshift __DIR__ + '/../lib'
+require __DIR__ + '/../init'
+
+# create tables
+load(__DIR__ + "/schema.rb")
+
+# insert sample data to the tables from 'fixtures/*.yml'
+Test::Unit::TestCase.fixture_path = __DIR__ + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+Test::Unit::TestCase.use_instantiated_fixtures  = true
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_bits
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- maiha
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-19 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: ActiveRecord plugin that maintains massive flags in one column
+email: maiha@wota.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/acts_as_bits.rb
+- tasks/acts_as_bits_tasks.rake
+- test/database.yml
+- test/fixtures/mixin.rb
+- test/fixtures/mixins.yml
+- test/schema.rb
+- test/prefix_test.rb
+- test/acts_as_bits_test.rb
+- test/spec_helper.rb
+- test/test_helper.rb
+- test/dirty_spec.rb
+has_rdoc: true
+homepage: http://github.com/maiha/acts_as_bits
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ActiveRecord plugin that maintains massive flags in one column
+test_files: []
+