solargraph 0.58.1 → 0.58.2

data/lib/solargraph/yard_map/helpers.rb

@@ -1,44 +1,44 @@
-module Solargraph
-  class YardMap
-    module Helpers
-      module_function
-
-      # @param code_object [YARD::CodeObjects::Base]
-      # @param spec [Gem::Specification, nil]
-      # @return [Solargraph::Location, nil]
-      def object_location code_object, spec
-        if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
-          if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
-            # If the code object is a namespace, use the namespace's location
-            return object_location(code_object.namespace, spec)
-          end
-          return Solargraph::Location.new(__FILE__, Solargraph::Range.from_to(__LINE__ - 1, 0, __LINE__ - 1, 0))
-        end
-        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
-
-      # @param code_object [YARD::CodeObjects::Base]
-      # @param spec [Gem::Specification, nil]
-      # @return [Solargraph::Pin::Namespace]
-      def create_closure_namespace_for(code_object, spec)
-        code_object_for_location = code_object
-        # code_object.namespace is sometimes a YARD proxy object pointing to a method path ("Object#new")
-        code_object_for_location = code_object.namespace if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
-        namespace_location = object_location(code_object_for_location, spec)
-        ns_name = code_object.namespace.to_s
-        if ns_name.empty?
-          Solargraph::Pin::ROOT_PIN
-        else
-          Solargraph::Pin::Namespace.new(
-            name: ns_name,
-            closure: Pin::ROOT_PIN,
-            gates: [code_object.namespace.to_s],
-            source: :yardoc,
-            location: namespace_location
-          )
-        end
-      end
-    end
-  end
-end
+module Solargraph
+  class YardMap
+    module Helpers
+      module_function
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param spec [Gem::Specification, nil]
+      # @return [Solargraph::Location, nil]
+      def object_location code_object, spec
+        if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+          if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+            # If the code object is a namespace, use the namespace's location
+            return object_location(code_object.namespace, spec)
+          end
+          return Solargraph::Location.new(__FILE__, Solargraph::Range.from_to(__LINE__ - 1, 0, __LINE__ - 1, 0))
+        end
+        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
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param spec [Gem::Specification, nil]
+      # @return [Solargraph::Pin::Namespace]
+      def create_closure_namespace_for(code_object, spec)
+        code_object_for_location = code_object
+        # code_object.namespace is sometimes a YARD proxy object pointing to a method path ("Object#new")
+        code_object_for_location = code_object.namespace if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+        namespace_location = object_location(code_object_for_location, spec)
+        ns_name = code_object.namespace.to_s
+        if ns_name.empty?
+          Solargraph::Pin::ROOT_PIN
+        else
+          Solargraph::Pin::Namespace.new(
+            name: ns_name,
+            closure: Pin::ROOT_PIN,
+            gates: [code_object.namespace.to_s],
+            source: :yardoc,
+            location: namespace_location
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,130 +1,130 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToMethod
-        extend YardMap::Helpers
-
-        VISIBILITY_OVERRIDE = {
-          # YARD pays attention to 'private' statements prior to class methods but shouldn't
-          ["Rails::Engine", :class, "find_root_with_flag"] => :public
-        }
-
-        # @param code_object [YARD::CodeObjects::MethodObject]
-        # @param name [String, nil]
-        # @param scope [Symbol, nil]
-        # @param visibility [Symbol, nil]
-        # @param closure [Solargraph::Pin::Namespace, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Solargraph::Pin::Method]
-        def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-          location = object_location(code_object, spec)
-          name ||= code_object.name.to_s
-          return_type = ComplexType::SELF if name == 'new'
-          comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          final_scope = scope || code_object.scope
-          override_key = [closure.path, final_scope, name]
-          final_visibility = VISIBILITY_OVERRIDE[override_key]
-          final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
-          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
-          final_visibility ||= visibility
-          final_visibility ||= :private if code_object.module_function? && final_scope == :instance
-          final_visibility ||= :public if code_object.module_function? && final_scope == :class
-          final_visibility ||= code_object.visibility
-          if code_object.is_alias?
-            origin_code_object = code_object.namespace.aliases[code_object]
-            pin = Pin::MethodAlias.new(
-              name: name,
-              location: location,
-              original: origin_code_object.name.to_s,
-              closure: closure,
-              comments: comments,
-              scope: final_scope,
-              visibility: final_visibility,
-              explicit: code_object.is_explicit?,
-              return_type: return_type,
-              parameters: [],
-              source: :yardoc,
-            )
-          else
-            pin = Pin::Method.new(
-              location: location,
-              closure: closure,
-              name: name,
-              comments: comments,
-              scope: final_scope,
-              visibility: final_visibility,
-              # @todo Might need to convert overloads to signatures
-              explicit: code_object.is_explicit?,
-              return_type: return_type,
-              attribute: code_object.is_attribute?,
-              parameters: [],
-              source: :yardoc,
-            )
-            pin.parameters.concat get_parameters(code_object, location, comments, pin)
-            pin.parameters.freeze
-          end
-          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
-          pin
-        end
-
-        class << self
-          include Logging
-
-          private
-
-          # @param code_object [YARD::CodeObjects::Base]
-          # @param location [Location],
-          # @param comments [String]
-          # @param pin [Pin::Base]
-          # @return [Array<Solargraph::Pin::Parameter>]
-          def get_parameters code_object, location, comments, pin
-            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
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
-            code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
-              Solargraph::Pin::Parameter.new(
-                location: location,
-                closure: pin,
-                comments: comments,
-                name: arg_name(a),
-                presence: nil,
-                decl: arg_type(a),
-                asgn_code: a[1],
-                source: :yardoc,
-              )
-            end
-          end
-
-          # @param a [Array<String>]
-          # @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
+
+        VISIBILITY_OVERRIDE = {
+          # YARD pays attention to 'private' statements prior to class methods but shouldn't
+          ["Rails::Engine", :class, "find_root_with_flag"] => :public
+        }
+
+        # @param code_object [YARD::CodeObjects::MethodObject]
+        # @param name [String, nil]
+        # @param scope [Symbol, nil]
+        # @param visibility [Symbol, nil]
+        # @param closure [Solargraph::Pin::Namespace, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Solargraph::Pin::Method]
+        def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+          location = object_location(code_object, spec)
+          name ||= code_object.name.to_s
+          return_type = ComplexType::SELF if name == 'new'
+          comments = code_object.docstring ? code_object.docstring.all.to_s : ''
+          final_scope = scope || code_object.scope
+          override_key = [closure.path, final_scope, name]
+          final_visibility = VISIBILITY_OVERRIDE[override_key]
+          final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
+          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          final_visibility ||= visibility
+          final_visibility ||= :private if code_object.module_function? && final_scope == :instance
+          final_visibility ||= :public if code_object.module_function? && final_scope == :class
+          final_visibility ||= code_object.visibility
+          if code_object.is_alias?
+            origin_code_object = code_object.namespace.aliases[code_object]
+            pin = Pin::MethodAlias.new(
+              name: name,
+              location: location,
+              original: origin_code_object.name.to_s,
+              closure: closure,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              parameters: [],
+              source: :yardoc,
+            )
+          else
+            pin = Pin::Method.new(
+              location: location,
+              closure: closure,
+              name: name,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              # @todo Might need to convert overloads to signatures
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              attribute: code_object.is_attribute?,
+              parameters: [],
+              source: :yardoc,
+            )
+            pin.parameters.concat get_parameters(code_object, location, comments, pin)
+            pin.parameters.freeze
+          end
+          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
+          pin
+        end
+
+        class << self
+          include Logging
+
+          private
+
+          # @param code_object [YARD::CodeObjects::Base]
+          # @param location [Location],
+          # @param comments [String]
+          # @param pin [Pin::Base]
+          # @return [Array<Solargraph::Pin::Parameter>]
+          def get_parameters code_object, location, comments, pin
+            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
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+            code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
+              Solargraph::Pin::Parameter.new(
+                location: location,
+                closure: pin,
+                comments: comments,
+                name: arg_name(a),
+                presence: nil,
+                decl: arg_type(a),
+                asgn_code: a[1],
+                source: :yardoc,
+              )
+            end
+          end
+
+          # @param a [Array<String>]
+          # @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,31 +1,31 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToNamespace
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::NamespaceObject]
-        # @param spec [Gem::Specification, nil]
-        # @param closure [Pin::Closure, nil]
-        # @return [Pin::Namespace]
-        def self.make code_object, spec, closure = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-          location = object_location(code_object, spec)
-
-          Pin::Namespace.new(
-            location: location,
-            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,
-            gates: closure.gates,
-            source: :yardoc,
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToNamespace
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::NamespaceObject]
+        # @param spec [Gem::Specification, nil]
+        # @param closure [Pin::Closure, nil]
+        # @return [Pin::Namespace]
+        def self.make code_object, spec, closure = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+          location = object_location(code_object, spec)
+
+          Pin::Namespace.new(
+            location: location,
+            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,
+            gates: closure.gates,
+            source: :yardoc,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper.rb

@@ -1,79 +1,79 @@
-# 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, nil]
-      def initialize code_objects, spec = nil
-        @code_objects = code_objects
-        @spec = spec
-        # @type [Array<Solargraph::Pin::Base>]
-        @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, source: :yard_map)
-          end
-          code_object.class_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path, source: :yard_map)
-          end
-          code_object.instance_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Include.new(
-              closure: nspin, # @todo Fix this
-              name: m.path,
-              source: :yard_map
-            )
-          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, nil]
+      def initialize code_objects, spec = nil
+        @code_objects = code_objects
+        @spec = spec
+        # @type [Array<Solargraph::Pin::Base>]
+        @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, source: :yard_map)
+          end
+          code_object.class_mixins.each do |m|
+            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path, source: :yard_map)
+          end
+          code_object.instance_mixins.each do |m|
+            result.push Solargraph::Pin::Reference::Include.new(
+              closure: nspin, # @todo Fix this
+              name: m.path,
+              source: :yard_map
+            )
+          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