akm-selectable_attr 0.3.0

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 3
+:patch: 0
+:major: 0

data/lib/selectable_attr/base.rb

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+module SelectableAttr
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    ENUM_ARRAY_METHODS = {
+      :none => { 
+        :to_hash_array => Proc.new do |enum, attr_value|
+          value = (attr_value || []).map(&:to_s)
+          enum.to_hash_array do |hash|
+            hash[:select] = value.include?(hash[:id].to_s)
+          end
+        end,
+        
+        :to_attr_value => Proc.new do |enum, hash_array|
+          hash_array.select{|hash| hash[:select]}.map{|hash| hash[:id]}
+        end
+      },
+      
+      :comma_string => {
+        :to_hash_array => Proc.new do |enum, attr_value|
+          values = attr_value.is_a?(Array) ? attr_value.map{|v|v.to_s} :
+            (attr_value || '').split(',')
+          enum.to_hash_array do |hash|
+            hash[:select] = values.include?(hash[:id].to_s)
+          end
+        end,
+        
+        :to_attr_value => Proc.new do |enum, hash_array|
+          hash_array.select{|hash| hash[:select]}.map{|hash| hash[:id]}.join(',')
+        end
+      },
+      
+      
+      :binary_string => {
+        :to_hash_array => Proc.new do |enum, attr_value|
+          value = attr_value || ''
+          idx = 0
+          enum.to_hash_array do |hash|
+            hash[:select] = (value[idx, 1] == '1')
+            idx += 1
+          end
+        end,
+        
+        :to_attr_value => Proc.new do |enum, hash_array|
+          result = ''
+          hash_map = hash_array.inject({}){|dest, hash| dest[hash[:id]] = hash; dest}
+          enum.each do |entry|
+            hash = hash_map[entry.id]
+            result << (hash[:select] ? '1' : '0')
+          end
+          result
+        end
+      }
+    }
+    
+    module ClassMethods
+      def single_selectable_attrs 
+        @single_selectable_attrs_hash ||= {};
+        @single_selectable_attrs_hash[self] ||= []
+      end
+      
+      def multi_selectable_attrs 
+        @multi_selectable_attrs_hash ||= {};
+        @multi_selectable_attrs_hash[self] ||= []
+      end
+      
+      def selectable_attr_type_for(attr)
+        single_selectable_attrs.include?(attr) ? :single :
+        multi_selectable_attrs.include?(attr) ? :multi : nil
+      end
+      
+      def enum(*args, &block)
+        process_definition(block, *args) do |enum, context|
+          self.single_selectable_attrs << context[:attr].to_s
+          define_enum_class_methods(context)
+          define_enum_instance_methods(context)
+        end
+      end
+      alias_method :single_selectable_attr, :enum
+      alias_method :selectable_attr, :enum
+      
+      
+      def enum_array(*args, &block)
+        base_options = args.last.is_a?(Hash) ? args.pop : {}
+        args << base_options # .update({:attr_accessor => false})
+        process_definition(block, *args) do |enum, context|
+          self.multi_selectable_attrs << context[:attr].to_s
+          define_enum_class_methods(context)
+          define_enum_array_instance_methods(context)
+        end
+      end
+      alias_method :multi_selectable_attr, :enum_array
+      
+      def process_definition(block, *args)
+        base_options = args.last.is_a?(Hash) ? args.pop : {}
+        enum = base_options[:enum] || create_enum(&block)
+        args.each do |attr|
+          context = {
+            :enum => enum,
+            :attr_accessor => !has_attr(attr),
+            :attr => attr,
+            :base_name => enum_base_name(attr)
+          }.update(base_options)
+          define_enum(context)
+          define_accessor(context)
+          yield(enum, context)
+          unless enum.i18n_scope
+            paths = [:selectable_attrs] + self.name.to_s.split('::').map{|s| s.to_sym}
+            paths << attr.to_sym
+            enum.i18n_scope(*paths)
+          end
+        end
+        enum
+      end
+      
+      def has_attr(attr)
+        return true if self.method_defined?(attr)
+        return false unless self.respond_to?(:columns)
+        if self.respond_to?(:connection) and self.respond_to?(:connected?)
+          begin
+            self.connection unless self.connected?
+          rescue Exception
+            return nil if !self.connected?
+          end
+        end
+        (self.columns || []).any?{|col|col.name.to_s == attr.to_s}
+      end
+      
+      def attr_enumeable_base(*args, &block)
+        @base_name_processor = block
+      end
+      
+      def enum_base_name(attr)
+        if @base_name_processor
+          @base_name_processor.call(attr).to_s
+        else
+          attr.to_s.gsub(selectable_attr_name_pattern, '')
+        end
+      end
+      
+      DEFAULT_SELECTABLE_ATTR_NAME_PATTERN = /(_cd$|_code$|_cds$|_codes$)/
+      
+      def selectable_attr_name_pattern
+        @selectable_attr_name_pattern ||= DEFAULT_SELECTABLE_ATTR_NAME_PATTERN
+      end
+      alias_method :enum_name_pattern, :selectable_attr_name_pattern
+      
+      def selectable_attr_name_pattern=(value)
+        @selectable_attr_name_pattern = value
+      end
+      alias_method :enum_name_pattern=, :selectable_attr_name_pattern=
+      
+      def create_enum(&block)
+        result = Enum.new
+        result.instance_eval(&block)
+        result
+      end
+      
+      def define_enum(context)
+        base_name = context[:base_name]
+        const_name = "#{base_name.upcase}_ENUM"
+        const_set(const_name, context[:enum]) unless const_defined?(const_name)
+      end
+      
+      def enum_for(attr)
+        base_name = enum_base_name(attr)
+        const_get("#{base_name.upcase}_ENUM")
+      end
+      
+      def define_accessor(context)
+        attr = context[:attr]
+        return unless (instance_methods & [attr, "#{attr}="]).empty? 
+        if context[:attr_accessor]
+          if context[:default]
+            if respond_to?(:attr_accessor_with_default)
+              attr_accessor_with_default(attr, context[:default])
+            else
+              instance_var_name = "@#{attr}"
+              attr_writer(attr)
+              define_method(attr) do
+                value = instance_variable_get(instance_var_name)
+                instance_variable_set(instance_var_name, value = context[:default]) unless value
+                value
+              end
+            end
+          else
+            attr_accessor(attr)
+          end
+        else
+          if context[:default]
+            $stderr.puts "WARNING! :default option ignored for #{attr}"
+          end
+        end
+      end
+      
+      def define_enum_class_methods(context)
+        base_name = context[:base_name]
+        enum = context[:enum]
+        mod = Module.new
+        mod.module_eval do
+          define_method("#{base_name}_enum"){enum}
+          define_method("#{base_name}_hash_array"){enum.to_hash_array}
+          define_method("#{base_name}_entries"){enum.entries}
+          define_method("#{base_name}_options"){|*ids_or_keys|enum.options(*ids_or_keys)}
+          define_method("#{base_name}_ids"){|*ids_or_keys| enum.ids(*ids_or_keys)}
+          define_method("#{base_name}_keys"){|*ids_or_keys|enum.keys(*ids_or_keys)}
+          define_method("#{base_name}_names"){|*ids_or_keys|enum.names(*ids_or_keys)}
+          define_method("#{base_name}_key_by_id"){|id|enum.key_by_id(id)}
+          define_method("#{base_name}_id_by_key"){|key|enum.id_by_key(key)}
+          define_method("#{base_name}_name_by_id"){|id|enum.name_by_id(id)}
+          define_method("#{base_name}_name_by_key"){|key|enum.name_by_key(key)}
+          define_method("#{base_name}_entry_by_id"){|id|enum.entry_by_id(id)}
+          define_method("#{base_name}_entry_by_key"){|key|enum.entry_by_key(key)}
+        end
+        if convertors = ENUM_ARRAY_METHODS[context[:convert_with] || :none]
+          mod.module_eval do
+            define_method("#{base_name}_to_hash_array", convertors[:to_hash_array])
+            define_method("hash_array_to_#{base_name}", convertors[:to_attr_value])
+          end
+        end
+        self.extend(mod)
+      end
+      
+      def define_enum_instance_methods(context)
+        attr = context[:attr]
+        base_name = context[:base_name]
+        instance_methods = <<-EOS
+          def #{base_name}_key
+            self.class.#{base_name}_key_by_id(#{attr})
+          end
+          def #{base_name}_key=(key)
+            self.#{attr} = self.class.#{base_name}_id_by_key(key)
+          end
+          def #{base_name}_name
+            self.class.#{base_name}_name_by_id(#{attr})
+          end
+          def #{base_name}_entry
+            self.class.#{base_name}_entry_by_id(#{attr})
+          end
+          def #{base_name}_entry
+            self.class.#{base_name}_entry_by_id(#{attr})
+          end
+        EOS
+        self.module_eval(instance_methods)
+      end
+        
+      def define_enum_array_instance_methods(context)
+        attr = context[:attr]
+        base_name = context[:base_name]
+        # ActiveRecord::Baseから継承している場合は、基本カラムに対応するメソッドはない
+        self.module_eval(<<-"EOS")
+          def #{base_name}_ids
+            #{base_name}_hash_array_selected.map{|hash|hash[:id]}
+          end
+          def #{base_name}_ids=(ids)
+            ids = ids.split(',') if ids.is_a?(String)
+            ids = ids ? ids.map(&:to_s) : []
+            update_#{base_name}_hash_array{|hash|ids.include?(hash[:id].to_s)}
+          end
+        EOS
+        self.module_eval(<<-"EOS")
+          def #{base_name}_hash_array
+            self.class.#{base_name}_to_hash_array(self.class.#{base_name}_enum, #{attr})
+          end
+          def #{base_name}_hash_array=(hash_array)
+            self.#{attr} = self.class.hash_array_to_#{base_name}(self.class.#{base_name}_enum, hash_array)
+          end
+          def #{base_name}_hash_array_selected
+            #{base_name}_hash_array.select{|hash|!!hash[:select]}
+          end
+          def update_#{base_name}_hash_array(&block)
+            hash_array = #{base_name}_hash_array.map do |hash|
+              hash.merge(:select => yield(hash))
+            end
+            self.#{base_name}_hash_array = hash_array
+          end
+          def #{base_name}_keys
+            #{base_name}_hash_array_selected.map{|hash|hash[:key]}
+          end
+          def #{base_name}_keys=(keys)
+            update_#{base_name}_hash_array{|hash|keys.include?(hash[:key])}
+          end
+          def #{base_name}_selection
+            #{base_name}_hash_array.map{|hash|!!hash[:select]}
+          end
+          def #{base_name}_selection=(selection)
+            idx = -1
+            update_#{base_name}_hash_array{|hash| idx += 1; !!selection[idx]}
+          end
+          def #{base_name}_names
+            #{base_name}_hash_array_selected.map{|hash|hash[:name]}
+          end
+          def #{base_name}_entries
+            ids = #{base_name}_ids
+            self.class.#{base_name}_enum.select{|entry|ids.include?(entry.id)}
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/selectable_attr/enum.rb

