selectable_attr 0.3.7

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.to_s) ? :single :
+        multi_selectable_attrs.include?(attr.to_s) ? :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
+        (respond_to?(:table_exists?) && self.table_exists?) ?
+          (self.columns || []).any?{|col|col.name.to_s == attr.to_s} : false
+      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)
+        name = "#{base_name.upcase}_ENUM"
+        const_defined?(name) ? const_get(name) : nil
+      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
+          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,168 @@
+# -*- coding: utf-8 -*-
+module SelectableAttr
+
+  class Enum
+    include Enumerable
+
+    class << self
+      def instances
+        @@instances ||= []
+      end
+    end
+    
+    def initialize(&block)
+      @entries = []
+      instance_eval(&block) if block_given?
+      SelectableAttr::Enum.instances << self
+    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
+      
+      attr_reader :name
+      
+      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
+
+      def inspect
+        # object_idを２倍にしているのは通常のinspectと合わせるためです。
+        '#<%s:%x @id=%s, @key=%s, @name=%s, @options=%s' % [
+          self.class.name, object_id * 2, id.inspect, key.inspect, name.inspect, @options.inspect]
+      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/selectable_attr.gemspec

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{selectable_attr}
+  s.version = "0.3.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Takeshi Akima"]
+  s.date = %q{2009-08-17}
+  s.description = %q{selectable_attr generates extra methods dynamically for attribute which has options}
+  s.email = %q{akima@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "install.rb",
+     "lib/selectable_attr.rb",
+     "lib/selectable_attr/base.rb",
+     "lib/selectable_attr/enum.rb",
+     "lib/selectable_attr/version.rb",
+     "selectable_attr.gemspec",
+     "spec/selectable_attr_base_alias_spec.rb",
+     "spec/selectable_attr_enum_spec.rb",
+     "spec/spec_helper.rb",
+     "tasks/selectable_attr_tasks.rake",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/akm/selectable_attr/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{selectable_attr generates extra methods dynamically}
+  s.test_files = [
+    "spec/selectable_attr_base_alias_spec.rb",
+     "spec/selectable_attr_enum_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end