power_enum 1.0.1 → 1.0.2

data/README.markdown

@@ -2,6 +2,9 @@
 
 https://github.com/albertosaurus/power_enum
 
+[![Build Status](https://travis-ci.org/albertosaurus/power_enum.png)](https://travis-ci.org/albertosaurus/power_enum)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/albertosaurus/power_enum)
+
 Enumerations for Rails 3.1/3.2 Done Right.
 
 NOTICE: Version 1.0 removes support from Rails 3.0, as that version of Rails has no longer been supported for
@@ -726,15 +729,25 @@ Of course `Booking.new.status.should === :received` still works, but is liable t
 
 ## How to run tests
 
+### Prepare the test database
+
+#### Automatically (preferred)
+
+Execute the test setup script:
+
+    script/test_setup.sh
+
+#### Manually (if required)
+
 Go to the 'dummy' project:
     
     cd ./spec/dummy
 
-Run migrations for test environment:
+If this is your first time, create the test database
 
-    RAILS_ENV=test rake db:migrate
+    RAILS_ENV=test bundle exec rake db:create
 
-You may need to use `bundle exec` if you have gem conflicts:
+Run migrations for test environment:
 
     RAILS_ENV=test bundle exec rake db:migrate
 
@@ -742,9 +755,9 @@ Go back to gem root directory:
 
     cd ../../
 
-And finally run tests:
+### Run tests
 
-    rake spec
+    bundle exec rake spec
 
 ## Copyrights and License
 
@@ -760,5 +773,5 @@ Released under the MIT License.  See the LICENSE file for more details.
 Contributions are welcome.  However, please make sure of the following before issuing a pull request:
 
 * All specs are passing.
-* Any new features have test coverage.
+* Any new features have test coverage.  Use the SimpleCov report to confirm.
 * Anything that breaks backward compatibility has a very good reason for doing so.

data/lib/power_enum/enumerated.rb

@@ -77,41 +77,56 @@ module PowerEnum::Enumerated
         end
       end
 
-      name_column = if options.has_key?(:name_column) && !options[:name_column].blank? then
-                      options[:name_column].to_s.to_sym
-                    else
-                      :name
-                    end
-
-      alias_name = if options.has_key?(:alias_name) then
-                     options[:alias_name]
-                   else
-                     true
-                   end
-
       class_attribute :acts_enumerated_name_column
-      self.acts_enumerated_name_column = name_column
+      self.acts_enumerated_name_column = get_name_column(options)
 
       unless self.is_a? PowerEnum::Enumerated::EnumClassMethods
-        extend PowerEnum::Enumerated::EnumClassMethods
+        extend_enum_class_methods( options )
+      end
+    end
 
-        class_eval do
-          include PowerEnum::Enumerated::EnumInstanceMethods
+    # Injects the class methods into model
+    def extend_enum_class_methods(options) #:nodoc:
+      extend PowerEnum::Enumerated::EnumClassMethods
 
-          before_save :enumeration_model_update
-          before_destroy :enumeration_model_update
-          validates name_column, :presence => true, :uniqueness => true
+      class_eval do
+        include PowerEnum::Enumerated::EnumInstanceMethods
 
-          define_method :__enum_name__ do
-            read_attribute( name_column ).to_s
-          end
+        before_save :enumeration_model_update
+        before_destroy :enumeration_model_update
+        validates acts_enumerated_name_column, :presence => true, :uniqueness => true
 
-          if alias_name && name_column != :name
-            alias_method :name, :__enum_name__
-          end
-        end # class_eval
+        define_method :__enum_name__ do
+          read_attribute(acts_enumerated_name_column).to_s
+        end
+
+        if should_alias_name?(options) && acts_enumerated_name_column != :name
+          alias_method :name, :__enum_name__
+        end
+      end # class_eval
+
+    end
+    private :extend_enum_class_methods
+
+    # Determines if the name column should be explicitly aliased
+    def should_alias_name?(options) #:nodoc:
+      if options.has_key?(:alias_name) then
+        options[:alias_name]
+      else
+        true
+      end
+    end
+    private :should_alias_name?
+
+    # Extracts the name column from options or gives the default
+    def get_name_column(options) #:nodoc:
+      if options.has_key?(:name_column) && !options[:name_column].blank? then
+        options[:name_column].to_s.to_sym
+      else
+        :name
       end
     end
+    private :get_name_column
   end
 
   module EnumClassMethods

data/lib/power_enum/has_enumerated.rb

@@ -19,7 +19,7 @@ module PowerEnum::HasEnumerated # :nodoc:
       enumerated_attributes.include? attribute.to_s
     end
 
-    # Defines an enumerated attribute with the given name on the model.  Also accepts a hash of options as an
+    # Defines an enumerated attribute with the given attribute_name on the model.  Also accepts a hash of options as an
     # optional second argument.
     #
     # === Supported options
@@ -37,7 +37,7 @@ module PowerEnum::HasEnumerated # :nodoc:
     #   subsequent lookups, but the model will fail validation.
     #   2) You can specify an instance method to be called in the case of a lookup failure. The method signature is
     #   as follows:
-    #     <tt>your_lookup_handler(operation, name, name_foreign_key, acts_enumerated_class_name, lookup_value)</tt>
+    #     <tt>your_lookup_handler(operation, attribute_name, name_foreign_key, acts_enumerated_class_name, lookup_value)</tt>
     #   The 'operation' arg will be either :read or :write.  In the case of :read you are expected to return
     #   something or raise an exception, while in the case of a :write you don't have to return anything.  Note that
     #   there's enough information in the method signature that you can specify one method to handle all lookup
@@ -89,35 +89,62 @@ module PowerEnum::HasEnumerated # :nodoc:
       reflection = PowerEnum::Reflection::EnumerationReflection.new(part_id, options, self)
       self.reflections = self.reflections.merge(part_id => reflection)
 
-      name            = part_id.to_s
-      class_name      = reflection.class_name
-      foreign_key     = reflection.foreign_key
-      failure_opt     = options[:on_lookup_failure]
-      empty_name      = options[:permit_empty_name]
-      create_scope    = options[:create_scope]
+      attribute_name   = part_id.to_s
+      class_name       = reflection.class_name
+      foreign_key      = reflection.foreign_key
+      failure_opt      = options[:on_lookup_failure]
+      allow_empty_name = options[:permit_empty_name]
+      create_scope     = options[:create_scope]
 
       failure_handler = get_lookup_failure_handler(failure_opt)
 
-      class_attribute "has_enumerated_#{name}_error_handler"
-      self.send("has_enumerated_#{name}_error_handler=", failure_handler)
+      class_attribute "has_enumerated_#{attribute_name}_error_handler"
+      self.send( "has_enumerated_#{attribute_name}_error_handler=", failure_handler )
 
+      define_enum_accessor attribute_name, class_name, foreign_key, failure_handler
+      define_enum_writer   attribute_name, class_name, foreign_key, failure_handler, allow_empty_name
+
+      if failure_opt.to_s == 'validation_error'
+        define_validation_error( attribute_name )
+      end
+
+      enumerated_attributes << attribute_name
+
+      if options.has_key?(:default)
+        define_default_enum_value( attribute_name, options[:default] )
+      end
+
+      unless create_scope == false
+        define_enum_scope( attribute_name, class_name, foreign_key )
+      end
+
+    end # has_enumerated
+
+    # Defines the accessor method
+    def define_enum_accessor(attribute_name, class_name, foreign_key, failure_handler) #:nodoc:
       module_eval( <<-end_eval, __FILE__, __LINE__ )
-        def #{name}
-          if @invalid_enum_values && @invalid_enum_values.has_key?(:#{name})
-            return @invalid_enum_values[:#{name}]
+        def #{attribute_name}
+          if @invalid_enum_values && @invalid_enum_values.has_key?(:#{attribute_name})
+            return @invalid_enum_values[:#{attribute_name}]
           end
           rval = #{class_name}.lookup_id(self.#{foreign_key})
           if rval.nil? && #{!failure_handler.nil?}
-            self.class.has_enumerated_#{name}_error_handler.call(self, :read, #{name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, self.#{foreign_key})
+            self.class.has_enumerated_#{attribute_name}_error_handler.call(self, :read, #{attribute_name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, self.#{foreign_key})
           else
             rval
           end
         end
+      end_eval
+    end
+    private :define_enum_accessor
 
-        def #{name}=(arg)
+    # Defines the enum attribute writer method
+    def define_enum_writer(attribute_name, class_name, foreign_key, failure_handler, allow_empty_name) #:nodoc:
+      module_eval( <<-end_eval, __FILE__, __LINE__ )
+        def #{attribute_name}=(arg)
           @invalid_enum_values ||= {}
 
-          #{!empty_name ? 'arg = nil if arg.blank?' : ''}
+          #{!allow_empty_name ? 'arg = nil if arg.blank?' : ''}
           case arg
           when #{class_name}
             val = #{class_name}.lookup_id(arg.id)
@@ -129,91 +156,94 @@ module PowerEnum::HasEnumerated # :nodoc:
             val = #{class_name}.lookup_id(arg)
           when nil
             self.#{foreign_key} = nil
-            @invalid_enum_values.delete :#{name}
+            @invalid_enum_values.delete :#{attribute_name}
             return nil
           else
-            raise TypeError, "#{self.name}: #{name}= argument must be a #{class_name}, String, Symbol or Fixnum but got a: \#{arg.class.name}"
+            raise TypeError, "#{self.name}: #{attribute_name}= argument must be a #{class_name}, String, Symbol or Fixnum but got a: \#{arg.class.attribute_name}"
           end
 
           if val.nil?
             if #{failure_handler.nil?}
-              raise ArgumentError, "#{self.name}: #{name}= can't assign a #{class_name} for a value of (\#{arg.inspect})"
+              raise ArgumentError, "#{self.name}: #{attribute_name}= can't assign a #{class_name} for a value of (\#{arg.inspect})"
             else
-              @invalid_enum_values.delete :#{name}
-              self.class.has_enumerated_#{name}_error_handler.call(self, :write, #{name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, arg)
+              @invalid_enum_values.delete :#{attribute_name}
+              self.class.has_enumerated_#{attribute_name}_error_handler.call(self, :write, #{attribute_name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, arg)
             end
           else
-            @invalid_enum_values.delete :#{name}
+            @invalid_enum_values.delete :#{attribute_name}
             self.#{foreign_key} = val.id
           end
         end
 
-        alias_method :'#{name}_bak=', :'#{name}='
+        alias_method :'#{attribute_name}_bak=', :'#{attribute_name}='
       end_eval
+    end
+    private :define_enum_writer
 
-      if failure_opt.to_s == 'validation_error'
-        module_eval( <<-end_eval, __FILE__, __LINE__ )
+    # Defines the default value for the enumerated attribute.
+    def define_default_enum_value(attribute_name, default) #:nodoc:
+      set_default_method = "set_default_value_for_#{attribute_name}".to_sym
+
+      after_initialize set_default_method
+
+      define_method set_default_method do
+        self.send("#{attribute_name}=", default) if self.send(attribute_name).nil?
+      end
+      private set_default_method
+    end
+    private :define_default_enum_value
+
+    # Defines validation_error handling mechanism
+    def define_validation_error(attribute_name) #:nodoc:
+      module_eval(<<-end_eval, __FILE__, __LINE__)
           validate do
-            if @invalid_enum_values && @invalid_enum_values.has_key?(:#{name})
-              errors.add(:#{name}, "is invalid")
+            if @invalid_enum_values && @invalid_enum_values.has_key?(:#{attribute_name})
+              errors.add(:#{attribute_name}, "is invalid")
             end
           end
 
-          def validation_error(operation, name, name_foreign_key, acts_enumerated_class_name, lookup_value)
+          def validation_error(operation, attribute_name, name_foreign_key, acts_enumerated_class_name, lookup_value)
             @invalid_enum_values ||= {}
             if operation == :write
-              @invalid_enum_values[name.to_sym] = lookup_value
+              @invalid_enum_values[attribute_name.to_sym] = lookup_value
             else
               nil
             end
           end
           private :validation_error
-        end_eval
-      end
-
-      enumerated_attributes << name
-
-      if options.has_key?(:default)
-        default = options[:default]
-        set_default_method = "set_default_value_for_#{name}".to_sym
-
-        after_initialize set_default_method
-
-        define_method set_default_method do
-          self.send("#{name}=", default) if self.send(name).nil?
-        end
-        private set_default_method
-      end
+      end_eval
+    end
+    private :define_validation_error
 
-      unless create_scope == false
-        module_eval( <<-end_eval, __FILE__, __LINE__)
-          scope :with_#{name}, lambda { |*args|
+    # Defines the enum scopes on the model
+    def define_enum_scope(attribute_name, class_name, foreign_key) #:nodoc:
+      module_eval(<<-end_eval, __FILE__, __LINE__)
+          scope :with_#{attribute_name}, lambda { |*args|
             ids = args.map{ |arg|
               n = #{class_name}[arg]
             }
             where(:#{foreign_key} => ids)
           }
-          scope :exclude_#{name}, lambda {|*args|
+          scope :exclude_#{attribute_name}, lambda {|*args|
             ids = #{class_name}.all - args.map{ |arg|
               n = #{class_name}[arg]
             }
             where(:#{foreign_key} => ids)
           }
-        end_eval
+      end_eval
 
-        if (name_p = name.pluralize) != name
-          module_eval( <<-end_eval, __FILE__, __LINE__)
+      if (name_p = attribute_name.pluralize) != attribute_name
+        module_eval(<<-end_eval, __FILE__, __LINE__)
             class << self
-              alias_method :with_#{name_p}, :with_#{name}
-              alias_method :exclude_#{name_p}, :exclude_#{name}
+              alias_method :with_#{name_p}, :with_#{attribute_name}
+              alias_method :exclude_#{name_p}, :exclude_#{attribute_name}
             end
-          end_eval
-        end
+        end_eval
       end
+    end
+    private :define_enum_scope
 
-    end #has_enumerated
-
-    # If the lookup failure handler is a method name, wraps it in a lambda.
+    # If the lookup failure handler is a method attribute_name, wraps it in a lambda.
     def get_lookup_failure_handler(failure_opt) # :nodoc:
       if failure_opt.nil?
         nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: power_enum
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-27 00:00:00.000000000 Z
+date: 2013-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -142,9 +142,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1934880016458665867
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: