solargraph 0.59.2 → 0.60.0

data/lib/solargraph/yard_map/directives/method_directive.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module MethodDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, comment_position, directive
+          namespace = closure_at(pins, source_position) || pins.first
+
+          namespace = closure_at(pins, comment_position) if namespace.location&.range&.start&.line&.< comment_position.line # rubocop:disable Style/SafeNavigationChainLength
+          begin
+            src = Solargraph::Source.load_string("def #{directive.tag.name};end", source.filename)
+            region = Parser::Region.new(source: src, closure: namespace)
+            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
+            gen_pin = method_gen_pins.last
+            return [] if gen_pin.nil?
+            # Move the location to the end of the line so it gets recognized
+            # as originating from a comment
+            shifted = Solargraph::Position.new(comment_position.line,
+                                               source.code.lines[comment_position.line].to_s.chomp.length)
+            comments = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring.all.to_s
+            # @todo: Smelly instance variable access
+            gen_pin.instance_variable_set(:@comments, comments)
+            gen_pin.instance_variable_set(:@location,
+                                          Solargraph::Location.new(source.filename, Range.new(shifted, shifted)))
+            gen_pin.instance_variable_set(:@explicit, false)
+            [gen_pin]
+          rescue Parser::SyntaxError
+            # @todo Handle error in directive
+            []
+          end
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/override_directive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module OverrideDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param _pins [Array<Solargraph::Pin::Base>]
+        # @param _source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Pin::Base>]
+        def process_directive source, _pins, _source_position, comment_position, directive
+          docstring = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring
+          location = Location.new(source.filename, Range.new(comment_position, comment_position))
+          [Pin::Reference::Override.new(location, directive.tag.name.to_s, docstring.tags, source: :yard_map)]
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/parse_directive.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module ParseDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Base>]
+        def process_directive source, pins, source_position, comment_position, directive
+          ns = closure_at(pins, source_position)
+          pins_copy = pins.dup
+          src = Solargraph::Source.load_string(directive.tag.text.to_s, source.filename)
+          region = Parser::Region.new(source: src, closure: ns)
+          # @todo These pins may need to be marked not explicit
+          old_pins_index = pins.length
+          loff = if source.code.lines[comment_position.line].strip.end_with?('@!parse')
+                   comment_position.line + 1
+                 else
+                   comment_position.line
+                 end
+          Parser.process_node(src.node, region, pins_copy)
+          new_pins = pins_copy[old_pins_index..] || []
+          new_pins.each do |p|
+            # @todo Smelly instance variable access
+            next if p.location.nil?
+            # @sg-ignore Unresolved call to range on Solargraph::Location, nil - does not account for next clause above.
+            p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
+            # @sg-ignore Unresolved call to range on Solargraph::Location, nil
+            p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
+          end
+
+          new_pins
+        rescue Parser::SyntaxError
+          # @todo Handle parser errors in !parse directives
+          []
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/visibility_directive.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module VisibilityDirective
+        module_function
+
+        VALID_VISIBILITIES = %i[public protected private].freeze
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Base>]
+        def process_directive source, pins, source_position, comment_position, directive
+          kind = directive.tag.text&.to_sym
+
+          # @sg-ignore include? only expects Symbol, but receives Symbol or nil
+          return [] unless VALID_VISIBILITIES.include?(kind.to_sym)
+
+          name = directive.tag.name
+          closure = closure_at(pins, source_position) || pins.first
+          closure = closure_at(pins, comment_position) if closure.location&.range&.start&.line&.< comment_position.line # rubocop:disable Style/SafeNavigationChainLength
+          if closure.is_a?(Pin::Method) && no_empty_lines?(source.code, comment_position.line, source_position.line)
+            # @todo Smelly instance variable access
+            closure.instance_variable_set(:@visibility, kind)
+          else
+            namespace = closure_at(pins, source_position)
+            matches = pins.select do |pin|
+              if pin.is_a?(Pin::Method) &&
+                 pin.name == name &&
+                 pin.namespace == namespace &&
+                 pin.context.scope == namespace.is_a?(Pin::Singleton)
+                :class
+              else
+                :instance
+              end
+            end
+
+            matches.each do |pin|
+              # @todo Smelly instance variable access
+              pin.instance_variable_set(:@visibility, kind)
+            end
+          end
+
+          []
+        end
+
+        # @param [String] code
+        # @param [Integer] line1
+        # @param [Integer] line2
+        # @return [Boolean]
+        # @sg-ignore return type could not be inferred
+        def no_empty_lines? code, line1, line2
+          # @sg-ignore unresolved call none? on the array.
+          code.lines[line1..line2].none? { |line| line.strip.empty? }
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      autoload :AttributeDirective, 'solargraph/yard_map/directives/attribute_directive'
+      autoload :MethodDirective, 'solargraph/yard_map/directives/method_directive'
+      autoload :DomainDirective, 'solargraph/yard_map/directives/domain_directive'
+      autoload :OverrideDirective, 'solargraph/yard_map/directives/override_directive'
+      autoload :ParseDirective, 'solargraph/yard_map/directives/parse_directive'
+      autoload :VisibilityDirective, 'solargraph/yard_map/directives/visibility_directive'
+
+      # @param directive [YARD::Tags::Directive]
+      # @return [Class<AttributeDirective>, Class<MethodDirective>, Class<DomainDirective>, Class<OverrideDirective>, Class<ParseDirective>, Class<VisibilityDirective>, nil]
+      def self.for directive
+        case directive.tag.tag_name
+        when 'attribute'
+          AttributeDirective
+        when 'method'
+          MethodDirective
+        when 'domain'
+          DomainDirective
+        when 'override'
+          OverrideDirective
+        when 'parse'
+          ParseDirective
+        when 'visibility'
+          VisibilityDirective
+        else # rubocop:disable Style/EmptyElse
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/macro.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Macro
+      PROCESSABLE_DIRECTIVES = %w[method attribute parse].freeze
+
+      class << self
+        # @param directive [YARD::Tags::Directive]
+        # @param method_pin [Pin::Method]
+        # @return [Macro]
+        def from_directive directive, method_pin
+          macro_name = directive.tag.name.empty? ? method_pin.path.downcase : directive.tag.name
+          method_object = method_object_from_pin(method_pin)
+          code = directive.tag.text.to_s.gsub(/\n(?!@!|\s)/, "\n  ")
+          macro_object = YARD::CodeObjects::MacroObject.create(macro_name.to_s, code, method_object)
+          new(macro_object, method_pin, directive)
+        end
+
+        private
+
+        # @param method_pin [Pin::Method]
+        # @return [YARD::CodeObjects::MethodObject]
+        def method_object_from_pin method_pin
+          namespace_object = nil
+          method_pin.each_closure do |namespace_pin|
+            next if namespace_pin.name.empty?
+
+            namespace_object = YARD::CodeObjects::NamespaceObject.new(
+              namespace_object,
+              namespace_pin.name.to_sym
+            )
+          end
+          # @sg-ignore Wrong argument type for YARD::CodeObjects::MethodObject.new: namespace
+          # expected YARD::CodeObjects::NamespaceObject, got nil.
+          #   False positive because namespace_object is set in the loop above.
+          YARD::CodeObjects::MethodObject.new(namespace_object, method_pin.name)
+        end
+      end
+
+      # @return [YARD::Tags::MacroDirective]
+      attr_reader :directive
+      # @return [YARD::CodeObjects::MacroObject]
+      attr_reader :macro_object
+
+      # @param macro_object [YARD::CodeObjects::MacroObject]
+      # @param method_pin [Pin::Method]
+      # @param directive [YARD::Tags::Directive]
+      def initialize macro_object, method_pin, directive
+        @macro_object = macro_object
+        @method_pin = method_pin
+        @directive = directive
+      end
+
+      # @return [String]
+      def name
+        @directive.tag.name.to_s
+      end
+
+      # @return [String]
+      def text
+        @directive.tag.text.to_s
+      end
+
+      # @return [YARD::Tags::Tag]
+      def tag
+        @directive.tag
+      end
+
+      # @param chain [Source::Chain]
+      # @param pin [Pin::Closure]
+      # @param source_map [SourceMap]
+      # @return [Array<Pin::Base>]
+      def generate_pins_from chain, pin, source_map
+        call_location = Solargraph::Location.from_node(chain.node)
+        # @param generated_pins [Array<Pin::Base>]
+        generate_yardoc_from(chain, source_map).reduce([]) do |generated_pins, directive|
+          directive_processor = YardMap::Directives.for(directive)
+          next generated_pins unless directive_processor && call_location
+          generated_pins + directive_processor.process_directive(
+            source_map.source, source_map.pins, call_location.range.start, call_location.range.start, directive
+          )
+        end
+      end
+
+      private
+
+      # @param chain [Solargraph::Source::Chain]
+      # @param [SourceMap] source_map
+      # @return [Array<YARD::Tags::Directive>]
+      def generate_yardoc_from chain, source_map
+        name = chain.links.last.word
+        # @sg-ignore chain.links.last is assumed to be a Chain::Call
+        values = chain.links.last.arguments.map(&:node).map { |arg| Solargraph::Parser::ParserGem::NodeMethods.simple_convert(arg).to_s }
+        # @sg-ignore chain.node is assumed to exist
+        code = source_map.source.code_for(chain.node)
+        expanded_comment = macro_object.expand([name, *values], code)
+                                       .gsub(/\n(?!@!|\s)/, "\n  ")
+        directives = Solargraph::Source.parse_docstring(expanded_comment).directives.select do |directive|
+          PROCESSABLE_DIRECTIVES.include?(directive.tag.tag_name)
+        end
+        directives.each do |directive|
+          # @sg-ignore chain.node is assumed to exist
+          comments = source_map.source.comments_for(chain.node)
+          if comments&.length&.positive? && directive.tag.tag_name != 'parse'
+            directive.tag.text += "\n#{comments}"
+          end
+        end
+        directives
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper.rb

