solargraph 0.39.13 → 0.40.0

data/lib/solargraph/yard_map/core_fills.rb

@@ -0,0 +1,185 @@
+module Solargraph
+  class YardMap
+    module CoreFills
+      Override = Pin::Reference::Override
+
+      KEYWORDS = [
+        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+        'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
+        'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
+        'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
+      ].map { |k| Pin::Keyword.new(k) }
+
+      methods_with_yieldparam_subtypes = %w[
+        Array#each Array#map Array#map! Array#any? Array#all? Array#index
+        Array#keep_if Array#delete_if
+        Enumerable#each_entry Enumerable#map Enumerable#any? Enumerable#all?
+        Enumerable#select Enumerable#reject
+        Set#each
+      ]
+
+      OVERRIDES = [
+        Override.method_return('Array#concat', 'Array'),
+        Override.method_return('Array#keep_if', 'self'),
+        Override.method_return('Array#delete_if', 'self'),
+        Override.from_comment('Array#map', %(
+@overload map(&block)
+  @return [Array]
+@overload map()
+  @return [Enumerator]
+        )),
+        Override.from_comment('Array#reject', %(
+@overload reject(&block)
+  @return [self]
+@overload reject()
+  @return [Enumerator]
+        )),
+        Override.method_return('Array#reverse', 'self', delete: ['overload']),
+        Override.from_comment('Array#select', %(
+@overload select(&block)
+  @return [self]
+@overload select()
+  @return [Enumerator]
+        )),
+        Override.from_comment('Array#[]', %(
+@overload [](range)
+  @param range [Range]
+  @return [self]
+@overload [](num1, num2)
+  @param num1 [Integer]
+  @param num2 [Integer]
+  @return [self]
+@overload [](num)
+  @param num [Integer]
+  @return_single_parameter
+@return_single_parameter
+        )),
+        Override.from_comment('Array#first', %(
+@overload first(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+        )),
+        Override.from_comment('Array#last', %(
+@overload last(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+        )),
+        Override.method_return('Array#map', 'Array'),
+        Override.method_return('Array#uniq', 'self'),
+        Override.method_return('Array#zip', 'Array, nil'),
+
+        Override.from_comment('BasicObject#==', %(
+@param other [BasicObject]
+@return [Boolean]
+        )),
+        Override.method_return('BasicObject#initialize', 'void'),
+
+        Override.method_return('Class#new', 'self'),
+        Override.method_return('Class.new', 'Class<Object>'),
+        Override.method_return('Class#allocate', 'self'),
+        Override.method_return('Class.allocate', 'Class<Object>'),
+
+        Override.method_return('Enumerable#select', 'self'),
+
+        Override.method_return('File.absolute_path', 'String'),
+        Override.method_return('File.basename', 'String'),
+        Override.method_return('File.dirname', 'String'),
+        Override.method_return('File.extname', 'String'),
+        Override.method_return('File.join', 'String'),
+
+        Override.from_comment('Float#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.from_comment('Hash#[]', %(
+@return_value_parameter
+        )),
+
+        # @todo This override isn't robust enough. It needs to allow for
+        #   parameterized Hash types, e.g., [Hash{Symbol => String}].
+        Override.from_comment('Hash#[]=', %(
+@param_tuple
+        )),
+
+        Override.method_return('Hash#merge', 'Hash'),
+
+        Override.from_comment('Integer#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.method_return('Kernel#puts', 'nil'),
+
+        Override.from_comment('Numeric#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.method_return('Object#!', 'Boolean'),
+        Override.method_return('Object#clone', 'self', delete: [:overload]),
+        Override.method_return('Object#dup', 'self', delete: [:overload]),
+        Override.method_return('Object#freeze', 'self', delete: [:overload]),
+        Override.method_return('Object#inspect', 'String'),
+        Override.method_return('Object#taint', 'self'),
+        Override.method_return('Object#to_s', 'String'),
+        Override.method_return('Object#untaint', 'self'),
+        Override.from_comment('Object#tap', %(
+@return [self]
+@yieldparam [self]
+        )),
+
+        Override.from_comment('STDERR', %(
+@type [IO]
+        )),
+
+        Override.from_comment('STDIN', %(
+@type [IO]
+        )),
+
+        Override.from_comment('STDOUT', %(
+@type [IO]
+        )),
+
+        Override.method_return('String#freeze', 'self'),
+        Override.method_return('String#split', 'Array<String>'),
+        Override.method_return('String#lines', 'Array<String>'),
+        Override.from_comment('String#each_line', %(
+@yieldparam [String]
+        )),
+        Override.from_comment('String.new', %(
+@overload new(*)
+  @return [self]
+      ))
+      ].concat(
+        methods_with_yieldparam_subtypes.map do |path|
+          Override.from_comment(path, %(
+@yieldparam_single_parameter
+            ))
+        end
+      )
+
+      PINS = [
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'File'), name: 'IO'),
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'Integer'), name: 'Numeric'),
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'Float'), name: 'Numeric')
+      ].concat(
+        # HACK: Add Errno exception classes
+        begin
+          errno = Solargraph::Pin::Namespace.new(name: 'Errno')
+          result = []
+          Errno.constants.each do |const|
+            result.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
+            result.push Solargraph::Pin::Reference::Superclass.new(closure: result.last, name: 'SystemCallError')
+          end
+          result
+        end
+      )
+
+      ALL = KEYWORDS + PINS + OVERRIDES
+    end
+  end
+end

