light-services 3.0.0 → 3.1.1

data/lib/ruby_lsp/light_services/definition.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module LightServices
+    class Definition
+      # Condition options that reference methods
+      CONDITION_OPTIONS = [:if, :unless].freeze
+
+      def initialize(response_builder, uri, node_context, index, dispatcher)
+        @response_builder = response_builder
+        @uri = uri
+        @node_context = node_context
+        @index = index
+
+        # Register for symbol nodes - this is what gets triggered when user clicks on :method_name
+        dispatcher.register(self, :on_symbol_node_enter)
+      end
+
+      # Called when cursor is on a symbol node (e.g., :validate in `step :validate`)
+      def on_symbol_node_enter(node)
+        # Check if this symbol is part of a step call by examining the call context
+        call_node = find_parent_step_call
+        return unless call_node
+
+        method_name = determine_method_name(node, call_node)
+        return unless method_name
+
+        find_and_append_method_location(method_name)
+      end
+
+      private
+
+      # Find the parent step call node from the node context
+      # The node_context.call_node returns the enclosing call if cursor is on an argument
+      def find_parent_step_call
+        call_node = @node_context.call_node
+        return unless call_node
+        return unless call_node.name == :step
+
+        call_node
+      end
+
+      # Determine which method name to look up based on where the symbol appears
+      # Returns nil if this symbol is not a method reference we should handle
+      def determine_method_name(symbol_node, call_node)
+        symbol_value = symbol_node.value.to_sym
+
+        # Check if this is the first argument (step method name)
+        first_arg = call_node.arguments&.arguments&.first
+        if first_arg.is_a?(Prism::SymbolNode) && first_arg.value.to_sym == symbol_value && same_location?(first_arg,
+                                                                                                          symbol_node)
+          # Verify the symbol node location matches (same node, not just same value)
+          return symbol_value.to_s
+        end
+
+        # Check if this is a condition option (if: or unless:)
+        keyword_hash = find_keyword_hash(call_node)
+        return unless keyword_hash
+
+        CONDITION_OPTIONS.each do |option_name|
+          condition_symbol = find_symbol_option(keyword_hash, option_name)
+          next unless condition_symbol
+          next unless same_location?(condition_symbol, symbol_node)
+
+          return condition_symbol.value.to_s
+        end
+
+        nil
+      end
+
+      # Check if two nodes have the same location (are the same node)
+      def same_location?(node1, node2)
+        node1.location.start_offset == node2.location.start_offset &&
+          node1.location.end_offset == node2.location.end_offset
+      end
+
+      # Find the keyword hash in call arguments
+      def find_keyword_hash(node)
+        node.arguments&.arguments&.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+      end
+
+      # Find a symbol value for a specific option in the keyword hash
+      # Returns the SymbolNode if found and value is a symbol, nil otherwise
+      def find_symbol_option(keyword_hash, option_name)
+        element = keyword_hash.elements.find do |elem|
+          elem.is_a?(Prism::AssocNode) &&
+            elem.key.is_a?(Prism::SymbolNode) &&
+            elem.key.value.to_sym == option_name
+        end
+
+        return unless element
+        return unless element.value.is_a?(Prism::SymbolNode)
+
+        element.value
+      end
+
+      # Find method definition in index and append location to response
+      def find_and_append_method_location(method_name)
+        owner_name = @node_context.nesting.join("::")
+        return if owner_name.empty?
+
+        # Look up method entries in the index
+        method_entries = @index.resolve_method(method_name, owner_name)
+        return unless method_entries&.any?
+
+        method_entries.each { |entry| append_location(entry) }
+
+        true
+      end
+
+      def append_location(entry)
+        @response_builder << Interface::Location.new(
+          uri: URI::Generic.from_path(path: entry.file_path).to_s,
+          range: build_range(entry.location),
+        )
+      end
+
+      def build_range(location)
+        Interface::Range.new(
+          start: Interface::Position.new(
+            line: location.start_line - 1,
+            character: location.start_column,
+          ),
+          end: Interface::Position.new(
+            line: location.end_line - 1,
+            character: location.end_column,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/light_services/indexing_enhancement.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module LightServices
+    class IndexingEnhancement < RubyIndexer::Enhancement # rubocop:disable Metrics/ClassLength
+      # DSL methods that generate getter, predicate, and setter methods
+      FIELD_DSL_METHODS = [:arg, :output].freeze
+
+      # Default type mappings for common dry-types to their underlying Ruby types
+      # These can be extended via Light::Services.config.ruby_lsp_type_mappings
+      DEFAULT_TYPE_MAPPINGS = {
+        "Types::String" => "String",
+        "Types::Strict::String" => "String",
+        "Types::Coercible::String" => "String",
+        "Types::Integer" => "Integer",
+        "Types::Strict::Integer" => "Integer",
+        "Types::Coercible::Integer" => "Integer",
+        "Types::Float" => "Float",
+        "Types::Strict::Float" => "Float",
+        "Types::Coercible::Float" => "Float",
+        "Types::Decimal" => "BigDecimal",
+        "Types::Strict::Decimal" => "BigDecimal",
+        "Types::Coercible::Decimal" => "BigDecimal",
+        "Types::Bool" => "TrueClass | FalseClass",
+        "Types::Strict::Bool" => "TrueClass | FalseClass",
+        "Types::True" => "TrueClass",
+        "Types::Strict::True" => "TrueClass",
+        "Types::False" => "FalseClass",
+        "Types::Strict::False" => "FalseClass",
+        "Types::Array" => "Array",
+        "Types::Strict::Array" => "Array",
+        "Types::Hash" => "Hash",
+        "Types::Strict::Hash" => "Hash",
+        "Types::Symbol" => "Symbol",
+        "Types::Strict::Symbol" => "Symbol",
+        "Types::Coercible::Symbol" => "Symbol",
+        "Types::Date" => "Date",
+        "Types::Strict::Date" => "Date",
+        "Types::DateTime" => "DateTime",
+        "Types::Strict::DateTime" => "DateTime",
+        "Types::Time" => "Time",
+        "Types::Strict::Time" => "Time",
+        "Types::Nil" => "NilClass",
+        "Types::Strict::Nil" => "NilClass",
+        "Types::Any" => "Object",
+      }.freeze
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Public API - Called by Ruby LSP indexer
+      # ─────────────────────────────────────────────────────────────────────────
+
+      # Called when the indexer encounters a method call node
+      # Detects `arg` and `output` DSL calls and registers the generated methods
+      def on_call_node_enter(node)
+        return unless @listener.current_owner
+        return unless FIELD_DSL_METHODS.include?(node.name)
+
+        field_name = extract_field_name(node)
+        return unless field_name
+
+        ruby_type = extract_ruby_type(node)
+        register_field_methods(field_name, node.location, ruby_type)
+      end
+
+      def on_call_node_leave(node); end
+
+      private
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Field Extraction
+      # ─────────────────────────────────────────────────────────────────────────
+
+      # Extract the field name from the first argument (symbol)
+      # Example: `arg :user` → "user"
+      def extract_field_name(node)
+        arguments = node.arguments&.arguments
+        return unless arguments&.any?
+
+        first_arg = arguments.first
+        return unless first_arg.is_a?(Prism::SymbolNode)
+
+        first_arg.value
+      end
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Type Resolution
+      # ─────────────────────────────────────────────────────────────────────────
+
+      # Extract and resolve the Ruby type from the `type:` keyword argument
+      # Returns the mapped Ruby type string or the original type if no mapping exists
+      def extract_ruby_type(node)
+        type_node = find_type_value_node(node)
+        return unless type_node
+
+        resolve_to_ruby_type(type_node)
+      end
+
+      # Find the value node for the `type:` keyword argument
+      def find_type_value_node(node)
+        arguments = node.arguments&.arguments
+        return unless arguments
+
+        keyword_hash = arguments.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return unless keyword_hash
+
+        # NOTE: Prism's SymbolNode#value returns a String, not a Symbol
+        type_element = keyword_hash.elements.find do |element|
+          element.is_a?(Prism::AssocNode) &&
+            element.key.is_a?(Prism::SymbolNode) &&
+            element.key.value == "type"
+        end
+
+        type_element&.value
+      end
+
+      # Resolve a Prism type node to a Ruby type string
+      # Handles constants, constant paths, and method chains
+      def resolve_to_ruby_type(node)
+        type_string = node_to_constant_string(node)
+        return unless type_string
+
+        map_to_ruby_type(type_string) || type_string
+      end
+
+      # Convert a Prism node to its constant string representation
+      def node_to_constant_string(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          build_constant_path(node)
+        when Prism::CallNode
+          # Handle method chains like Types::String.constrained(...) or Types::Array.of(...)
+          extract_receiver_constant(node)
+        end
+      end
+
+      # Build a full constant path string from nested ConstantPathNodes
+      # Example: Types::Strict::String
+      def build_constant_path(node)
+        parts = []
+        current = node
+
+        while current.is_a?(Prism::ConstantPathNode)
+          parts.unshift(current.name.to_s)
+          current = current.parent
+        end
+
+        parts.unshift(current.name.to_s) if current.is_a?(Prism::ConstantReadNode)
+        parts.join("::")
+      end
+
+      # Extract the receiver constant from a method call chain
+      # Example: Types::String.constrained(format: /@/) → "Types::String"
+      def extract_receiver_constant(node)
+        receiver = node.receiver
+        return unless receiver
+
+        case receiver
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          node_to_constant_string(receiver)
+        when Prism::CallNode
+          extract_receiver_constant(receiver)
+        end
+      end
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Type Mapping
+      # ─────────────────────────────────────────────────────────────────────────
+
+      # Map a type string to its corresponding Ruby type
+      # Uses custom mappings from config (if available) merged with defaults
+      def map_to_ruby_type(type_string)
+        mappings = effective_type_mappings
+
+        # Direct mapping lookup (custom mappings take precedence)
+        return mappings[type_string] if mappings.key?(type_string)
+
+        # Handle parameterized types: Types::Array.of(...) → Types::Array
+        base_type = type_string.split(".").first
+        mappings[base_type]
+      end
+
+      # Returns the effective type mappings (defaults + custom from config)
+      # Custom mappings take precedence over defaults
+      def effective_type_mappings
+        return DEFAULT_TYPE_MAPPINGS unless defined?(Light::Services)
+        return DEFAULT_TYPE_MAPPINGS unless Light::Services.respond_to?(:config)
+
+        custom_mappings = Light::Services.config&.ruby_lsp_type_mappings
+        return DEFAULT_TYPE_MAPPINGS if custom_mappings.nil? || custom_mappings.empty?
+
+        DEFAULT_TYPE_MAPPINGS.merge(custom_mappings)
+      rescue NoMethodError
+        DEFAULT_TYPE_MAPPINGS
+      end
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Method Registration
+      # ─────────────────────────────────────────────────────────────────────────
+
+      # Register all three generated methods for a field (getter, predicate, setter)
+      def register_field_methods(field_name, location, ruby_type)
+        register_getter(field_name, location, ruby_type)
+        register_predicate(field_name, location)
+        register_setter(field_name, location, ruby_type)
+      end
+
+      def register_getter(field_name, location, ruby_type)
+        @listener.add_method(
+          field_name.to_s,
+          location,
+          no_params_signature,
+          comments: return_type_comment(ruby_type),
+        )
+      end
+
+      def register_predicate(field_name, location)
+        @listener.add_method(
+          "#{field_name}?",
+          location,
+          no_params_signature,
+          comments: "@return [Boolean]",
+        )
+      end
+
+      def register_setter(field_name, location, ruby_type)
+        @listener.add_method(
+          "#{field_name}=",
+          location,
+          value_param_signature,
+          comments: setter_comment(ruby_type),
+        )
+      end
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Signatures & Comments
+      # ─────────────────────────────────────────────────────────────────────────
+
+      def no_params_signature
+        [RubyIndexer::Entry::Signature.new([])]
+      end
+
+      def value_param_signature
+        [RubyIndexer::Entry::Signature.new([
+          RubyIndexer::Entry::RequiredParameter.new(name: :value),
+        ])]
+      end
+
+      def return_type_comment(ruby_type)
+        return nil unless ruby_type
+
+        "@return [#{ruby_type}]"
+      end
+
+      def setter_comment(ruby_type)
+        return "@param value the value to set" unless ruby_type
+
+        "@param value [#{ruby_type}] the value to set\n@return [#{ruby_type}]"
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: light-services
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Andrew Kodkod
@@ -34,6 +34,8 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docs/README.md
+- docs/SUMMARY.md
 - docs/arguments.md
 - docs/best-practices.md
 - docs/callbacks.md
@@ -46,11 +48,11 @@ files:
 - docs/outputs.md
 - docs/pundit-authorization.md
 - docs/quickstart.md
-- docs/readme.md
 - docs/recipes.md
+- docs/rubocop.md
+- docs/ruby-lsp.md
 - docs/service-rendering.md
 - docs/steps.md
-- docs/summary.md
 - docs/testing.md
 - lib/generators/light_services/install/USAGE
 - lib/generators/light_services/install/install_generator.rb
@@ -86,10 +88,22 @@ files:
 - lib/light/services/rspec/matchers/have_error_on.rb
 - lib/light/services/rspec/matchers/have_warning_on.rb
 - lib/light/services/rspec/matchers/trigger_callback.rb
+- lib/light/services/rubocop.rb
+- lib/light/services/rubocop/cop/light_services/argument_type_required.rb
+- lib/light/services/rubocop/cop/light_services/condition_method_exists.rb
+- lib/light/services/rubocop/cop/light_services/deprecated_methods.rb
+- lib/light/services/rubocop/cop/light_services/dsl_order.rb
+- lib/light/services/rubocop/cop/light_services/missing_private_keyword.rb
+- lib/light/services/rubocop/cop/light_services/no_direct_instantiation.rb
+- lib/light/services/rubocop/cop/light_services/output_type_required.rb
+- lib/light/services/rubocop/cop/light_services/step_method_exists.rb
 - lib/light/services/settings/field.rb
 - lib/light/services/settings/step.rb
 - lib/light/services/utils.rb
 - lib/light/services/version.rb
+- lib/ruby_lsp/light_services/addon.rb
+- lib/ruby_lsp/light_services/definition.rb
+- lib/ruby_lsp/light_services/indexing_enhancement.rb
 - light-services.gemspec
 homepage: https://light-services-docs.vercel.app/
 licenses: