enum_machine 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3e8eb3957fd71860a322260031d255c8034c53a0d263bd43d68911bcf97507f
+  data.tar.gz: 05306e2ad610425b729a1716ee854614e697acc4dbd0cf6a9d85a476dd1f5209
+SHA512:
+  metadata.gz: ea4de98d78c4cb4d0a67655f6c6bcce58f3168696e43b311a5e23873caf49fa4624745de266c852ab34f5edc892c5a7d4459803e772669522d6cf04fa63dff28
+  data.tar.gz: 9233aa651cd9efb8ed0c2cbb16172da70d99fb1b919ba0d4a9146b6c8c312ec85d0d12fc183af82bb3b90f0cdfb4af78c55305f3f53b78a73cd546bb41ac0b7a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,18 @@
+inherit_gem:
+  rubocop-gp:
+    - ./config/default.yml
+
+AllCops:
+  TargetRubyVersion: 2.6
+
+Rails/ApplicationRecord:
+  Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Style/Next:
+  Enabled: false
+
+Style/ClassVars:
+ Enabled: false

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'dry-types'
+gem 'priscilla', github: 'corp-gp/priscilla'
+gem 'pry', '~> 0.12'
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.9'
+gem 'rubocop-gp', github: 'corp-gp/rubocop-gp'
+gem 'sqlite3', '~> 1.4'

data/Gemfile.lock

