enum_machine 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3e8eb3957fd71860a322260031d255c8034c53a0d263bd43d68911bcf97507f
-  data.tar.gz: 05306e2ad610425b729a1716ee854614e697acc4dbd0cf6a9d85a476dd1f5209
+  metadata.gz: 14dc3dff76ded6b1aea680c93860bdd7aad7edb2c11b65e4e0a741ebd9d71e92
+  data.tar.gz: 5a30e39776ee6de5073e987863e55a768faf88f68cc8075e49dbf01fc335d908
 SHA512:
-  metadata.gz: ea4de98d78c4cb4d0a67655f6c6bcce58f3168696e43b311a5e23873caf49fa4624745de266c852ab34f5edc892c5a7d4459803e772669522d6cf04fa63dff28
-  data.tar.gz: 9233aa651cd9efb8ed0c2cbb16172da70d99fb1b919ba0d4a9146b6c8c312ec85d0d12fc183af82bb3b90f0cdfb4af78c55305f3f53b78a73cd546bb41ac0b7a
+  metadata.gz: 516f79da30dc8ca2ac1aaa152a566fc30b681de1f0e4091001715a6598517d6630b274b6e215b4563a8afc411adf52731e76efa7aa948e7b34218631fcdb29e1
+  data.tar.gz: 23b0ca783312d70257e4654550810585c3ccf7ce69014f729e11d719147116d3db7bbd6496bc0120f8d0362544d3078f353f29c64cb06a14e6f98539f6167442

data/.rubocop.yml

@@ -3,7 +3,7 @@ inherit_gem:
     - ./config/default.yml
 
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0
 
 Rails/ApplicationRecord:
   Enabled: false

data/Gemfile.lock

@@ -19,10 +19,10 @@ GIT
 PATH
   remote: .
   specs:
-    enum_machine (0.1.0)
-      activemodel (~> 6.0)
-      activerecord (~> 6.0)
-      activesupport (~> 6.0)
+    enum_machine (1.0.0)
+      activemodel
+      activerecord
+      activesupport
 
 GEM
   remote: https://rubygems.org/
@@ -118,6 +118,8 @@ GEM
     zeitwerk (2.5.4)
 
 PLATFORMS
+  arm64-darwin-21
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES
@@ -131,4 +133,4 @@ DEPENDENCIES
   sqlite3 (~> 1.4)
 
 BUNDLED WITH
-   2.2.29
+   2.3.15

data/README.md

