solargraph 0.32.1 → 0.32.2

data/lib/solargraph/pin/localized.rb

@@ -1,22 +1,22 @@
-module Solargraph
-  module Pin
-    module Localized
-      attr_reader :block
-
-      # @return [Range]
-      attr_reader :presence
-
-      # @param other [Pin::Base] The caller's block
-      # @param position [Position, Array(Integer, Integer)] The caller's position
-      # @return [Boolean]
-      def visible_from?(other, position)
-        position = Position.normalize(position)
-        other.filename == filename and
-          ( other == block or 
-            (block.location.range.contain?(other.location.range.start) and block.location.range.contain?(other.location.range.ending))
-          ) and
-          presence.contain?(position)
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    module Localized
+      attr_reader :block
+
+      # @return [Range]
+      attr_reader :presence
+
+      # @param other [Pin::Base] The caller's block
+      # @param position [Position, Array(Integer, Integer)] The caller's position
+      # @return [Boolean]
+      def visible_from?(other, position)
+        position = Position.normalize(position)
+        other.filename == filename and
+          ( other == block or 
+            (block.location.range.contain?(other.location.range.start) and block.location.range.contain?(other.location.range.ending))
+          ) and
+          presence.contain?(position)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/method.rb

@@ -1,126 +1,126 @@
-module Solargraph
-  module Pin
-    class Method < BaseMethod
-      include Source::NodeMethods
-
-      # @return [Array<String>]
-      attr_reader :parameters
-
-      # @return [Parser::AST::Node]
-      attr_reader :node
-
-      def initialize location, namespace, name, comments, scope, visibility, args, node = nil
-        super(location, namespace, name, comments)
-        @scope = scope
-        @visibility = visibility
-        @parameters = args
-        @node = node
-      end
-
-      # @return [Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first}
-      end
-
-      def kind
-        Solargraph::Pin::METHOD
-      end
-
-      def path
-        @path ||= namespace + (scope == :instance ? '#' : '.') + name
-      end
-
-      def context
-        @context ||= begin
-          if scope == :class
-            # @todo Determine whether the namespace is a class or a module
-            ComplexType.try_parse("Class<#{namespace}>")
-          else
-            ComplexType.try_parse(namespace)
-          end
-        end
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::METHOD
-      end
-
-      def symbol_kind
-        LanguageServer::SymbolKinds::METHOD
-      end
-
-      def documentation
-        if @documentation.nil?
-          @documentation ||= super || ''
-          param_tags = docstring.tags(:param)
-          unless param_tags.nil? or param_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Params:\n"
-            lines = []
-            param_tags.each do |p|
-              l = "* #{p.name}"
-              l += " [#{p.types.join(', ')}]" unless p.types.nil? or p.types.empty?
-              l += " #{p.text}"
-              lines.push l
-            end
-            @documentation += lines.join("\n")
-          end
-        end
-        @documentation
-      end
-
-      def nearly? other
-        return false unless super
-        parameters == other.parameters and
-          scope == other.scope and
-          visibility == other.visibility
-      end
-
-      def probe api_map
-        infer_from_return_nodes(api_map)
-      end
-
-      # @deprecated Use #typify and/or #probe instead
-      def infer api_map
-        Solargraph::Logging.logger.warn 'WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead.'
-        type = typify(api_map)
-        return type unless type.undefined?
-        probe api_map
-      end
-
-      def try_merge! pin
-        return false unless super
-        @node = pin.node
-        true
-      end
-
-      private
-
-      # @return [Parser::AST:Node, nil]
-      def method_body_node
-        return nil if node.nil?
-        return node.children[2] if node.type == :def
-        return node.children[3] if node.type == :defs
-        nil
-      end
-
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def infer_from_return_nodes api_map
-        result = []
-        returns_from(method_body_node).each do |n|
-          next if n.loc.nil?
-          clip = api_map.clip_at(
-            location.filename,
-            [n.loc.expression.last_line, n.loc.expression.last_column]
-          )
-          chain = Solargraph::Source::NodeChainer.chain(n, location.filename)
-          type = chain.infer(api_map, self, clip.locals)
-          result.push type unless type.undefined?
-        end
-        return ComplexType::UNDEFINED if result.empty?
-        ComplexType.try_parse(*result.map(&:tag))
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    class Method < BaseMethod
+      include Source::NodeMethods
+
+      # @return [Array<String>]
+      attr_reader :parameters
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      def initialize location, namespace, name, comments, scope, visibility, args, node = nil
+        super(location, namespace, name, comments)
+        @scope = scope
+        @visibility = visibility
+        @parameters = args
+        @node = node
+      end
+
+      # @return [Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map{|p| p.split(/[ =:]/).first}
+      end
+
+      def kind
+        Solargraph::Pin::METHOD
+      end
+
+      def path
+        @path ||= namespace + (scope == :instance ? '#' : '.') + name
+      end
+
+      def context
+        @context ||= begin
+          if scope == :class
+            # @todo Determine whether the namespace is a class or a module
+            ComplexType.try_parse("Class<#{namespace}>")
+          else
+            ComplexType.try_parse(namespace)
+          end
+        end
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::METHOD
+      end
+
+      def symbol_kind
+        LanguageServer::SymbolKinds::METHOD
+      end
+
+      def documentation
+        if @documentation.nil?
+          @documentation ||= super || ''
+          param_tags = docstring.tags(:param)
+          unless param_tags.nil? or param_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Params:\n"
+            lines = []
+            param_tags.each do |p|
+              l = "* #{p.name}"
+              l += " [#{p.types.join(', ')}]" unless p.types.nil? or p.types.empty?
+              l += " #{p.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+        end
+        @documentation
+      end
+
+      def nearly? other
+        return false unless super
+        parameters == other.parameters and
+          scope == other.scope and
+          visibility == other.visibility
+      end
+
+      def probe api_map
+        infer_from_return_nodes(api_map)
+      end
+
+      # @deprecated Use #typify and/or #probe instead
+      def infer api_map
+        Solargraph::Logging.logger.warn 'WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead.'
+        type = typify(api_map)
+        return type unless type.undefined?
+        probe api_map
+      end
+
+      def try_merge! pin
+        return false unless super
+        @node = pin.node
+        true
+      end
+
+      private
+
+      # @return [Parser::AST:Node, nil]
+      def method_body_node
+        return nil if node.nil?
+        return node.children[2] if node.type == :def
+        return node.children[3] if node.type == :defs
+        nil
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer_from_return_nodes api_map
+        result = []
+        returns_from(method_body_node).each do |n|
+          next if n.loc.nil?
+          clip = api_map.clip_at(
+            location.filename,
+            [n.loc.expression.last_line, n.loc.expression.last_column]
+          )
+          chain = Solargraph::Source::NodeChainer.chain(n, location.filename)
+          type = chain.infer(api_map, self, clip.locals)
+          result.push type unless type.undefined?
+        end
+        return ComplexType::UNDEFINED if result.empty?
+        ComplexType.try_parse(*result.map(&:tag))
+      end
+    end
+  end
+end