@@ -0,0 +1,190 @@
+module SelectableAttr
+
+  class Enum
+    include Enumerable
+
+    class << self
+      def instances
+        @@instances ||= []
+      end
+      
+      if defined?(I18n)
+        def i18n_export
+          result = {}
+          instances.each do |instance|
+            unless instance.i18n_scope
+              # puts "no i18n_scope of #{instance.inspect}"
+              next 
+            end
+            paths = instance.i18n_scope.dup
+            current = result
+            paths.each do |path|
+              current = current[path] ||= {}
+            end
+            instance.entries.each do |entry|
+              current[entry.key] = entry.name
+            end
+          end
+          result
+        end
+      end
+    end
+    
+    def initialize(&block)
+      @entries = []
+      instance_eval(&block) if block_given?
+      SelectableAttr::Enum.instances << self if defined?(I18n)
+    end
+    
+    def entries
+      @entries
+    end
+    
+    def each(&block)
+      entries.each(&block)
+    end
+    
+    def define(id, key, name, options = nil, &block)
+      entry = Entry.new(self, id, key, name, options, &block)
+      entry.instance_variable_set(:@defined_in_code, true)
+      @entries << entry
+    end
+    alias_method :entry, :define
+    
+    def i18n_scope(*path)
+      @i18n_scope = path unless path.empty?
+      @i18n_scope
+    end
+    
+    def match_entry(entry, value, *attrs)
+      attrs.any?{|attr| entry[attr].to_s == value.to_s}
+    end
+
+    def entry_by(value, *attrs)
+      entries.detect{|entry| match_entry(entry, value, *attrs)} || Entry::NULL
+    end
+    
+    def entry_by_id(id)
+      entry_by(id, :id)
+    end
+    
+    def entry_by_key(key)
+      entry_by(key, :key)
+    end
+    
+    def entry_by_id_or_key(id_or_key)
+      entry_by(id_or_key, :id, :key)
+    end
+    
+    def entry_by_hash(attrs)
+      entries.detect{|entry| attrs.all?{|(attr, value)| entry[attr].to_s == value.to_s }} || Entry::NULL
+    end
+    
+    def [](arg)
+      arg.is_a?(Hash) ? entry_by_hash(arg) : entry_by_id_or_key(arg)
+    end
+    
+    def values(*args)
+      args = args.empty? ? [:name, :id] : args
+      result = entries.collect{|entry| args.collect{|arg| entry.send(arg) }}
+      (args.length == 1) ? result.flatten : result
+    end
+    
+    def map_attrs(attrs, *ids_or_keys)
+      if attrs.is_a?(Array)
+        ids_or_keys.empty? ? 
+          entries.map{|entry| attrs.map{|attr|entry.send(attr)}} : 
+          ids_or_keys.map do |id_or_key|
+            entry = entry_by_id_or_key(id_or_key)
+            attrs.map{|attr|entry.send(attr)}
+          end
+      else
+        attr = attrs
+        ids_or_keys.empty? ? 
+          entries.map(&attr.to_sym) : 
+          ids_or_keys.map{|id_or_key|entry_by_id_or_key(id_or_key).send(attr)}
+      end
+    end
+    
+    def ids(*ids_or_keys); map_attrs(:id, *ids_or_keys); end
+    def keys(*ids_or_keys); map_attrs(:key, *ids_or_keys); end
+    def names(*ids_or_keys); map_attrs(:name, *ids_or_keys); end
+    def options(*ids_or_keys); map_attrs([:name, :id], *ids_or_keys); end
+
+    def key_by_id(id); entry_by_id(id).key; end
+    def id_by_key(key); entry_by_key(key).id; end
+    def name_by_id(id); entry_by_id(id).name; end
+    def name_by_key(key); entry_by_key(key).name; end
+    
+    def find(options = nil, &block)
+      entries.detect{|entry| 
+          block_given? ? yield(entry) : entry.match?(options) 
+        } || Entry::NULL
+    end
+    
+    def to_hash_array
+      entries.map do |entry|
+        result = entry.to_hash
+        yield(result) if defined? yield
+        result
+      end
+    end
+    
+    def length
+      entries.length
+    end
+    alias_method :size, :length
+
+    class Entry
+      BASE_ATTRS = [:id, :key, :name]
+      attr_reader :id, :key
+      attr_reader :defined_in_code
+      def initialize(enum, id, key, name, options = nil, &block)
+        @enum = enum
+        @id = id
+        @key = key
+        @name = name
+        @options = options
+        self.instance_eval(&block) if block
+      end
+      
+      if defined?(I18n)
+        def name
+          I18n.locale.nil? ? @name :
+            @enum.i18n_scope.blank? ? @name :
+            I18n.translate(key, :scope => @enum.i18n_scope, :default => @name)
+        end
+      else
+        attr_reader :name
+      end
+      
+      def [](option_key)
+        BASE_ATTRS.include?(option_key) ? send(option_key) :
+        @options ? @options[option_key] : nil
+      end
+      
+      def match?(options)
+        @options === options
+      end
+      
+      def null?
+        false
+      end
+      
+      def null_object?
+        self.null?
+      end
+      
+      def to_hash
+        (@options || {}).merge(:id => @id, :key => @key, :name => @name)
+      end
+      
+      NULL = new(nil, nil, nil, nil) do
+        def null?; true; end
+        def name; nil; end
+      end
+    end
+    
+  end
+
+end

