has_state_machine 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aad95d7b489183fa7a7c49af178871cb5cc169dbc3a9ae6bd4a93f7ce48ebea
-  data.tar.gz: 180dbc281d868326a908955013b17fcc935e54de43dbb367212f017e642b994d
+  metadata.gz: 4d16c6b958f2e470af9f3120259e802badad7fcd6b8a4ea1d004c84f64e8d09d
+  data.tar.gz: 2f9933db38477a1b1020303ab9848aa122fe7e699d153315b830144ffdbfd1a6
 SHA512:
-  metadata.gz: 1eca09471018292e2cc4f41a6a53ec2cf12bc087de32af80595901099a4b589131b529bbf53891de89eacc86c5a9a3c16ca7102f31faec63443003c697c45a7e
-  data.tar.gz: 1b5a1e0a93e9f0648deac92b4fcba653ffeec037e9b3959092e71b5f9b391c93118e352ced5e7c1f44f385ceed1130ab62f1fde11dc4282ea2fb17097e66d47a
+  metadata.gz: 35f89aad901be7f976ee42573449c0d7412a633285e41f869f50d7be3215da2752470cf5c4b1299d483605f90b8925f5baa5065729b06f2121678518beeafdb4
+  data.tar.gz: cb4e1a772fa2aa9828adfd3ab6bb548e5f489f403f4574cc464e9fa77f4633b886de5c486e4bb9b014eeb71c8ede380fab19320f8b85023e9643b38b3b9866c8

data/README.md

@@ -96,6 +96,13 @@ module Workflow
       # after_transition callbacks as well.
       Rails.logger.info "== Transitioned from #{previous_state} ==\n"
     end
+
+    # after_transition_commit runs only once the transition has been
+    # committed: after the record is saved for normal transitions, and
+    # outside the transaction for transactional transitions (see below).
+    after_transition_commit do
+      MyJob.perform_later(object)
+    end
   end
 end
 ```
@@ -206,10 +213,20 @@ module Workflow
       rollback_transition unless notified_watchers?
     end
 
+    after_transition_commit do
+      enqueue_external_work
+    end
+
     private
 
+    def enqueue_external_work
+      # Any work you want to happen only after the transition is committed.
+      # Enqueuing a job, calling an external API, sending a webhook, etc.
+    end
+
     def notified_watchers?
-      #...
+      # Any dependent work that you want to run that should play a part in determining
+      # whether the transition was successful or not and needs to be rolled back.
     end
   end
 end

data/lib/has_state_machine/state.rb

@@ -15,6 +15,11 @@ module HasStateMachine
     # for use on a HasStateMachine::State instance.
     define_model_callbacks :transition, only: %i[before after]
 
+    ##
+    # Defines the after_transition_commit callback. It runs only after a
+    # transition has committed.
+    define_model_callbacks :transition_commit, only: %i[after]
+
     ##
     # possible_transitions - Retrieves the next available transitions for a given state.
     # transactional? - Determines whether or not the transition should happen with a transactional block.
@@ -80,25 +85,34 @@ module HasStateMachine
 
     ##
     # Makes the actual transition from one state to the next and
-    # runs the before and after transition callbacks.
+    # runs the before and after transition callbacks. The
+    # after_transition_commit callbacks run after the update completes
+    # and only when it succeeds.
     def perform_transition!
-      run_callbacks :transition do
-        object.update("#{object.state_attribute}": state)
+      run_callbacks :transition_commit do
+        run_callbacks :transition do
+          object.update("#{object.state_attribute}": state)
+        end
       end
     end
 
     ##
     # Makes the actual transition from one state to the next and
     # runs the before and after transition callbacks in a transaction
-    # to allow for roll backs.
+    # to allow for roll backs. The after_transition_commit callbacks run
+    # outside the transaction and only when it commits (not on rollback).
     def perform_transactional_transition!
-      ActiveRecord::Base.transaction(requires_new: true, joinable: false) do
-        run_callbacks :transition do
-          rollback_transition unless object.update("#{object.state_attribute}": state)
+      run_callbacks :transition_commit do
+        ActiveRecord::Base.transaction(requires_new: true, joinable: false) do
+          run_callbacks :transition do
+            rollback_transition unless object.update("#{object.state_attribute}": state)
+          end
         end
-      end
 
-      object.reload.public_send(object.state_attribute) == state
+        @previous_state = previous_state
+
+        object.reload.public_send(object.state_attribute) == state
+      end
     end
 
     private
@@ -112,7 +126,7 @@ module HasStateMachine
     # it has been transitioned to the new state. Useful in
     # after_transition blocks
     def previous_state
-      object.previous_changes[object.state_attribute]&.first
+      @previous_state.presence || object.previous_changes[object.state_attribute]&.first
     end
 
     def state_instance(desired_state, transient_values)

data/lib/has_state_machine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HasStateMachine
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/lib/ruby_lsp/has_state_machine/addon.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+
+require "has_state_machine/version"
+require_relative "definition"
+
+::RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.18.0", "< 1.0") if ::RubyLsp::Addon.respond_to?(:depend_on_ruby_lsp!)
+
+module RubyLsp
+  module HasStateMachine
+    class Addon < ::RubyLsp::Addon
+      def activate(global_state, outgoing_queue)
+        @global_state = global_state
+        @rails_client = register_rails_server_addon(outgoing_queue)
+      end
+
+      def deactivate
+        @global_state = nil
+        @rails_client = nil
+      end
+
+      def name
+        "Has State Machine"
+      end
+
+      def version
+        ::HasStateMachine::VERSION
+      end
+
+      def create_definition_listener(response_builder, uri, node_context, dispatcher)
+        Definition.new(
+          response_builder,
+          uri,
+          node_context,
+          dispatcher,
+          index: @global_state&.index,
+          rails_client: @rails_client
+        )
+      end
+
+      private
+
+      def register_rails_server_addon(outgoing_queue)
+        register_rails_runner_client
+      rescue => error
+        handle_rails_registration_error(outgoing_queue, error)
+      end
+
+      def register_rails_runner_client
+        rails_addon = ::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0") if ::RubyLsp::Addon.respond_to?(:get)
+        return unless rails_addon&.respond_to?(:rails_runner_client)
+
+        client = rails_addon.rails_runner_client
+        return unless client.respond_to?(:register_server_addon)
+
+        client.register_server_addon(File.expand_path("rails_server_addon.rb", __dir__))
+        client
+      end
+
+      def handle_rails_registration_error(outgoing_queue, error)
+        unless addon_not_found?(error)
+          log(outgoing_queue, "Has State Machine Ruby LSP Rails integration unavailable: #{error.message}")
+        end
+
+        nil
+      end
+
+      def addon_not_found?(error)
+        if defined?(::RubyLsp::Addon::AddonNotFoundError)
+          return true if error.is_a?(::RubyLsp::Addon::AddonNotFoundError)
+        end
+
+        error.class.name&.end_with?("AddonNotFoundError")
+      end
+
+      def log(outgoing_queue, message)
+        return if outgoing_queue.nil? || outgoing_queue.closed?
+        return unless defined?(::RubyLsp::Notification)
+
+        outgoing_queue << ::RubyLsp::Notification.window_log_message(message)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/has_state_machine/definition.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "workflow_resolver"
+
+module RubyLsp
+  module HasStateMachine
+    class Definition
+      SERVER_ADDON_NAME = "has_state_machine"
+
+      def initialize(response_builder, _uri, node_context, dispatcher, index: nil, rails_client: nil)
+        @response_builder = response_builder
+        @node_context = node_context
+        @index = index
+        @rails_client = rails_client
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        return unless current_target?(node)
+        return unless resolved_model_name
+
+        if object_call?(node)
+          push_entries(constant_entries(resolved_model_name))
+        elsif object_method_call?(node)
+          method_name = message(node)
+          entries = method_entries(resolved_model_name, method_name)
+          entries = association_entries(resolved_model_name, method_name) if entries.empty?
+
+          push_entries(entries)
+        end
+      end
+
+      private
+
+      attr_reader :index, :node_context, :rails_client, :response_builder
+
+      def current_target?(node)
+        target = node_context.node if node_context.respond_to?(:node)
+        call_node = node_context.call_node if node_context.respond_to?(:call_node)
+
+        node.equal?(target) || node.equal?(call_node)
+      end
+
+      def resolved_model_name
+        return @resolved_model_name if defined?(@resolved_model_name)
+        return @resolved_model_name = nil unless current_class_name
+
+        @resolved_model_name = model_name_from_rails(workflow_namespace) || convention_model_name
+      end
+
+      def convention_model_name
+        return @convention_model_name if defined?(@convention_model_name)
+
+        @convention_model_name = current_class_name && WorkflowResolver.model_name_for(current_class_name)
+      end
+
+      def workflow_namespace
+        return @workflow_namespace if defined?(@workflow_namespace)
+
+        @workflow_namespace = current_class_name && WorkflowResolver.workflow_namespace_for(current_class_name)
+      end
+
+      def current_class_name
+        return @current_class_name if defined?(@current_class_name)
+        return @current_class_name = nil unless node_context.respond_to?(:nesting)
+
+        @current_class_name = class_name_from_nesting(node_context.nesting)
+      end
+
+      def class_name_from_nesting(nesting)
+        parts = nesting.map(&:to_s).reject(&:empty?)
+        return if parts.empty?
+
+        # Nesting entries may already contain "::" (e.g. "Post::Draft").
+        parts.join("::").gsub(/:{3,}/, "::")
+      end
+
+      def model_name_from_rails(workflow_namespace)
+        return unless workflow_namespace && rails_client
+
+        result = rails_client.delegate_request(
+          server_addon_name: SERVER_ADDON_NAME,
+          request_name: "model_for_workflow_namespace",
+          workflow_namespace: workflow_namespace
+        )
+
+        response_name(result)
+      rescue
+        nil
+      end
+
+      def association_entries(model_name, association_name)
+        association_model_name = association_model_name(model_name, association_name)
+        return [] unless association_model_name
+
+        constant_entries(association_model_name)
+      end
+
+      def association_model_name(model_name, association_name)
+        return unless rails_client&.respond_to?(:association_target)
+
+        result = rails_client.association_target(model_name: model_name, association_name: association_name)
+        response_name(result)
+      rescue
+        nil
+      end
+
+      def response_name(result)
+        return unless result
+
+        result[:name] || result["name"]
+      end
+
+      def constant_entries(name)
+        return [] unless name && index
+
+        Array(index[name])
+      end
+
+      def method_entries(model_name, method_name)
+        return [] unless index && method_name
+
+        if index.respond_to?(:resolve_method)
+          entries = index.resolve_method(method_name, model_name)
+          return Array(entries)
+        end
+
+        Array(index[method_name]).select { |entry| entry_owner_name(entry) == model_name }
+      end
+
+      def entry_owner_name(entry)
+        owner = entry.owner if entry.respond_to?(:owner)
+        owner.name if owner.respond_to?(:name)
+      end
+
+      def push_entries(entries)
+        entries.each do |entry|
+          response_builder << location_for(entry)
+        end
+      end
+
+      def location_for(entry)
+        return entry unless defined?(::RubyLsp::Interface::Location)
+
+        location = entry_location(entry)
+        return entry unless location
+
+        ::RubyLsp::Interface::Location.new(
+          uri: entry.uri.to_s,
+          range: range_for(location)
+        )
+      end
+
+      def entry_location(entry)
+        return entry.location if entry.respond_to?(:location)
+        entry.name_location if entry.respond_to?(:name_location)
+      end
+
+      def range_for(location)
+        ::RubyLsp::Interface::Range.new(
+          start: ::RubyLsp::Interface::Position.new(
+            line: location.start_line - 1,
+            character: location.start_column
+          ),
+          end: ::RubyLsp::Interface::Position.new(
+            line: location.end_line - 1,
+            character: location.end_column
+          )
+        )
+      end
+
+      def object_method_call?(node)
+        message(node) && object_call?(receiver(node))
+      end
+
+      def object_call?(node)
+        node && receiver(node).nil? && message(node) == "object"
+      end
+
+      def receiver(node)
+        node.receiver if node.respond_to?(:receiver)
+      end
+
+      def message(node)
+        node.message.to_s if node.respond_to?(:message) && node.message
+      end
+    end
+  end
+end

data/lib/ruby_lsp/has_state_machine/rails_server_addon.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/ruby_lsp_rails/server"
+
+module RubyLsp
+  module HasStateMachine
+    class RailsServerAddon < ::RubyLsp::Rails::ServerAddon
+      def name
+        "has_state_machine"
+      end
+
+      def execute(request, params)
+        with_request_error_handling(request) do
+          case request
+          when "model_for_workflow_namespace"
+            send_result(model_for_workflow_namespace(params.fetch("workflow_namespace")))
+          else
+            raise NotImplementedError, "Unknown request: #{request}"
+          end
+        end
+      end
+
+      private
+
+      def model_for_workflow_namespace(workflow_namespace)
+        model = models_by_workflow_namespace[workflow_namespace]
+        return unless model
+
+        {name: model.name}
+      end
+
+      def models_by_workflow_namespace
+        @models_by_workflow_namespace ||= active_record_models.each_with_object({}) do |model, index|
+          next unless model.respond_to?(:workflow_namespace)
+
+          index[model.workflow_namespace] = model
+        end
+      end
+
+      def active_record_models
+        @active_record_models ||= begin
+          ::Rails.application&.eager_load!
+          ::ActiveRecord::Base.descendants.reject(&:abstract_class?)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/has_state_machine/workflow_resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module HasStateMachine
+    module WorkflowResolver
+      WORKFLOW_PREFIX = "Workflow::"
+
+      module_function
+
+      def model_name_for(workflow_class_name)
+        namespace = workflow_namespace_for(workflow_class_name)
+        return unless namespace&.start_with?(WORKFLOW_PREFIX)
+
+        name = namespace.delete_prefix(WORKFLOW_PREFIX)
+        return if name.empty?
+
+        name
+      end
+
+      def workflow_namespace_for(workflow_class_name)
+        namespace = workflow_class_name.to_s.delete_prefix("::").sub(/::[^:]+\z/, "")
+        return if namespace.empty?
+
+        namespace
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has_state_machine
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Benjamin Hargett
@@ -31,6 +31,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -38,6 +41,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.19'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +128,104 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.17
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.17
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: drb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: HasStateMachine uses ruby classes to make creating a finite state machine
   in your ActiveRecord models a breeze.
 email:
@@ -114,6 +246,10 @@ files:
 - lib/has_state_machine/state.rb
 - lib/has_state_machine/state_helpers.rb
 - lib/has_state_machine/version.rb
+- lib/ruby_lsp/has_state_machine/addon.rb
+- lib/ruby_lsp/has_state_machine/definition.rb
+- lib/ruby_lsp/has_state_machine/rails_server_addon.rb
+- lib/ruby_lsp/has_state_machine/workflow_resolver.rb
 homepage: https://www.github.com/encampment/has_state_machine
 licenses:
 - MIT