statesman-multi_state 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: abc46124837badbc6906ffb68ad2dfb368c1a79baadb7d90064527d2c22b5afc
+  data.tar.gz: 0b7c420e4a634798411eae000309d0b7f156db80745e8091aa3525a2d1488ca9
+SHA512:
+  metadata.gz: f25f298ab42306d5cf579b41c3382a11e205e5fe8f7f159fd82c456f7651f3af99d4753b8e3789911f8cb069f32940c2b1230e7701a64bea11f5068af443e4bc
+  data.tar.gz: e3eea7741b07995f8ba036c49036cb405c90563c15df46df8e499eb39805e9b2d61fa904e729e87227cd21383767105e854cbc2c865540d94d9cdd201b74830b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 chaadow
+
+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,42 @@
+# Statesman::MultiState
+![Build](https://github.com/chaadow/statesman-multi_state/actions/workflows/ruby.yml/badge.svg)
+
+Handle multi state for `statesman` through `has_one_state_machine` ActiveRecord macro
+
+## Usage
+
+After you generate your transition classes as well as your state machines, all
+you need to add is this in your model:
+
+```ruby
+class MyActiveRecordModel < ActiveRecord::Base
+  has_one_state_machine :state, state_machine_klass: 'StateMachineKlass', transition_klass: 'MyTransitionKlass'
+end
+```
+
+It also plugs into `ActiveRecord::Reflection` apis, so you can go fancy with
+dynamic form generation
+```ruby
+  MyActiveRecordModel.reflect_on_all_state_machines
+  MyActiveRecordModel.reflect_on_state_machine(:state)
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "statesman-multi_state"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install statesman-multi_state
+```
+
+## 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,5 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'bundler/gem_tasks'

data/lib/statesman/adapters/custom_active_record_queries.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Statesman
+  module Adapters
+    module CustomActiveRecordQueries
+      def self.[](**args)
+        ClassMethods.new(**args)
+      end
+
+      class ClassMethods < Module
+        def initialize(**args)
+          @args = args
+        end
+
+        def included(base)
+          ensure_inheritance(base)
+
+          field_name = @args.delete(:field_name)
+
+          query_builder = ::Statesman::Adapters::ActiveRecordQueries::QueryBuilder.new(base, **@args)
+
+          join_name = :"#{field_name}_most_recent_transition_join"
+
+          base.define_singleton_method(join_name) do
+            query_builder.most_recent_transition_join
+          end
+
+          define_in_state(base, query_builder, join_name, field_name)
+          define_not_in_state(base, query_builder, join_name, field_name)
+        end
+
+        private
+
+        def ensure_inheritance(base)
+          klass = self
+          existing_inherited = base.method(:inherited)
+          base.define_singleton_method(:inherited) do |subclass|
+            existing_inherited.call(subclass)
+            subclass.send(:include, klass)
+          end
+        end
+
+        def define_in_state(base, query_builder, join_name, field_name)
+          base.define_singleton_method(:"#{field_name}_in_state") do |*states|
+            states = states.flatten
+
+            joins(public_send(join_name))
+              .where(query_builder.states_where(states), states)
+          end
+        end
+
+        def define_not_in_state(base, query_builder, join_name, field_name)
+          base.define_singleton_method(:"#{field_name}_not_in_state") do |*states|
+            states = states.flatten
+
+            joins(public_send(join_name))
+              .where.not(query_builder.states_where(states), states)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/statesman/multi_state/active_record_macro.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'statesman/adapters/custom_active_record_queries'
+
+module Statesman
+  module MultiState
+    module ActiveRecordMacro
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def has_one_state_machine(field_name, state_machine_klass:, transition_klass:, transition_name: transition_klass.to_s.underscore.pluralize.to_sym)
+          state_machine_name = "#{field_name}_state_machine"
+          virtual_attribute_name = "#{field_name}_state_form"
+
+          # To handle STI, this needs to be done to get the base klass
+          base_klass = caller_locations.first.label.split(':').last[...-1]
+
+          has_many transition_name, class_name: transition_klass.to_s, autosave: false, dependent: :destroy
+
+          include Statesman::Adapters::CustomActiveRecordQueries[
+            transition_class: transition_klass.constantize,
+            initial_state: state_machine_klass.constantize.send(:initial_state),
+            transition_name: transition_name,
+            most_recent_transition_alias: "#{field_name}_alias",
+            field_name: field_name
+          ]
+
+          attribute virtual_attribute_name
+
+          %w[current_state in_state? transition_to transition_to! can_transition_to? history last_transition
+             last_transition_to].each do |meth|
+            delegate meth, to: state_machine_name, prefix: field_name
+          end
+
+          generated_association_methods.class_eval <<~CODE, __FILE__, __LINE__ + 1
+
+            def #{state_machine_name}
+              key = "@#{state_machine_name}"
+              return instance_variable_get(key) if instance_variable_defined?(key)
+
+              instance_variable_set(key, #{state_machine_klass}.new(
+                self,
+                transition_class: #{transition_klass},
+                association_name: "#{transition_name}"
+              ))
+            end
+
+            def #{virtual_attribute_name}
+              super() || #{field_name}_current_state
+            end
+
+            def #{field_name}_current_state_human
+              Hash[self.class.#{field_name}_human_wrapper]
+                .invert[#{field_name}_current_state]
+            end
+          CODE
+
+          include(const_set("#{field_name}#{SecureRandom.hex(4)}_mod".classify, Module.new).tap do |mod|
+            mod.module_eval do
+              extend ActiveSupport::Concern
+
+              class_methods do
+                define_method :"#{field_name}_human_wrapper" do
+                  key = "@#{field_name}_human_wrapper"
+                  return instance_variable_get(key) if instance_variable_defined?(key)
+
+                  instance_variable_set(key, state_machine_klass.constantize.send(:states).map do |s|
+                                               [I18n.t(s, scope: "statesman.#{field_name}_#{base_klass.underscore}"), s]
+                                             end)
+                end
+              end
+
+              class_eval <<~METHOD, __FILE__, __LINE__ + 1
+                def save_with_state(**options)
+                  @registered_callbacks ||= []
+                  if #{virtual_attribute_name}_changed? && #{field_name}_can_transition_to?(#{virtual_attribute_name})
+                    @registered_callbacks << -> { #{field_name}_transition_to(#{virtual_attribute_name}, **options) }
+                  end
+
+                  if defined?(super)
+                    super
+                  else
+                    save
+                    @registered_callbacks.each(&:call)
+                    @registered_callbacks = []
+                  end
+                end
+              METHOD
+            end
+          end)
+
+          reflection = ActiveRecord::Reflection.create(
+            :has_one_state_machine,
+            field_name,
+            nil,
+            { state_machine_klass: state_machine_klass, transition_klass: transition_klass,
+              transition_name: transition_name },
+            self
+          )
+
+          yield reflection if block_given?
+
+          ActiveRecord::Reflection.add_state_machine_reflection(self, field_name, reflection)
+        end
+      end
+    end
+  end
+end

data/lib/statesman/multi_state/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Statesman
+  module MultiState
+    class Railtie < ::Rails::Railtie
+      initializer 'statesman.multi_state.init' do
+        require 'statesman/multi_state/reflection'
+        require 'statesman/multi_state/active_record_macro'
+
+        ActiveSupport.on_load(:active_record) do
+          include Statesman::MultiState::ActiveRecordMacro
+          include Statesman::MultiState::Reflection::ActiveRecordExtensions
+
+          ActiveRecord::Reflection.singleton_class.prepend(Statesman::MultiState::Reflection::ReflectionExtension)
+        end
+      end
+    end
+  end
+end

data/lib/statesman/multi_state/reflection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Statesman
+  module MultiState
+    module Reflection
+      # Holds all the metadata about a  state_machine as it was
+      # specified in the Active Record class.
+      class HasOneStateMachineReflection < ::ActiveRecord::Reflection::MacroReflection # :nodoc:
+        def macro
+          :has_one_state_machine
+        end
+      end
+
+      module ReflectionExtension
+        def add_state_machine_reflection(model, name, reflection)
+          model.state_machine_reflections = model.state_machine_reflections.merge(name.to_s => reflection)
+        end
+
+        private
+
+        def reflection_class_for(macro)
+          case macro
+          when :has_one_state_machine
+            HasOneStateMachineReflection
+          else
+            super
+          end
+        end
+      end
+
+      module ActiveRecordExtensions
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :state_machine_reflections, instance_writer: false, default: {}
+        end
+
+        class_methods do
+          # Returns an array of reflection objects for all the state
+          # machines in the class.
+          def reflect_on_all_state_machines
+            state_machine_reflections.values
+          end
+
+          # Returns the reflection object for the named +state_machine+.
+          #
+          #    User.reflect_on_state_machine(:status)
+          #    # => the status reflection
+          #
+          def reflect_on_state_machine(state_machine)
+            state_machine_reflections[state_machine.to_s]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/statesman/multi_state/version.rb

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

data/lib/statesman/multi_state.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'statesman/multi_state/version'
+require 'statesman/multi_state/railtie'
+
+module Statesman
+  module MultiState
+    # Your code goes here...
+  end
+end

data/lib/tasks/statesman/multi_state_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :statesman_multi_state do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: statesman-multi_state
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chedli Bourguiba
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: statesman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 9.0.0
+description: Handle multi state for statesman through `has_one_state_machine` ActiveRecord
+  macro
+email:
+- bourguiba.chedli@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/statesman/adapters/custom_active_record_queries.rb
+- lib/statesman/multi_state.rb
+- lib/statesman/multi_state/active_record_macro.rb
+- lib/statesman/multi_state/railtie.rb
+- lib/statesman/multi_state/reflection.rb
+- lib/statesman/multi_state/version.rb
+- lib/tasks/statesman/multi_state_tasks.rake
+homepage: https://github.com/chaadow/statesman-multi_state
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/chaadow/statesman-multi_state
+  source_code_uri: https://github.com/chaadow/statesman-multi_state
+  changelog_uri: https://github.com/chaadow/statesman-multi_state/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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: Handle multi state for statesman through has_one_state_machine
+test_files: []