estate 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f445ae55c16632d7805cd1774f2800eed57ebf16ce63db5ef7e780225ecc52a1
-  data.tar.gz: 60527e77ed67584c663bde4504a104c1b9b38e179fdd299e5344bef2031d6bb9
+  metadata.gz: a5e27471f690e289d113e8e69a6c72ad1c063a20b57bdead1f97040b71cb101f
+  data.tar.gz: 233b56c93ade0cc71d91d721bd58f207bc17bc320b9e2165d31ad2a4700786d7
 SHA512:
-  metadata.gz: e27a18f1f5a82b3b2316d559eb7847f400f15b025fad62dc3d1ced8106856d2c8c60014a86af2837e81f03cf6956175af7f2ab0dabf08d0b0d4fb6b7dac37495
-  data.tar.gz: a2f52b92fff0482abbc7981ab5685d59b5430e171f37c568f68f8ab72d1ed57d851886b0bbf631c472ee34ced52699203571c1ffd420ee636d94cfa00daf1984
+  metadata.gz: c1330c6a3512171bdb6deaa89612fa4adf4d6aad6ef621e97aa456c0e792e48f21b1d7cac9ef47fe36a7a8b1806c6148da9b973200e1ff5f27e5434deac43c11
+  data.tar.gz: 1452e5b9408d8cfd658ed983d11f1f8a0300e533400875285af65c84ee7a451edf6f29be6df4f779e991ce47a25fd6e230404b8949d37a15a1353414ef1be521

data/README.md

@@ -1,6 +1,6 @@
 # Estate Gem
 
-Estate is a Ruby gem designed to simplify state management in ActiveRecord models. The primary focus of this gem is to provide a straightforward way to define states and transitions using a clean syntax, allowing seamless integration into ActiveRecord models.
+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.
 
 ## Installation
 
@@ -17,8 +17,8 @@ gem install estate
 ```
 
 ## Usage
-
-To use the Estate gem, include it in your ActiveRecord model and define your states and transitions inside a block using the `estate` method. Here's a simple example:
+### ActiveRecord
+To use the Estate gem with ActiveRecord, include it in your model and define your states and transitions inside a block using the `estate` method. Here's a simple example:
 
 ```ruby
 class MyModel < ApplicationRecord
@@ -36,13 +36,59 @@ class MyModel < ApplicationRecord
 end
 ```
 
-The default field for storing the state is named state. You can customize this field by providing options to the estate method:
+And then
+
+```ruby
+model = MyModel.create(state: :state_1)
+model.update(state: :state_2) # you don't need to call any extra code to change the state; treat it like a normal field
+```
+
+The default field for storing the state is named "state". You can customize this name by providing options to the estate method:
 
 ```ruby
 class MyModel < ApplicationRecord
   include Estate
 
-  estate(column: :custom_state_field, empty_initial_state: true) do
+  estate column: :custom_state_field do
+    # ...
+  end
+end
+```
+
+You can also use the `empty_initial_state: true` option to enable the creation of a model with a `nil` initial state:
+
+```ruby
+class MyModel < ApplicationRecord
+  include Estate
+
+  estate empty_initial_state: true do
+    # ...
+  end
+end
+```
+
+The `estate` method now supports a `raise_on_error` option. When set to `true`, the gem will raise a specific exception instead of the standard ActiveRecord validation error upon a validation failure.
+
+```ruby
+class MyModel < ApplicationRecord
+  include Estate
+
+  estate raise_on_error: true do
+    # ...
+  end
+end
+```
+
+### Sequel
+To use the Estate gem with Sequel, include it in your model, and ensure you have the `plugin: dirty` enabled for validation to work correctly. The `raise_on_error` option is not needed with Sequel, as exceptions are always raised on validation errors.
+
+```ruby
+class MySequelModel < Sequel::Model
+  include Estate
+
+  plugin :dirty # Ensure the dirty plugin is enabled for validation to work
+
+  estate do
     state :state_1
     state :state_2
     state :state_3
@@ -54,7 +100,7 @@ class MyModel < ApplicationRecord
 end
 ```
 
-## Migration Example
+## Migration Example for ActiveRecord
 
 ```bash
 bundle exec rails generate migration AddStateToMyModels state:string

data/lib/estate/configuration.rb

@@ -3,17 +3,19 @@
 module Estate
   module Configuration
     class << self
-      def init_config(column_name:, allow_empty_initial_state:)
+      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
+      attr_reader :column_name, :allow_empty_initial_state, :raise_on_error
     end
 
     module Defaults
       COLUMN_NAME = :state
       ALLOW_EMPTY_INITIAL_STATE = false
+      RAISE_ON_ERROR = false
     end
   end
 end

data/lib/estate/core.rb

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

data/lib/estate/estate.rb

@@ -5,16 +5,16 @@ module Estate
     base.extend Estate::ClassMethods
 
     Estate::Requirements.check_requirements(base)
-    Estate::ActiveRecord.setup_callbacks(base)
     Estate::StateMachine.create_store
-
-    super
+    Estate::Core.setup(base)
   end
 
   module ClassMethods
     def estate(column: Estate::Configuration::Defaults::COLUMN_NAME,
-               empty_initial_state: Estate::Configuration::Defaults::ALLOW_EMPTY_INITIAL_STATE)
-      Estate::Configuration.init_config(column_name: column, allow_empty_initial_state: empty_initial_state)
+               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)
 
       yield if block_given?
     end

data/lib/estate/requirements.rb

@@ -5,7 +5,9 @@ module Estate
     def check_requirements(base)
       ancestors = base.ancestors.map(&:to_s)
 
-      raise(StandardError, 'Estate requires ActiveRecord') unless ancestors.include?('ActiveRecord::Base')
+      unless 'Sequel::Model'.in?(ancestors) || 'ActiveRecord::Base'.in?(ancestors)
+        raise(StandardError, 'Estate requires ActiveRecord or Sequel')
+      end
     end
 
     module_function :check_requirements

data/lib/estate/state_machine.rb

@@ -24,7 +24,6 @@ module Estate
       end
 
       def transition_exists?(from:, to:)
-        # TODO: validate from and to
         transition_key = { from: from.to_sym, to: to.to_sym }
         transitions.key?(transition_key)
       end

data/lib/estate/version.rb

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

data/lib/estate.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'estate/version'
-require 'estate/requirements'
 require 'estate/configuration'
-require 'estate/state_machine'
-require 'estate/active_record'
+require 'estate/core'
 require 'estate/estate'
+require 'estate/requirements'
+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.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Igor Korepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-22 00:00:00.000000000 Z
+date: 2024-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -66,6 +66,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 3.12.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !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
@@ -76,8 +90,10 @@ files:
 - LICENSE.txt
 - README.md
 - lib/estate.rb
-- lib/estate/active_record.rb
 - lib/estate/configuration.rb
+- lib/estate/core.rb
+- lib/estate/db/active_record.rb
+- lib/estate/db/sequel.rb
 - lib/estate/estate.rb
 - lib/estate/requirements.rb
 - lib/estate/state_machine.rb

data/lib/estate/active_record.rb

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