@@ -11,6 +11,7 @@ module Solargraph
       # @param spec [Gem::Specification, nil]
       def initialize code_objects, spec = nil
         @code_objects = code_objects
+        @macro_code_objects = code_objects.select { |co| co.is_a?(YARD::CodeObjects::MacroObject) }
         @spec = spec
         # @type [Array<Solargraph::Pin::Base>]
         @pins = []
@@ -24,7 +25,7 @@ module Solargraph
         end
         # Some yardocs contain documentation for dependencies that can be
         # ignored here. The YardMap will load dependencies separately.
-        # @sg-ignore Need to add nil check here
+        # @sg-ignore does not consider `pin.location.nil? || ` condition
         @pins.keep_if { |pin| pin.location.nil? || File.file?(pin.location.filename) } if @spec
         @pins
       end
@@ -65,6 +66,7 @@ module Solargraph
           end
         when YARD::CodeObjects::MethodObject
           closure = @namespace_pins[code_object.namespace.to_s]
+          macros_for_method_object(code_object)
           # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
           if code_object.name == :initialize && code_object.scope == :instance
             # @todo Check the visibility of <Class>.new
@@ -79,6 +81,22 @@ module Solargraph
         end
         result
       end
+
+      # @return [Array<YARD::CodeObjects::MacroObject>]
+      def attached_macros
+        @attached_macros ||= @macro_code_objects.select(&:attached?)
+      end
+
+      # @return [Hash{YARD::CodeObjects::MethodObject => Array<YARD::CodeObjects::MacroObject>}]
+      def attached_macros_by_method_object
+        @attached_macros_by_method_object ||= attached_macros.group_by(&:method_object)
+      end
+
+      # @param method_object [YARD::CodeObjects::MethodObject]
+      # @return [Array<YARD::CodeObjects::MacroObject>]
+      def macros_for_method_object method_object
+        attached_macros_by_method_object[method_object]
+      end
     end
   end
 end

