enum_machine 0.1.0 → 2.0.0

data/lib/enum_machine/build_enum_class.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  module BuildEnumClass
+    def self.call(enum_values:, i18n_scope:, value_class:, machine: nil)
+      aliases = machine&.instance_variable_get(:@aliases) || {}
+
+      Class.new do
+        define_singleton_method(:machine) { machine } if machine
+        define_singleton_method(:values) { enum_values.map { value_class.new(_1).freeze } }
+
+        value_attribute_mapping = values.to_h { [_1.to_s, _1] }
+        define_singleton_method(:value_attribute_mapping) { value_attribute_mapping }
+        define_singleton_method(:[]) do |enum_value|
+          key = enum_value.to_s
+          # Check for key existence because `[]` will call `default_proc`, and we don’t want that
+          value_attribute_mapping[key] if value_attribute_mapping.key?(key)
+        end
+
+        if i18n_scope
+          def self.values_for_form(specific_values = nil) # rubocop:disable Gp/OptArgParameters
+            (specific_values || values).map { |v| [human_name_for(v), v] }
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def self.human_name_for(name)
+            #   ::I18n.t(name, scope: "enums.test_model", default: name)
+            # end
+
+            def self.human_name_for(name)
+              ::I18n.t(name, scope: "enums.#{i18n_scope}", default: name)
+            end
+          RUBY
+        end
+
+        enum_values.each do |enum_value|
+          const_set enum_value.underscore.upcase, enum_value.to_s.freeze
+        end
+
+        aliases.each_key do |key|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def self.forming
+            #   @alias_forming ||= machine.fetch_alias('forming').freeze
+            # end
+
+            def self.#{key}
+              @alias_#{key} ||= machine.fetch_alias('#{key}').freeze
+            end
+          RUBY
+        end
+
+        private_class_method def self.const_missing(name)
+          name_s = name.to_s
+          return super unless name_s.include?("__")
+
+          const_set name_s, name_s.split("__").map { |i| const_get(i) }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/enum_machine/build_value_class.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  module BuildValueClass
+    def self.call(enum_values:, i18n_scope:, value_decorator:, machine: nil)
+      aliases = machine&.instance_variable_get(:@aliases) || {}
+
+      Class.new(String) do
+        include(value_decorator) if value_decorator
+
+        define_method(:machine) { machine } if machine
+
+        def inspect
+          "#<EnumMachine \"#{self}\">"
+        end
+
+        if machine&.transitions?
+          def possible_transitions
+            machine.possible_transitions(self)
+          end
+
+          def can?(enum_value)
+            possible_transitions.include?(enum_value)
+          end
+        end
+
+        enum_values.each do |enum_value|
+          enum_name = enum_value.underscore
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def active?
+            #   self == 'active'
+            # end
+
+            def #{enum_name}?
+              self == '#{enum_value}'
+            end
+          RUBY
+
+          if machine&.transitions?
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              # def can_active?
+              #   possible_transitions.include?('canceled')
+              # end
+
+              def can_#{enum_name}?
+                possible_transitions.include?('#{enum_value}')
+              end
+            RUBY
+          end
+        end
+
+        aliases.each_key do |key|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def forming?
+            #   machine.fetch_alias('forming').include?(self)
+            # end
+
+            def #{key}?
+              machine.fetch_alias('#{key}').include?(self)
+            end
+          RUBY
+        end
+
+        if i18n_scope
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def human_name
+            #   ::I18n.t(self, scope: "enums.product.state", default: self)
+            # end
+
+            def human_name
+              ::I18n.t(self, scope: "enums.#{i18n_scope}", default: self)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/enum_machine/driver_active_record.rb

@@ -2,58 +2,116 @@
 
 module EnumMachine
   module DriverActiveRecord
-
-    def enum_machine(attr, enum_values, i18n_scope: nil, &block)
+    def enum_machine(attr, enum_values, i18n_scope: nil, value_decorator: nil, &block)
       klass = self
 
-      attr_klass_name = attr.to_s.capitalize
-      read_method = "_read_attribute('#{attr}')"
       i18n_scope ||= "#{klass.base_class.to_s.underscore}.#{attr}"
 
-      machine = Machine.new(enum_values)
+      enum_const_name = attr.to_s.upcase
+      machine = Machine.new(enum_values, klass, enum_const_name, attr)
       machine.instance_eval(&block) if block
-      aliases = machine.instance_variable_get(:@aliases)
 
-      if machine.transitions?
-        klass.class_variable_set("@@#{attr}_machine", machine)
+      value_class = BuildValueClass.call(enum_values: enum_values, i18n_scope: i18n_scope, machine: machine, value_decorator: value_decorator)
+      enum_class = BuildEnumClass.call(enum_values: enum_values, i18n_scope: i18n_scope, machine: machine, value_class: value_class)
 