data/lib/solargraph/yard_map/helpers.rb

@@ -0,0 +1,16 @@
+module Solargraph
+  class YardMap
+    module Helpers
+      module_function
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param spec [Gem::Specification]
+      # @return [Solargraph::Location, nil]
+      def object_location code_object, spec
+        return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+        file = File.join(spec.full_gem_path, code_object.file)
+        Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper.rb

@@ -3,6 +3,10 @@
 module Solargraph
   class YardMap
     class Mapper
+      autoload :ToMethod, 'solargraph/yard_map/mapper/to_method'
+      autoload :ToNamespace, 'solargraph/yard_map/mapper/to_namespace'
+      autoload :ToConstant, 'solargraph/yard_map/mapper/to_constant'
+
       # @param code_objects [Array<YARD::CodeObjects::Base>]
       # @param spec [Gem::Specification]
       def initialize code_objects, spec = nil
@@ -23,22 +27,24 @@ module Solargraph
         @pins
       end
 
+      private
+
       # @param code_object [YARD::CodeObjects::Base]
       # @return [Array<Pin::Base>]
       def generate_pins code_object
         result = []
         if code_object.is_a?(YARD::CodeObjects::NamespaceObject)
-          nspin = Solargraph::Pin::YardPin::Namespace.new(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
+          nspin = ToNamespace.make(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
           @namespace_pins[code_object.path] = nspin
           result.push nspin
           if code_object.is_a?(YARD::CodeObjects::ClassObject) and !code_object.superclass.nil?
             # This method of superclass detection is a bit of a hack. If
             # the superclass is a Proxy, it is assumed to be undefined in its
             # yardoc and converted to a fully qualified namespace.
-            if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
-              superclass = "::#{code_object.superclass}"
+            superclass = if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
+              "::#{code_object.superclass}"
             else
-              superclass = code_object.superclass.to_s
+              code_object.superclass.to_s
             end
             result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
           end
@@ -55,14 +61,14 @@ module Solargraph
           closure = @namespace_pins[code_object.namespace.to_s]
           if code_object.name == :initialize && code_object.scope == :instance
             # @todo Check the visibility of <Class>.new
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, 'new', :class, :public, closure, @spec)
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, 'initialize', :instance, :private, closure, @spec)
+            result.push ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
+            result.push ToMethod.make(code_object, 'initialize', :instance, :private, closure, @spec)
           else
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, nil, nil, nil, closure, @spec)
+            result.push ToMethod.make(code_object, nil, nil, nil, closure, @spec)
           end
         elsif code_object.is_a?(YARD::CodeObjects::ConstantObject)
           closure = @namespace_pins[code_object.namespace]
