has_enum 0.6.1 → 0.7.0

data/.gitignore

@@ -6,3 +6,4 @@ pkg/*
 spec/*.db
 *.swp
 Gemfile.lock
+bin

data/Gemfile

@@ -1,3 +1,3 @@
-source "http://rubygems.org"
+source "http://gems.openteam.ru"
 
 gemspec

data/has_enum.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "has_enum"
   s.version     = HasEnum::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Andreas Korth", "Konstantin Shabanov"]
-  s.email       = ["kes.eclipse@gmail.com"]
+  s.authors     = ["Andreas Korth", "Konstantin Shabanov", "Dmitry Lihachev"]
+  s.email       = ["lda@openteam.ru"]
   s.homepage    = "http://github.com/openteam/has_enum"
   s.summary     = %q{Gem for Rails to easily handle enumeration attributes in models}
   s.description = %q{Gem for and Rails3 to easily handle enumeration attributes in ActiveRecord's models}

data/lib/has_enum.rb

@@ -1,4 +1,40 @@
-require 'has_enum/active_record'
-require 'has_enum/helpers'
+module HasEnum
 
-ActiveRecord::Base.send(:include, HasEnum::ActiveRecord)
+  autoload :ClassMethods,            'has_enum/class_methods'
+
+  def self.included(base)
+    base.write_inheritable_attribute(:enums, HashWithIndifferentAccess.new)
+    base.extend ClassMethods
+  end
+
+end
+
+class ActiveRecord::Base
+  include HasEnum
+end
+
+begin
+  require 'formtastic'
+
+  Formtastic::SemanticFormBuilder.class_eval do
+
+    def enum_input(method, options = {})
+      value = @object.send(method)
+      options.reverse_merge! :as => :select,
+                             :collection => @object.class.human_enums[method].invert.to_a
+      self.input(method, options).gsub(/class="select/, 'class="enum')
+    end
+
+    def input_with_enum(method, options={})
+      if @object.class.respond_to?(:enums) && @object.class.enums[method] && !options[:as]
+        enum_input(method, options)
+      else
+        input_without_enum(method, options)
+      end
+    end
+
+    alias_method_chain :input, :enum
+
+  end
+rescue LoadError
+end

data/lib/has_enum/class_methods.rb

@@ -0,0 +1,79 @@
+module HasEnum::ClassMethods
+
+  def enums
+    @enums ||= read_inheritable_attribute(:enums)
+  end
+
+  def enum_values(attribute)
+    enums[attribute]
+  end
+
+  def has_enum(*params)
+    options = params.extract_options!
+    options.assert_valid_keys(:query_methods, :scopes, :presence)
+
+    raise ArgumentError, "Empty arguments list for has_enum call" if params.empty?
+
+    default_values = nil
+    case params.second
+      when NilClass                   # has_enum :enum
+        attributes = [*params.first]
+      when Array                      # has_enum :enum, %w[foo bar]
+        attributes = [*params.first]
+        default_values = params.second.map(&:to_s)
+      else                            # has_enum :state, :status
+        attributes = params
+    end
+
+    attributes.map(&:to_sym).each do | attribute |
+      values = default_values || human_enum_values(attribute).keys.map(&:to_s)
+
+      enums[attribute] = values
+
+      validates attribute, :inclusion => { :in => values + [nil]}
+      validates attribute, :presence => options[:presence] if options[:presence]
+
+      values.each do |val|
+        scope "#{attribute}_#{val}", where(attribute => val)
+      end if options[:scopes]
+
+      values.each do |val|
+        define_method "#{attribute}_#{val}?" do
+           self.send(attribute) == val.to_s
+        end
+      end if options[:query_methods] != false
+
+      define_method "human_#{attribute}" do
+        self.class.human_enums[attribute][self[attribute]]
+      end
+
+      define_method "#{attribute}=" do | value |
+        value = value.to_s
+        value = nil if value == ''
+        self[attribute] = value
+      end
+    end
+  end
+
+
+  def human_enums
+    @human_enums ||= enums.keys.inject HashWithIndifferentAccess.new do | hash, enum |
+      hash[enum] = human_enum_values enum
+      hash
+    end
+  end
+
+  def human_enum_values(enum)
+    begin
+      options = {:default => nil, :raise => true, :count => nil}
+      HashWithIndifferentAccess.new(human_attribute_name("#{enum}_enum", options))
+    rescue I18n::MissingTranslationData
+      (enums[enum] || []).inject HashWithIndifferentAccess.new do |hash, value|
+        hash[value] = value.humanize
+        hash
+      end
+    end
+  end
+
+end
+

data/lib/has_enum/helpers.rb

@@ -1,10 +1,12 @@
 module ActionView::Helpers::FormHelper
   def radio_button_enum(object_name, method, options = {})
-    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_radio_button_enum_tag(options)
+    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).
+      to_radio_button_enum_tag(options)
   end
 
   def select_enum(object_name, method, options = {})
-    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_select_enum_tag(options)
+    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).
+      to_select_enum_tag(options)
   end
 end
 
@@ -13,7 +15,7 @@ class ActionView::Helpers::InstanceTag
   def to_radio_button_enum_tag(options = {})
     values_for_enum_tag.map do |val|
       radio_button = to_radio_button_tag(val.last, options)
-      [ radio_button, to_label_tag(val.first, :for => radio_button.match(/ id="(.*?)"/)[1]) ] * $/
+      [radio_button, to_label_tag(val.first, :for => radio_button.match(/ id="(.*?)"/)[1])] * $/
     end.join($/)
   end
 
@@ -23,13 +25,7 @@ class ActionView::Helpers::InstanceTag
   end
 
   def values_for_enum_tag
-    values = object.class.enum(method_name.to_sym)
-    begin
-      translation = I18n.translate("activerecord.attributes.#{object.class.name.i18nize}.#{method_name}_enum", :raise => true)
-      values.map { |val| [translation[val.to_sym], val] }
-    rescue I18n::MissingTranslationData
-      values.map { |val| [val.humanize, val] }
-    end
+    object.class.human_enums[method_name].invert.to_a
   end
 end
 
@@ -42,4 +38,5 @@ class ActionView::Helpers::FormBuilder
   def select_enum(method, options = {})
     @template.select_enum(@object_name, method, objectify_options(options.merge(:include_blank => true)))
   end
-end
+end
+

data/lib/has_enum/version.rb

@@ -1,3 +1,3 @@
 module HasEnum
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/spec/has_enum_spec.rb

@@ -2,149 +2,192 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe HasEnum::ActiveRecord do
-  before :each do
-    @model = TestModel.new(:category => 'misc', :color => 'blue', :foo => 'bar', :status => :pending)
+describe HasEnum do
+  let :model do
+    TestModel.new(:category => :stuff, :status => :pending, :state => :done)
+  end
+
+  let :human_enums do
+    {
+      :category => {
+        :stuff    => 'Stuff',
+        :things   => 'Things',
+        :misc     => 'Misc'
+      },
+      :color    => {
+        :red      => 'Red',
+        :green    => 'Green',
+        :blue     => 'Blue'
+      },
+      :size => {
+        :small    => "Маленький",
+        :medium   => "Средний",
+        :large    => "Большой"
+      },
+      :status => {
+        :pending  => 'На рассмотрении',
+        :failed   => "Обработано с ошибкой",
+        :done     => "Завершено"
+      },
+      :state => {
+        :pending  => 'Pending',
+        :failed   => 'Failed',
+        :done     => 'Done'
+      },
+    }.with_indifferent_access
+  end
+
+  it "should return values by name symbol" do
+    TestModel.enums[:state].should eql human_enums[:state].stringify_keys.keys
+  end
+
+  it "should return values by name string" do
+    TestModel.enums["state"].should eql human_enums[:state].stringify_keys.keys
   end
 
   it "should return the values for a given enum attribute" do
-    TestModel.enum[:category].should eql(%w(stuff things misc))
+    TestModel.enums[:category].should eql human_enums[:category].stringify_keys.keys
   end
 
   it "should return hash of values with it's translated equivalent" do
-    I18n.reload!
-    TestModel.human_enum[:size].should eql Hash[:small  => "Маленький",
-                                                :medium => "Средний",
-                                                 :large  => "Большой"]
-    TestModel.human_enum[:status].should eql Hash[:pending => "На рассмотрении",
-                                                  :failed  =>"Обработано с ошибкой",
-                                                  :done    =>"Завершено"]
-    TestModel.human_enum[:category].should eql Hash[:stuff  => 'Stuff',
-                                                    :things => 'Things',
-                                                    :misc   => 'Misc']
+    TestModel.human_enums[:size].should     eql human_enums[:size]
+    TestModel.human_enums[:status].should   eql human_enums[:status]
+    TestModel.human_enums[:category].should eql human_enums[:category]
   end
-  
+
   it "should return hash of enums with hashes of attributes and theirs translated equivalent" do
-    I18n.reload!
-    TestModel.human_enum.should eql Hash[:category => {:stuff=>"Stuff",
-                                                       :things=>"Things",
-                                                       :misc=>"Misc"},
-                                         :color    => {:red=>"Red",
-                                                       :green=>"Green",
-                                                       :blue=>"Blue"},
-                                         :size     => {:small=>"Маленький",
-                                                       :medium=>"Средний",
-                                                       :large=>"Большой"},
-                                         :status   => {:pending=>"На рассмотрении",
-                                                       :failed=>"Обработано с ошибкой",
-                                                       :done=>"Завершено"}]
+    TestModel.human_enums.should eql human_enums
   end
 
   it "should return translated value for attribute" do
-    I18n.reload!
-    TestModel.human_enum[:size][:large].should eql "Большой"
-    TestModel.human_enum[:color][:red].should eql "Red"
-    TestModel.human_enum[:status][:done].should eql "Завершено"
+    TestModel.human_enums[:size][:large].should eql "Большой"
+    TestModel.human_enums[:color][:red].should eql "Red"
+    TestModel.human_enums[:status][:done].should eql "Завершено"
   end
 
   describe "category enum" do
-    it "should accept enum values for the attribute" do
+    it "should accept string enum values" do
       %w(stuff things misc).each do |value|
-        @model.category = value
-        @model.should be_valid
+        model.category = value
+        model.should be_valid
       end
     end
 
-    it "should accept nil value for the attribute" do
-      @model.category = nil
-      @model.category.should be_nil
+    it "should accept symbol enum values" do
+      %w(stuff things misc).each do |value|
+        model.category = value.to_sym
+        model.should be_valid
+      end
     end
 
-    it "should reject non enum values for the attribute" do
-      @model.category = 'objects'
-      @model.errors[:category].size.should eql(1)
+    it "should reject not enum values" do
+      model.category = "not_listed_in_enum"
+      model.should_not be_valid
+    end
+
+    it "should accept nil value for the attribute on create" do
+      model.category = nil
+      model.should be_valid
+    end
+
+    it "should not accept nil value for the attribute on update" do
+      model.save
+      model.category = nil
+      model.should_not be_valid
+    end
+
+    it "should not accept blank value for the attribute" do
+      model.category = '   '
+      model.should_not be_valid
+    end
+
+    it "should normalize empty value for the attribute" do
+      model.category = ''
+      model.category.should be_nil
     end
 
     it "should define query methods for enum values" do
-      %w( stuff things misc ).each do |value|
-        @model.should respond_to(:"category_#{value}?")
+      %w[stuff things misc].each do |value|
+        model.should respond_to(:"category_#{value}?")
       end
     end
-  end
 
-  describe "color enum" do
-    it "should accept any value for the attribute" do
-      %w(red orange yellow).each do |value|
-        @model.color = value
-        @model.should be_valid
-      end
+    it "query methods should works" do
+      model.category = :stuff
+      model.should     be_category_stuff
+      model.should_not be_category_things
+      model.should_not be_category_misc
+
+      model.category = :things
+      model.should_not be_category_stuff
+      model.should     be_category_things
+      model.should_not be_category_misc
+
+      model.category = :misc
+      model.should_not be_category_stuff
+      model.should_not be_category_things
+      model.should     be_category_misc
     end
 
-    it "should reject an empty value for the attribute" do
-      @model.color = ''
-      @model.errors[:color].size.should eql(1)
+    it "should not define a scope methods for each enum value" do
+      TestModel.should_not respond_to :category_stuff
+      TestModel.should_not respond_to :category_things
+      TestModel.should_not respond_to :category_misc
     end
 
-    it "should define a query method for each enum value" do
-      @model.color     = 'green'
-      @model.category  = 'stuff'
-      @model.should be_category_stuff
-      @model.should be_color_green
-      @model.should_not be_color_red
-      @model.should_not be_color_blue
+    it "should translate category by human_category method" do
+      model.human_category.should eql 'Stuff'
     end
+  end
 
+  describe "color enum" do
     it "should define a scope for each enum value" do
-      @model.color = 'red'
-      @model.save
-      @model2 = TestModel.new(:color => 'red')
-      @model2.save
+      model.color = 'red'
+      model.save
+
+      model2 = model.clone
+      model2.color = :blue
+      model2.save
 
       TestModel.color_red.all.should eql TestModel.where(:color => 'red').all
-      TestModel.color_green.all.should be_empty
+
+      TestModel.color_red.should be_one
+      TestModel.color_blue.should be_one
+      TestModel.color_green.count.should be_zero
     end
-  end
 
-  describe "size enum" do
-    it "should accept any value for the attribute" do
-      ['orange', 'medium', 'misc', '', nil].each do |value|
-        @model.size = value
-        @model.should be_valid
-      end
+    it "should accept nil value for the attribute" do
+      model.color = nil
+      model.should be_valid
+      model.save
+      model.should be_valid
+    end
+
+    it "should accept blank value for the attribute" do
+      model.color = ''
+      model.should be_valid
+      model.save
+      model.should be_valid
     end
+  end
 
+  describe "size enum" do
     it "should not define query methods for enum values" do
       %w(small medium large).each do |value|
-        @model.should_not respond_to(:"size_#{value}?")
+        model.should_not respond_to(:"size_#{value}?")
       end
     end
-
-    it "should return humanized translation if not localized" do
-      @model.category = 'stuff'
-      @model.human_category.should eql("Stuff")
-    end
   end
 
   describe "status enum" do
-    it "should accept symbols as symbols" do
-      @model.status = :pending
-      @model.status.should eql(:pending)
-    end
-
-    it "should define query methods for enum values" do
-      @model.status = :pending
-      @model.should be_status_pending
-    end
-
-    it "should accept nil value for the attribute" do
-      @model.status = nil
-      @model.status.should be_nil
+    it "should not accept nil value for the attribute" do
+      model.status = nil
+      model.should_not be_valid
     end
 
-    it "should translate values for the enum" do
-      I18n.reload!
-      @model.status = :pending
-      @model.human_status.should eql("На рассмотрении")
+    it "should not accept blank value for the attribute" do
+      model.status = ''
+      model.should_not be_valid
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string "color"
     t.string "size"
     t.string "status"
-    t.string "foo"
+    t.string "state"
   end
 
   create_table "schema_info", :id => false, :force => true do |t|
@@ -26,4 +26,4 @@ end
 I18n.load_path << 'spec/ru.yml'
 I18n.default_locale = :ru
 
-require File.dirname(__FILE__) + "/test_model" unless defined?(Model)
+require File.dirname(__FILE__) + "/test_model" unless defined?(Model)

data/spec/test_model.rb

@@ -1,6 +1,12 @@
 class TestModel < ActiveRecord::Base
-  has_enum :category, %w( stuff things misc )
-  has_enum :color   , %w( red green blue )       , :scopes        => true
-  has_enum :size    , %w( small medium large )   , :query_methods => false
-  has_enum :status  , [:pending, :failed, :done]
-end
+
+  has_enum :category,           %w[stuff things misc],      :presence       => {:on => :update}
+
+  has_enum :color,              %w[red green blue],         :scopes         => true
+
+  has_enum :size,                                           :query_methods  => false
+
+  has_enum ["status", :state],  [:pending, :failed, :done], :presence       => true
+
+end
+

metadata

@@ -2,16 +2,17 @@
 name: has_enum
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors: 
 - Andreas Korth
 - Konstantin Shabanov
+- Dmitry Lihachev
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 +06:00
+date: 2011-03-24 00:00:00 +06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,7 +50,7 @@ dependencies:
   version_requirements: *id003
 description: Gem for and Rails3 to easily handle enumeration attributes in ActiveRecord's models
 email: 
-- kes.eclipse@gmail.com
+- lda@openteam.ru
 executables: []
 
 extensions: []
@@ -67,7 +68,7 @@ files:
 - Rakefile
 - has_enum.gemspec
 - lib/has_enum.rb
-- lib/has_enum/active_record.rb
+- lib/has_enum/class_methods.rb
 - lib/has_enum/helpers.rb
 - lib/has_enum/version.rb
 - spec/has_enum_spec.rb
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: Gem for Rails to easily handle enumeration attributes in models

data/lib/has_enum/active_record.rb

@@ -1,86 +0,0 @@
-module HasEnum
-  module ActiveRecord
-    def self.included(base)
-      base.write_inheritable_hash(:enum, {})
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def enum(attribute = nil)
-        @enum ||= read_inheritable_attribute(:enum)
-        attribute ? @enum[attribute.to_sym] : @enum
-      end
-
-      def has_enum(attribute, values, options = {})
-        options.assert_valid_keys(:query_methods, :scopes)
-        enum[attribute] = values.freeze
-
-        values.each do |val|
-          scope :"#{attribute}_#{val}", where(:"#{attribute}" => "#{val}")
-        end if options[:scopes]
-
-        values.each do |val|
-          define_method(:"#{attribute}_#{val}?") { self.send(attribute) == val }
-        end if options[:query_methods] != false
-
-        define_method(:"#{attribute}=") do |value|
-          if value.nil? or values.find{ |val| val == value }
-            set_value  = lambda { |value| value.is_a?(Symbol) ? Marshal.dump(value) : value }
-            self[:"#{attribute}"] = value.nil? ? nil : set_value.call(value)
-          else
-            errors.add(:"#{attribute}", "#{value} is not in enum")
-          end
-        end
-
-        define_method(:"#{attribute}") do
-          load_value = lambda { |value| value[0].getbyte(0) == 4 ? Marshal.load(value) : value }
-          value = self[:"#{attribute}"]
-          value ? load_value.call(value) : nil
-        end
-
-        define_method "human_#{attribute}" do
-          return nil unless self.send(attribute)
-
-          defaults  = ["activerecord.attributes.#{self.class.klass_key}.#{attribute}_enum.#{self.send(attribute)}"]
-          defaults << self.send(attribute).to_s.humanize
-          I18n.translate(defaults.shift, :default => defaults, :raise => true)
-        end
-      end
-
-      def human_enum
-        scope = "activerecord.attributes.#{self.klass_key}"
-        i18n = lambda { |key| I18n.t(key, :scope => scope, :raise => true) }
-        trans_hash = {}
-        
-        enum.each_pair do |attribute, values|
-          begin
-            trans_hash[attribute] = i18n.call("#{attribute}_enum")
-          rescue I18n::MissingTranslationData
-            hash = {}
-            values.each do |value|
-              hash[value.to_sym] = value.humanize
-            end
-            trans_hash[attribute] = hash
-          end
-        end
-        
-        trans_hash
-      end
-      
-      def values_for_select_tag(enum)
-        values = enum(enum)
-        begin
-          translation = I18n.translate("activerecord.attributes.#{self.klass_key}.#{enum}_enum", :raise => true)
-
-          values.map { |value| [translation[value.to_sym], value] }
-        rescue I18n::MissingTranslationData
-          values.map { |value| [value.to_s.humanize, value] }
-        end
-      end
-
-      def klass_key
-        self.model_name.respond_to?(:i18n_key) ? self.model_name.i18n_key : self.name.underscore
-      end
-    end
-  end
-end