+      value_class.extend(AttributePersistenceMethods[attr, enum_values])
+
+      # default_proc for working with custom values not defined in enum list but may exists in db
+      enum_class.value_attribute_mapping.default_proc =
+        proc do |hash, enum_value|
+          hash[enum_value] = value_class.new(enum_value).freeze
+        end
+
+      if machine.transitions?
         klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
-          after_validation do
-            unless (attr_changes = changes['#{attr}']).blank?
-              @@#{attr}_machine.fetch_before_transitions(attr_changes).each { |i| i.call(self) }
+          before_save :__enum_machine_#{attr}_before_save
+          after_save :__enum_machine_#{attr}_after_save
+
+          def __enum_machine_#{attr}_before_save
+            if (attr_changes = changes['#{attr}']) && !@__enum_machine_#{attr}_skip_transitions
+              value_was, value_new = *attr_changes
+              self.class::#{enum_const_name}.machine.fetch_before_transitions(attr_changes).each do |block|
+                @__enum_machine_#{attr}_forced_value = value_was
+                instance_exec(self, value_was, value_new, &block)
+              ensure
+                @__enum_machine_#{attr}_forced_value = nil
+              end
             end
           end
-          after_save do
-            unless (attr_changes = previous_changes['#{attr}']).blank?
-              @@#{attr}_machine.fetch_after_transitions(attr_changes).each { |i| i.call(self) }
+
+          def __enum_machine_#{attr}_after_save
+            if (attr_changes = previous_changes['#{attr}']) && !@__enum_machine_#{attr}_skip_transitions
+              self.class::#{enum_const_name}.machine.fetch_after_transitions(attr_changes).each { |block| instance_exec(self, *attr_changes, &block) }
             end
           end
         RUBY
       end
 
-      klass.const_set attr_klass_name, BuildClass.new(enum_values, aliases)
-
-      attribute_klass =
-        BuildAttribute.call(
-          attr:         attr,
-          read_method:  read_method,
-          enum_values:  enum_values,
-          i18n_scope:   i18n_scope,
-          machine:      machine,
-          aliases_keys: aliases.keys,
-        )
-      klass.class_variable_set("@@#{attr}_attribute", attribute_klass)
-
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      define_methods = Module.new
+      define_methods.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         # def state
-        #   @state_enum ||= @@state_attribute.new(self)
+        #   enum_value = @__enum_machine_state_forced_value || super()
+        #   return unless enum_value
+        #
+        #   unless @__enum_value_state == enum_value
+        #     @__enum_value_state = self.class::STATE.value_attribute_mapping[enum_value].dup
+        #     @__enum_value_state.parent = self
+        #     @__enum_value_state.freeze
+        #   end
+        #
+        #   @__enum_value_state
+        # end
+        #
+        # def skip_state_transitions
+        #   @__enum_machine_state_skip_transitions = true
+        #   yield
+        # ensure
+        #   @__enum_machine_state_skip_transitions = false
+        # end
+        #
+        # def initialize_dup(other)
+        #   @__enum_value_state = nil
+        #   super
         # end
 
         def #{attr}
-          @#{attr}_enum ||= @@#{attr}_attribute.new(self)
+          enum_value = @__enum_machine_#{attr}_forced_value || super()
+          return unless enum_value
+
+          unless @__enum_value_#{attr} == enum_value
+            @__enum_value_#{attr} = self.class::#{enum_const_name}.value_attribute_mapping[enum_value].dup
+            @__enum_value_#{attr}.parent = self
+            @__enum_value_#{attr}.freeze
+          end
+
+          @__enum_value_#{attr}
+        end
+
+        def skip_#{attr}_transitions
+          @__enum_machine_#{attr}_skip_transitions = true
+          yield
+        ensure
+          @__enum_machine_#{attr}_skip_transitions = false
+        end
+
+        def initialize_dup(other)
+          @__enum_value_#{attr} = nil
+          super
         end
       RUBY
-    end
 
+      enum_decorator =
+        Module.new do
+          define_singleton_method(:included) do |decorating_class|
+            decorating_class.prepend define_methods
+            decorating_class.const_set enum_const_name, enum_class
+          end
+        end
+      enum_class.define_singleton_method(:enum_decorator) { enum_decorator }
+
+      klass.include(enum_decorator)
+
+      enum_decorator
+    end
   end
 end

data/lib/enum_machine/driver_simple_class.rb

@@ -2,7 +2,6 @@
 
 module EnumMachine
   module DriverSimpleClass
-
     # include EnumMachine[
     #   state: { enum: %w[choice in_delivery], i18n_scope: 'line_item.state' },
     #   color: { enum: %w[red green yellow] },
