power_enum 0.8.6 → 0.9.1

data/lib/power_enum/has_enumerated.rb

@@ -0,0 +1,234 @@
+# Copyright (c) 2005 Trevor Squires
+# Copyright (c) 2012 Arthur Shagall
+# Released under the MIT License.  See the LICENSE file for more details.
+
+module PowerEnum::HasEnumerated # :nodoc:
+
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    # Returns a list of all the attributes on the ActiveRecord model which are enumerated.
+    def enumerated_attributes
+      @enumerated_attributes ||= []
+    end
+
+    # Returns +true+ if +attribute+ is an enumerated attribute, +false+ otherwise.
+    def has_enumerated?(attribute)
+      return false if attribute.nil?
+      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
+    # optional second argument.
+    #
+    # === Supported options
+    # [:class_name]
+    #   Name of the enum class.  By default it is the camelized version of the has_enumerated attribute.
+    # [:foreign_key]
+    #   Explicitly set the foreign key column.  By default it's assumed to be your_enumerated_attribute_name_id.
+    # [:on_lookup_failure]
+    #   The :on_lookup_failure option in has_enumerated is there because you may want to create an error handler for
+    #   situations where the argument passed to status=(arg) is invalid. By default, an invalid value will cause an
+    #   ArgumentError to be raised.  Since this may not be optimal in your situation, you can do one of three
+    #   things:
+    #
+    #   1) You can set it to 'validation_error'.  In this case, the invalid value will be cached and returned on
+    #   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>
+    #   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
+    #   failures for all has_enumerated fields if you happen to have more than one defined in your model.
+    #   'NOTE': A nil is always considered to be a valid value for status=(arg) since it's assumed you're trying to
+    #    null out the foreign key. The :on_lookup_failure method will be bypassed.
+    #   3) You can give it a lambda function.  In that case, the lambda needs to accept the ActiveRecord model as
+    #   its first argument, with the rest of the arguments being identical to the signature of the lookup handler
+    #   instance method.
+    # [:permit_empty_name]
+    #   Setting this to 'true' disables automatic conversion of empty strings to nil.  Default is 'false'.
+    # [:default]
+    #   Setting this option will generate an after_initialize callback to set a default value on the attribute
+    #   unless a non-nil one already exists.
+    # [:create_scope]
+    #   Setting this option to 'false' will disable automatically creating 'with_enum_attribute' and
+    #   'exclude_enum_attribute' scope.
+    #
+    # === Example
+    #  class Booking < ActiveRecord::Base
+    #    has_enumerated  :status,
+    #                    :class_name        => 'BookingStatus',
+    #                    :foreign_key       => 'status_id',
+    #                    :on_lookup_failure => :optional_instance_method,
+    #                    :permit_empty_name => true,
+    #                    :default           => :unconfirmed,
+    #                    :create_cope       => false
+    #  end
+    #
+    # === Example 2
+    #
+    #  class Booking < ActiveRecord::Base
+    #    has_enumerated  :booking_status,
+    #                    :class_name        => 'BookingStatus',
+    #                    :foreign_key       => 'status_id',
+    #                    :on_lookup_failure => lambda{ |record, op, attr, fk, cl_name, value|
+    #                      # handle lookup failure
+    #                    }
+    #  end
+    def has_enumerated(part_id, options = {})
+      options.assert_valid_keys( :class_name,
+                                 :foreign_key,
+                                 :on_lookup_failure,
+                                 :permit_empty_name,
+                                 :default,
+                                 :create_scope )
+
+      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]
+
+      failure_handler = get_lookup_failure_handler(failure_opt)
+
+      class_attribute "has_enumerated_#{name}_error_handler"
+      self.send("has_enumerated_#{name}_error_handler=", failure_handler)
+
+      module_eval( <<-end_eval, __FILE__, __LINE__ )
+        def #{name}
+          if @invalid_enum_values && @invalid_enum_values.has_key?(:#{name})
+            return @invalid_enum_values[:#{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})
+          else
+            rval
+          end
+        end
+
+        def #{name}=(arg)
+          @invalid_enum_values ||= {}
+
+          #{!empty_name ? 'arg = nil if arg.blank?' : ''}
+          case arg
+          when #{class_name}
+            val = #{class_name}.lookup_id(arg.id)
+          when String
+            val = #{class_name}.lookup_name(arg)
+          when Symbol
+            val = #{class_name}.lookup_name(arg.id2name)
+          when Fixnum
+            val = #{class_name}.lookup_id(arg)
+          when nil
+            self.#{foreign_key} = nil
+            @invalid_enum_values.delete :#{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}"
+          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})"
+            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)
+            end
+          else
+            @invalid_enum_values.delete :#{name}
+            self.#{foreign_key} = val.id
+          end
+        end
+
+        alias_method :'#{name}_bak=', :'#{name}='
+      end_eval
+
+      if failure_opt.to_s == 'validation_error'
+        module_eval( <<-end_eval, __FILE__, __LINE__ )
+          validate do
+            if @invalid_enum_values && @invalid_enum_values.has_key?(:#{name})
+              errors.add(:#{name}, "is invalid")
+            end
+          end
+
+          def validation_error(operation, name, name_foreign_key, acts_enumerated_class_name, lookup_value)
+            @invalid_enum_values ||= {}
+            if operation == :write
+              @invalid_enum_values[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
+
+      unless create_scope == false
+        module_eval( <<-end_eval, __FILE__, __LINE__)
+          scope :with_#{name}, lambda { |*args|
+            ids = args.map{ |arg|
+              n = #{class_name}[arg]
+            }
+            where(:#{foreign_key} => ids)
+          }
+          scope :exclude_#{name}, lambda {|*args|
+            ids = #{class_name}.all - args.map{ |arg|
+              n = #{class_name}[arg]
+            }
+            where(:#{foreign_key} => ids)
+          }
+        end_eval
+
+        if (name_p = name.pluralize) != name
+          module_eval( <<-end_eval, __FILE__, __LINE__)
+            class << self
+              alias_method :with_#{name_p}, :with_#{name}
+              alias_method :exclude_#{name_p}, :exclude_#{name}
+            end
+          end_eval
+        end
+      end
+
+    end #has_enumerated
+
+    def get_lookup_failure_handler(failure_opt) # :nodoc:
+      if failure_opt.nil?
+        nil
+      else
+        case failure_opt
+        when Proc
+          failure_opt
+        else
+          lambda { |record, op, attr, fk, cl_name, value|
+            record.send(failure_opt.to_s, op, attr, fk, cl_name, value)
+          }
+        end
+
+      end
+    end
+    private :get_lookup_failure_handler
+
+  end #module MacroMethods
+
+end #module PowerEnum::HasEnumerated

data/lib/power_enum.rb

@@ -6,8 +6,8 @@ class PowerEnum < Rails::Engine
 
   initializer 'power_enum' do
     ActiveSupport.on_load(:active_record) do
-      include ActiveRecord::Acts::Enumerated
-      include ActiveRecord::Aggregations::HasEnumerated
+      include PowerEnum::Enumerated
+      include PowerEnum::HasEnumerated
       include PowerEnum::Reflection
 
       ActiveRecord::ConnectionAdapters.module_eval do
@@ -19,6 +19,22 @@ class PowerEnum < Rails::Engine
           include PowerEnum::Migration::CommandRecorder
         end
       end
+
+      # patch Module to support VirtualEnumerations
+      ::Module.module_eval do
+
+        alias_method :enumerations_original_const_missing, :const_missing
+
+        # Override const_missing to see if VirtualEnumerations can create it.
+        def const_missing(const_id)
+          # let rails have a go at loading it
+          enumerations_original_const_missing(const_id)
+        rescue NameError
+          # now it's our turn
+          ActiveRecord::VirtualEnumerations.synthesize_if_defined(const_id) or raise
+        end
+
+      end
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: power_enum
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-29 00:00:00.000000000 Z
+date: 2012-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -111,11 +111,8 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.md
+- README.markdown
 files:
-- examples/virtual_enumerations_sample.rb
-- lib/active_record/acts/enumerated.rb
-- lib/active_record/aggregations/has_enumerated.rb
 - lib/active_record/virtual_enumerations.rb
 - lib/generators/enum/USAGE
 - lib/generators/enum/enum_generator.rb
@@ -123,12 +120,14 @@ files:
 - lib/generators/enum/templates/rails30_migration.rb.erb
 - lib/generators/enum/templates/rails31_migration.rb.erb
 - lib/power_enum.rb
+- lib/power_enum/enumerated.rb
+- lib/power_enum/has_enumerated.rb
 - lib/power_enum/migration/command_recorder.rb
 - lib/power_enum/reflection.rb
 - lib/power_enum/schema/schema_statements.rb
 - lib/testing/rspec.rb
 - LICENSE
-- README.md
+- README.markdown
 homepage: http://github.com/albertosaurus/power_enum
 licenses: []
 post_install_message: 
@@ -143,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1167487358875782212
+      hash: -1309889999666641931
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/examples/virtual_enumerations_sample.rb

@@ -1,76 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Released under the MIT License.  See the LICENSE file for more details.
-
-# Copy this file to Rails.root/config/initializers/virtual_enumerations.rb
-# and configure it accordingly.
-ActiveRecord::VirtualEnumerations.define do |config|
-  ###
-  # USAGE (and don't worry, it doesn't have to be as ugly as this):
-  # config.define 'ClassName', 
-  #               :table_name => 'table', :extends => 'SuperclassName',
-  #               :conditions => ['something = ?', "value"], :order => 'column ASC',
-  #               :on_lookup_failure => :enforce_strict_literals do
-  # class_evaled_functions
-  # end 
-  #
-  # 'ClassName', :table_name and :extends are used to define your virtual class.
-  # Note that 'ClassName' can be a :symbol or a 'CamelString'.  
-  #
-  # The :conditions, :order and :on_lookup_failure arguments are passed to
-  # acts_as_enumerated in your virtual class.  See README_ENUMERATIONS for info
-  # on how acts_as_enumerated works.
-  #
-  # The 'do' block will be class_eval'd by your virtual class after it has 
-  # been loaded-on-demand.
-  #
-  ###
-  # Okay, that's pretty long-winded.
-  # Everything after the initial 'class_name' is optional so for most applications, this
-  # is about as verbose as you're likely to get:
-  #
-  # config.define :booking_status, :order => 'position ASC'
-  #
-  # In the above example, ActiveRecord assumes the table will be called 'booking_statuses'
-  # and the table should have a 'position' column defined.
-  #
-  # If you've got a bunch of enumeration classes that share the same optional parameters
-  # you can pass an array of names as the first argument, saving your fingers from typing
-  # config.define over and over again:
-  #
-  # config.define [:booking_status, :card_issuer], :order => 'position ASC'
-  #
-  # You can also take advantage of ActiveRecord's STI:
-  #
-  # config.define :enum_record, :order => 'position ASC', :table_name => 'enumrecords'
-  # config.define [:booking_status, :card_issuer], :extends => 'EnumRecord'
-  #
-  # In the above example, all of the records are stored in the table called 'enumrecords'
-  # and all acts_as_enumerated parameters are automatically inherited by the
-  # subclasses (although you can override them if you want).
-  # You can also use :extends to extend a non-virtual model class (that's already in 
-  # your models directory) if that floats your boat.
-  #
-  # Finally, that strange optional 'do' block.
-  # You may be struck by the need to tamper with your virtual enumeration class after
-  # it has been loaded-on-demand.  This can be as simple as blessing it with a 
-  # certain 'act':
-  #
-  # config.define :enum_record, :order => 'position ASC' do
-  #   acts_as_list # but see README_ENUMERATIONS for rules about modifying your records 
-  # end
-  #
-  # or you may be experimenting with the dark-side... singleton methods
-  #
-  # config.define :card_issuer do
-  #   class << self[:visa]; def verify_number(arg); some_code_here; end; end
-  #   class << self[:master_card]; def verify_number(arg); some_other_code_here; end; end
-  # end
-  #
-  # For virtual enumerations, this sort of tampering *has* to be defined in the 
-  # config.define do block.  This is because in development mode, rails loads and 
-  # subsequently clobbers your model classes for each request.  The 'do' block will
-  # be evaluated each time your model class is loaded-on-demand.
-  #
-  ###
-  
-end