solargraph 0.59.1 → 0.60.0

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/to_constant.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToConstant
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param closure [Pin::Closure, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Pin::Constant]
-        def self.make code_object, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-
-          Pin::Constant.new(
-            location: object_location(code_object, spec),
-            closure: closure,
-            name: code_object.name.to_s,
-            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility,
-            source: :yardoc
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
+        def self.make code_object, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+
+          Pin::Constant.new(
+            location: object_location(code_object, spec),
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            visibility: code_object.visibility,
+            source: :yardoc
+          )
+        end
+      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.1
+  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
@@ -804,7 +827,6 @@ files:
 - rbs/fills/rubygems/0/errors.rbs
 - rbs/fills/rubygems/0/spec_fetcher.rbs
 - rbs/fills/rubygems/0/specification.rbs
-- rbs/fills/tuple/tuple.rbs
 - rbs/shims/ast/0/node.rbs
 - rbs/shims/ast/2.4/.rbs_meta.yaml
 - rbs/shims/ast/2.4/ast.rbs

data/rbs/fills/tuple/tuple.rbs

@@ -1,177 +0,0 @@
-# <-- liberally borrowed from
-#     https://github.com/ruby/rbs/blob/master/core/array.rbs, which
-#     was generated from
-#     https://github.com/ruby/ruby/blob/master/array.c
-#     -->
-module Solargraph
-  module Fills
-    class Tuple[unchecked out A,
-                unchecked out B = A,
-                unchecked out C = A | B,
-                unchecked out D = A | B | C,
-                unchecked out E = A | B | C | D,
-                unchecked out F = A | B | C | D | E,
-                unchecked out G = A | B | C | D | E | F,
-                unchecked out H = A | B | C | D | E | F | G,
-                unchecked out I = A | B | C | D | E | F | G | H,
-                unchecked out J = A | B | C | D | E | F | G | H | I] < Array[A | B | C | D | E | F | G | H | I | J]
-      # <!--
-      #   rdoc-file=array.c
-      #   - self[index] -> object or nil
-      # -->
-      # Returns elements from `self`; does not modify `self`.
-      #
-      # In brief:
-      #
-      #     a = [:foo, 'bar', 2]
-      #
-      #     # Single argument index: returns one element.
-      #     a[0]     # => :foo          # Zero-based index.
-      #
-      # When a single integer argument `index` is given, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a[0] # => :foo
-      #     a[2] # => 2
-      #     a # => [:foo, "bar", 2]
-      def []: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - at(index) -> object or nil
-      # -->
-      # Returns the element of `self` specified by the given `index` or `nil` if there
-      # is no such element; `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # For non-negative `index`, returns the element of `self` at offset `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.at(0)   # => :foo
-      #     a.at(2)   # => 2
-      #     a.at(2.0) # => 2
-      #
-      # Related: Array#[]; see also [Methods for
-      # Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def at: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - fetch(index) -> element
-      #   - fetch(index, default_value) -> element or default_value
-      #   - fetch(index) {|index| ... } -> element or block_return_value
-      # -->
-      # Returns the element of `self` at offset `index` if `index` is in range;
-      # `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # With the single argument `index` and no block, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1)   # => "bar"
-      #     a.fetch(1.1) # => "bar"
-      #
-      # With arguments `index` and `default_value` (which may be any object) and no
-      # block, returns `default_value` if `index` is out-of-range:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1, nil)  # => "bar"
-      #     a.fetch(3, :foo) # => :foo
-      #
-      # With argument `index` and a block, returns the element at offset `index` if
-      # index is in range (and the block is not called); otherwise calls the block
-      # with index and returns its return value:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
-      #     a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
-      #
-      # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def fetch: (0 index) -> A
-               | (1 index) -> B
-               | (2 index) -> C
-               | (3 index) -> D
-               | (4 index) -> E
-               | (5 index) -> F
-               | (6 index) -> G
-               | (7 index) -> H
-               | (8 index) -> I
-               | (9 index) -> J
-               | (int index) -> void
-               | [T] (0 index, T default) -> (A | T)
-               | [T] (1 index, T default) -> (B | T)
-               | [T] (2 index, T default) -> (C | T)
-               | [T] (3 index, T default) -> (D | T)
-               | [T] (4 index, T default) -> (E | T)
-               | [T] (5 index, T default) -> (F | T)
-               | [T] (6 index, T default) -> (G | T)
-               | [T] (7 index, T default) -> (H | T)
-               | [T] (8 index, T default) -> (I | T)
-               | [T] (9 index, T default) -> (J | T)
-               | [T] (int index, T default) -> (A | B | C | D | E | F | G | H | I | J | T)
-               | [T] (0 index) { (int index) -> T } -> (A | T)
-               | [T] (1 index) { (int index) -> T } -> (B | T)
-               | [T] (2 index) { (int index) -> T } -> (C | T)
-               | [T] (3 index) { (int index) -> T } -> (D | T)
-               | [T] (4 index) { (int index) -> T } -> (E | T)
-               | [T] (5 index) { (int index) -> T } -> (F | T)
-               | [T] (6 index) { (int index) -> T } -> (G | T)
-               | [T] (7 index) { (int index) -> T } -> (H | T)
-               | [T] (8 index) { (int index) -> T } -> (I | T)
-               | [T] (9 index) { (int index) -> T } -> (J | T)
-               | [T] (int index) { (int index) -> T } -> (A | B | C | D | E | F | G | H | I | J | T)
-
-      # <!--
-      #   rdoc-file=array.rb
-      #   - first -> object or nil
-      #   - first(count) -> new_array
-      # -->
-      # Returns elements from `self`, or `nil`; does not modify `self`.
-      #
-      # With no argument given, returns the first element (if available):
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.first # => :foo
-      #     a # => [:foo, "bar", 2]
-      #
-      # If `self` is empty, returns `nil`.
-      #
-      #     [].first # => nil
-      #
-      # With a non-negative integer argument `count` given, returns the first `count`
-      # elements (as available) in a new array:
-      #
-      #     a.first(0)  # => []
-      #     a.first(2)  # => [:foo, "bar"]
-      #     a.first(50) # => [:foo, "bar", 2]
-      #
-      # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
-      #
-      def first: %a{implicitly-returns-nil} () -> A
-    end
-  end
-end