data/lib/selectable_attr/version.rb

@@ -0,0 +1,3 @@
+module SelectableAttr
+  VERSION = '0.0.3'
+end

data/lib/selectable_attr.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+module SelectableAttr
+  autoload :VERSION, 'selectable_attr/version'
+  autoload :Enum, 'selectable_attr/enum'
+  autoload :Base, 'selectable_attr/base'
+end

data/spec/selectable_attr_base_alias_spec.rb

@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe SelectableAttr do
+  
+  def assert_enum_class_methods(klass, attr = :enum1)
+    klass.send("#{attr}_enum").length.should == 3
+    expected_hash_array = [
+        {:id => 1, :key => :entry1, :name => "エントリ1"},
+        {:id => 2, :key => :entry2, :name => "エントリ2"},
+        {:id => 3, :key => :entry3, :name => "エントリ3"}
+      ]
+    klass.send("#{attr}_hash_array").should == expected_hash_array
+    klass.send("#{attr}_enum").to_hash_array.should == expected_hash_array
+    klass.send("#{attr}_entries").
+      map{|entry| {:id => entry.id, :key => entry.key, :name => entry.name} }.
+      should == expected_hash_array
+
+    klass.send("#{attr}_ids").should == [1,2,3]
+    klass.send("#{attr}_ids", :entry2, :entry3).should == [2,3]
+    klass.send("#{attr}_keys").should == [:entry1, :entry2, :entry3]
+    klass.send("#{attr}_keys", 1,3).should == [:entry1, :entry3]
+    klass.send("#{attr}_names").should == ["エントリ1", "エントリ2", "エントリ3"]
+    klass.send("#{attr}_names", 1,2).should == ["エントリ1", "エントリ2"]
+    klass.send("#{attr}_names", :entry1, :entry2).should == ["エントリ1", "エントリ2"]
+    klass.send("#{attr}_options").should == [['エントリ1', 1], ['エントリ2', 2], ['エントリ3', 3]]
+    klass.send("#{attr}_options", :entry2, :entry3).should == [['エントリ2', 2], ['エントリ3', 3]]
+    klass.send("#{attr}_options", 1,2).should == [['エントリ1', 1], ['エントリ2', 2]]
+
+    klass.send("#{attr}_id_by_key", nil).should be_nil
+    klass.send("#{attr}_id_by_key", :entry1).should == 1
+    klass.send("#{attr}_id_by_key", :entry2).should == 2
+    klass.send("#{attr}_id_by_key", :entry3).should == 3
+    klass.send("#{attr}_name_by_key", nil).should be_nil
+    klass.send("#{attr}_name_by_key", :entry1).should == "エントリ1"
+    klass.send("#{attr}_name_by_key", :entry2).should == "エントリ2"
+    klass.send("#{attr}_name_by_key", :entry3).should == "エントリ3"
+
+    klass.send("#{attr}_key_by_id", nil).should be_nil
+    klass.send("#{attr}_key_by_id", 1).should == :entry1
+    klass.send("#{attr}_key_by_id", 2).should == :entry2
+    klass.send("#{attr}_key_by_id", 3).should == :entry3
+    klass.send("#{attr}_name_by_id", nil).should be_nil
+    klass.send("#{attr}_name_by_id", 1).should == "エントリ1"
+    klass.send("#{attr}_name_by_id", 2).should == "エントリ2"
+    klass.send("#{attr}_name_by_id", 3).should == "エントリ3"
+  end
+  
+  def assert_single_enum_instance_methods(obj, attr = :enum1)
+    obj.send("#{attr}=", 1)
+    obj.send(attr).should == 1
+    obj.enum1_key.should == :entry1 
+    obj.enum1_name.should == "エントリ1"
+    obj.enum1_entry.to_hash.should == {:id => 1, :key => :entry1, :name => "エントリ1"}
+    
+    obj.enum1_key = :entry2
+    obj.send(attr).should == 2
+    obj.enum1_key.should == :entry2
+    obj.enum1_name.should == "エントリ2"
+    obj.enum1_entry.to_hash.should == {:id => 2, :key => :entry2, :name => "エントリ2"}
+    
+    obj.send("#{attr}=", 3)
+    obj.send(attr).should == 3
+    obj.enum1_key.should == :entry3
+    obj.enum1_name.should == "エントリ3"
+    obj.enum1_entry.to_hash.should == {:id => 3, :key => :entry3, :name => "エントリ3"}
+  end
+  
+  class EnumBase
+    include ::SelectableAttr::Base
+  end
+
+  class EnumMock1 < EnumBase
+    selectable_attr :enum1, :default => 2 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  class EnumMock1WithEnum < EnumBase
+    selectable_attr :enum1, :default => 2 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  it "test_selectable_attr1" do
+    assert_enum_class_methods(EnumMock1)
+    mock1 = EnumMock1.new
+    mock1.enum1.should == 2
+    assert_single_enum_instance_methods(mock1)
+    
+    assert_enum_class_methods(EnumMock1WithEnum)
+    mock1 = EnumMock1WithEnum.new
+    mock1.enum1.should == 2
+    assert_single_enum_instance_methods(mock1)
+  end
+  
+
+  class EnumMock2 < EnumBase
+    attr_enumeable_base do |attr|
+      attr.to_s.gsub(/(.*)_code(.*)$/){"#{$1}#{$2}"}
+    end
+
+    selectable_attr :enum_code1 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+
+  class EnumMock2WithEnum < EnumBase
+    attr_enumeable_base do |attr|
+      attr.to_s.gsub(/(.*)_code(.*)$/){"#{$1}#{$2}"}
+    end
+
+    enum :enum_code1 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+
+  it "test_selectable_attr2" do
+    assert_enum_class_methods(EnumMock2)
+    assert_single_enum_instance_methods(EnumMock2.new, :enum_code1)
+    assert_enum_class_methods(EnumMock2WithEnum)
+    assert_single_enum_instance_methods(EnumMock2WithEnum.new, :enum_code1)
+  end
+  
+
+  
+  def assert_multi_enum_instance_methods(obj, patterns)
+    obj.enum_array1_hash_array.should == [
+        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
+        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
+        {:id => 3, :key => :entry3, :name => "エントリ3", :select => false}
+      ]
+    obj.enum_array1_selection.should == [false, false, false]
+    obj.enum_array1.should be_nil
+    obj.enum_array1_entries.should == []
+    obj.enum_array1_keys.should == []
+    obj.enum_array1_names.should == []
+    
+    obj.enum_array1 = patterns[0]
+    obj.enum_array1.should == patterns[0]
+    obj.enum_array1_hash_array.should == [
+        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
+        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
+        {:id => 3, :key => :entry3, :name => "エントリ3", :select => false}
+      ]
+    obj.enum_array1_selection.should == [false, false, false]
+    obj.enum_array1_entries.should == []
+    obj.enum_array1_keys.should == []
+    obj.enum_array1_names.should == []
+
+    obj.enum_array1 = patterns[1]
+    obj.enum_array1.should == patterns[1]
+    obj.enum_array1_hash_array.should == [
+        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
+        {:id => 2, :key => :entry2, :name => "エントリ2", :select => false},
+        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
+      ]
+    obj.enum_array1_selection.should == [false, false, true]
+    obj.enum_array1_entries.map(&:id).should == [3]
+    obj.enum_array1_keys.should == [:entry3]
+    obj.enum_array1_names.should == ['エントリ3']
+    
+    obj.enum_array1 = patterns[3]
+    obj.enum_array1.should == patterns[3]
+    obj.enum_array1_hash_array.should == [
+        {:id => 1, :key => :entry1, :name => "エントリ1", :select => false},
+        {:id => 2, :key => :entry2, :name => "エントリ2", :select => true},
+        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
+      ]
+    obj.enum_array1_selection.should == [false, true, true]
+    obj.enum_array1_entries.map(&:id).should == [2, 3]
+    obj.enum_array1_keys.should == [:entry2, :entry3]
+    obj.enum_array1_names.should == ['エントリ2', 'エントリ3']
+
+    obj.enum_array1 = patterns[7]
+    obj.enum_array1.should == patterns[7]
+    obj.enum_array1_hash_array.should == [
+        {:id => 1, :key => :entry1, :name => "エントリ1", :select => true},
+        {:id => 2, :key => :entry2, :name => "エントリ2", :select => true},
+        {:id => 3, :key => :entry3, :name => "エントリ3", :select => true}
+      ]
+    obj.enum_array1_selection.should == [true, true, true]
+    obj.enum_array1_ids.should == [1, 2, 3]
+    obj.enum_array1_entries.map(&:id).should == [1, 2, 3]
+    obj.enum_array1_keys.should == [:entry1, :entry2, :entry3]
+    obj.enum_array1_names.should == ['エントリ1', 'エントリ2', 'エントリ3']
+    
+    obj.enum_array1_ids = [1,3]; obj.enum_array1.should == patterns[5]
+    obj.enum_array1_ids = [1,2]; obj.enum_array1.should == patterns[6]
+    obj.enum_array1_ids = [2]; obj.enum_array1.should == patterns[2]
+
+    obj.enum_array1_keys = [:entry1,:entry3]; obj.enum_array1.should == patterns[5]
+    obj.enum_array1_keys = [:entry1,:entry2]; obj.enum_array1.should == patterns[6]
+    obj.enum_array1_keys = [:entry2]; obj.enum_array1.should == patterns[2]
+
+    obj.enum_array1_selection = [true, false, true]; obj.enum_array1.should == patterns[5]
+    obj.enum_array1_selection = [true, true, false]; obj.enum_array1.should == patterns[6]
+    obj.enum_array1_selection = [false, true, false]; obj.enum_array1.should == patterns[2]
+
+    obj.enum_array1_ids = "1,3"; obj.enum_array1.should == patterns[5]
+    obj.enum_array1_ids = "1,2"; obj.enum_array1.should == patterns[6]
+    obj.enum_array1_ids = "2"; obj.enum_array1.should == patterns[2]
+  end
+  
+  class EnumMock3 < EnumBase
+    multi_selectable_attr :enum_array1, :convert_with => :binary_string do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  class EnumMock3WithEnumArray < EnumBase
+    enum_array :enum_array1, :convert_with => :binary_string do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  it "test_multi_selectable_attr_with_binary_string" do
+    expected = (0..7).map{|i| '%-03b' % i} # ["000", "001", "010", "011", "100", "101", "110", "111"]
+    assert_enum_class_methods(EnumMock3, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock3.new, expected)
+    assert_enum_class_methods(EnumMock3WithEnumArray, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock3WithEnumArray.new, expected)
+  end
+
+  class EnumMock4 < EnumBase
+    multi_selectable_attr :enum_array1 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  class EnumMock4WithEnumArray < EnumBase
+    enum_array :enum_array1 do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  it "test_multi_selectable_attr2" do
+    # [[], [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3]]
+    expected = 
+      (0..7).map do |i|
+        s = '%03b' % i
+        a = s.split('').map{|v| v.to_i}
+        ret = []
+        a.each_with_index{|val, pos| ret << pos + 1 if val == 1}
+        ret
+      end
+    assert_enum_class_methods(EnumMock4, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock4.new, expected)
+    assert_enum_class_methods(EnumMock4WithEnumArray, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock4WithEnumArray.new, expected)
+  end
+
+  class EnumMock5 < EnumBase
+    multi_selectable_attr :enum_array1, :convert_with => :comma_string do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  class EnumMock5WithEnumArray < EnumBase
+    enum_array :enum_array1, :convert_with => :comma_string do
+      entry 1, :entry1, "エントリ1"
+      entry 2, :entry2, "エントリ2"
+      entry 3, :entry3, "エントリ3"
+    end
+  end
+  
+  it "test_multi_selectable_attr_with_comma_string" do
+    # ["", "3", "2", "2,3", "1", "1,3", "1,2", "1,2,3"]
+    expected = 
+      (0..7).map do |i|
+        s = '%03b' % i
+        a = s.split('').map{|v| v.to_i}
+        ret = []
+        a.each_with_index{|val, pos| ret << pos + 1 if val == 1}
+        ret.join(',')
+      end
+    assert_enum_class_methods(EnumMock5, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock5.new, expected)
+    assert_enum_class_methods(EnumMock5WithEnumArray, :enum_array1)
+    assert_multi_enum_instance_methods(EnumMock5WithEnumArray.new, expected)
+  end
+    
+  class EnumMock6 < EnumBase
+    # self.selectable_attr_name_pattern = /(_cd$|_code$|_cds$|_codes$)/
+    selectable_attr :category_id do 
+      entry "01", :category1, "カテゴリ1"
+      entry "02", :category2, "カテゴリ2"
+    end
+  end
+  
+  class EnumMock7 < EnumBase
+    self.selectable_attr_name_pattern = /(_cd$|_id$|_cds$|_ids$)/
+    selectable_attr :category_id do 
+      entry "01", :category1, "カテゴリ1"
+      entry "02", :category2, "カテゴリ2"
+    end
+  end
+  
+  it "test_selectable_attr_name_pattern" do
+    EnumMock6.selectable_attr_name_pattern.should == /(_cd$|_code$|_cds$|_codes$)/
+    EnumMock6.respond_to?(:category_enum).should == false
+    EnumMock6.respond_to?(:category_id_enum).should == true
+    EnumMock6.new.respond_to?(:category_key).should == false
+    EnumMock6.new.respond_to?(:category_id_key).should == true
+    
+    EnumMock7.selectable_attr_name_pattern.should == /(_cd$|_id$|_cds$|_ids$)/
+    EnumMock7.respond_to?(:category_enum).should == true
+    EnumMock7.respond_to?(:category_id_enum).should == false
+    EnumMock7.new.respond_to?(:category_key).should == true
+    EnumMock7.new.respond_to?(:category_id_key).should == false
+  end
+
+end