@@ -1,38 +1,173 @@
-# EnumMachine
+# Enum machine
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/enum_machine`. To experiment with that code, run `bin/console` for an interactive prompt.
+Enum machine is a library for defining enums and setting state machines for attributes in ActiveRecord models and plain Ruby classes.
 
-TODO: Delete this and the text above, and describe your gem
+You can visualize the state machine with [enum_machine-contrib](https://github.com/corp-gp/enum_machine-contrib)
+
+## Why not state_machines/aasm?
+
+The [aasm](https://github.com/aasm/aasm) and [state_machines](https://github.com/state-machines/state_machines) gems suggest calling special methods to change the `state`. In practice, this can lead to errors. In enum_machine, the `state` is changed by updating the corresponding field, and the validation of the ability to change from one state to another is done in the `after_validation` callback. This allows the `state` of a model to be changed consistently with the usual `save!`. In addition aasm/state_machines add many autogenerated methods to the model class and instances. This makes it much more difficult to search by the project. Pollutes the method's space. Adds a bottleneck in method naming because you have to remember these methods in your code.
+
+Performance comparison (see [test/performance.rb](../master/test/performance.rb))
+
+| Gem            | Method                                                            |                                |
+| :---           |                                                              ---: | :---                           |
+| enum_machine   | order.state.forming?                                              |  894921.3 i/s                  |
+| state_machines | order.forming?                                                    |  189901.8 i/s - 4.71x  slower  |
+| aasm           | order.forming?                                                    |  127073.7 i/s - 7.04x  slower  |
+|                |                                                                   |                                |
+| enum_machine   | order.state.can_closed?                                           |  473150.4 i/s                  |
+| aasm           | order.may_to_closed?                                              |   24459.1 i/s - 19.34x  slower |
+| state_machines | order.can_to_closed?                                              |   12136.8 i/s - 38.98x  slower |
+|                |                                                                   |                                |
+| enum_machine   | Order::STATE.values                                               | 6353820.4 i/s                  |
+| aasm           | Order.aasm(:state).states.map(&:name)                             |  131390.5 i/s - 48.36x  slower |
+| state_machines | Order.state_machines[:state].states.map(&:value)                  |  108449.7 i/s - 58.59x  slower |
+|                |                                                                   |                                |
+| enum_machine   | order.state = "forming" and order.valid?                          |   13873.4 i/s                  |
+| state_machines | order.state_event = "to_forming" and order.valid?                 |   6173.6 i/s - 2.25x  slower   |
+| aasm           | order.to_forming                                                  |   3095.9 i/s - 4.48x  slower   |
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to your Gemfile:
 
 ```ruby
 gem 'enum_machine'
 ```
 
-And then execute:
+## Usage
 
-    $ bundle install
+### Enums
 
-Or install it yourself as:
+```ruby
+# With ActiveRecord
+class Product < ActiveRecord::Base
+  enum_machine :color, %w(red green)
+end
+
+# Or with plain class
+class Product
+  include EnumMachine[color: { enum: %w[red green] }]
+end
+
+Product::COLOR.values # => ["red", "green"]
+Product::COLOR::RED # => "red"
+Product::COLOR::RED__GREEN # => ["red", "green"]
+
+product = Product.new
+product.color # => nil
+product.color = 'red'
+product.color.red? # => true
+```
 
-    $ gem install enum_machine
+### Aliases
 
-## Usage
+```ruby
+class Product < ActiveRecord::Base
+  enum_machine :state, %w[created approved published] do
+    aliases(
+      'forming' => %w[created approved],
+    )
+end
+
+Product::STATE.forming # => %w[created approved]
+
+product = Product.new(state: 'created')
+product.state.forming? # => true
+```
 
-TODO: Write usage instructions here
+### Transitions
 
-## Development
+```ruby
+class Product < ActiveRecord::Base
+  enum_machine :color, %w[red green blue]
+  enum_machine :state, %w[created approved cancelled activated] do
+    transitions(
+      nil                    => 'red',
+      'created'              => [nil, 'approved'],
+      %w[cancelled approved] => 'activated',
+      'activated'            => %w[created cancelled],
+    )
+
+    # Will be executed in `before_save` callback
+    before_transition 'created' => 'approved' do |product|
+      product.color = 'green' if product.color.red?
+    end
+
+    # Will be executed in `after_save` callback
+    after_transition %w[created] => %w[approved] do |product|
+      product.color = 'red'
+    end
+
+    after_transition any => 'cancelled' do |product|
+      product.cancelled_at = Time.zone.now
+    end
+  end
+end
+
+product = Product.create(state: 'created')
+product.state.possible_transitions # => [nil, "approved"]
+product.state.can_activated? # => false
+product.state.to_activated! # => EnumMachine::Error: transition "created" => "activated" not defined in enum_machine
+product.state.to_approved! # => true; equal to `product.update!(state: 'approved')`
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### I18n
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+**ru.yml**
+```yml
+ru:
+  enums:
+    product:
+      color:
+        red: Красный
+        green: Зеленый
+```
 
-## Contributing
+```ruby
+# ActiveRecord
+class Product < ActiveRecord::Base
+  enum_machine :color, %w(red green)
+end
+
+# Plain class
+class Product
+  # `i18n_scope` option must be explicitly set to use methods below
+  include EnumMachine[color: { enum: %w[red green], i18n_scope: 'product' }]
+end
+
+Product::COLOR.human_name_for('red') # => 'Красный'
+Product::COLOR.values_for_form # => [["Красный", "red"], ["Зеленый", "green"]]
+
+product = Product.new(color: 'red')
+product.color.human_name # => 'Красный'
+```
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/enum_machine.
+I18n scope can be changed with `i18n_scope` option:
+
+```ruby
+# For AciveRecord
+class Product < ActiveRecord::Base
+  enum_machine :color, %w(red green), i18n_scope: 'users.product'
+end
+
+# For plain class
+class Product
+  include EnumMachine[color: { enum: %w[red green], i18n_scope: 'users.product' }]
+end
+```
+
+**ru.yml**
+```yml
+ru:
+  enums:
+    users:
+      product:
+        color:
+          red: Красный
+          green: Зеленый
+```
 
 ## License
 