@@ -12,41 +11,42 @@ module EnumMachine
       Module.new do
         define_singleton_method(:included) do |klass|
           args.each do |attr, params|
-            enum_values  = params.fetch(:enum)
-            i18n_scope   = params.fetch(:i18n_scope, nil)
-            enum_class   = params.fetch(:enum_class, true)
-
-            attr_klass_name = attr.to_s.capitalize
-            read_method = "__#{attr}"
-
-            attribute_klass =
-              BuildAttribute.call(
-                attr:        attr,
-                read_method: read_method,
-                enum_values: enum_values,
-                i18n_scope:  i18n_scope,
-              )
-
-            klass.class_variable_set("@@#{attr}_attribute", attribute_klass)
-
-            klass.alias_method read_method, attr
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              # def state
-              #   @state_enum ||= @@state_attribute.new(self)
-              # end
-
-              def #{attr}
-                @#{attr}_enum ||= @@#{attr}_attribute.new(self)
-              end
-            RUBY
-
-            next unless enum_class
-
-            klass.const_set attr_klass_name, BuildClass.new(enum_values)
+            enum_values     = params.fetch(:enum)
+            i18n_scope      = params.fetch(:i18n_scope, nil)
+            value_decorator = params.fetch(:value_decorator, nil)
+
+            if defined?(ActiveRecord) && klass <= ActiveRecord::Base
+              klass.enum_machine(attr, enum_values, i18n_scope: i18n_scope)
+            else
+              enum_const_name = attr.to_s.upcase
+              value_class = BuildValueClass.call(enum_values: enum_values, i18n_scope: i18n_scope, value_decorator: value_decorator)
+              enum_class = BuildEnumClass.call(enum_values: enum_values, i18n_scope: i18n_scope, value_class: value_class)
+
+              define_methods =
+                Module.new do
+                  define_method(attr) do
+                    enum_value = super()
+                    return unless enum_value
+
+                    enum_class.value_attribute_mapping.fetch(enum_value)
+                  end
+                end
+
+              enum_decorator =
+                Module.new do
+                  define_singleton_method(:included) do |decorating_class|
+                    decorating_class.prepend define_methods
+                    decorating_class.const_set enum_const_name, enum_class
+                  end
+                end
+              enum_class.define_singleton_method(:enum_decorator) { enum_decorator }
+
+              klass.include(enum_decorator)
+              enum_decorator
+            end
           end
         end
       end
     end
-
   end
 end

data/lib/enum_machine/machine.rb

@@ -2,11 +2,13 @@
 
 module EnumMachine
   class Machine
+    attr_reader :enum_values, :base_klass, :enum_const_name, :attr_name
 
-    attr_reader :enum_values
-
-    def initialize(enum_values)
+    def initialize(enum_values, base_klass = nil, enum_const_name = nil, attr_name = nil) # rubocop:disable Gp/OptArgParameters
       @enum_values = enum_values
+      @base_klass = base_klass
+      @enum_const_name = enum_const_name
+      @attr_name = attr_name
       @transitions = {}
       @before_transition = {}
       @after_transition = {}
@@ -18,8 +20,8 @@ module EnumMachine
     def transitions(from__to_hash)
       validate_state!(from__to_hash)
 
-      from__to_hash.each do |from_arr, to|
-        array_wrap(from_arr).each do |from|
+      from__to_hash.each do |from_arr, to_arr|
+        array_wrap(from_arr).product(array_wrap(to_arr)).each do |from, to|
           @transitions[from] ||= []
           @transitions[from] << to
         end
@@ -32,9 +34,7 @@ module EnumMachine
     def before_transition(from__to_hash, &block)
       validate_state!(from__to_hash)
 
-      from, to = from__to_hash.to_a.first
-      array_wrap(from).product(Array(to)).each do |from_pair_to|
-        valid_transition!(from_pair_to)
+      filter_transitions(from__to_hash).each do |from_pair_to|
         @before_transition[from_pair_to] ||= []
         @before_transition[from_pair_to] << block
       end
@@ -46,30 +46,36 @@ module EnumMachine
     def after_transition(from__to_hash, &block)
       validate_state!(from__to_hash)
 
-      from, to = from__to_hash.to_a.first
-      array_wrap(from).product(Array(to)).each do |from_pair_to|
-        valid_transition!(from_pair_to)
+      filter_transitions(from__to_hash).each do |from_pair_to|
         @after_transition[from_pair_to] ||= []
         @after_transition[from_pair_to] << block
       end
     end
 
     # public api
-    def all
-      enum_values
+    def any
+      @any ||= AnyEnumValues.new(enum_values + [nil])
     end
 
     def aliases(hash)
       @aliases = hash
     end
 
+    def fetch_aliases
+      @aliases
+    end
+
     def transitions?
       @transitions.present?
     end
 
