solargraph 0.44.2 → 0.46.0

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

@@ -1,78 +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
+# 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/yard_map/mapper/to_namespace.rb

@@ -1,27 +1,27 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToNamespace
-        extend YardMap::Helpers
-
-        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]
-          )
-          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 : '',
-            type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
-            visibility: code_object.visibility,
-            closure: closure
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToNamespace
+        extend YardMap::Helpers
+
+        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]
+          )
+          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 : '',
+            type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
+            visibility: code_object.visibility,
+            closure: closure
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper.rb

@@ -1,77 +1,77 @@
-# frozen_string_literal: true
-
-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
-        @code_objects = code_objects
-        @spec = spec
-        @pins = []
-        @namespace_pins = {}
-      end
-
-      # @return [Array<Pin::Base>]
-      def map
-        @code_objects.each do |co|
-          @pins.concat generate_pins co
-        end
-        # Some yardocs contain documentation for dependencies that can be
-        # ignored here. The YardMap will load dependencies separately.
-        @pins.keep_if { |pin| pin.location.nil? || File.file?(pin.location.filename) } if @spec
-        @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 = 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.
-            superclass = if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
-              "::#{code_object.superclass}"
-            else
-              code_object.superclass.to_s
-            end
-            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
-          end
-          code_object.class_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path)
-          end
-          code_object.instance_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Include.new(
-              closure: nspin, # @todo Fix this
-              name: m.path
-            )
-          end
-        elsif code_object.is_a?(YARD::CodeObjects::MethodObject)
-          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 ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
-            result.push ToMethod.make(code_object, 'initialize', :instance, :private, closure, @spec)
-          else
-            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 ToConstant.make(code_object, closure, @spec)
-        end
-        result
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+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
+        @code_objects = code_objects
+        @spec = spec
+        @pins = []
+        @namespace_pins = {}
+      end
+
+      # @return [Array<Pin::Base>]
+      def map
+        @code_objects.each do |co|
+          @pins.concat generate_pins co
+        end
+        # Some yardocs contain documentation for dependencies that can be
+        # ignored here. The YardMap will load dependencies separately.
+        @pins.keep_if { |pin| pin.location.nil? || File.file?(pin.location.filename) } if @spec
+        @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 = 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.
+            superclass = if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
+              "::#{code_object.superclass}"
+            else
+              code_object.superclass.to_s
+            end
+            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
+          end
+          code_object.class_mixins.each do |m|
+            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path)
+          end
+          code_object.instance_mixins.each do |m|
+            result.push Solargraph::Pin::Reference::Include.new(
+              closure: nspin, # @todo Fix this
+              name: m.path
+            )
+          end
+        elsif code_object.is_a?(YARD::CodeObjects::MethodObject)
+          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 ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
+            result.push ToMethod.make(code_object, 'initialize', :instance, :private, closure, @spec)
+          else
+            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 ToConstant.make(code_object, closure, @spec)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/rdoc_to_yard.rb

