has_state_machine 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 902498121bd57b97de373beaa68557c3591de8a221d524af5b9033be1cca8a73
-  data.tar.gz: fb4806d204772d488c4fb2bc69360cd989edf4c8a5312508b37868d961adf059
+  metadata.gz: d311fd40183ff49f406df6216c0a48f910f05bae0d91dc8a77d1456cfbafadd5
+  data.tar.gz: a08e788ca3012cb4a74570d463f0c30344b476732702848184439efaa3a6b79a
 SHA512:
-  metadata.gz: 1baeee9d74f64325427b52e2e867cab05db7848f384316b8175cbb5d49a2c4030dcf905020ac8091c495f6cfa20f8dcae657bcffd78b86987e9c867665f5cf42
-  data.tar.gz: 7e998865b342452f802266b3408bd673b26fb622672ed48ff18cb384259c34a7ec1f591a9ed99efb12f33364e5a1c9bff33d9b95bd4fbac3794ff9d3f2ccdd25
+  metadata.gz: a6cd82cab96a81efd97f3495770baa6542c65f23ae602d00362c27b6517779df747b330460f833eb318e313e23e40318ef32c0fe4c9685a3c587df6912a4e6ab
+  data.tar.gz: 86620a6b8db88cfd2a267c06197269cea8f7320f2cc0cc70829d04e9d00736b276609af2bf0ba93d376d079aa2e6afcd16bb4bad0059f707a1bd63c7edff0856

data/README.md

