power_enum 3.5.0 → 4.0.1

data/lib/power_enum/has_enumerated.rb

@@ -2,137 +2,141 @@
 # Copyright (c) 2012 Arthur Shagall
 # Released under the MIT License.  See the LICENSE file for more details.
 
-# Implementation of has_enumerated
-module PowerEnum::HasEnumerated
-
-  extend ActiveSupport::Concern
-
-  # Class-level behavior injected into ActiveRecord to support has_enumerated
-  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 attribute_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, 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
-    #   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 )
-
-      # Add a reflection for the enumerated attribute.
-      reflection       = create_ar_reflection(part_id, options)
-
-      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_#{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
+module PowerEnum
+
+  # Implementation of has_enumerated
+  module HasEnumerated
+
+    extend ActiveSupport::Concern
 
-      enumerated_attributes << attribute_name
+    # Class-level behavior injected into ActiveRecord to support has_enumerated
+    module ClassMethods
+
+      # Returns a list of all the attributes on the ActiveRecord model which are enumerated.
+      def enumerated_attributes
+        @enumerated_attributes ||= []
+      end
 
-      if options.has_key?(:default)
-        define_default_enum_value( attribute_name, options[:default] )
+      # 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
 
-      unless create_scope == false
-        define_enum_scope( attribute_name, class_name, foreign_key )
+      # 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
+      # [: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, 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
+      #   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)
+
+        # Add a reflection for the enumerated attribute.
+        reflection = create_ar_reflection(part_id, options)
+
+        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_#{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
 
-    end # has_enumerated
+      # has_enumerated
 
-    # Creates the ActiveRecord reflection
-    def create_ar_reflection(part_id, options)
-      reflection = PowerEnum::Reflection::EnumerationReflection.new(part_id, options, self)
+      # Creates the ActiveRecord reflection
+      private def create_ar_reflection(part_id, options)
+        reflection = PowerEnum::Reflection::EnumerationReflection.new(part_id, options, self)
 
-      self._reflections = self._reflections.merge(part_id.to_s => reflection)
-      reflection
-    end
-    private :create_ar_reflection
+        self._reflections = self._reflections.merge(part_id.to_s => reflection)
+        reflection
+      end
 