data/lib/solargraph/yard_map.rb

@@ -13,5 +13,7 @@ module Solargraph
     autoload :Cache,       'solargraph/yard_map/cache'
     autoload :Mapper,      'solargraph/yard_map/mapper'
     autoload :Helpers,     'solargraph/yard_map/helpers'
+    autoload :Macro,       'solargraph/yard_map/macro'
+    autoload :Directives,  'solargraph/yard_map/directives'
   end
 end

data/lib/solargraph.rb

@@ -49,6 +49,7 @@ module Solargraph
   autoload :RbsMap,           'solargraph/rbs_map'
   autoload :GemPins,          'solargraph/gem_pins'
   autoload :PinCache,         'solargraph/pin_cache'
+  autoload :RbsTranslator,    'solargraph/rbs_translator'
 
   dir = File.dirname(__FILE__)
   VIEWS_PATH = File.join(dir, 'solargraph', 'views')

data/solargraph.gemspec

@@ -47,6 +47,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'rbs', '>= 3.10.0'
   s.add_dependency 'reverse_markdown', '~> 3.0'
   s.add_dependency 'rubocop', '~> 1.76'
+  s.add_dependency 'sord', '~> 7.0'
   s.add_dependency 'thor', '~> 1.0'
   s.add_dependency 'tilt', '~> 2.0'
   s.add_dependency 'yard', '~> 0.9', '>= 0.9.24'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.59.2
+  version: 0.60.0
 platform: ruby
 authors:
 - Fred Snyder
@@ -253,6 +253,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.76'
+- !ruby/object:Gem::Dependency
+  name: sord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -742,6 +756,7 @@ files:
 - lib/solargraph/rbs_map/core_fills.rb
 - lib/solargraph/rbs_map/core_map.rb
 - lib/solargraph/rbs_map/stdlib_map.rb
+- lib/solargraph/rbs_translator.rb
 - lib/solargraph/server_methods.rb
 - lib/solargraph/shell.rb
 - lib/solargraph/source.rb
@@ -790,7 +805,15 @@ files:
 - lib/solargraph/workspace/require_paths.rb
 - lib/solargraph/yard_map.rb
 - lib/solargraph/yard_map/cache.rb
+- lib/solargraph/yard_map/directives.rb
+- lib/solargraph/yard_map/directives/attribute_directive.rb
+- lib/solargraph/yard_map/directives/domain_directive.rb
+- lib/solargraph/yard_map/directives/method_directive.rb
+- lib/solargraph/yard_map/directives/override_directive.rb
+- lib/solargraph/yard_map/directives/parse_directive.rb
+- lib/solargraph/yard_map/directives/visibility_directive.rb
 - lib/solargraph/yard_map/helpers.rb
+- lib/solargraph/yard_map/macro.rb
 - lib/solargraph/yard_map/mapper.rb
 - lib/solargraph/yard_map/mapper/to_constant.rb
 - lib/solargraph/yard_map/mapper/to_method.rb