@@ -1,7 +1,7 @@
 # HasStateMachine
 
 [![CI](https://github.com/beehiiv/has_state_machine/actions/workflows/ci.yml/badge.svg)](https://github.com/beehiiv/has_state_machine/actions/workflows/ci.yml)
-[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
 
 HasStateMachine uses ruby classes to make creating a finite state machine for your ActiveRecord models a breeze.
 
@@ -98,8 +98,10 @@ module Workflow
     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).
+    # committed to the database: after the OUTERMOST database transaction
+    # commits, or immediately after the transition when no transaction is
+    # open. It never runs if the transition or a surrounding transaction
+    # rolls back. (Requires Rails 7.2+; see Advanced Usage below.)
     after_transition_commit do
       MyJob.perform_later(object)
     end
@@ -232,6 +234,20 @@ module Workflow
 end
 ```
 
+#### `after_transition_commit` Semantics
+
+`after_transition_commit` callbacks run after the outermost database transaction commits. In detail:
+
+- If no transaction is open when `transition_to` is called, they run immediately after the transition commits.
+- If the transition happens inside an open transaction — an app-level `ActiveRecord::Base.transaction`, or a nested transition triggered from another state's `before_transition`/`after_transition` — they are deferred until that outermost transaction commits.
+- They never run if the transition fails, if `rollback_transition` is raised, or if a surrounding transaction rolls back after the transition. Multiple transitions inside one transaction each fire their callbacks after commit, in transition order.
+
+This makes `after_transition_commit` the safe place to enqueue background jobs, call external APIs, etc.: the work only happens once the new state is actually visible to other database connections.
+
+**Note on Rails versions:** deferral to an outer transaction requires Rails 7.2+. On older Rails versions the callbacks fire as soon as the transition itself completes, which may be inside an uncommitted outer transaction.
+
+**Footgun: `ActiveRecord.after_all_transactions_commit`** does not work as a substitute inside `before_transition`/`after_transition`. Rails skips non-joinable transactions when deciding whether any transaction is open, and transactional transitions run inside the gem's own non-joinable transaction — so the block yields *immediately*, while the transition is still uncommitted. Use `after_transition_commit` instead.
+
 #### Transient Transition Variables
 
 Sometimes you may may want to pass additional arguments to a state transition for additional context in your transition callbacks. To do this, add the `transients` option to the `state_options` declaration. This allows you to define any additional attributes you want to be able to pass along during a state transition to that state.

data/Rakefile

@@ -17,11 +17,11 @@ namespace :test do
 end
 
 task :test do
-  sh "bin/test"
+  sh "bin/rspec"
 end
 
 task :lint do
-  sh "bin/standardrb --no-fix"
+  sh "bin/rubocop --no-server"
 end
 
 namespace :changelog do

data/lib/has_state_machine/core_ext/string.rb

@@ -10,7 +10,9 @@ class String
   #
   # @example
   #   "some random string".transition_to("draft") #=> false
-  def transition_to(_desired_state)
+  # rubocop:disable Naming/PredicateMethod -- mirrors HasStateMachine::State#transition_to API
+  def transition_to(_desired_state, **_options)
     false
   end
+  # rubocop:enable Naming/PredicateMethod
 end

data/lib/has_state_machine/state.rb

@@ -16,8 +16,8 @@ module HasStateMachine
     define_model_callbacks :transition, only: %i[before after]
 
     ##
-    # Defines the after_transition_commit callback. It runs only after a
-    # transition has committed.
+    # Defines the after_transition_commit callback, which runs once a
+    # successful transition is committed to the database.
     define_model_callbacks :transition_commit, only: %i[after]
 
     ##
@@ -63,7 +63,7 @@ module HasStateMachine
     # @return [Boolean] whether or not the transition took place
     def transition_to(desired_state, **options)
       transitioned = false
-      options = options.transform_keys(&:to_sym)
+      options = options.symbolize_keys
       desired_state_instance = state_instance(desired_state, options)
 
       with_transition_options(options) do
@@ -78,45 +78,66 @@ module HasStateMachine
 
       transitioned
     ensure
-      (desired_state_instance&.errors || []).each do |error|
+      desired_state_instance&.errors&.each do |error|
         object.errors.add(error.attribute, error.type)
       end
     end
 
     ##
     # Makes the actual transition from one state to the next and
-    # 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_commit do
-        run_callbacks :transition do
-          object.update("#{object.state_attribute}": state)
-        end
+    # runs the before and after transition callbacks.
+    #
+    # @return [Boolean] whether or not the transition succeeded
+    def perform_transition! # rubocop:disable Naming/PredicateMethod -- public API
+      transitioned = run_callbacks :transition do
+        object.update("#{object.state_attribute}": state)
       end
+      return false unless transitioned
+
+      @previous_state = previous_state
+      enqueue_transition_commit_callbacks
+      true
     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. The after_transition_commit callbacks run
-    # outside the transaction and only when it commits (not on rollback).
-    def perform_transactional_transition!
-      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
+    # Same as {#perform_transition!}, but wrapped in a transaction so
+    # callbacks can roll the transition back.
+    #
+    # @return [Boolean] whether or not the transition succeeded
+    def perform_transactional_transition! # rubocop:disable Naming/PredicateMethod -- public API
+      ActiveRecord::Base.transaction(requires_new: true, joinable: false) do
+        run_callbacks :transition do
+          rollback_transition unless object.update("#{object.state_attribute}": state)
         end
+      end
 
-        @previous_state = previous_state
+      @previous_state = previous_state
+      return false unless object.reload.public_send(object.state_attribute) == state
 
-        object.reload.public_send(object.state_attribute) == state
-      end
+      enqueue_transition_commit_callbacks
+      true
     end
 
     private
 
+    ##
+    # Runs the after_transition_commit callbacks once the outermost open
+    # transaction commits, discarding them on rollback.
+    #
+    # @note Registers on the connection's current transaction because
+    #   +ActiveRecord.after_all_transactions_commit+ ignores non-joinable
+    #   transactions (like the gem's own) and would fire immediately.
+    # @return [void]
+    def enqueue_transition_commit_callbacks
+      current_transaction = object.class.connection.current_transaction
+
+      # Rails < 7.2 has no Transaction#after_commit, so callbacks fire
+      # immediately with no deferral. Drop this guard at Rails 7.2+.
+      return run_callbacks(:transition_commit) { true } unless current_transaction.respond_to?(:after_commit)
+
+      current_transaction.after_commit { run_callbacks(:transition_commit) { true } }
+    end
+
     def rollback_transition
       raise ActiveRecord::Rollback
     end

data/lib/has_state_machine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HasStateMachine
-  VERSION = "1.1.0"
+  VERSION = "1.2.1"
 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,208 @@
+# 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,
+        model_name_cache: nil)
+        @response_builder = response_builder
+        @node_context = node_context
+        @index = index
+        @rails_client = rails_client
+        @model_name_cache = model_name_cache
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        return unless current_target?(node)
+
+        # Check the node shape first: resolving the model name may require a
+        # round-trip to the Rails runner, so only pay it for `object` calls.
+        if object_call?(node)
+          return unless resolved_model_name
+
+          push_entries(constant_entries(resolved_model_name))
+        elsif object_method_call?(node)
+          return unless resolved_model_name
+
+          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, :model_name_cache, :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
+
+        # Cache hits and misses for the life of the LSP process; the set of
+        # models rarely changes mid-session. Failures raise past the cache
+        # write, so a slow-to-boot Rails runner can succeed on a later request.
+        cache = model_name_cache.to_h
+        cache.fetch(workflow_namespace) do
+          cache[workflow_namespace] = request_model_name(workflow_namespace)
+        end
+      rescue
+        nil
+      end
+
+      def request_model_name(workflow_namespace)
+        result = rails_client.delegate_request(
+          server_addon_name: SERVER_ADDON_NAME,
+          request_name: "model_for_workflow_namespace",
+          workflow_namespace: workflow_namespace
+        )
+
+        response_name(result)
+      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,60 @@
+# 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 = conventional_model_for(workflow_namespace) || models_by_workflow_namespace[workflow_namespace]
+        return unless model
+
+        {name: model.name}
+      end
+
+      ##
+      # Fast path: for the default "Workflow::<Model>" namespace, autoload just
+      # that one constant instead of eager loading the whole application. Only
+      # custom workflow_namespace configurations need the full scan below.
+      def conventional_model_for(workflow_namespace)
+        workflow_namespace = workflow_namespace.to_s
+        return unless workflow_namespace.start_with?("Workflow::")
+
+        model = workflow_namespace.delete_prefix("Workflow::").safe_constantize
+        model if model.try(:workflow_namespace) == workflow_namespace
+      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.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Benjamin Hargett
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
+- !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
@@ -67,7 +81,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: standard
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.74'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.74'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,6 +108,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
@@ -95,19 +137,117 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.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: ruby-lsp-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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:
@@ -128,6 +268,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
@@ -146,7 +290,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Class based state machine for ActiveRecord models.
 test_files: []