data/lib/solargraph/pin/method_alias.rb

@@ -1,30 +1,30 @@
-module Solargraph
-  module Pin
-    # Use this class to track method aliases for later remapping. Common
-    # examples that defer mapping are aliases for superclass methods or
-    # methods from included modules.
-    #
-    class MethodAlias < Base
-      attr_reader :scope
-
-      attr_reader :original
-
-      def initialize location, namespace, name, scope, original
-        # @todo Determine how to handle these parameters. Among other things,
-        #   determine if the visibility is defined by the location of the
-        #   alias call or the original method.
-        super(location, namespace, name, '')
-        @scope = scope
-        @original = original
-      end
-
-      def kind
-        Pin::METHOD_ALIAS
-      end
-
-      def path
-        @path ||= namespace + (scope == :instance ? '#' : '.') + name
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    # Use this class to track method aliases for later remapping. Common
+    # examples that defer mapping are aliases for superclass methods or
+    # methods from included modules.
+    #
+    class MethodAlias < Base
+      attr_reader :scope
+
+      attr_reader :original
+
+      def initialize location, namespace, name, scope, original
+        # @todo Determine how to handle these parameters. Among other things,
+        #   determine if the visibility is defined by the location of the
+        #   alias call or the original method.
+        super(location, namespace, name, '')
+        @scope = scope
+        @original = original
+      end
+
+      def kind
+        Pin::METHOD_ALIAS
+      end
+
+      def path
+        @path ||= namespace + (scope == :instance ? '#' : '.') + name
+      end
+    end
+  end
+end