data/spec/selectable_attr_enum_spec.rb

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe SelectableAttr::Enum do
+
+  Enum1 = SelectableAttr::Enum.new do
+    entry 1, :book, '書籍'
+    entry 2, :dvd, 'DVD'
+    entry 3, :cd, 'CD'
+    entry 4, :vhs, 'VHS'
+  end
+
+  it "test_define" do
+    Enum1[1].id.should == 1
+    Enum1[2].id.should == 2
+    Enum1[3].id.should == 3
+    Enum1[4].id.should == 4
+    Enum1[1].key.should == :book
+    Enum1[2].key.should == :dvd
+    Enum1[3].key.should == :cd
+    Enum1[4].key.should == :vhs
+    Enum1[1].name.should == '書籍'
+    Enum1[2].name.should == 'DVD'
+    Enum1[3].name.should == 'CD'
+    Enum1[4].name.should == 'VHS'
+    
+    Enum1[:book].id.should == 1
+    Enum1[:dvd ].id.should == 2
+    Enum1[:cd  ].id.should == 3
+    Enum1[:vhs ].id.should == 4
+    Enum1[:book].key.should == :book
+    Enum1[:dvd ].key.should == :dvd
+    Enum1[:cd  ].key.should == :cd
+    Enum1[:vhs ].key.should == :vhs
+    Enum1[:book].name.should == '書籍'
+    Enum1[:dvd].name.should  == 'DVD'
+    Enum1[:cd].name.should   == 'CD'
+    Enum1[:vhs].name.should  == 'VHS'
+    
+    Enum1.values.should == [['書籍', 1], ['DVD', 2], ['CD', 3], ['VHS', 4]]
+    Enum1.values(:name, :id).should == [['書籍', 1], ['DVD', 2], ['CD', 3], ['VHS', 4]]
+    Enum1.values(:name, :key).should == [['書籍', :book], ['DVD', :dvd], ['CD', :cd], ['VHS', :vhs]]
+  end
+
+  InetAccess = SelectableAttr::Enum.new do
+    entry 1, :email, 'Eメール', :protocol => 'mailto:'
+    entry 2, :website, 'ウェブサイト', :protocol => 'http://'
+    entry 3, :ftp, 'FTP', :protocol => 'ftp://'
+  end
+
+  it "test_define_with_options" do
+    InetAccess[1].id.should == 1
+    InetAccess[2].id.should == 2
+    InetAccess[3].id.should == 3
+    InetAccess[1].key.should == :email
+    InetAccess[2].key.should == :website
+    InetAccess[3].key.should == :ftp
+    
+    
+    InetAccess[1].name.should == 'Eメール'
+    InetAccess[2].name.should == 'ウェブサイト'
+    InetAccess[3].name.should == 'FTP'
+    InetAccess[1][:protocol].should == 'mailto:'
+    InetAccess[2][:protocol].should == 'http://'
+    InetAccess[3][:protocol].should == 'ftp://'
+
+    InetAccess[9].id.should be_nil
+    InetAccess[9].key.should be_nil
+    InetAccess[9].name.should be_nil
+    InetAccess[9][:protocol].should be_nil
+    InetAccess[9][:xxxx].should be_nil
+  end
+
+  it "test_get_by_option" do
+    InetAccess[:protocol => 'mailto:'].should == InetAccess[1]
+    InetAccess[:protocol => 'http://'].should == InetAccess[2]
+    InetAccess[:protocol => 'ftp://'].should == InetAccess[3]
+  end
+  
+  it "test_null?" do
+    InetAccess[1].null?.should == false
+    InetAccess[2].null?.should == false
+    InetAccess[3].null?.should == false
+    InetAccess[9].null?.should == true
+    InetAccess[:protocol => 'mailto:'].null?.should == false
+    InetAccess[:protocol => 'http://'].null?.should == false
+    InetAccess[:protocol => 'ftp://'].null?.should == false
+    InetAccess[:protocol => 'svn://'].null?.should == true
+  end
+  
+  it "test_null_object?" do
+    InetAccess[1].null_object?.should == false
+    InetAccess[2].null_object?.should == false
+    InetAccess[3].null_object?.should == false
+    InetAccess[9].null_object?.should == true
+    InetAccess[:protocol => 'mailto:'].null_object?.should == false
+    InetAccess[:protocol => 'http://'].null_object?.should == false
+    InetAccess[:protocol => 'ftp://'].null_object?.should == false
+    InetAccess[:protocol => 'svn://'].null_object?.should == true
+  end
+  
+  it "test_to_hash_array" do
+    Enum1.to_hash_array.should == [
+        {:id => 1, :key => :book, :name => '書籍'},
+        {:id => 2, :key => :dvd, :name => 'DVD'},
+        {:id => 3, :key => :cd, :name => 'CD'},
+        {:id => 4, :key => :vhs, :name => 'VHS'}
+      ]
+    
+    InetAccess.to_hash_array.should == [
+        {:id => 1, :key => :email, :name => 'Eメール', :protocol => 'mailto:'},
+        {:id => 2, :key => :website, :name => 'ウェブサイト', :protocol => 'http://'},
+        {:id => 3, :key => :ftp, :name => 'FTP', :protocol => 'ftp://'}
+      ]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$KCODE='u'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+def assert_hash(expected, actual)
+  keys = (expected.keys + actual.keys).uniq
+  keys.each do |key|
+    assert_equal expected[key], actual[key], "unmatch value for #{key.inspect}"
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: akm-selectable_attr
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Takeshi Akima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-27 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: selectable_attr generates extra methods dynamically for attribute which has options
+email: akima@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/selectable_attr
+- lib/selectable_attr/base.rb
+- lib/selectable_attr/enum.rb
+- lib/selectable_attr/version.rb
+- lib/selectable_attr.rb
+- spec/selectable_attr_base_alias_spec.rb
+- spec/selectable_attr_enum_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/akm/selectable_attr/
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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.2.0
+signing_key: 
+specification_version: 2
+summary: selectable_attr generates extra methods dynamically
+test_files: []
+