-    # Defines the accessor method
-    def define_enum_accessor(attribute_name, class_name, foreign_key, failure_handler) #:nodoc:
-      module_eval( <<-end_eval, __FILE__, __LINE__ )
+      # Defines the accessor method
+      private def define_enum_accessor(attribute_name, class_name, foreign_key, failure_handler)
+        #:nodoc:
+        module_eval(<<-end_eval, __FILE__, __LINE__)
         def #{attribute_name}
           if @invalid_enum_values && @invalid_enum_values.has_key?(:#{attribute_name})
             return @invalid_enum_values[:#{attribute_name}]
@@ -144,13 +148,13 @@ module PowerEnum::HasEnumerated
             rval
           end
         end
-      end_eval
-    end
-    private :define_enum_accessor
+        end_eval
+      end
 
-    # 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__ )
+      # Defines the enum attribute writer method
+      private 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 ||= {}
 
@@ -186,26 +190,26 @@ module PowerEnum::HasEnumerated
         end
 
         alias_method :'#{attribute_name}_bak=', :'#{attribute_name}='
-      end_eval
-    end
-    private :define_enum_writer
+        end_eval
+      end
 
-    # 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
+      # Defines the default value for the enumerated attribute.
+      private 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
+        after_initialize set_default_method
 
-      define_method set_default_method do
-        self.send("#{attribute_name}=", default) if self.send(attribute_name).nil?
+        define_method set_default_method do
+          self.send("#{attribute_name}=", default) if self.send(attribute_name).nil?
+        end
+        private set_default_method
       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__)
+      # Defines validation_error handling mechanism
+      private def define_validation_error(attribute_name)
+        #:nodoc:
+        module_eval(<<-end_eval, __FILE__, __LINE__)
           validate do
             if @invalid_enum_values && @invalid_enum_values.has_key?(:#{attribute_name})
               errors.add(:#{attribute_name}, "is invalid")
@@ -221,13 +225,13 @@ module PowerEnum::HasEnumerated
             end
           end
           private :validation_error
-      end_eval
-    end
-    private :define_validation_error
+        end_eval
+      end
 
-    # Defines the enum scopes on the model
-    def define_enum_scope(attribute_name, class_name, foreign_key) #:nodoc:
-      module_eval(<<-end_eval, __FILE__, __LINE__)
+      # Defines the enum scopes on the model
+      private 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]
@@ -240,37 +244,36 @@ module PowerEnum::HasEnumerated
             }
             where(:#{foreign_key} => ids)
           }
-      end_eval
+        end_eval
 
-      if (name_p = attribute_name.pluralize) != attribute_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_#{attribute_name}
               alias_method :exclude_#{name_p}, :exclude_#{attribute_name}
             end
-        end_eval
+          end_eval
+        end
       end
-    end
-    private :define_enum_scope
-
-    # 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
-      else
-        case failure_opt
-        when Proc
-          failure_opt
+
+      # If the lookup failure handler is a method attribute_name, wraps it in a lambda.
+      private def get_lookup_failure_handler(failure_opt)
+        # :nodoc:
+        if failure_opt.nil?
+          nil
         else
-          lambda { |record, op, attr, fk, cl_name, value|
-            record.send(failure_opt.to_s, op, attr, fk, cl_name, value)
-          }
-        end
+          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
-    end
-    private :get_lookup_failure_handler
-
-  end #module MacroMethods
 
+    end #module MacroMethods
+  end
 end #module PowerEnum::HasEnumerated

data/lib/power_enum/schema/schema_statements.rb

@@ -8,7 +8,9 @@ module PowerEnum::Schema
 
     def self.included(base) # :nodoc:
       base::AbstractAdapter.class_eval do
-        include PowerEnum::Schema::AbstractAdapter
+        # This squashes the "#create_enum" in the PostgreSQL adapter in Rails 7+.
+        # .../activerecord-7.0.X.Y/lib/active_record/connection_adapters/postgresql_adapter.rb
+        prepend PowerEnum::Schema::AbstractAdapter
       end
     end
 
@@ -92,7 +94,7 @@ module PowerEnum::Schema
       desc_limit = options[:desc_limit]
       table_options = options[:table_options] || {}
 
-      create_table enum_table_name, table_options do |t|
+      create_table enum_table_name, **table_options do |t|
         t.string name_column, :limit => name_limit, :null => false
         if generate_description
           t.string :description, :limit => desc_limit

data/lib/power_enum.rb

@@ -2,34 +2,44 @@ require 'rails'
 require 'active_record'
 require 'testing/rspec'
 
+require "power_enum/has_enumerated"
+require "power_enum/enumerated"
+require "power_enum/reflection"
+
+require "power_enum/schema/schema_statements"
+require "power_enum/migration/command_recorder"
+
+require "active_record/virtual_enumerations"
+
 # Power Enum allows you to treat instances of your ActiveRecord models as
 # though they were an enumeration of values. It allows you to cleanly solve
 # many of the problems that the traditional Rails alternatives handle poorly
 # if at all. It is particularly suitable for scenarios where your Rails
 # application is not the only user of the database, such as when it's used for
 # analytics or reporting.
-class PowerEnum < Rails::Engine
-  config.autoload_paths << File.expand_path(File.join(__FILE__, "../"))
+module PowerEnum
+  class Engine < Rails::Engine
 
-  initializer 'power_enum' do
-    ActiveSupport.on_load(:active_record) do
-      include PowerEnum::Enumerated
-      include PowerEnum::HasEnumerated
+    initializer 'power_enum' do
+      ActiveSupport.on_load(:active_record) do
+        include PowerEnum::Enumerated
+        include PowerEnum::HasEnumerated
 
-      ActiveRecord::Base.module_eval do
-        class << self
-          prepend ::PowerEnum::Reflection
+        ActiveRecord::Base.module_eval do
+          class << self
+            prepend ::PowerEnum::Reflection
+          end
         end
-      end
 
-      ActiveRecord::ConnectionAdapters.module_eval do
-        include PowerEnum::Schema::SchemaStatements
-      end
+        ActiveRecord::ConnectionAdapters.module_eval do
+          include PowerEnum::Schema::SchemaStatements
+        end
 
-      ActiveRecord::Migration::CommandRecorder.class_eval do
-        include PowerEnum::Migration::CommandRecorder
+        ActiveRecord::Migration::CommandRecorder.class_eval do
+          include PowerEnum::Migration::CommandRecorder
+        end
       end
-    end
 
+    end
   end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: power_enum
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Trevor Squires
 - Pivotal Labs
 - Arthur Shagall
 - Sergey Potapov
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2023-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,60 +61,60 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 description: |
   Power Enum allows you to treat instances of your ActiveRecord models as though they were an enumeration of values.
   It allows you to cleanly solve many of the problems that the traditional Rails alternatives handle poorly if at all.
@@ -126,9 +126,11 @@ extensions: []
 extra_rdoc_files:
 - LICENSE
 - README.markdown
+- VERSION
 files:
 - LICENSE
 - README.markdown
+- VERSION
 - lib/active_record/virtual_enumerations.rb
 - lib/generators/enum/USAGE
 - lib/generators/enum/enum_generator.rb
@@ -149,7 +151,7 @@ homepage: http://github.com/albertosaurus/power_enum_2
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -157,15 +159,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: Allows you to treat instances of your ActiveRecord models as though they
   were an enumeration of values