@@ -0,0 +1,134 @@
+GIT
+  remote: https://github.com/corp-gp/priscilla.git
+  revision: 46ba7460df8209dfe80e344beed07dfe56648aaf
+  specs:
+    priscilla (1.0.3)
+      colorize (~> 0.7)
+      rumoji (~> 0.3)
+
+GIT
+  remote: https://github.com/corp-gp/rubocop-gp.git
+  revision: 4d390b6cdd2b27f151fe0535bd266525fbf8f25d
+  specs:
+    rubocop-gp (0.0.2)
+      rubocop
+      rubocop-performance
+      rubocop-rails
+      rubocop-rspec
+
+PATH
+  remote: .
+  specs:
+    enum_machine (0.1.0)
+      activemodel (~> 6.0)
+      activerecord (~> 6.0)
+      activesupport (~> 6.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.4.6)
+      activesupport (= 6.1.4.6)
+    activerecord (6.1.4.6)
+      activemodel (= 6.1.4.6)
+      activesupport (= 6.1.4.6)
+    activesupport (6.1.4.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    coderay (1.1.3)
+    colorize (0.8.1)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.5.0)
+    dry-configurable (0.14.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.6)
+    dry-container (0.9.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.13, >= 0.13.0)
+    dry-core (0.7.1)
+      concurrent-ruby (~> 1.0)
+    dry-inflector (0.2.1)
+    dry-logic (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-types (1.5.1)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 1.0, >= 1.0.2)
+    i18n (1.9.1)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    parallel (1.21.0)
+    parser (3.1.0.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rack (2.2.3)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.2.1)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.25.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.15.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.1)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.13.2)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.13.2)
+      activesupport (>= 4.2.0)
+      rack (>= 1.1)
+      rubocop (>= 1.7.0, < 2.0)
+    rubocop-rspec (2.8.0)
+      rubocop (~> 1.19)
+    ruby-progressbar (1.11.0)
+    rumoji (0.5.0)
+    sqlite3 (1.4.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    zeitwerk (2.5.4)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  dry-types
+  enum_machine!
+  priscilla!
+  pry (~> 0.12)
+  rake (~> 13.0)
+  rspec (~> 3.9)
+  rubocop-gp!
+  sqlite3 (~> 1.4)
+
+BUNDLED WITH
+   2.2.29

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Ermolaev Andrey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# EnumMachine
+
+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.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'enum_machine'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install enum_machine
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+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.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/enum_machine.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "enum_machine"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/enum_machine/build_attribute.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+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
+
+        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
+            '<enum_machine :#{attr}>'
+          end
+
+          def ==(other)
+            raise EnumMachine::Error, "use `#{attr}.\#{other}?` instead `#{attr} == '\#{other}'`"
+          end
+        RUBY
+
+        enum_values.each do |enum_value|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def active?
+            #   @parent.__state == 'active'
+            # end
+            #
+            # def in?(values)
+            #   values.include?(@parent.__state)
+            # end
+
+            def #{enum_value}?
+              #{parent_attr} == '#{enum_value}'
+            end
+
+            def in?(values)
+              values.include?(#{parent_attr})
+            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')
+              # end
+
+              def can_#{enum_value}?
+                machine.possible_transitions(#{parent_attr}).include?('#{enum_value}')
+              end
+
+              def to_#{enum_value}!
+                @parent.update!('#{attr}' => '#{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|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def forming?
+            #   @parent.class::State.forming.include?('active')
+            # end
+
+            def #{key}?
+              @parent.class::State.#{key}.include?(#{parent_attr})
+            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)
+            # end
+
+            def i18n
+              enum_value = #{parent_attr}
+              ::I18n.t(enum_value, scope: "enums.#{i18n_scope}", default: enum_value)
+            end
+          RUBY
+        end
+      end
+    end
+
+  end
+end

data/lib/enum_machine/build_class.rb

@@ -0,0 +1,41 @@
+# 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"
+      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
+end

data/lib/enum_machine/driver_active_record.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  module DriverActiveRecord
+
+    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)
+      machine.instance_eval(&block) if block
+      aliases = machine.instance_variable_get(:@aliases)
+
+      if machine.transitions?
+        klass.class_variable_set("@@#{attr}_machine", machine)
+
+        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) }
+            end
+          end
+          after_save do
+            unless (attr_changes = previous_changes['#{attr}']).blank?
+              @@#{attr}_machine.fetch_after_transitions(attr_changes).each { |i| i.call(self) }
+            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
+        # def state
+        #   @state_enum ||= @@state_attribute.new(self)
+        # end
+
+        def #{attr}
+          @#{attr}_enum ||= @@#{attr}_attribute.new(self)
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/enum_machine/driver_simple_class.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  module DriverSimpleClass
+
+    # include EnumMachine[
+    #   state: { enum: %w[choice in_delivery], i18n_scope: 'line_item.state' },
+    #   color: { enum: %w[red green yellow] },
+    #   type:  { enum: %w[CartType BookmarkType] },
+    # ]
+    def self.call(args)
+      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)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/enum_machine/machine.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  class Machine
+
+    attr_reader :enum_values
+
+    def initialize(enum_values)
+      @enum_values = enum_values
+      @transitions = {}
+      @before_transition = {}
+      @after_transition = {}
+      @aliases = {}
+    end
+
+    # public api
+    # transitions('s1' => 's2', %w[s3 s3] => 's4')
+    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|
+          @transitions[from] ||= []
+          @transitions[from] << to
+        end
+      end
+    end
+
+    # public api
+    # before_transition('s1' => 's4')
+    # before_transition(%w[s1 s2] => %w[s3 s4])
+    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)
+        @before_transition[from_pair_to] ||= []
+        @before_transition[from_pair_to] << block
+      end
+    end
+
+    # public api
+    # after_transition('s1' => 's4')
+    # after_transition(%w[s1 s2] => %w[s3 s4])
+    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)
+        @after_transition[from_pair_to] ||= []
+        @after_transition[from_pair_to] << block
+      end
+    end
+
+    # public api
+    def all
+      enum_values
+    end
+
+    def aliases(hash)
+      @aliases = hash
+    end
+
+    def transitions?
+      @transitions.present?
+    end
+
+    # internal api
+    def fetch_before_transitions(from__to)
+      valid_transition!(from__to)
+      @before_transition.fetch(from__to, [])
+    end
+
+    # internal api
+    def fetch_after_transitions(from__to)
+      @after_transition.fetch(from__to, [])
+    end
+
+    # internal api
+    def possible_transitions(from)
+      @transitions.fetch(from, [])
+    end
+
+    private def validate_state!(object_with_values)
+      unless (undefined = object_with_values.to_a.flatten - enum_values - [nil]).empty?
+        raise EnumMachine::Error, "values #{undefined} not defined in enum_machine"
+      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"
+      end
+    end
+
+    private def array_wrap(value)
+      if value.nil?
+        [nil]
+      else
+        Array(value)
+      end
+    end
+
+  end
+end

data/lib/enum_machine/version.rb

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

data/lib/enum_machine.rb

@@ -0,0 +1,23 @@
+# 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'
+
+module EnumMachine
+
+  class Error < StandardError; 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)
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: enum_machine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ermolaev Andrey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-02-19 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: state machine for enums
+email:
+- andruhafirst@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/enum_machine.rb
+- lib/enum_machine/build_attribute.rb
+- lib/enum_machine/build_class.rb
+- lib/enum_machine/driver_active_record.rb
+- lib/enum_machine/driver_simple_class.rb
+- lib/enum_machine/machine.rb
+- lib/enum_machine/version.rb
+homepage: https://github.com/corp-gp/enum_machine
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: state machine for enums
+test_files: []