@@ -1,140 +1,140 @@
-# frozen_string_literal: true
-
-require 'rdoc'
-require 'rdoc/rdoc'
-require 'tmpdir'
-require 'fileutils'
-
-module Solargraph
-  class YardMap
-    module RdocToYard
-      extend ApiMap::SourceToYard
-
-      # @param spec [Gem::Specification]
-      # @param cache_dir [String]
-      # @return [void]
-      def self.run spec, cache_dir: nil
-        Dir.mktmpdir do |tmpdir|
-          rdir = File.join(tmpdir, 'sg_tmp_rdoc')
-          FileUtils.cp_r Dir.glob(File.join(spec.full_gem_path, '*')), tmpdir
-          Dir.chdir tmpdir do
-            pins = []
-            pins.push Solargraph::Pin::ROOT_PIN
-            name_hash = {}
-
-            argv = ['-q', '-r', '-N', '-o', rdir]
-            spec.load_paths.each do |path|
-              argv.concat ['-i', path]
-            end
-            rdoc = RDoc::RDoc.new
-            rdoc.document argv
-            # @type [RDoc::Store]
-            store = rdoc.store
-            store.path = rdir
-            store.cache[:modules].each do |mod|
-              # @type [RDoc::NormalClass]
-              mod = store.find_class_or_module(mod)
-              closure = pins.select { |pin| pin.path == mod.full_name.split('::')[0..-2].join('::') }.first || pins.first
-              namepin = Solargraph::Pin::Namespace.new(
-                type: (mod.module? ? :module : :class),
-                name: mod.name,
-                comments: commentary(mod.comment),
-                closure: closure,
-                location: locate(mod)
-              )
-              mod.parse(mod.comment_location)
-              # @param inc [RDoc::Include]
-              mod.includes.each do |inc|
-                pins.push Solargraph::Pin::Reference::Include.new(
-                  location: locate(inc),
-                  name: inc.name,
-                  closure: namepin
-                )
-              end
-              # @param ext [RDoc::Extend]
-              mod.extends.each do |ext|
-                pins.push Solargraph::Pin::Reference::Extend.new(
-                  location: locate(ext),
-                  name: ext.name,
-                  closure: namepin
-                )
-              end
-              pins.push namepin
-              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::Method.new
-                pins.push Solargraph::Pin::Method.new(
-                  name: met.name,
-                  closure: namepin,
-                  comments: commentary(met.comment),
-                  scope: met.type.to_sym,
-                  parameters: pin.parameters,
-                  visibility: met.visibility,
-                  location: locate(met)
-                )
-              end
-              # @param const [RDoc::Constant]
-              mod.each_constant do |const|
-                pins.push Solargraph::Pin::Constant.new(
-                  name: const.name,
-                  closure: namepin,
-                  comments: commentary(const.comment),
-                  location: locate(const)
-                )
-              end
-            end
-            mapstore = Solargraph::ApiMap::Store.new(pins)
-            rake_yard(mapstore)
-            YARD::Registry.clear
-            code_object_map.values.each do |co|
-              YARD::Registry.register(co)
-            end
-            cache_dir ||= File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}", "yardoc")
-            FileUtils.remove_entry_secure cache_dir if File.exist?(cache_dir)
-            FileUtils.mkdir_p cache_dir
-            # @todo Should merge be true?
-            YARD::Registry.save true, cache_dir
-            # Clear the serialized cache if it exists
-            FileUtils.safe_unlink File.join(CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}.ser")
-          end
-        end
-      end
-
-      def self.base_name mod
-        mod.full_name.split('::')[0..-2].join('::')
-      end
-
-      # @param cmnt [RDoc::Comment]
-      # @return [String]
-      def self.commentary cmnt
-        return cmnt if cmnt.is_a?(String)
-        return cmnt.text if cmnt.is_a?(RDoc::Comment)
-        result = []
-        cmnt.parts.each do |part|
-          result.push RDoc::Markup::ToHtml.new({}).to_html(part.text) if part.respond_to?(:text)
-        end
-        result.join("\n\n")
-      end
-
-      # @param obj [RDoc::Context]
-      def self.locate obj
-        # @todo line is always nil for some reason
-        file, line = find_file(obj)
-        return nil if file.nil?
-        Location.new(
-          file,
-          Range.from_to(line || 1, 0, line || 1, 0)
-        )
-      end
-
-      def self.find_file obj
-        if obj.respond_to?(:in_files) && !obj.in_files.empty?
-          [obj.in_files.first.to_s.sub(/^file /, ''), obj.line]
-        else
-          [obj.file, obj.line]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'rdoc'
+require 'rdoc/rdoc'
+require 'tmpdir'
+require 'fileutils'
+
+module Solargraph
+  class YardMap
+    module RdocToYard
+      extend ApiMap::SourceToYard
+
+      # @param spec [Gem::Specification]
+      # @param cache_dir [String]
+      # @return [void]
+      def self.run spec, cache_dir: nil
+        Dir.mktmpdir do |tmpdir|
+          rdir = File.join(tmpdir, 'sg_tmp_rdoc')
+          FileUtils.cp_r Dir.glob(File.join(spec.full_gem_path, '*')), tmpdir
+          Dir.chdir tmpdir do
+            pins = []
+            pins.push Solargraph::Pin::ROOT_PIN
+            name_hash = {}
+
+            argv = ['-q', '-r', '-N', '-o', rdir]
+            spec.load_paths.each do |path|
+              argv.concat ['-i', path]
+            end
+            rdoc = RDoc::RDoc.new
+            rdoc.document argv
+            # @type [RDoc::Store]
+            store = rdoc.store
+            store.path = rdir
+            store.cache[:modules].each do |mod|
+              # @type [RDoc::NormalClass]
+              mod = store.find_class_or_module(mod)
+              closure = pins.select { |pin| pin.path == mod.full_name.split('::')[0..-2].join('::') }.first || pins.first
+              namepin = Solargraph::Pin::Namespace.new(
+                type: (mod.module? ? :module : :class),
+                name: mod.name,
+                comments: commentary(mod.comment),
+                closure: closure,
+                location: locate(mod)
+              )
+              mod.parse(mod.comment_location)
+              # @param inc [RDoc::Include]
+              mod.includes.each do |inc|
+                pins.push Solargraph::Pin::Reference::Include.new(
+                  location: locate(inc),
+                  name: inc.name,
+                  closure: namepin
+                )
+              end
+              # @param ext [RDoc::Extend]
+              mod.extends.each do |ext|
+                pins.push Solargraph::Pin::Reference::Extend.new(
+                  location: locate(ext),
+                  name: ext.name,
+                  closure: namepin
+                )
+              end
+              pins.push namepin
+              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::Method.new
+                pins.push Solargraph::Pin::Method.new(
+                  name: met.name,
+                  closure: namepin,
+                  comments: commentary(met.comment),
+                  scope: met.type.to_sym,
+                  parameters: pin.parameters,
+                  visibility: met.visibility,
+                  location: locate(met)
+                )
+              end
+              # @param const [RDoc::Constant]
+              mod.each_constant do |const|
+                pins.push Solargraph::Pin::Constant.new(
+                  name: const.name,
+                  closure: namepin,
+                  comments: commentary(const.comment),
+                  location: locate(const)
+                )
+              end
+            end
+            mapstore = Solargraph::ApiMap::Store.new(pins)
+            rake_yard(mapstore)
+            YARD::Registry.clear
+            code_object_map.values.each do |co|
+              YARD::Registry.register(co)
+            end
+            cache_dir ||= File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}", "yardoc")
+            FileUtils.remove_entry_secure cache_dir if File.exist?(cache_dir)
+            FileUtils.mkdir_p cache_dir
+            # @todo Should merge be true?
+            YARD::Registry.save true, cache_dir
+            # Clear the serialized cache if it exists
+            FileUtils.safe_unlink File.join(CoreDocs.cache_dir, 'gems', "#{spec.name}-#{spec.version}.ser")
+          end
+        end
+      end
+
+      def self.base_name mod
+        mod.full_name.split('::')[0..-2].join('::')
+      end
+
+      # @param cmnt [RDoc::Comment]
+      # @return [String]
+      def self.commentary cmnt
+        return cmnt if cmnt.is_a?(String)
+        return cmnt.text if cmnt.is_a?(RDoc::Comment)
+        result = []
+        cmnt.parts.each do |part|
+          result.push RDoc::Markup::ToHtml.new({}).to_html(part.text) if part.respond_to?(:text)
+        end
+        result.join("\n\n")
+      end
+
+      # @param obj [RDoc::Context]
+      def self.locate obj
+        # @todo line is always nil for some reason
+        file, line = find_file(obj)
+        return nil if file.nil?
+        Location.new(
+          file,
+          Range.from_to(line || 1, 0, line || 1, 0)
+        )
+      end
+
+      def self.find_file obj
+        if obj.respond_to?(:in_files) && !obj.in_files.empty?
+          [obj.in_files.first.to_s.sub(/^file /, ''), obj.line]
+        else
+          [obj.file, obj.line]
+        end
+      end
+    end
+  end
+end