estate 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0777265b6deae44f96eb4fbc8f150bb73b1f2d98849107b9750eeb0ac025ca49
-  data.tar.gz: 916c2a835c05ed793d87e25883cb6999ebf87687c260f39eba90e994cf0aa228
+  metadata.gz: 71bb34f3ba838cee7a69c1c149e10fa539f074d887503dc97e02818a05c8712b
+  data.tar.gz: 97e67199bd544a360a0b7da92a6321144d1bfce380d15463c929c540713ffcce
 SHA512:
-  metadata.gz: 37e595f2f4451386df31a2b563af980037c90f91786760c9c88f9090418ffd3b640473bc5c2d16a1826c3646302d2041b151a0807d106e1dbc6c85dc126bbfbd
-  data.tar.gz: f939381283ace662a7d97169cc7e0bf26ad8d05a78eb40585f456e84768bda4474c1ae0501d5f7d232eb401d577341d2ce09f4fa3b02137adca8019e87c65114
+  metadata.gz: a1efa655c9bf89e4a19bd4b5840e816ad048418c509b267e569e0040f793ab2bfad11b817d7d97b19ee8cf777455da1e040cfb5e0be8abdf36900d10301a093d
+  data.tar.gz: 93f161f47890608d3a2ec5a92195524c6fe884a1d3a140557908f0c76402f2effcf9b5b687347b0eec07d414eca7dc2a85bf3ec87e291f6d6fccdf2573dbdcfd

data/README.md

@@ -2,7 +2,7 @@
 
 # Estate Gem
 
-Estate is a Ruby gem designed to simplify state management in both ActiveRecord and Sequel models. The primary focus of this gem is to provide a straightforward way to define states and transitions using a clean syntax.
+Estate is a Ruby gem designed to simplify state management in models, including ActiveRecord, Sequel, as well as plain Ruby objects. The primary focus of this gem is to provide a straightforward way to define states and transitions using a clean syntax.
 
 ## Installation
 

data/lib/estate/configuration.rb

@@ -2,16 +2,6 @@
 
 module Estate
   module Configuration
-    class << self
-      def init_config(column_name, allow_empty_initial_state, raise_on_error)
-        @column_name = column_name
-        @allow_empty_initial_state = allow_empty_initial_state
-        @raise_on_error = raise_on_error
-      end
-
-      attr_reader :column_name, :allow_empty_initial_state, :raise_on_error
-    end
-
     module Defaults
       COLUMN_NAME = :state
       ALLOW_EMPTY_INITIAL_STATE = false

data/lib/estate/constants/{orm.rb → adapters.rb}

@@ -2,9 +2,10 @@
 
 module Estate
   module Constants
-    module Orm
+    module Adapters
       ACTIVE_RECORD = 'active_record'
       SEQUEL = 'sequel'
+      PLAIN_RUBY_OBJECT = 'plain_ruby_object'
     end
   end
 end

data/lib/estate/estate.rb

@@ -3,28 +3,25 @@
 module Estate
   def self.included(base)
     base.extend Estate::ClassMethods
-
-    Estate::Requirements.check_requirements(base)
-    Estate::StateMachine.create_store
-    Estate::Setup.call(base)
   end
 
   module ClassMethods
     def estate(column: Estate::Configuration::Defaults::COLUMN_NAME,
                empty_initial_state: Estate::Configuration::Defaults::ALLOW_EMPTY_INITIAL_STATE,
                raise_on_error: Estate::Configuration::Defaults::RAISE_ON_ERROR)
-      Estate::Configuration.init_config(column, empty_initial_state, raise_on_error)
+      Estate::StateMachine.init(name, column, empty_initial_state, raise_on_error)
+      Estate::Setup.call(self)
 
       yield if block_given?
     end
 
-    def state(name = nil)
-      raise(StandardError, 'state must be a Symbol or a String') unless Estate::StateMachine.argument_valid?(name)
+    def state(state_name = nil)
+      raise(StandardError, 'state must be a Symbol or a String') unless Estate::StateMachine.argument_valid?(state_name)
 
-      if Estate::StateMachine.state_exists?(name)
-        raise(StandardError, "state `:#{name}` is already defined")
+      if Estate::StateMachine.state_exists?(name, state_name)
+        raise(StandardError, "state `:#{state_name}` is already defined")
       else
-        Estate::StateMachine.register_state(name)
+        Estate::StateMachine.register_state(name, state_name)
       end
     end
 
@@ -35,15 +32,15 @@ module Estate
 
       raise(StandardError, 'argument `to` must be a Symbol or a String') unless Estate::StateMachine.argument_valid?(to)
 
-      raise(StandardError, "state `#{from}` is not defined") unless Estate::StateMachine.state_exists?(from)
+      raise(StandardError, "state `#{from}` is not defined") unless Estate::StateMachine.state_exists?(name, from)
 
-      raise(StandardError, "state `#{to}` is not defined") unless Estate::StateMachine.state_exists?(to)
+      raise(StandardError, "state `#{to}` is not defined") unless Estate::StateMachine.state_exists?(name, to)
 
-      if Estate::StateMachine.transition_exists?(from, to)
+      if Estate::StateMachine.transition_exists?(name, from, to)
         raise(StandardError, "`transition from: :#{from}, to: :#{to}` already defined")
       end
 
-      Estate::StateMachine.register_transition(from, to)
+      Estate::StateMachine.register_transition(name, from, to)
     end
   end
 end

data/lib/estate/logic/active_record/setup.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'estate/logic/common_logic'
+require 'estate/logic/active_record/specific_logic'
+
 module Estate
   module Logic
     module ActiveRecord
@@ -9,7 +12,9 @@ module Estate
         def call(base)
           base.class_eval do
             public_send(:before_validation) do
-              Estate::Logic::Core.call(Estate::Constants::Orm::ACTIVE_RECORD, self)
+              extend Estate::Logic::CommonLogic
+              extend Estate::Logic::ActiveRecord::SpecificLogic
+              validate_state_changes(self, *get_states(self))
             end
           end
         end

data/lib/estate/logic/active_record/specific_logic.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-require 'estate/logic/common_logic'
-
 module Estate
   module Logic
     module ActiveRecord
       module SpecificLogic
-        extend Estate::Logic::CommonLogic
-
         module_function
 
         def add_error(instance, message, attribute: :base)
-          if Estate::Configuration.raise_on_error
+          if config_for(instance)[:raise_on_error]
             exception_message = attribute == :base ? message : "#{attribute}: #{message}"
             raise(StandardError, exception_message)
           else
@@ -20,8 +16,8 @@ module Estate
         end
 
         def get_states(instance)
-          from_state = instance.public_send("#{Estate::Configuration.column_name}_was")
-          to_state = instance.public_send(Estate::Configuration.column_name)
+          from_state = instance.public_send("#{config_for(instance)[:column_name]}_was")
+          to_state = instance.public_send(config_for(instance)[:column_name])
           [from_state, to_state]
         end
       end

data/lib/estate/logic/common_logic.rb

@@ -4,22 +4,29 @@ module Estate
   module Logic
     module CommonLogic
       def validate_state_changes(instance, from_state, to_state)
+        state_machine_name = instance.class.name
+
         if from_state == to_state
-          if from_state.nil? && !Estate::Configuration.allow_empty_initial_state
-            add_error(instance, "empty `#{Estate::Configuration.column_name}` is not allowed")
+          if from_state.nil? && !config_for(instance)[:empty_initial_state]
+            add_error(instance, "empty `#{config_for(instance)[:column_name]}` is not allowed")
           end
         elsif to_state.nil?
           add_error(instance, 'transition to empty state is not allowed')
-        elsif !Estate::StateMachine.state_exists?(to_state)
+        elsif !Estate::StateMachine.state_exists?(state_machine_name, to_state)
           add_error(instance, "state `#{to_state}` is not defined")
-        elsif !transition_allowed?(from_state, to_state)
+        elsif !transition_allowed?(state_machine_name, from_state, to_state)
           add_error(instance, "transition from `#{from_state}` to `#{to_state}` is not allowed",
-                    attribute: Estate::Configuration.column_name)
+                    attribute: config_for(instance)[:column_name])
         end
       end
 
-      def transition_allowed?(from_state, to_state)
-        from_state.nil? || Estate::StateMachine.transition_exists?(from_state, to_state)
+      def transition_allowed?(state_machine_name, from_state, to_state)
+        from_state.nil? || Estate::StateMachine.transition_exists?(state_machine_name, from_state, to_state)
+      end
+
+      def config_for(klass)
+        state_machine_name = klass.is_a?(Class) ? klass.name : klass.class.name
+        Estate::StateMachine.state_machines[state_machine_name][:config]
       end
     end
   end

data/lib/estate/logic/plain_ruby_object/setup.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'estate/logic/common_logic'
+require 'estate/logic/plain_ruby_object/specific_logic'
+
+module Estate
+  module Logic
+    module PlainRubyObject
+      module Setup
+        module_function
+
+        def call(base)
+          base.prepend(Module.new do
+            extend Estate::Logic::CommonLogic
+
+            define_method("#{config_for(base)[:column_name]}=") do |new_value|
+              extend Estate::Logic::CommonLogic
+              extend Estate::Logic::PlainRubyObject::SpecificLogic
+
+              validate_state_changes(self, state, new_value)
+
+              super(new_value)
+            end
+          end)
+        end
+      end
+    end
+  end
+end

data/lib/estate/logic/plain_ruby_object/specific_logic.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Estate
+  module Logic
+    module PlainRubyObject
+      module SpecificLogic
+        module_function
+
+        def add_error(_, message, attribute: :base)
+          exception_message = attribute == :base ? message : "#{attribute}: #{message}"
+          raise(StandardError, exception_message)
+        end
+      end
+    end
+  end
+end

data/lib/estate/logic/sequel/setup.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'estate/logic/common_logic'
+require 'estate/logic/sequel/specific_logic'
+
 module Estate
   module Logic
     module Sequel
@@ -11,7 +14,9 @@ module Estate
             def validate
               super
 
-              Estate::Logic::Core.call(Estate::Constants::Orm::SEQUEL, self)
+              extend Estate::Logic::CommonLogic
+              extend Estate::Logic::Sequel::SpecificLogic
+              validate_state_changes(self, *get_states(self))
             end
           end
         end

data/lib/estate/logic/sequel/specific_logic.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-require 'estate/logic/common_logic'
-
 module Estate
   module Logic
     module Sequel
       module SpecificLogic
-        extend Estate::Logic::CommonLogic
-
         module_function
 
         # TODO: remove :base
@@ -16,8 +12,8 @@ module Estate
         end
 
         def get_states(instance)
-          from_state, = instance.column_change(Estate::Configuration.column_name)
-          to_state = instance.values[Estate::Configuration.column_name]
+          from_state, = instance.column_change(config_for(instance)[:column_name])
+          to_state = instance.values[config_for(instance)[:column_name]]
           [from_state, to_state]
         end
       end

data/lib/estate/setup.rb

@@ -5,12 +5,16 @@ module Estate
     module_function
 
     def call(base)
-      if base.ancestors.map(&:to_s).include? 'ActiveRecord::Base'
+      ancestors = base.ancestors.map(&:to_s)
+      if ancestors.include? 'ActiveRecord::Base'
         require File.join(File.dirname(__FILE__), 'logic', 'active_record', 'setup')
         Estate::Logic::ActiveRecord::Setup.call(base)
-      else
+      elsif ancestors.include? 'Sequel::Model'
         require File.join(File.dirname(__FILE__), 'logic', 'sequel', 'setup')
         Estate::Logic::Sequel::Setup.call(base)
+      else
+        require File.join(File.dirname(__FILE__), 'logic', 'plain_ruby_object', 'setup')
+        Estate::Logic::PlainRubyObject::Setup.call(base)
       end
     end
   end

data/lib/estate/state_machine.rb

@@ -3,34 +3,42 @@
 module Estate
   class StateMachine
     class << self
-      def create_store
-        @states = {}
-        @transitions = {}
+      def init(state_machine_name, column_name, empty_initial_state, raise_on_error)
+        @state_machines ||= {}
+        @state_machines[state_machine_name] = {
+          config: {
+            column_name: column_name,
+            empty_initial_state: empty_initial_state, # TODO: allow_empty_initial_state ?
+            raise_on_error: raise_on_error
+          },
+          states: {},
+          transitions: {}
+        }
       end
 
-      def state_exists?(state)
-        states.key?(state.to_sym)
+      def state_exists?(state_machine_name, state_name)
+        state_machines[state_machine_name][:states].key?(state_name.to_sym)
       end
 
-      def register_state(state)
-        states[state.to_sym] = nil
+      def register_state(state_machine_name, state_name)
+        state_machines[state_machine_name][:states][state_name.to_sym] = nil
       end
 
-      def transition_exists?(from_state, to_state)
+      def transition_exists?(state_machine_name, from_state, to_state)
         transition_key = { from: from_state.to_sym, to: to_state.to_sym }
-        transitions.key?(transition_key)
+        state_machines[state_machine_name][:transitions].key?(transition_key)
       end
 
-      def register_transition(from_state, to_state)
+      def register_transition(state_machine_name, from_state, to_state)
         transition_key = { from: from_state.to_sym, to: to_state.to_sym }
-        transitions[transition_key] = nil
+        state_machines[state_machine_name][:transitions][transition_key] = nil
       end
 
       def argument_valid?(argument)
         argument.is_a?(Symbol) || argument.is_a?(String)
       end
 
-      attr_reader :states, :transitions
+      attr_reader :state_machines
     end
   end
 end

data/lib/estate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Estate
-  VERSION = '0.1.1'
+  VERSION = '1.0.0'
 end

data/lib/estate.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 require 'estate/configuration'
-require 'estate/constants/orm'
+require 'estate/constants/adapters'
 require 'estate/estate'
-require 'estate/logic/core'
-require 'estate/requirements'
 require 'estate/setup'
 require 'estate/state_machine'
 require 'estate/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: estate
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Igor Korepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-29 00:00:00.000000000 Z
+date: 2024-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -80,9 +80,9 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.22.0
-description: Estate is a Ruby gem designed to simplify state management in ActiveRecord
-  models
-email: noemail@example.com
+description: Estate is a Ruby gem designed to simplify state management in models,
+  as well as plain Ruby objects
+email: korepanovigor87@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -91,15 +91,15 @@ files:
 - README.md
 - lib/estate.rb
 - lib/estate/configuration.rb
-- lib/estate/constants/orm.rb
+- lib/estate/constants/adapters.rb
 - lib/estate/estate.rb
 - lib/estate/logic/active_record/setup.rb
 - lib/estate/logic/active_record/specific_logic.rb
 - lib/estate/logic/common_logic.rb
-- lib/estate/logic/core.rb
+- lib/estate/logic/plain_ruby_object/setup.rb
+- lib/estate/logic/plain_ruby_object/specific_logic.rb
 - lib/estate/logic/sequel/setup.rb
 - lib/estate/logic/sequel/specific_logic.rb
-- lib/estate/requirements.rb
 - lib/estate/setup.rb
 - lib/estate/state_machine.rb
 - lib/estate/version.rb
@@ -125,5 +125,5 @@ requirements: []
 rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
-summary: State machine for Rails models
+summary: State machine for Rails models and plain Ruby objects
 test_files: []

data/lib/estate/logic/core.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Estate
-  module Logic
-    module Core
-      module_function
-
-      def call(orm, instance)
-        require 'estate/logic/common_logic'
-        require File.join(File.dirname(__FILE__), orm, 'specific_logic')
-
-        extend Estate::Logic::CommonLogic
-        extend "Estate::Logic::#{orm.classify}::SpecificLogic".safe_constantize
-
-        validate_state_changes(instance, *get_states(instance))
-      end
-    end
-  end
-end

data/lib/estate/requirements.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Estate
-  module Requirements
-    def check_requirements(base)
-      ancestors = base.ancestors.map(&:to_s)
-
-      unless 'Sequel::Model'.in?(ancestors) || 'ActiveRecord::Base'.in?(ancestors)
-        raise(StandardError, 'Estate requires ActiveRecord or Sequel')
-      end
-    end
-
-    module_function :check_requirements
-  end
-end