has_state_machine 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 902498121bd57b97de373beaa68557c3591de8a221d524af5b9033be1cca8a73
-  data.tar.gz: fb4806d204772d488c4fb2bc69360cd989edf4c8a5312508b37868d961adf059
+  metadata.gz: 4d16c6b958f2e470af9f3120259e802badad7fcd6b8a4ea1d004c84f64e8d09d
+  data.tar.gz: 2f9933db38477a1b1020303ab9848aa122fe7e699d153315b830144ffdbfd1a6
 SHA512:
-  metadata.gz: 1baeee9d74f64325427b52e2e867cab05db7848f384316b8175cbb5d49a2c4030dcf905020ac8091c495f6cfa20f8dcae657bcffd78b86987e9c867665f5cf42
-  data.tar.gz: 7e998865b342452f802266b3408bd673b26fb622672ed48ff18cb384259c34a7ec1f591a9ed99efb12f33364e5a1c9bff33d9b95bd4fbac3794ff9d3f2ccdd25
+  metadata.gz: 35f89aad901be7f976ee42573449c0d7412a633285e41f869f50d7be3215da2752470cf5c4b1299d483605f90b8925f5baa5065729b06f2121678518beeafdb4
+  data.tar.gz: cb4e1a772fa2aa9828adfd3ab6bb548e5f489f403f4574cc464e9fa77f4633b886de5c486e4bb9b014eeb71c8ede380fab19320f8b85023e9643b38b3b9866c8

data/lib/has_state_machine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HasStateMachine
-  VERSION = "1.1.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.1.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
@@ -108,6 +142,90 @@ dependencies:
     - - "~>"
       - !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:
@@ -128,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