data/lib/solargraph/pin/method_parameter.rb

@@ -1,40 +1,40 @@
-module Solargraph
-  module Pin
-    class MethodParameter < LocalVariable
-      def return_complex_type
-        if @return_complex_type.nil?
-          @return_complex_type = ComplexType.new
-          found = nil
-          params = block.docstring.tags(:param)
-          params.each do |p|
-            next unless p.name == name
-            found = p
-            break
-          end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
-          end
-          @return_complex_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
-        end
-        super
-        @return_complex_type
-      end
-
-      # The parameter's zero-based location in the block's signature.
-      #
-      # @return [Integer]
-      def index
-        block.parameter_names.index(name)
-      end
-
-      def try_merge! pin
-        return false unless super
-        # @todo This is a little expensive, but it's necessary because
-        #   parameter data depends on the method's docstring.
-        @return_complex_type = pin.return_complex_type
-        reset_conversions
-        true
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    class MethodParameter < LocalVariable
+      def return_complex_type
+        if @return_complex_type.nil?
+          @return_complex_type = ComplexType.new
+          found = nil
+          params = block.docstring.tags(:param)
+          params.each do |p|
+            next unless p.name == name
+            found = p
+            break
+          end
+          if found.nil? and !index.nil?
+            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          end
+          @return_complex_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+        end
+        super
+        @return_complex_type
+      end
+
+      # The parameter's zero-based location in the block's signature.
+      #
+      # @return [Integer]
+      def index
+        block.parameter_names.index(name)
+      end
+
+      def try_merge! pin
+        return false unless super
+        # @todo This is a little expensive, but it's necessary because
+        #   parameter data depends on the method's docstring.
+        @return_complex_type = pin.return_complex_type
+        reset_conversions
+        true
+      end
+    end
+  end
+end

data/lib/solargraph/pin/namespace.rb

@@ -1,54 +1,54 @@
-module Solargraph
-  module Pin
-    class Namespace < Pin::Base
-      # @return [Symbol] :public or :private
-      attr_reader :visibility
-
-      # @return [Symbol] :class or :module
-      attr_reader :type
-
-      def initialize location, namespace, name, comments, type, visibility
-        super(location, namespace, name, comments)
-        @type = type
-        @visibility = visibility
-      end
-
-      def kind
-        Pin::NAMESPACE
-      end
-
-      def context
-        @context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
-      end
-
-      def scope
-        context.scope
-      end
-
-      def completion_item_kind
-        (type == :class ? LanguageServer::CompletionItemKinds::CLASS : LanguageServer::CompletionItemKinds::MODULE)
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
-      end
-
-      def path
-        @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
-      end
-
-      def return_complex_type
-        @return_complex_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
-      end
-
-      def domains
-        @domains ||= []
-      end
-
-      def typify api_map
-        return_complex_type
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    class Namespace < Pin::Base
+      # @return [Symbol] :public or :private
+      attr_reader :visibility
+
+      # @return [Symbol] :class or :module
+      attr_reader :type
+
+      def initialize location, namespace, name, comments, type, visibility
+        super(location, namespace, name, comments)
+        @type = type
+        @visibility = visibility
+      end
+
+      def kind
+        Pin::NAMESPACE
+      end
+
+      def context
+        @context ||= ComplexType.try_parse("#{type.to_s.capitalize}<#{path}>")
+      end
+
+      def scope
+        context.scope
+      end
+
+      def completion_item_kind
+        (type == :class ? LanguageServer::CompletionItemKinds::CLASS : LanguageServer::CompletionItemKinds::MODULE)
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        (type == :class ? LanguageServer::SymbolKinds::CLASS : LanguageServer::SymbolKinds::MODULE)
+      end
+
+      def path
+        @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
+      end
+
+      def return_complex_type
+        @return_complex_type ||= ComplexType.try_parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+      end
+
+      def domains
+        @domains ||= []
+      end
+
+      def typify api_map
+        return_complex_type
+      end
+    end
+  end
+end