+    def fetch_transitions
+      @transitions
+    end
+
     # internal api
     def fetch_before_transitions(from__to)
-      valid_transition!(from__to)
+      validate_transition!(from__to)
       @before_transition.fetch(from__to, [])
     end
 
@@ -78,6 +84,11 @@ module EnumMachine
       @after_transition.fetch(from__to, [])
     end
 
+    # internal api
+    def fetch_alias(alias_key)
+      array_wrap(@aliases.fetch(alias_key))
+    end
+
     # internal api
     def possible_transitions(from)
       @transitions.fetch(from, [])
@@ -89,10 +100,25 @@ module EnumMachine
       end
     end
 
-    private def valid_transition!(from_pair_to)
-      from, to = from_pair_to
-      unless @transitions[from]&.include?(to)
-        raise EnumMachine::Error, "transition #{from} => #{to} not defined in enum_machine"
+    private def filter_transitions(from__to_hash)
+      from_arr, to_arr = from__to_hash.to_a.first
+      is_any_enum_values = from_arr.is_a?(AnyEnumValues) || to_arr.is_a?(AnyEnumValues)
+
+      array_wrap(from_arr).product(array_wrap(to_arr)).filter do |from__to|
+        if is_any_enum_values
+          from, to = from__to
+          possible_transitions(from).include?(to)
+        else
+          validate_transition!(from__to)
+          true
+        end
+      end
+    end
+
+    private def validate_transition!(from__to)
+      from, to = from__to
+      unless possible_transitions(from).include?(to)
+        raise EnumMachine::InvalidTransition.new(self, from, to)
       end
     end
 
@@ -104,5 +130,7 @@ module EnumMachine
       end
     end
 
+    class AnyEnumValues < Array
+    end
   end
 end

data/lib/enum_machine/version.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
 module EnumMachine
-
-  VERSION = '0.1.0'
-
+  VERSION = "2.0.0"
 end

data/lib/enum_machine.rb

@@ -1,23 +1,37 @@
 # frozen_string_literal: true
 
-require_relative 'enum_machine/version'
-require_relative 'enum_machine/driver_simple_class'
-require_relative 'enum_machine/build_attribute'
-require_relative 'enum_machine/build_class'
-require_relative 'enum_machine/machine'
-require 'active_support'
+require_relative "enum_machine/version"
+require_relative "enum_machine/driver_simple_class"
+require_relative "enum_machine/build_value_class"
+require_relative "enum_machine/attribute_persistence_methods"
+require_relative "enum_machine/build_enum_class"
+require_relative "enum_machine/machine"
+require "active_support"
 
 module EnumMachine
-
   class Error < StandardError; end
 
+  class InvalidTransition < Error
+    attr_reader :from, :to, :enum_const
+
+    def initialize(machine, from, to)
+      @from = from
+      @to = to
+      @enum_const =
+        begin
+          machine.base_klass.const_get(machine.enum_const_name)
+        rescue NameError # rubocop:disable Lint/SuppressedException
+        end
+      super("Transition #{from.inspect} => #{to.inspect} not defined in enum_machine :#{machine.attr_name}")
+    end
+  end
+
   def self.[](args)
     DriverSimpleClass.call(args)
   end
-
 end
 
 ActiveSupport.on_load(:active_record) do
-  require_relative 'enum_machine/driver_active_record'
-  ActiveRecord::Base.extend(EnumMachine::DriverActiveRecord)
+  require_relative "enum_machine/driver_active_record"
+  ActiveSupport.on_load(:active_record) { extend EnumMachine::DriverActiveRecord }
 end

metadata

@@ -1,58 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: enum_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ermolaev Andrey
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-19 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
-description: state machine for enums
+        version: '0'
+description: Enum machine is a library for defining enums and setting state machines
+  for attributes in ActiveRecord models and plain Ruby classes.
 email:
 - andruhafirst@yandex.ru
 executables: []
@@ -68,9 +69,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docs/MIGRATING_FROM_RAILS_STRING_ENUM.ru.md
 - lib/enum_machine.rb
-- lib/enum_machine/build_attribute.rb
-- lib/enum_machine/build_class.rb
+- lib/enum_machine/attribute_persistence_methods.rb
+- lib/enum_machine/build_enum_class.rb
+- lib/enum_machine/build_value_class.rb
 - lib/enum_machine/driver_active_record.rb
 - lib/enum_machine/driver_simple_class.rb
 - lib/enum_machine/machine.rb
@@ -83,7 +86,7 @@ metadata:
   homepage_uri: https://github.com/corp-gp/enum_machine
   source_code_uri: https://github.com/corp-gp/enum_machine
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,15 +94,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.17
+signing_key:
 specification_version: 4
-summary: state machine for enums
+summary: fast and siple usage state machine in your app
 test_files: []