maiha-acts_as_bits 0.1 → 0.2

data/README

@@ -41,6 +41,30 @@ Finding methods work only on PostgreSQL, MySQL and SQL Server because we use "su
   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"
+
+
+Changes
+=======
+
+0.2: support dirty columns for Rails2
+
+
 Author
 ======
 

data/Rakefile

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

data/acts_as_bits.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "acts_as_bits"
+  s.version = "0.2"
+  s.date = "2009-01-21"
+  s.summary = ""
+  s.email = "maiha@wota.jp"
+  s.homepage = "http://github.com/maiha/acts_as_bits"
+  s.description = ""
+  s.has_rdoc = true
+  s.authors = ["maiha"]
+  s.files = ["README", "Rakefile", "acts_as_bits.gemspec", "init.rb", "install.rb", "lib/acts_as_bits.rb", "tasks/acts_as_bits_tasks.rake", "test/acts_as_bits_test.rb", "test/database.yml", "test/dirty_spec.rb", "test/fixtures/mixin.rb", "test/fixtures/mixins.yml", "test/prefix_test.rb", "test/schema.rb", "test/spec_helper.rb", "test/test_helper.rb"]
+end

data/init.rb

@@ -0,0 +1 @@
+require 'acts_as_bits'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/acts_as_bits.rb

@@ -0,0 +1,191 @@
+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
+          "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+        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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: maiha-acts_as_bits
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - maiha
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-04 00:00:00 -07:00
+date: 2009-01-21 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,21 @@ extra_rdoc_files: []
 
 files: 
 - README
+- Rakefile
+- acts_as_bits.gemspec
+- init.rb
+- install.rb
+- lib/acts_as_bits.rb
+- tasks/acts_as_bits_tasks.rake
+- test/acts_as_bits_test.rb
+- test/database.yml
+- test/dirty_spec.rb
+- test/fixtures/mixin.rb
+- test/fixtures/mixins.yml
+- test/prefix_test.rb
+- test/schema.rb
+- test/spec_helper.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/maiha/acts_as_bits
 post_install_message: 
@@ -45,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: ""