-          result.push Solargraph::Pin::YardPin::Constant.new(code_object, closure, @spec)
+          result.push ToConstant.make(code_object, closure, @spec)
         end
         result
       end

data/lib/solargraph/{pin/yard_pin/constant.rb → yard_map/mapper/to_constant.rb}

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 module Solargraph
-  module Pin
-    module YardPin
-      class Constant < Pin::Constant
-        include YardMixin
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
 
-        def initialize code_object, closure = nil, spec = nil
+        def self.make code_object, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             gates: [code_object.namespace.to_s]
           )
-          super(
+          Pin::Constant.new(
             location: object_location(code_object, spec),
             closure: closure,
             name: code_object.name.to_s,

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToMethod
+        extend YardMap::Helpers
+
+        def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
+          closure ||= Solargraph::Pin::Namespace.new(
+            name: code_object.namespace.to_s,
+            gates: [code_object.namespace.to_s]
+          )
+          location = object_location(code_object, spec)
+          comments = code_object.docstring ? code_object.docstring.all.to_s : ''
+          Pin::Method.new(
+            location: location,
+            closure: closure,
+            name: name || code_object.name.to_s,
+            comments: comments,
+            scope: scope || code_object.scope,
+            visibility: visibility || code_object.visibility,
+            parameters: get_parameters(code_object, location, comments),
+            explicit: code_object.is_explicit?
+          )
+        end
+
+        class << self
+          private
+
+          # @param code_object [YARD::CodeObjects::Base]
+          # @return [Array<Solargraph::Pin::Parameter>]
+          def get_parameters code_object, location, comments
+            return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
+            # HACK: Skip `nil` and `self` parameters that are sometimes emitted
+            # for methods defined in C
+            # See https://github.com/castwide/solargraph/issues/345
+            code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
+              Solargraph::Pin::Parameter.new(
+                location: location,
+                closure: self,
+                comments: comments,
+                name: arg_name(a),
+                presence: nil,
+                decl: arg_type(a),
+                asgn_code: a[1]
+              )
+            end
+          end
+
+          # @param a [Array]
+          # @return [String]
+          def arg_name a
+            a[0].gsub(/[^a-z0-9_]/i, '')
+          end
+
+          # @param a [Array]
+          # @return [::Symbol]
+          def arg_type a
+            if a[0].start_with?('**')
+              :kwrestarg
+            elsif a[0].start_with?('*')
+              :restarg
+            elsif a[0].start_with?('&')
+              :blockarg
+            elsif a[0].end_with?(':')
+              a[1] ? :kwoptarg : :kwarg
+            elsif a[1]
+              :optarg
+            else
+              :arg
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/{pin/yard_pin/namespace.rb → yard_map/mapper/to_namespace.rb}

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 module Solargraph
-  module Pin
-    module YardPin
-      class Namespace < Pin::Namespace
-        include YardMixin
+  class YardMap
+    class Mapper
+      module ToNamespace
+        extend YardMap::Helpers
 
-        def initialize code_object, spec, closure = nil
+        def self.make code_object, spec, closure = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             closure: Pin::ROOT_PIN,
             gates: [code_object.namespace.to_s]
           )
-          super(
+          Pin::Namespace.new(
             location: object_location(code_object, spec),
             name: code_object.name.to_s,
             comments: code_object.docstring ? code_object.docstring.all.to_s : '',

data/lib/solargraph/yard_map/rdoc_to_yard.rb

@@ -63,7 +63,7 @@ module Solargraph
               name_hash[mod.full_name] = namepin
               # @param met [RDoc::AnyMethod]
               mod.each_method do |met|
-                pin = Solargraph::SourceMap.load_string("def Object.tmp#{met.param_seq};end").first_pin('Object.tmp') || Solargraph::Pin::BaseMethod.new
+                pin = Solargraph::SourceMap.load_string("def Object.tmp#{met.param_seq};end").first_pin('Object.tmp') || Solargraph::Pin::Method.new
                 pins.push Solargraph::Pin::Method.new(
                   name: met.name,
                   closure: namepin,

data/lib/solargraph/yard_map/stdlib_fills.rb

@@ -0,0 +1,43 @@
+module Solargraph
+  class YardMap
+    module StdlibFills
+      Override = Pin::Reference::Override
+
+      LIBS = {
+        'benchmark' => [
+          Override.method_return('Benchmark.measure', 'Benchmark::Tms')
+        ],
+
+        'pathname' => [
+          Override.method_return('Pathname#join', 'Pathname'),
+          Override.method_return('Pathname#basename', 'Pathname'),
+          Override.method_return('Pathname#dirname', 'Pathname'),
+          Override.method_return('Pathname#cleanpath', 'Pathname'),
+          Override.method_return('Pathname#children', 'Array<Pathname>'),
+          Override.method_return('Pathname#entries', 'Array<Pathname>')
+        ],
+
+        'set' => [
+          Override.method_return('Enumerable#to_set', 'Set'),
+          Override.method_return('Set#add', 'self'),
+          Override.method_return('Set#add?', 'self, nil'),
+          Override.method_return('Set#classify', 'Hash'),
+          Override.from_comment('Set#each', '@yieldparam_single_parameter'),
+        ],
+
+        'tempfile' => [
+          Override.from_comment('Tempfile.open', %(
+@yieldparam [Tempfile]
+@return [Tempfile]
+          ))
+        ]
+      }.freeze
+
+      # @param path [String]
+      # @return [Array<Pin::Reference::Override>]
+      def self.get path
+        LIBS[path] || []
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/to_method.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class ToMethod
+      module InnerMethods
+        module_function
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @return [Array<Solargraph::Pin::Parameter>]
+        def get_parameters code_object, location, comments
+          return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
+          # HACK: Skip `nil` and `self` parameters that are sometimes emitted
+          # for methods defined in C
+          # See https://github.com/castwide/solargraph/issues/345
+          code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
+            Solargraph::Pin::Parameter.new(
+              location: location,
+              closure: self,
+              comments: comments,
+              name: arg_name(a),
+              presence: nil,
+              decl: arg_type(a),
+              asgn_code: a[1]
+            )
+          end
+        end
+
+        # @param a [Array]
+        # @return [String]
+        def arg_name a
+          a[0].gsub(/[^a-z0-9_]/i, '')
+        end
+
+        # @param a [Array]
+        # @return [::Symbol]
+        def arg_type a
+          if a[0].start_with?('**')
+            :kwrestarg
+          elsif a[0].start_with?('*')
+            :restarg
+          elsif a[0].start_with?('&')
+            :blockarg
+          elsif a[0].end_with?(':')
+            a[1] ? :kwoptarg : :kwarg
+          elsif a[1]
+            :optarg
+          else
+            :arg
+          end
+        end
+      end
+      private_constant :InnerMethods
+
+      # include YardMixin
+      # extend YardMixin
+      extend Helpers
+
+      def make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
+        closure ||= Solargraph::Pin::Namespace.new(
+          name: code_object.namespace.to_s,
+          gates: [code_object.namespace.to_s]
+        )
+        location = object_location(code_object, spec)
+        comments = code_object.docstring ? code_object.docstring.all.to_s : ''
+        Pin::Method.new(
+          location: location,
+          closure: closure,
+          name: name || code_object.name.to_s,
+          comments: comments,
+          scope: scope || code_object.scope,
+          visibility: visibility || code_object.visibility,
+          parameters: InnerMethods.get_parameters(code_object, location, comments),
+          explicit: code_object.is_explicit?
+        )
+      end
+    end
+  end
+end