data/docs/MIGRATING_FROM_RAILS_STRING_ENUM.ru.md

@@ -0,0 +1,54 @@
+# Переход с `rails_string_enum` на `enum_machine`
+
+### 1. Объявление в классе
+```ruby
+class Product
+  string_enum :color, %w[red green] # Было
+  enum_machine :color, %w[red green] # Стало
+end
+```
+
+### 2. Константы
+
+Все константы находятся в Product::COLOR
+
+* `Product::RED` => `Product::COLOR::RED`
+* `Product::RED__GREEN` => `Product::COLOR::RED__GREEN`
+* `Product::COLORS` => `Product::COLOR.values`
+
+### 3. Методы инстанса
+
+* `@product.red?` => `@product.color.red?`
+
+### 4. I18n хелперы
+
+* `Product.colors_i18n` => `Product::COLOR.values_for_form`
+* `Product.color_i18n_for('red')` => `Product::COLOR.human_name_for('red')`
+* `@product.color_i18n` => `@product.color.human_name`
+
+### 5. scopes
+
+В `enum_machine` нет опции `scopes`, нужно задать необходимые вручную
+
+```ruby
+class Product
+  # Было
+  string_enum :color, %w[red green], scopes: true
+
+  # Стало
+  enum_machine :color, %w[red green]
+  scope :only_red, -> { where(color: COLOR::RED) }
+end
+```
+
+### 6. Интеграция с `simple_form`
+
+`enum_machine` не предоставляет интеграцию с `simple_form`, тип инпута и коллекцию нужно передавать самостоятельно
+
+```ruby
+# Было
+f.input :color
+
+# Стало
+f.input :color, as: :select, collection: Product::COLOR.values_for_form
+```

data/lib/enum_machine/attribute_persistence_methods.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  module AttributePersistenceMethods
+
+    def self.[](attr, enum_values)
+      Module.new do
+        define_singleton_method(:extended) do |klass|
+          klass.attr_accessor :parent
+
+          klass.define_method(:inspect) do
+            "#<EnumMachine:BuildAttribute value=#{self} parent=#{parent.inspect}>"
+          end
+
+          enum_values.each do |enum_value|
+            enum_name = enum_value.underscore
+
+            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              # def to_created!
+              #   parent.update!('state' => 'created')
+              # end
+
+              def to_#{enum_name}!
+                parent.update!('#{attr}' => '#{enum_value}')
+              end
+            RUBY
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/enum_machine/build_attribute.rb

@@ -3,116 +3,72 @@
 module EnumMachine
   module BuildAttribute
 
-    def self.call(attr:, read_method:, enum_values:, i18n_scope:, machine: nil, aliases_keys: {})
-      parent_attr = "@parent.#{read_method}"
-
-      Class.new do
-        def initialize(parent)
-          @parent = parent
-        end
+    def self.call(enum_values:, i18n_scope:, machine: nil)
+      aliases = machine&.instance_variable_get(:@aliases) || {}
 
+      Class.new(String) do
         define_method(:machine) { machine } if machine
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          # def to_s
-          #   @parent.__state
-          # end
-          #
-          # def inspect
-          #   '<enum_machine :state>'
-          # end
-          #
-          # def ==(other)
-          #   raise EnumMachine::Error, "use `state.\#{other}?` instead `state == '\#{other}'`"
-          # end
-
-          def to_s
-            #{parent_attr}
-          end
+        def inspect
+          "#<EnumMachine:BuildAttribute value=#{self}>"
+        end
 
-          def inspect
-            '<enum_machine :#{attr}>'
+        if machine&.transitions?
+          def possible_transitions
+            machine.possible_transitions(self)
           end
 
-          def ==(other)
-            raise EnumMachine::Error, "use `#{attr}.\#{other}?` instead `#{attr} == '\#{other}'`"
+          def can?(enum_value)
+            possible_transitions.include?(enum_value)
           end
-        RUBY
+        end
 
         enum_values.each do |enum_value|
+          enum_name = enum_value.underscore
+
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             # def active?
-            #   @parent.__state == 'active'
-            # end
-            #
-            # def in?(values)
-            #   values.include?(@parent.__state)
+            #   self == 'active'
             # end
 
