power_enum 0.8.4 → 0.8.5

data/README.md

@@ -1,6 +1,6 @@
 # Power Enum
 
-https://github.com/albertosaurus/enumerations\_mixin
+https://github.com/albertosaurus/power\_enum
 
 Enumerations for Rails 3.X Done Right.
 
@@ -12,9 +12,8 @@ It is particularly suitable for scenarios where your Rails application is not th
 when it's used for analytics or reporting.
 
 Power Enum is a fork of the Rails 3 modernization made by the fine folks at Protocool
-https://github.com/protocool/enumerations\_mixin to the original plugin by Trevor Squires located at
-https://github.com/protocool/enumerations\_mixin.  While many of the core ideas remain, it has been reworked and a full
-test suite written to facilitate further development.
+https://github.com/protocool/enumerations\_mixin to the original plugin by Trevor Squires.  While many of the core ideas
+remain, it has been reworked and a full test suite written to facilitate further development.
 
 At it's most basic level, it allows you to say things along the lines of:
 
@@ -22,8 +21,7 @@ At it's most basic level, it allows you to say things along the lines of:
     booking.status = :confirmed
     booking = Booking.create( :status => :rejected )
 
-    Booking.find :first,
-                 :conditions => ['status_id = ?', BookingStatus[:provisional].id]
+    Booking.where(:status_id => BookingStatus[:provisional])
 
     BookingStatus.all.collect {|status|, [status.name, status.id]}
 
@@ -402,7 +400,7 @@ The `:on_lookup_failure` option in has\_enumerated is there because you may want
 situations where the argument passed to `status=(arg)` is invalid.  By default, an invalid value will cause an
 ArgumentError to be raised.
 
-Of course, this may not be optimal in your situation.  In this case you can do one of two thigs:
+Of course, this may not be optimal in your situation.  In this case 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.
@@ -417,6 +415,14 @@ raise an exception, while in the case of a `:write` you don't have to return any
 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.
 
+3) (Since version 0.8.5) 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.
+
+    :on_lookup_failure => lambda{ |record, op, attr, fk, cl_name, value|
+       # handle lookup failure
+    }
+
 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` will be bypassed.
 

data/lib/active_record/aggregations/has_enumerated.rb

@@ -32,7 +32,8 @@ module ActiveRecord
         # [: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 two things:
+        #   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.
@@ -45,6 +46,9 @@ module ActiveRecord
         #   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]
@@ -64,6 +68,17 @@ module ActiveRecord
         #                    :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,
@@ -78,18 +93,23 @@ module ActiveRecord
           name         = part_id.to_s
           class_name   = reflection.class_name
           foreign_key  = reflection.foreign_key
-          failure      = options[:on_lookup_failure]
+          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.nil?}
-                self.send(#{failure.inspect}, :read, #{name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, 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
@@ -117,20 +137,22 @@ module ActiveRecord
               end
 
               if val.nil?
-                if #{failure.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.send(#{failure.inspect}, :write, #{name.inspect}, #{foreign_key.inspect}, #{class_name.inspect}, arg)
+                  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.to_s == 'validation_error'
+          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})
@@ -192,6 +214,23 @@ module ActiveRecord
 
         end #has_enumerated
 
+        def get_lookup_failure_handler(failure_opt)
+          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 HasEnumerated

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: power_enum
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-23 00:00:00.000000000 Z
+date: 2012-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -143,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4154336654451249829
+      hash: -1049060871827763452
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: