estate 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5e27471f690e289d113e8e69a6c72ad1c063a20b57bdead1f97040b71cb101f
-  data.tar.gz: 233b56c93ade0cc71d91d721bd58f207bc17bc320b9e2165d31ad2a4700786d7
+  metadata.gz: 4b3da0543146b0a82972f87969bc2278b1deb7ab600965370caf143bd8b342d7
+  data.tar.gz: e87a26965c47b976746059431196048fb2b03cb829475e5e1eabf48b80054694
 SHA512:
-  metadata.gz: c1330c6a3512171bdb6deaa89612fa4adf4d6aad6ef621e97aa456c0e792e48f21b1d7cac9ef47fe36a7a8b1806c6148da9b973200e1ff5f27e5434deac43c11
-  data.tar.gz: 1452e5b9408d8cfd658ed983d11f1f8a0300e533400875285af65c84ee7a451edf6f29be6df4f779e991ce47a25fd6e230404b8949d37a15a1353414ef1be521
+  metadata.gz: bd904b3f3dbcf36895fb76c3c76ce05c7cb4af45ab30150fb8d9becd2120c9a7add11ada7051396e3f5cfc7093702221b7f6e77de994e04e347f1018802ce0f3
+  data.tar.gz: c69b6df5691fcc4104c28e9ce5eb23ad294c54002a8ff32c498750074c7c6bded4bbe7cb0707d69f3abd23ab4f47e67b59ca25571784c008e63c41135620e76e

data/README.md

@@ -1,3 +1,5 @@
+![CI](https://github.com/igorkorepanov/estate/actions/workflows/main.yml/badge.svg)
+
 # 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.

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Estate
+  module Constants
+    module Orm
+      ACTIVE_RECORD = 'active_record'
+      SEQUEL = 'sequel'
+    end
+  end
+end

data/lib/estate/estate.rb

@@ -5,38 +5,44 @@ module Estate
     base.extend Estate::ClassMethods
 
     Estate::Requirements.check_requirements(base)
-    Estate::StateMachine.create_store
-    Estate::Core.setup(base)
+    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_name: column, allow_empty_initial_state: empty_initial_state,
-                                        raise_on_error: raise_on_error)
+      Estate::StateMachine.init(name, column, empty_initial_state, raise_on_error)
 
       yield if block_given?
     end
 
-    def state(name)
-      if Estate::StateMachine.state_exists?(name)
-        raise(StandardError, "state `:#{name}` is already defined")
+    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, 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
 
-    def transition(from:, to:)
-      raise(StandardError, "state `#{from}` is not defined") unless Estate::StateMachine.state_exists?(from)
+    def transition(from: nil, to: nil)
+      unless Estate::StateMachine.argument_valid?(from)
+        raise(StandardError, 'argument `from` must be a Symbol or a String')
+      end
+
+      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?(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: from, to: to)
+      if Estate::StateMachine.transition_exists?(name, from, to)
         raise(StandardError, "`transition from: :#{from}, to: :#{to}` already defined")
       end
 
-      Estate::StateMachine.register_transition(from: from, to: to)
+      Estate::StateMachine.register_transition(name, from, to)
     end
   end
 end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Estate
+  module Logic
+    module ActiveRecord
+      module Setup
+        module_function
+
+        def call(base)
+          base.class_eval do
+            public_send(:before_validation) do
+              Estate::Logic::Core.call(Estate::Constants::Orm::ACTIVE_RECORD, self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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 config_for(instance)[:raise_on_error]
+            exception_message = attribute == :base ? message : "#{attribute}: #{message}"
+            raise(StandardError, exception_message)
+          else
+            instance.errors.add(attribute, message) unless instance.errors[attribute].include?(message)
+          end
+        end
+
+        def get_states(instance)
+          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
+    end
+  end
+end

data/lib/estate/logic/common_logic.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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? && !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?(state_machine_name, to_state)
+          add_error(instance, "state `#{to_state}` is not defined")
+        elsif !transition_allowed?(state_machine_name, from_state, to_state)
+          add_error(instance, "transition from `#{from_state}` to `#{to_state}` is not allowed",
+                    attribute: config_for(instance)[:column_name])
+        end
+      end
+
+      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(instance)
+        state_machine_name = instance.class.name
+        Estate::StateMachine.state_machines[state_machine_name][:config]
+      end
+    end
+  end
+end

data/lib/estate/logic/core.rb

@@ -0,0 +1,19 @@
+# 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/logic/sequel/setup.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Estate
+  module Logic
+    module Sequel
+      module Setup
+        module_function
+
+        def call(base)
+          base.class_eval do
+            def validate
+              super
+
+              Estate::Logic::Core.call(Estate::Constants::Orm::SEQUEL, self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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
+        def add_error(instance, message, attribute: :base)
+          instance.errors.add(attribute, message)
+        end
+
+        def get_states(instance)
+          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
+    end
+  end
+end

data/lib/estate/setup.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Estate
+  module Setup
+    module_function
+
+    def call(base)
+      if base.ancestors.map(&:to_s).include? 'ActiveRecord::Base'
+        require File.join(File.dirname(__FILE__), 'logic', 'active_record', 'setup')
+        Estate::Logic::ActiveRecord::Setup.call(base)
+      else
+        require File.join(File.dirname(__FILE__), 'logic', 'sequel', 'setup')
+        Estate::Logic::Sequel::Setup.call(base)
+      end
+    end
+  end
+end

data/lib/estate/state_machine.rb

@@ -3,38 +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)
-        !state.nil? && 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)
-        case state
-        when Symbol
-          states[state] = nil
-        when String
-          states[state.to_sym] = nil
-        else
-          raise(ArgumentError, 'State must be a Symbol or a String')
-        end
+      def register_state(state_machine_name, state_name)
+        state_machines[state_machine_name][:states][state_name.to_sym] = nil
       end
 
-      def transition_exists?(from:, to:)
-        transition_key = { from: from.to_sym, to: to.to_sym }
-        transitions.key?(transition_key)
+      def transition_exists?(state_machine_name, from_state, to_state)
+        transition_key = { from: from_state.to_sym, to: to_state.to_sym }
+        state_machines[state_machine_name][:transitions].key?(transition_key)
       end
 
-      def register_transition(from:, to:)
-        # TODO: validate from and to
-        transition_key = { from: from.to_sym, to: to.to_sym }
-        transitions[transition_key] = nil
+      def register_transition(state_machine_name, from_state, to_state)
+        transition_key = { from: from_state.to_sym, to: to_state.to_sym }
+        state_machines[state_machine_name][:transitions][transition_key] = nil
       end
 
-      attr_reader :states, :transitions
+      def argument_valid?(argument)
+        argument.is_a?(Symbol) || argument.is_a?(String)
+      end
+
+      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.0'
+  VERSION = '0.2.0'
 end

data/lib/estate.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'estate/configuration'
-require 'estate/core'
+require 'estate/constants/orm'
 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.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Igor Korepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-27 00:00:00.000000000 Z
+date: 2024-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -91,11 +91,16 @@ files:
 - README.md
 - lib/estate.rb
 - lib/estate/configuration.rb
-- lib/estate/core.rb
-- lib/estate/db/active_record.rb
-- lib/estate/db/sequel.rb
+- lib/estate/constants/orm.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/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
 homepage: https://github.com/igorkorepanov/estate

data/lib/estate/core.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Estate
-  module Core
-    module_function
-
-    def setup(base)
-      if 'ActiveRecord::Base'.in? base.ancestors.map(&:to_s)
-        require File.join(File.dirname(__FILE__), 'db', 'active_record')
-        Estate::Db::ActiveRecord.setup_callbacks(base)
-      else
-        require File.join(File.dirname(__FILE__), 'db', 'sequel')
-        Estate::Db::Sequel.setup_callbacks(base)
-      end
-    end
-  end
-end

data/lib/estate/db/active_record.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Estate
-  module Db
-    module ActiveRecord
-      module_function
-
-      def setup_callbacks(base)
-        base.class_eval do
-          public_send(:before_validation) do
-            from_state = public_send("#{Estate::Configuration.column_name}_was")
-            to_state = public_send(Estate::Configuration.column_name)
-            Estate::Db::ActiveRecord.validate_state_changes(self, from_state, to_state)
-          end
-        end
-      end
-
-      def validate_state_changes(instance, from_state, to_state)
-        if from_state == to_state
-          if from_state.nil? && !Estate::Configuration.allow_empty_initial_state
-            add_error(instance: instance, message: "empty `#{Estate::Configuration.column_name}` is not allowed")
-          end
-        elsif to_state.nil?
-          add_error(instance: instance, message: 'transition to empty state is not allowed')
-        elsif !Estate::StateMachine.state_exists?(to_state)
-          add_error(instance: instance, message: "state `#{to_state}` is not defined")
-        elsif !transition_allowed?(from_state: from_state, to_state: to_state)
-          add_error(instance: instance, message: "transition from `#{from_state}` to `#{to_state}` is not allowed",
-                    attribute: Estate::Configuration.column_name)
-        end
-      end
-
-      def add_error(instance:, message:, attribute: :base)
-        if Estate::Configuration.raise_on_error
-          exception_message = attribute == :base ? message : "#{attribute}: #{message}"
-          raise(StandardError, exception_message)
-        else
-          instance.errors.add(attribute, message) unless instance.errors[attribute].include?(message)
-        end
-      end
-
-      def transition_allowed?(from_state:, to_state:)
-        from_state.nil? || Estate::StateMachine.transition_exists?(from: from_state, to: to_state)
-      end
-    end
-  end
-end

data/lib/estate/db/sequel.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Estate
-  module Db
-    module Sequel
-      module_function
-
-      def setup_callbacks(base)
-        base.class_eval do
-          def validate
-            super
-
-            to_state = values[Estate::Configuration.column_name]
-            from_state, = column_change(Estate::Configuration.column_name)
-            Estate::Db::Sequel.validate_state_changes(self, from_state, to_state)
-          end
-        end
-      end
-
-      def validate_state_changes(instance, from_state, to_state)
-        if from_state == to_state
-          if from_state.nil? && !Estate::Configuration.allow_empty_initial_state
-            add_error(instance: instance, message: "empty `#{Estate::Configuration.column_name}` is not allowed")
-          end
-        elsif to_state.nil?
-          add_error(instance: instance, message: 'transition to empty state is not allowed')
-        elsif !Estate::StateMachine.state_exists?(to_state)
-          add_error(instance: instance, message: "state `#{to_state}` is not defined")
-        elsif !transition_allowed?(from_state: from_state, to_state: to_state)
-          add_error(instance: instance, message: "transition from `#{from_state}` to `#{to_state}` is not allowed",
-                    attribute: Estate::Configuration.column_name)
-        end
-      end
-
-      # TODO: remove base
-      def add_error(instance:, message:, attribute: :base)
-        instance.errors.add(attribute, message)
-      end
-
-      def transition_allowed?(from_state:, to_state:)
-        from_state.nil? || Estate::StateMachine.transition_exists?(from: from_state, to: to_state)
-      end
-    end
-  end
-end