-            def #{enum_value}?
-              #{parent_attr} == '#{enum_value}'
-            end
-
-            def in?(values)
-              values.include?(#{parent_attr})
+            def #{enum_name}?
+              self == '#{enum_value}'
             end
           RUBY
 
           if machine&.transitions?
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
               # def can_active?
-              #   machine.possible_transitions(@parent.__state).include?('canceled')
-              # end
-              #
-              # def to_canceled!
-              #  @parent.update!('state' => 'canceled')
+              #   possible_transitions.include?('canceled')
               # end
 
-              def can_#{enum_value}?
-                machine.possible_transitions(#{parent_attr}).include?('#{enum_value}')
-              end
-
-              def to_#{enum_value}!
-                @parent.update!('#{attr}' => '#{enum_value}')
+              def can_#{enum_name}?
+                possible_transitions.include?('#{enum_value}')
               end
             RUBY
           end
         end
 
-        if machine&.transitions?
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            # def possible_transitions
-            #   machine.possible_transitions('active')
-            # end
-
-            def possible_transitions
-              machine.possible_transitions(#{parent_attr})
-            end
-          RUBY
-        end
-
-        aliases_keys.each do |key|
+        aliases.each_key do |key|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             # def forming?
-            #   @parent.class::State.forming.include?('active')
+            #   machine.fetch_alias('forming').include?(self)
             # end
 
             def #{key}?
-              @parent.class::State.#{key}.include?(#{parent_attr})
+              machine.fetch_alias('#{key}').include?(self)
             end
           RUBY
         end
 
         if i18n_scope
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            # def i18n
-            #   enum_value = @parent.__state
-            #   ::I18n.t(enum_value, scope: "enums.product.state", default: enum_value)
+            # def human_name
+            #   ::I18n.t(self, scope: "enums.product.state", default: self)
             # end
 
-            def i18n
-              enum_value = #{parent_attr}
-              ::I18n.t(enum_value, scope: "enums.#{i18n_scope}", default: enum_value)
+            def human_name
+              ::I18n.t(self, scope: "enums.#{i18n_scope}", default: self)
             end
           RUBY
         end

data/lib/enum_machine/build_class.rb

@@ -1,40 +1,54 @@
 # frozen_string_literal: true
 
 module EnumMachine
-  class BuildClass
-
-    attr_reader :values
-
-    def initialize(values, aliases = {})
-      @values = values
-      @values.each { |v| memo_attr(v, v) }
-      aliases.each { |k, v| memo_attr(k, v) }
-    end
-
-    def i18n_for(name)
-      ::I18n.t(name, scope: "enums.#{i18n_scope}", default: name)
-    end
-
-    def method_missing(name)
-      name_s = name.to_s
-      return super unless name_s.include?('__')
-
-      array_values = name_s.split('__').freeze
-
-      unless (unexists_values = array_values - values).empty?
-        raise EnumMachine::Error, "enums #{unexists_values} not exists"
+  module BuildClass
+
+    def self.call(enum_values:, i18n_scope:, machine: nil)
+      aliases = machine&.instance_variable_get(:@aliases) || {}
+
+      Class.new do
+        define_singleton_method(:machine) { machine } if machine
+        define_singleton_method(:values) { enum_values }
+
+        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.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
-
-      memo_attr(name_s, array_values)
-    end
-
-    def respond_to_missing?(name_s, include_all)
-      name_s.include?('__') || super
-    end
-
-    private def memo_attr(name, value)
-      self.class.attr_reader(name)
-      instance_variable_set("@#{name}", value)
     end
 
   end

data/lib/enum_machine/driver_active_record.rb

@@ -6,53 +6,113 @@ module EnumMachine
     def enum_machine(attr, enum_values, i18n_scope: 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)
       machine.instance_eval(&block) if block
-      aliases = machine.instance_variable_get(:@aliases)
 
-      if machine.transitions?
-        klass.class_variable_set("@@#{attr}_machine", machine)
+      enum_klass = BuildClass.call(enum_values: enum_values, i18n_scope: i18n_scope, machine: machine)
+
+      enum_value_klass = BuildAttribute.call(enum_values: enum_values, i18n_scope: i18n_scope, machine: machine)
+      enum_value_klass.extend(AttributePersistenceMethods[attr, enum_values])
+
+      enum_klass.const_set :VALUE_KLASS, enum_value_klass
 
+      # Hash.new with default_proc for working with custom values not defined in enum list
+      value_attribute_mapping = Hash.new { |hash, enum_value| hash[enum_value] = enum_klass::VALUE_KLASS.new(enum_value).freeze }
+      enum_klass.define_singleton_method(:value_attribute_mapping) { value_attribute_mapping }
+
+      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
+
+      enum_decorator =
+        Module.new do
+          define_singleton_method(:included) do |decorating_klass|
+            decorating_klass.prepend define_methods
+            decorating_klass.const_set enum_const_name, enum_klass
+          end
+        end
+      enum_klass.define_singleton_method(:decorator_module) { enum_decorator }
+
+      klass.include(enum_decorator)
+
+      enum_decorator
     end
 
   end

data/lib/enum_machine/driver_simple_class.rb

@@ -14,35 +14,40 @@ module EnumMachine
           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)
+            if defined?(ActiveRecord) && klass <= ActiveRecord::Base
+              klass.enum_machine(attr, enum_values, i18n_scope: i18n_scope)
+            else
+              enum_const_name = attr.to_s.upcase
+              enum_klass = BuildClass.call(enum_values: enum_values, i18n_scope: i18n_scope)
+
+              enum_value_klass = BuildAttribute.call(enum_values: enum_values, i18n_scope: i18n_scope)
+              enum_klass.const_set :VALUE_KLASS, enum_value_klass
+
+              value_attribute_mapping = enum_values.to_h { |enum_value| [enum_value, enum_klass::VALUE_KLASS.new(enum_value).freeze] }
+
+              define_methods =
+                Module.new do
+                  define_method(attr) do
+                    enum_value = super()
+                    return unless enum_value
+
+                    value_attribute_mapping.fetch(enum_value)
+                  end
+                end
+
+              enum_decorator =
+                Module.new do
+                  define_singleton_method(:included) do |decorating_klass|
+                    decorating_klass.prepend define_methods
+                    decorating_klass.const_set enum_const_name, enum_klass
+                  end
+                end
+              enum_klass.define_singleton_method(:decorator_module) { enum_decorator }
+
+              klass.include(enum_decorator)
+              enum_decorator
+            end
           end
         end
       end

data/lib/enum_machine/machine.rb

@@ -3,10 +3,12 @@
 module EnumMachine
   class Machine
 
-    attr_reader :enum_values
+    attr_reader :enum_values, :base_klass, :enum_const_name
 
-    def initialize(enum_values)
+    def initialize(enum_values, base_klass = nil, enum_const_name = nil) # rubocop:disable Gp/OptArgParameters
       @enum_values = enum_values
+      @base_klass = base_klass
+      @enum_const_name = enum_const_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,9 @@ module EnumMachine
       end
     end
 
+    class AnyEnumValues < Array
+
+    end
+
   end
 end

data/lib/enum_machine/version.rb

@@ -2,6 +2,6 @@
 
 module EnumMachine
 
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 
 end

data/lib/enum_machine.rb

@@ -3,6 +3,7 @@
 require_relative 'enum_machine/version'
 require_relative 'enum_machine/driver_simple_class'
 require_relative 'enum_machine/build_attribute'
+require_relative 'enum_machine/attribute_persistence_methods'
 require_relative 'enum_machine/build_class'
 require_relative 'enum_machine/machine'
 require 'active_support'
@@ -11,6 +12,19 @@ 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 = machine.base_klass.const_get(machine.enum_const_name)
+      super "Transition #{from.inspect} => #{to.inspect} not defined in enum_machine #{enum_const.name}"
+    end
+
+  end
+
   def self.[](args)
     DriverSimpleClass.call(args)
   end

metadata

@@ -1,58 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: enum_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ermolaev Andrey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-19 00:00:00.000000000 Z
+date: 2024-09-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,7 +69,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docs/MIGRATING_FROM_RAILS_STRING_ENUM.ru.md
 - lib/enum_machine.rb
+- lib/enum_machine/attribute_persistence_methods.rb
 - lib/enum_machine/build_attribute.rb
 - lib/enum_machine/build_class.rb
 - lib/enum_machine/driver_active_record.rb
@@ -91,7 +94,7 @@ 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:
   - - ">="
@@ -101,5 +104,5 @@ requirements: []
 rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
-summary: state machine for enums
+summary: fast and siple usage state machine in your app
 test_files: []