enumerate_it 0.7.17 → 1.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enumerate_it (0.7.17)
+    enumerate_it (1.0.0)
       activesupport (>= 3.0.0)
 
 GEM

data/README.rdoc

@@ -39,6 +39,15 @@ What does it mean when we say that someone or something is '2'?
 
 Enter EnumerateIt.
 
+== Documentation
+
+http://rubydoc.info/gems/enumerate_it/1.0.0/frames
+
+== About versions compatibility
+
+Versions 1.x.x are NOT backwards compatible with 0.x.x versions. The biggest difference is that on 1.0.0 you need to `extend` the EnumerateIt
+module inside classes that are going to have enumerated attributes, while in past versions you would use `include`.
+
 == Creating enumerations
 
 Enumerations are created as models, but you can put then anywhere in your application. In Rails
@@ -84,7 +93,7 @@ This will create some nice stuff:
 
    RelationshipStatus.each_value { |value| # ... }
 
-* You can iterate over the list of the enumeration's translations: 
+* You can iterate over the list of the enumeration's translations:
 
    RelationshipStatus.each_translation { |translation| # ... }
 
@@ -119,7 +128,7 @@ The cool part is that you can use these enumerations with any class, be it an Ac
 or not.
 
    class Person
-     include EnumerateIt
+     extend EnumerateIt
      attr_accessor :relationship_status
 
      has_enumeration_for :relationship_status, :with => RelationshipStatus
@@ -133,7 +142,7 @@ This will create:
 
    p = Person.new
    p.relationship_status = RelationshipStatus::DIVORCED
-   p.relationsip_status_humanize # => 'Divorced'
+   p.relationship_status_humanize # => 'Divorced'
 
 * If you don't supply a humanized string to represent an option, EnumerateIt will use a 'humanized' version of the hash's key to humanize the attribute's value:
 
@@ -163,7 +172,7 @@ This will create:
    p.married? #=> true
    p.divorced? #=> false
 
-* It's also possible to "namespace" the created helper methods, passing a hash to the :create_helpers option. 
+* It's also possible to "namespace" the created helper methods, passing a hash to the :create_helpers option.
   This can be useful when two or more of the enumerations used share the same constants.
 
   class Person < ActiveRecord::Base
@@ -194,7 +203,7 @@ This will create:
 
    Person.married.to_sql # => SELECT "people".* FROM "people" WHERE "people"."relationship_status" = 1
 
-NOTE: The :create_scopes option can only be used for Rails.version >= 3.0.0. 
+NOTE: The :create_scopes option can only be used for Rails.version >= 3.0.0.
 
 * If your class can manage validations and responds to :validates_inclusion_of, it will create this validation:
 
@@ -261,7 +270,7 @@ You can also translate specific values:
 
 * Create an initializer with the following code:
 
-  ActiveRecord::Base.send :include, EnumerateIt
+  ActiveRecord::Base.extend EnumerateIt
 
 * Add the 'enumerate_it' gem as a dependency in your environment.rb (Rails 2.3.x) or Gemfile (if you're using Bundler)
 
@@ -273,7 +282,7 @@ An interesting approach to use it in Rails apps is to create an app/enumerations
     end
   end
 
-There is also a Rails Generator that you can use to generate enumerations and their locale files. Take a look at how to use it running 
+There is also a Rails Generator that you can use to generate enumerations and their locale files. Take a look at how to use it running
 
   rails generate enumerate_it --help
 

data/lib/enumerate_it.rb

@@ -78,7 +78,7 @@
 #
 #   RelationshipStatus.each_value { |value| # ... }
 #
-# You can iterate over the list of the enumeration's translations: 
+# You can iterate over the list of the enumeration's translations:
 #
 #   RelationshipStatus.each_translation { |translation| # ... }
 #
@@ -91,17 +91,17 @@
 # RelationshipStatus.enumeration # returns the exact hash used to define the enumeration
 #
 # You can also create enumerations in the following ways:
-# 
+#
 # * Passing an array of symbols, so that the respective value for each symbol will be the stringified version of the symbol itself:
-# 
+#
 #    class RelationshipStatus < EnumerateIt::Base
 #      associate_values :married, :single
 #    end
-# 
+#
 #    RelationshipStatus::MARRIED # returns "married" and so on
-# 
+#
 # * Passing hashes where the value for each key/pair does not include a translation. In this case, the I18n feature will be used (more on this below):
-# 
+#
 #    class RelationshipStatus < EnumerateIt::Base
 #      associate_values :married => 1, :single => 2
 #    end
@@ -112,7 +112,7 @@
 # or not.
 #
 # class Person
-#   include EnumerateIt
+#   extend EnumerateIt
 #   attr_accessor :relationship_status
 #
 #   has_enumeration_for :relationship_status, :with => RelationshipStatus
@@ -158,7 +158,7 @@
 #  p.married? #=> true
 #  p.divorced? #=> false
 #
-# - It's also possible to "namespace" the created helper methods, passing a hash to the :create_helpers option. 
+# - It's also possible to "namespace" the created helper methods, passing a hash to the :create_helpers option.
 #  This can be useful when two or more of the enumerations used share the same constants.
 #
 #  class Person < ActiveRecord::Base
@@ -205,7 +205,7 @@
 #
 # * Create an initializer with the following code:
 #
-# ActiveRecord::Base.send :include, EnumerateIt
+# ActiveRecord::Base.extend EnumerateIt
 #
 # * Add the 'enumerate_it' gem as a dependency in your environment.rb (Rails 2.3.x) or Gemfile (if you're using Bundler)
 #
@@ -223,173 +223,11 @@
 #
 
 require "active_support/core_ext/class/attribute"
-module EnumerateIt
-  class Base
-    @@registered_enumerations = {}
-
-    def self.associate_values(*args)
-      values_hash = args.first.is_a?(Hash) ? args.first : args.inject({}) { |h, v| h[v] = v.to_s; h }
-
-      register_enumeration normalize_enumeration(values_hash)
-      values_hash.each_pair { |value_name, attributes| define_enumeration_constant value_name, attributes[0] }
-    end
-
-    def self.list
-      enumeration.values.map { |value| value[0] }.sort
-    end
-
-    def self.enumeration
-      @@registered_enumerations[self]
-    end
-
-    def self.to_a
-      enumeration.values.map {|value| [translate(value[1]), value[0]] }.sort_by { |value| value[0] }
-    end
-
-    def self.length
-      list.length
-    end
-
-    def self.each_translation
-      each_value { |value| yield t(value) }
-    end
-
-    def self.each_value
-      list.each { |value| yield value }
-    end
-
-    def self.to_json
-      enumeration.values.collect {|value| { :value => value[0], :label => translate(value[1]) } }.to_json
-    end
-
-    def self.t(value)
-      target = to_a.detect { |item| item[1] == value }
-      target ? target[0] : value
-    end
-
-    def self.values_for(values)
-      values.map { |v| self.const_get(v.to_sym) }
-    end
-
-    def self.value_for(value)
-      self.const_get(value.to_sym)
-    end
-
-    def self.key_for(value)
-      enumeration.map {|e| e[0] if e[1][0] == value }.compact.first
-    end
-
-    def self.to_range
-      (list.min..list.max)
-    end
-
-    private
-    def self.translate(value)
-      return value unless value.is_a? Symbol
+require "enumerate_it/base"
+require "enumerate_it/class_methods"
 
-      default = value.to_s.gsub(/_/, ' ').split.map(&:capitalize).join(' ')
-      I18n.t("enumerations.#{self.name.underscore}.#{value.to_s.underscore}", :default => default)
-    end
-
-    def self.normalize_enumeration(values_hash)
-      values_hash.each_pair do |key, value|
-        unless value.is_a? Array
-          values_hash[key] = [value, key]
-        end
-      end
-    end
-
-    def self.register_enumeration(values_hash)
-      @@registered_enumerations[self] = values_hash
-    end
-
-    def self.define_enumeration_constant(name, value)
-      const_set name.to_s.upcase, value
-    end
-  end
-
-  module ClassMethods
-    def has_enumeration_for(attribute, options = {})
-      self.enumerations = self.enumerations.dup
-
-      define_enumeration_class attribute, options
-      set_validations attribute, options
-      create_enumeration_humanize_method options[:with], attribute
-      store_enumeration options[:with], attribute
-      if options[:create_helpers]
-        create_helper_methods options[:with], attribute, options[:create_helpers]
-        create_mutator_methods options[:with], attribute, options[:create_helpers]
-      end
-
-      if options[:create_scopes]
-        create_scopes options[:with], attribute
-      end
-    end
-
-    private
-    def store_enumeration(klass, attribute)
-      enumerations[attribute] = klass
-    end
-
-    def create_enumeration_humanize_method(klass, attribute_name)
-      class_eval do
-        define_method "#{attribute_name}_humanize" do
-          values = klass.enumeration.values.detect { |v| v[0] == self.send(attribute_name) }
-
-          values ? klass.translate(values[1]) : nil
-        end
-      end
-    end
-
-    def create_helper_methods(klass, attribute_name, helpers)
-      prefix_name = "#{attribute_name}_" if helpers.is_a?(Hash) && helpers[:prefix]
-
-      class_eval do
-        klass.enumeration.keys.each do |option|
-          define_method "#{prefix_name}#{option}?" do
-            self.send(attribute_name) == klass.enumeration[option].first
-          end
-        end
-      end
-    end
-
-    def create_scopes(klass, attribute_name)
-      klass.enumeration.keys.each do |option|
-        if respond_to? :scope
-          scope option, lambda { where(attribute_name => klass.enumeration[option].first)}
-        end
-      end
-    end
-
-    def create_mutator_methods(klass, attribute_name, helpers)
-      prefix_name = "#{attribute_name}_" if helpers.is_a?(Hash) && helpers[:prefix]
-
-      class_eval do
-        klass.enumeration.each_pair do |key, values|
-          define_method "#{prefix_name}#{key}!" do
-            self.send "#{attribute_name}=", values.first
-          end
-        end
-      end
-    end
-
-    def define_enumeration_class(attribute, options)
-      if options[:with].nil?
-        options[:with] = attribute.to_s.camelize.constantize
-      end
-    end
-
-    def set_validations(attribute, options)
-      validates_inclusion_of(attribute, :in => options[:with].list, :allow_blank => true) if self.respond_to?(:validates_inclusion_of)
-
-      if options[:required] && respond_to?(:validates_presence_of)
-        opts = options[:required].is_a?(Hash) ? options[:required] : {}
-        validates_presence_of(attribute, opts)
-      end
-    end
-  end
-
-  def self.included(receiver)
+module EnumerateIt
+  def self.extended(receiver)
     receiver.class_attribute :enumerations, :instance_writer => false, :instance_reader => false
     receiver.enumerations = {}
 

data/lib/enumerate_it/base.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module EnumerateIt
+  class Base
+    @@registered_enumerations = {}
+
+    def self.associate_values(*args)
+      values_hash = args.first.is_a?(Hash) ? args.first : args.inject({}) { |h, v| h[v] = v.to_s; h }
+
+      register_enumeration normalize_enumeration(values_hash)
+      values_hash.each_pair { |value_name, attributes| define_enumeration_constant value_name, attributes[0] }
+    end
+
+    def self.list
+      enumeration.values.map { |value| value[0] }.sort
+    end
+
+    def self.enumeration
+      @@registered_enumerations[self]
+    end
+
+    def self.to_a
+      enumeration.values.map {|value| [translate(value[1]), value[0]] }.sort_by { |value| value[0] }
+    end
+
+    def self.length
+      list.length
+    end
+
+    def self.each_translation
+      each_value { |value| yield t(value) }
+    end
+
+    def self.each_value
+      list.each { |value| yield value }
+    end
+
+    def self.to_json
+      enumeration.values.collect {|value| { :value => value[0], :label => translate(value[1]) } }.to_json
+    end
+
+    def self.t(value)
+      target = to_a.detect { |item| item[1] == value }
+      target ? target[0] : value
+    end
+
+    def self.values_for(values)
+      values.map { |v| self.const_get(v.to_sym) }
+    end
+
+    def self.value_for(value)
+      self.const_get(value.to_sym)
+    end
+
+    def self.key_for(value)
+      enumeration.map {|e| e[0] if e[1][0] == value }.compact.first
+    end
+
+    def self.to_range
+      (list.min..list.max)
+    end
+
+    private
+    def self.translate(value)
+      return value unless value.is_a? Symbol
+
+      default = value.to_s.gsub(/_/, ' ').split.map(&:capitalize).join(' ')
+      I18n.t("enumerations.#{self.name.underscore}.#{value.to_s.underscore}", :default => default)
+    end
+
+    def self.normalize_enumeration(values_hash)
+      values_hash.each_pair do |key, value|
+        unless value.is_a? Array
+          values_hash[key] = [value, key]
+        end
+      end
+    end
+
+    def self.register_enumeration(values_hash)
+      @@registered_enumerations[self] = values_hash
+    end
+
+    def self.define_enumeration_constant(name, value)
+      const_set name.to_s.upcase, value
+    end
+  end
+end

data/lib/enumerate_it/class_methods.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+module EnumerateIt
+  module ClassMethods
+    def has_enumeration_for(attribute, options = {})
+      self.enumerations = self.enumerations.dup
+
+      define_enumeration_class attribute, options
+      set_validations attribute, options
+      create_enumeration_humanize_method options[:with], attribute
+      store_enumeration options[:with], attribute
+      if options[:create_helpers]
+        create_helper_methods options[:with], attribute, options[:create_helpers]
+        create_mutator_methods options[:with], attribute, options[:create_helpers]
+      end
+
+      if options[:create_scopes]
+        create_scopes options[:with], attribute
+      end
+    end
+
+    private
+    def store_enumeration(klass, attribute)
+      enumerations[attribute] = klass
+    end
+
+    def create_enumeration_humanize_method(klass, attribute_name)
+      class_eval do
+        define_method "#{attribute_name}_humanize" do
+          values = klass.enumeration.values.detect { |v| v[0] == self.send(attribute_name) }
+
+          values ? klass.translate(values[1]) : nil
+        end
+      end
+    end
+
+    def create_helper_methods(klass, attribute_name, helpers)
+      prefix_name = "#{attribute_name}_" if helpers.is_a?(Hash) && helpers[:prefix]
+
+      class_eval do
+        klass.enumeration.keys.each do |option|
+          define_method "#{prefix_name}#{option}?" do
+            self.send(attribute_name) == klass.enumeration[option].first
+          end
+        end
+      end
+    end
+
+    def create_scopes(klass, attribute_name)
+      klass.enumeration.keys.each do |option|
+        if respond_to? :scope
+          scope option, lambda { where(attribute_name => klass.enumeration[option].first)}
+        end
+      end
+    end
+
+    def create_mutator_methods(klass, attribute_name, helpers)
+      prefix_name = "#{attribute_name}_" if helpers.is_a?(Hash) && helpers[:prefix]
+
+      class_eval do
+        klass.enumeration.each_pair do |key, values|
+          define_method "#{prefix_name}#{key}!" do
+            self.send "#{attribute_name}=", values.first
+          end
+        end
+      end
+    end
+
+    def define_enumeration_class(attribute, options)
+      if options[:with].nil?
+        options[:with] = attribute.to_s.camelize.constantize
+      end
+    end
+
+    def set_validations(attribute, options)
+      validates_inclusion_of(attribute, :in => options[:with].list, :allow_blank => true) if self.respond_to?(:validates_inclusion_of)
+
+      if options[:required] && respond_to?(:validates_presence_of)
+        opts = options[:required].is_a?(Hash) ? options[:required] : {}
+        validates_presence_of(attribute, opts)
+      end
+    end
+  end
+end

data/lib/enumerate_it/version.rb

@@ -1,3 +1,3 @@
 module EnumerateIt
-  VERSION = "0.7.17"
+  VERSION = "1.0.0"
 end

data/spec/enumerate_it_spec.rb

@@ -37,14 +37,14 @@ class Foobar < EnumerateIt::Base
 end
 
 class BaseClass
-  include EnumerateIt
+  extend EnumerateIt
   has_enumeration_for :foobar, :with => TestEnumeration
 end
 
 describe EnumerateIt do
   before :each do
     class TestClass
-      include EnumerateIt
+      extend EnumerateIt
       attr_accessor :foobar
       has_enumeration_for :foobar, :with => TestEnumeration
 
@@ -104,7 +104,7 @@ describe EnumerateIt do
     context "passing the value of each option without the human string (just the value, without an array)" do
       before :each do
         class TestClassForEnumerationWithoutArray
-          include EnumerateIt
+          extend EnumerateIt
           attr_accessor :foobar
           has_enumeration_for :foobar, :with => TestEnumerationWithoutArray
 
@@ -130,7 +130,7 @@ describe EnumerateIt do
     context "without passing the enumeration class" do
       before :each do
         class FooBar
-          include EnumerateIt
+          extend EnumerateIt
           attr_accessor :test_enumeration
           has_enumeration_for :test_enumeration
           def initialize(test_enumeration_value)
@@ -367,7 +367,7 @@ describe EnumerateIt::Base do
       end
 
       ActiveRecordStub.stub!(:validates_inclusion_of).and_return(true)
-      ActiveRecordStub.send :include, EnumerateIt
+      ActiveRecordStub.extend EnumerateIt
     end
 
     it "creates a validation for inclusion" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enumerate_it
 version: !ruby/object:Gem::Version
-  version: 0.7.17
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-24 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -95,6 +95,8 @@ files:
 - Rakefile
 - enumerate_it.gemspec
 - lib/enumerate_it.rb
+- lib/enumerate_it/base.rb
+- lib/enumerate_it/class_methods.rb
 - lib/enumerate_it/version.rb
 - lib/generators/USAGE
 - lib/generators/enumerate_it_generator.rb
@@ -119,7 +121,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -392427821220719135
+      hash: -1315505449336147275
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -128,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -392427821220719135
+      hash: -1315505449336147275
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24