power_enum 0.8.6 → 0.9.1

data/lib/active_record/acts/enumerated.rb

@@ -1,395 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Copyright (c) 2012 Arthur Shagall
-# Released under the MIT License.  See the LICENSE file for more details.
-
-module ActiveRecord
-  module Acts 
-    module Enumerated 
-      extend ActiveSupport::Concern
-      
-      module ClassMethods
-
-        # Returns false for ActiveRecord models that do not act as enumerated.
-        def acts_as_enumerated?
-          false
-        end
-
-        # Declares the model as enumerated.  See the README for detailed usage instructions.
-        #
-        # === Supported options
-        # [:conditions]
-        #   SQL search conditions
-        # [:order]
-        #   SQL load order clause
-        # [:on_lookup_failure]
-        #   Specifies the name of a class method to invoke when the +[]+ method is unable to locate a BookingStatus
-        #   record for arg. The default is the built-in :enforce_none which returns nil. There are also built-ins for
-        #   :enforce_strict (raise and exception regardless of the type for arg), :enforce_strict_literals (raises an
-        #   exception if the arg is a Fixnum or Symbol), :enforce_strict_ids (raises and exception if the arg is a
-        #   Fixnum) and :enforce_strict_symbols (raises an exception if the arg is a Symbol).  The purpose of the
-        #   :on_lookup_failure option is that a) under some circumstances a lookup failure is a Bad Thing and action
-        #   should be taken, therefore b) a fallback action should be easily configurable.  You can also give it a
-        #   lambda that takes in a single argument (The arg that was passed to +[]+).
-        # [:name_column]
-        #   Override for the 'name' column.  By default, assumed to be 'name'.
-        #
-        # === Examples
-        #
-        # ====Example 1
-        #  class BookingStatus < ActiveRecord::Base
-        #    acts_as_enumerated
-        #  end
-        #
-        # ====Example 2
-        #  class BookingStatus < ActiveRecord::Base
-        #    acts_as_enumerated :on_lookup_failure => :enforce_strict
-        #  end
-        #
-        # ====Example 3
-        #  class BookingStatus < ActiveRecord::Base
-        #    acts_as_enumerated :conditions        => [:exclude => false],
-        #                       :order             => 'created_at DESC',
-        #                       :on_lookup_failure => :lookup_failed,
-        #                       :name_column       => :status_code
-        #
-        #    def self.lookup_failed(arg)
-        #      logger.error("Invalid status code lookup #{arg.inspect}")
-        #      nil
-        #    end
-        #  end
-        #
-        # ====Example 4
-        #  class BookingStatus < ActiveRecord::Base
-        #    acts_as_enumerated :conditions        => [:exclude => false],
-        #                       :order             => 'created_at DESC',
-        #                       :on_lookup_failure => lambda { |arg| raise CustomError, "BookingStatus lookup failed; #{arg}" },
-        #                       :name_column       => :status_code
-        #  end
-        def acts_as_enumerated(options = {})
-          valid_keys = [:conditions, :order, :on_lookup_failure, :name_column]
-          options.assert_valid_keys(*valid_keys)
-          
-          valid_keys.each do |key|
-            class_attribute "acts_enumerated_#{key.to_s}"
-            if options.has_key?( key )
-              self.send "acts_enumerated_#{key.to_s}=", options[key]
-            end
-          end
-          
-          name_column = if options.has_key?(:name_column) then
-                          options[:name_column].to_s.to_sym
-                        else
-                          :name
-                        end
-
-          class_attribute :acts_enumerated_name_column
-          self.acts_enumerated_name_column = name_column
-
-          unless self.is_a? ActiveRecord::Acts::Enumerated::EnumClassMethods
-            extend ActiveRecord::Acts::Enumerated::EnumClassMethods
-            
-            class_eval do
-              include ActiveRecord::Acts::Enumerated::EnumInstanceMethods
-              
-              before_save :enumeration_model_update
-              before_destroy :enumeration_model_update
-              validates name_column, :presence => true, :uniqueness => true
-              
-              define_method :name do
-                read_attribute( name_column )
-              end
-            end
-          end
-        end
-      end
-      
-      module EnumClassMethods
-        attr_accessor :enumeration_model_updates_permitted
-
-        # Returns true for ActiveRecord models that act as enumerated.
-        def acts_as_enumerated?
-          true
-        end
-
-        # Returns all the enum values.  Caches results after the first time this method is run.
-        def all
-          return @all if @all
-          conditions = self.acts_enumerated_conditions
-          order = self.acts_enumerated_order
-          @all = where(conditions).order(order).collect{|val| val.freeze}.freeze
-        end
-
-        # Returns all the active enum values.  See the 'active?' instance method.
-        def active
-          return @all_active if @all_active
-          @all_active = all.select{ |enum| enum.active? }.freeze
-        end
-
-        # Returns all the inactive enum values.  See the 'inactive?' instance method.
-        def inactive
-          return @all_inactive if @all_inactive
-          @all_inactive = all.select{ |enum| !enum.active? }.freeze
-        end
-
-        # Returns the names of all the enum values as an array of symbols.
-        def names
-          all.map { |item| item.name_sym }
-        end
-
-        # Enum lookup by Symbol, String, or id.  Returns <tt>arg<tt> if arg is
-        # an enum instance.  Passing in a list of arguments returns a list of enums.
-        def [](*args)
-          case args.size
-          when 0
-            nil
-          when 1
-            arg = args.first
-            case arg
-            when Symbol
-              return_val = lookup_name(arg.id2name) and return return_val
-            when String
-              return_val = lookup_name(arg) and return return_val
-            when Fixnum
-              return_val = lookup_id(arg) and return return_val
-            when self
-              return arg
-            when nil
-              nil
-            else
-              raise TypeError, "#{self.name}[]: argument should be a String, Symbol or Fixnum but got a: #{arg.class.name}"
-            end
-
-            handle_lookup_failure(arg)
-          else
-            args.map{ |item| self[item] }.uniq
-          end
-        end
-
-        # Deals with a lookup failure for the given argument.
-        def handle_lookup_failure(arg)
-          if (lookup_failure_handler = self.acts_enumerated_on_lookup_failure)
-            case lookup_failure_handler
-            when Proc
-              lookup_failure_handler.call(arg)
-            else
-              self.send(lookup_failure_handler, arg)
-            end
-          else
-            self.send(:enforce_none, arg)
-          end
-        end
-        private :handle_lookup_failure
-
-        # Enum lookup by id
-        def lookup_id(arg)
-          all_by_id[arg]
-        end
-
-        # Enum lookup by String
-        def lookup_name(arg)
-          all_by_name[arg]
-        end
-
-        # Returns true if the enum lookup by the given Symbol, String or id would have returned a value, false otherwise.
-        def include?(arg)
-          case arg
-          when Symbol
-            !lookup_name(arg.id2name).nil?
-          when String
-            !lookup_name(arg).nil?
-          when Fixnum
-            !lookup_id(arg).nil?
-          when self
-            possible_match = lookup_id(arg.id) 
-            !possible_match.nil? && possible_match == arg
-          else
-            false
-          end
-        end
-
-        # NOTE: purging the cache is sort of pointless because
-        # of the per-process rails model.  
-        # By default this blows up noisily just in case you try to be more 
-        # clever than rails allows.  
-        # For those times (like in Migrations) when you really do want to 
-        # alter the records you can silence the carping by setting
-        # enumeration_model_updates_permitted to true.
-        def purge_enumerations_cache
-          unless self.enumeration_model_updates_permitted
-            raise "#{self.name}: cache purging disabled for your protection"
-          end
-          @all = @all_by_name = @all_by_id = @all_active = nil
-        end
-
-        # The preferred method to update an enumerations model.  The same
-        # warnings as 'purge_enumerations_cache' and
-        # 'enumerations_model_update_permitted' apply.  Pass a block to this
-        # method (no args) where you perform your updates.  Cache will be
-        # flushed automatically.
-        def update_enumerations_model
-          if block_given?
-            begin
-              self.enumeration_model_updates_permitted = true
-              yield
-            ensure
-              purge_enumerations_cache
-              self.enumeration_model_updates_permitted = false
-            end
-          end
-        end
-
-        # Returns the name of the column this enum uses as the basic underlying value.
-        def name_column
-          @name_column ||= self.acts_enumerated_name_column
-        end
-
-        # ---Private methods---
-
-        # Returns a hash of all enumeration members keyed by their ids.
-        def all_by_id
-          @all_by_id ||= all_by_attribute( :id )
-        end
-        private :all_by_id
-
-        # Returns a hash of all the enumeration members keyed by their names.
-        def all_by_name
-          begin
-            @all_by_name ||= all_by_attribute( :name )
-          rescue NoMethodError => err
-            if err.name == name_column
-              raise TypeError, "#{self.name}: you need to define a '#{name_column}' column in the table '#{table_name}'"
-            end
-            raise
-          end            
-        end
-        private :all_by_name
-
-        def all_by_attribute(attr)
-          all.inject({}) { |memo, item|
-            memo[item.send(attr)] = item
-            memo
-          }.freeze
-        end
-        private :all_by_attribute
-        
-        def enforce_none(arg)
-          nil
-        end
-        private :enforce_none
-
-        def enforce_strict(arg)
-          raise_record_not_found(arg)
-        end
-        private :enforce_strict
-
-        def enforce_strict_literals(arg)
-          raise_record_not_found(arg) if (Fixnum === arg) || (Symbol === arg)
-          nil
-        end
-        private :enforce_strict_literals
-
-        def enforce_strict_ids(arg)
-          raise_record_not_found(arg) if Fixnum === arg
-          nil
-        end
-        private :enforce_strict_ids
-
-        def enforce_strict_symbols(arg)
-          raise_record_not_found(arg) if Symbol === arg
-          nil
-        end
-        private :enforce_strict_symbols
-
-        def raise_record_not_found(arg)
-          raise ActiveRecord::RecordNotFound, "Couldn't find a #{self.name} identified by (#{arg.inspect})"
-        end
-        private :raise_record_not_found
-        
-      end
-
-      module EnumInstanceMethods
-        # Behavior depends on the type of +arg+.
-        #
-        # * If +arg+ is +nil+, returns +false+.
-        # * If +arg+ is an instance of +Symbol+, +Fixnum+ or +String+, returns the result of +BookingStatus[:foo] == BookingStatus[arg]+.
-        # * If +arg+ is an +Array+, returns +true+ if any member of the array returns +true+ for +===(arg)+, +false+ otherwise.
-        # * In all other cases, delegates to +===(arg)+ of the superclass.
-        #
-        # Examples:
-        #
-        #     BookingStatus[:foo] === :foo #Returns true
-        #     BookingStatus[:foo] === 'foo' #Returns true
-        #     BookingStatus[:foo] === :bar #Returns false
-        #     BookingStatus[:foo] === [:foo, :bar, :baz] #Returns true
-        #     BookingStatus[:foo] === nil #Returns false
-        #
-        # You should note that defining an +:on_lookup_failure+ method that raises an exception will cause +===+ to
-        # also raise an exception for any lookup failure of +BookingStatus[arg]+.
-        def ===(arg)
-          case arg
-          when nil
-            false
-          when Symbol, String, Fixnum
-            return self == self.class[arg]
-          when Array
-            return self.in?(*arg)
-          else
-            super
-          end
-        end
-        
-        alias_method :like?, :===
-
-        # Returns true if any element in the list returns true for ===(arg), false otherwise.
-        def in?(*list)
-          for item in list
-            self === item and return true
-          end
-          false
-        end
-
-        # Returns the symbol representation of the name of the enum. BookingStatus[:foo].name_sym returns :foo.
-        def name_sym
-          self.name.to_sym
-        end
-
-        # By default enumeration #to_s should return stringified name of the enum. BookingStatus[:foo].to_s returns "foo"
-        def to_s
-          self.name.to_s
-        end
-
-        # Returns true if the instance is active, false otherwise.  If it has an attribute 'active',
-        # returns the attribute cast to a boolean, otherwise returns true.  This method is used by the 'active'
-        # class method to select active enums.
-        def active?
-          @_active_status ||= ( attributes.include?('active') ? !!self.active : true )
-        end
-
-        # Returns true if the instance is inactive, false otherwise.  Default implementations returns !active?
-        # This method is used by the 'inactive' class method to select inactive enums.
-        def inactive?
-          !active?
-        end
-
-        # NOTE: updating the models that back an acts_as_enumerated is 
-        # rather dangerous because of rails' per-process model.
-        # The cached values could get out of synch between processes
-        # and rather than completely disallow changes I make you jump 
-        # through an extra hoop just in case you're defining your enumeration 
-        # values in Migrations.  I.e. set enumeration_model_updates_permitted = true
-        def enumeration_model_update
-          if self.class.enumeration_model_updates_permitted    
-            self.class.purge_enumerations_cache
-            true
-          else
-            # Ugh.  This just seems hack-ish.  I wonder if there's a better way.
-            self.errors.add(self.class.name_column, "changes to acts_as_enumeration model instances are not permitted")
-            false
-          end
-        end
-        private :enumeration_model_update
-      end
-    end
-  end
-end
-        

data/lib/active_record/aggregations/has_enumerated.rb

@@ -1,238 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Copyright (c) 2012 Arthur Shagall
-# Released under the MIT License.  See the LICENSE file for more details.
-
-module ActiveRecord
-  module Aggregations # :nodoc:
-    module 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)
-          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
-  end #module Aggregations
-end