solargraph 0.32.1 → 0.32.2

data/lib/solargraph/source/node_methods.rb

@@ -1,225 +1,225 @@
-module Solargraph
-  class Source
-    module NodeMethods
-      module_function
-
-      # @param node [Parser::AST::Node]
-      # @return [String]
-      def unpack_name(node)
-        pack_name(node).join("::")
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [Array<String>]
-      def pack_name(node)
-        parts = []
-        if node.kind_of?(AST::Node)
-          node.children.each { |n|
-            if n.kind_of?(AST::Node)
-              if n.type == :cbase
-                parts = [''] + pack_name(n)
-              else
-                parts += pack_name(n)
-              end
-            else
-              parts.push n unless n.nil?
-            end
-          }
-        end
-        parts
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [String]
-      def const_from node
-        if node.kind_of?(AST::Node) and node.type == :const
-          result = ''
-          unless node.children[0].nil?
-            result = const_from(node.children[0])
-          end
-          if result == ''
-            result = node.children[1].to_s
-          else
-            result = result + '::' + node.children[1].to_s
-          end
-          result
-        else
-          nil
-        end
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [String]
-      def infer_literal_node_type node
-        return nil unless node.kind_of?(AST::Node)
-        if node.type == :str or node.type == :dstr
-          return 'String'
-        elsif node.type == :array
-          return 'Array'
-        elsif node.type == :hash
-          return 'Hash'
-        elsif node.type == :int
-          return 'Integer'
-        elsif node.type == :float
-          return 'Float'
-        elsif node.type == :sym
-          return 'Symbol'
-        elsif node.type == :regexp
-          return 'Regexp'
-        # @todo Maybe ignore nils
-        # elsif node.type == :nil
-        #   return 'NilClass'
-        end
-        nil
-      end
-
-      # Get a call signature from a node.
-      # The result should be a string in the form of a method path, e.g.,
-      # String.new or variable.method.
-      #
-      # @param node [Parser::AST::Node]
-      # @return [String]
-      def resolve_node_signature node
-        result = drill_signature node, ''
-        return nil if result.empty?
-        result
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [Position]
-      def get_node_start_position(node)
-        Position.new(node.loc.line, node.loc.column)
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [Position]
-      def get_node_end_position(node)
-        Position.new(node.loc.last_line, node.loc.last_column)
-      end
-
-      def drill_signature node, signature
-        return signature unless node.kind_of?(AST::Node)
-        if node.type == :const or node.type == :cbase
-          unless node.children[0].nil?
-            signature += drill_signature(node.children[0], signature)
-          end
-          signature += '::' unless signature.empty?
-          signature += node.children[1].to_s
-        elsif node.type == :lvar or node.type == :ivar or node.type == :cvar
-          signature += '.' unless signature.empty?
-          signature += node.children[0].to_s
-        elsif node.type == :send
-          unless node.children[0].nil?
-            signature += drill_signature(node.children[0], signature)
-          end
-          signature += '.' unless signature.empty?
-          signature += node.children[1].to_s
-        end
-        signature
-      end
-
-      # Find all the nodes within the provided node that potentially return a
-      # value.
-      #
-      # The node parameter typically represents a method's logic, e.g., the
-      # second child (after the :args node) of a :def node. A simple one-line
-      # method would typically return itself, while a node with conditions
-      # would return the resulting node from each conditional branch. Nodes
-      # that follow a :return node are assumed to be unreachable. Implicit nil
-      # values are ignored.
-      #
-      # @todo Maybe this method should include implicit nil values in results.
-      #   For example, a bare `return` would return a :nil node instead of an
-      #   empty array.
-      #
-      # @param node [AST::Node]
-      # @return [Array<AST::Node>]
-      def returns_from node
-        DeepInference.get_return_nodes(node)
-      end
-
-      module DeepInference
-        class << self
-          CONDITIONAL = [:if, :unless]
-          REDUCEABLE = [:begin, :kwbegin]
-          SKIPPABLE = [:def, :defs, :class, :sclass, :module]
-
-          # @param node [Parser::AST::Node]
-          # @return [Array<Parser::AST::Node>]
-          def get_return_nodes node
-            return [] unless node.is_a?(Parser::AST::Node)
-            result = []
-            if REDUCEABLE.include?(node.type)
-              result.concat get_return_nodes_from_children(node)
-            elsif CONDITIONAL.include?(node.type)
-              result.concat reduce_to_value_nodes(node.children[1..-1])
-            elsif node.type == :and || node.type == :or
-              result.concat reduce_to_value_nodes(node.children)
-            elsif node.type == :return
-              result.concat reduce_to_value_nodes([node.children[0]])
-            else
-              result.push node
-            end
-            result
-          end
-
-          private
-
-          def get_return_nodes_from_children parent
-            result = []
-            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
-            nodes[0..-2].each do |node|
-              next if SKIPPABLE.include?(node.type)
-              if node.type == :return
-                result.concat reduce_to_value_nodes([node.children[0]])
-                # Return the result here because the rest of the code is
-                # unreachable
-                return result
-              else
-                result.concat get_return_nodes_only(node)
-              end
-            end
-            result.concat reduce_to_value_nodes([nodes.last]) unless nodes.last.nil?
-            result
-          end
-
-          def get_return_nodes_only parent
-            result = []
-            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
-            nodes.each do |node|
-              next if SKIPPABLE.include?(node.type)
-              if node.type == :return
-                result.concat reduce_to_value_nodes([node.children[0]])
-                # Return the result here because the rest of the code is
-                # unreachable
-                return result
-              else
-                result.concat get_return_nodes_only(node)
-              end
-            end
-            result
-          end
-
-          def reduce_to_value_nodes nodes
-            result = []
-            nodes.each do |node|
-              next unless node.is_a?(Parser::AST::Node)
-              if REDUCEABLE.include?(node.type)
-                result.concat get_return_nodes_from_children(node)
-              elsif CONDITIONAL.include?(node.type)
-                result.concat reduce_to_value_nodes(node.children[1..-1])
-              elsif node.type == :return
-                result.concat get_return_nodes(node.children[0])
-              elsif node.type == :and || node.type == :or
-                result.concat reduce_to_value_nodes(node.children)
-              else
-                result.push node
-              end
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end
+module Solargraph
+  class Source
+    module NodeMethods
+      module_function
+
+      # @param node [Parser::AST::Node]
+      # @return [String]
+      def unpack_name(node)
+        pack_name(node).join("::")
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [Array<String>]
+      def pack_name(node)
+        parts = []
+        if node.kind_of?(AST::Node)
+          node.children.each { |n|
+            if n.kind_of?(AST::Node)
+              if n.type == :cbase
+                parts = [''] + pack_name(n)
+              else
+                parts += pack_name(n)
+              end
+            else
+              parts.push n unless n.nil?
+            end
+          }
+        end
+        parts
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [String]
+      def const_from node
+        if node.kind_of?(AST::Node) and node.type == :const
+          result = ''
+          unless node.children[0].nil?
+            result = const_from(node.children[0])
+          end
+          if result == ''
+            result = node.children[1].to_s
+          else
+            result = result + '::' + node.children[1].to_s
+          end
+          result
+        else
+          nil
+        end
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [String]
+      def infer_literal_node_type node
+        return nil unless node.kind_of?(AST::Node)
+        if node.type == :str or node.type == :dstr
+          return 'String'
+        elsif node.type == :array
+          return 'Array'
+        elsif node.type == :hash
+          return 'Hash'
+        elsif node.type == :int
+          return 'Integer'
+        elsif node.type == :float
+          return 'Float'
+        elsif node.type == :sym
+          return 'Symbol'
+        elsif node.type == :regexp
+          return 'Regexp'
+        # @todo Maybe ignore nils
+        # elsif node.type == :nil
+        #   return 'NilClass'
+        end
+        nil
+      end
+
+      # Get a call signature from a node.
+      # The result should be a string in the form of a method path, e.g.,
+      # String.new or variable.method.
+      #
+      # @param node [Parser::AST::Node]
+      # @return [String]
+      def resolve_node_signature node
+        result = drill_signature node, ''
+        return nil if result.empty?
+        result
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_start_position(node)
+        Position.new(node.loc.line, node.loc.column)
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [Position]
+      def get_node_end_position(node)
+        Position.new(node.loc.last_line, node.loc.last_column)
+      end
+
+      def drill_signature node, signature
+        return signature unless node.kind_of?(AST::Node)
+        if node.type == :const or node.type == :cbase
+          unless node.children[0].nil?
+            signature += drill_signature(node.children[0], signature)
+          end
+          signature += '::' unless signature.empty?
+          signature += node.children[1].to_s
+        elsif node.type == :lvar or node.type == :ivar or node.type == :cvar
+          signature += '.' unless signature.empty?
+          signature += node.children[0].to_s
+        elsif node.type == :send
+          unless node.children[0].nil?
+            signature += drill_signature(node.children[0], signature)
+          end
+          signature += '.' unless signature.empty?
+          signature += node.children[1].to_s
+        end
+        signature
+      end
+
+      # Find all the nodes within the provided node that potentially return a
+      # value.
+      #
+      # The node parameter typically represents a method's logic, e.g., the
+      # second child (after the :args node) of a :def node. A simple one-line
+      # method would typically return itself, while a node with conditions
+      # would return the resulting node from each conditional branch. Nodes
+      # that follow a :return node are assumed to be unreachable. Implicit nil
+      # values are ignored.
+      #
+      # @todo Maybe this method should include implicit nil values in results.
+      #   For example, a bare `return` would return a :nil node instead of an
+      #   empty array.
+      #
+      # @param node [AST::Node]
+      # @return [Array<AST::Node>]
+      def returns_from node
+        DeepInference.get_return_nodes(node)
+      end
+
+      module DeepInference
+        class << self
+          CONDITIONAL = [:if, :unless]
+          REDUCEABLE = [:begin, :kwbegin]
+          SKIPPABLE = [:def, :defs, :class, :sclass, :module]
+
+          # @param node [Parser::AST::Node]
+          # @return [Array<Parser::AST::Node>]
+          def get_return_nodes node
+            return [] unless node.is_a?(Parser::AST::Node)
+            result = []
+            if REDUCEABLE.include?(node.type)
+              result.concat get_return_nodes_from_children(node)
+            elsif CONDITIONAL.include?(node.type)
+              result.concat reduce_to_value_nodes(node.children[1..-1])
+            elsif node.type == :and || node.type == :or
+              result.concat reduce_to_value_nodes(node.children)
+            elsif node.type == :return
+              result.concat reduce_to_value_nodes([node.children[0]])
+            else
+              result.push node
+            end
+            result
+          end
+
+          private
+
+          def get_return_nodes_from_children parent
+            result = []
+            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+            nodes[0..-2].each do |node|
+              next if SKIPPABLE.include?(node.type)
+              if node.type == :return
+                result.concat reduce_to_value_nodes([node.children[0]])
+                # Return the result here because the rest of the code is
+                # unreachable
+                return result
+              else
+                result.concat get_return_nodes_only(node)
+              end
+            end
+            result.concat reduce_to_value_nodes([nodes.last]) unless nodes.last.nil?
+            result
+          end
+
+          def get_return_nodes_only parent
+            result = []
+            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+            nodes.each do |node|
+              next if SKIPPABLE.include?(node.type)
+              if node.type == :return
+                result.concat reduce_to_value_nodes([node.children[0]])
+                # Return the result here because the rest of the code is
+                # unreachable
+                return result
+              else
+                result.concat get_return_nodes_only(node)
+              end
+            end
+            result
+          end
+
+          def reduce_to_value_nodes nodes
+            result = []
+            nodes.each do |node|
+              next unless node.is_a?(Parser::AST::Node)
+              if REDUCEABLE.include?(node.type)
+                result.concat get_return_nodes_from_children(node)
+              elsif CONDITIONAL.include?(node.type)
+                result.concat reduce_to_value_nodes(node.children[1..-1])
+              elsif node.type == :return
+                result.concat get_return_nodes(node.children[0])
+              elsif node.type == :and || node.type == :or
+                result.concat reduce_to_value_nodes(node.children)
+              else
+                result.push node
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/source_chainer.rb

@@ -1,183 +1,183 @@
-module Solargraph
-  class Source
-    # Information about a location in a source, including the location's word
-    # and signature, literal values at the base of signatures, and whether the
-    # location is inside a string or comment. ApiMaps use Fragments to provide
-    # results for completion and definition queries.
-    #
-    class SourceChainer
-      include Source::NodeMethods
-
-      private_class_method :new
-
-      class << self
-        # @param source [Source]
-        # @param position [Position]
-        # @return [Source::Chain]
-        def chain source, position
-          # raise "Not a source" unless source.is_a?(Source)
-          new(source, position).chain
-        end
-      end
-
-      # @param source [Source]
-      # @param position [Position]
-      def initialize source, position
-        @source = source
-        @position = position
-        @calculated_literal = false
-      end
-
-      # @return [Source::Chain]
-      def chain
-        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
-        begin
-          return Chain.new([]) if phrase.end_with?('..')
-          if !source.repaired? && source.parsed? && source.synchronized?
-            node = source.node_at(position.line, position.column)
-          else
-            node = nil
-            node = source.node_at(fixed_position.line, fixed_position.column) unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
-            # Exception for positions that chain literal nodes in unsynchronized sources
-            node = nil unless source.synchronized? || !infer_literal_node_type(node).nil?
-            node = Source.parse(fixed_phrase) if node.nil?
-          end
-        rescue Parser::SyntaxError
-          return Chain.new([Chain::UNDEFINED_CALL])
-        end
-        return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
-        chain = NodeChainer.chain(node, source.filename)
-        if source.repaired? || !source.parsed? || !source.synchronized?
-          if end_of_phrase.strip == '.'
-            chain.links.push Chain::UNDEFINED_CALL
-          elsif end_of_phrase.strip == '::'
-            chain.links.push Chain::UNDEFINED_CONSTANT
-          end
-        end
-        chain
-      end
-
-      private
-
-      # @return [Position]
-      attr_reader :position
-
-      # @return [Solargraph::Source]
-      attr_reader :source
-
-      # @return [String]
-      def phrase
-        @phrase ||= source.code[signature_data[0]..offset-1]
-      end
-
-      # @return [String]
-      def fixed_phrase
-        @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
-      end
-
-      # @return [Position]
-      def fixed_position
-        @fixed_position ||= Position.from_offset(source.code, offset - end_of_phrase.length)
-      end
-
-      # @return [String]
-      def end_of_phrase
-        @end_of_phrase ||= begin
-          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
-          if match
-            match[0]
-          else
-            ''
-          end
-        end
-      end
-
-      # True if the current offset is inside a string.
-      #
-      # @return [Boolean]
-      def string?
-        # @string ||= (node.type == :str or node.type == :dstr)
-        @string ||= @source.string_at?(position)
-      end
-
-      # @return [Integer]
-      def offset
-        @offset ||= get_offset(position.line, position.column)
-      end
-
-      # @param line [Integer]
-      # @param column [Integer]
-      # @return [Integer]
-      def get_offset line, column
-        Position.line_char_to_offset(@source.code, line, column)
-      end
-
-      def signature_data
-        @signature_data ||= get_signature_data_at(offset)
-      end
-
-      def get_signature_data_at index
-        brackets = 0
-        squares = 0
-        parens = 0
-        signature = ''
-        index -=1
-        in_whitespace = false
-        while index >= 0
-          pos = Position.from_offset(@source.code, index)
-          break if index > 0 and @source.comment_at?(pos)
-          unless !in_whitespace and string?
-            break if brackets > 0 or parens > 0 or squares > 0
-            char = @source.code[index, 1]
-            break if char.nil? # @todo Is this the right way to handle this?
-            if brackets.zero? and parens.zero? and squares.zero? and [' ', "\r", "\n", "\t"].include?(char)
-              in_whitespace = true
-            else
-              if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
-                unless char == '.' or @source.code[index+1..-1].strip.start_with?('.')
-                  old = @source.code[index+1..-1]
-                  nxt = @source.code[index+1..-1].lstrip
-                  index += (@source.code[index+1..-1].length - @source.code[index+1..-1].lstrip.length)
-                  break
-                end
-              end
-              if char == ')'
-                parens -=1
-              elsif char == ']'
-                squares -=1
-              elsif char == '}'
-                brackets -= 1
-              elsif char == '('
-                parens += 1
-              elsif char == '{'
-                brackets += 1
-              elsif char == '['
-                squares += 1
-                signature = ".[]#{signature}" if parens.zero? and brackets.zero? and squares.zero? and @source.code[index-2] != '%'
-              end
-              if brackets.zero? and parens.zero? and squares.zero?
-                break if ['"', "'", ',', ';', '%'].include?(char)
-                break if !signature.empty? && ['!', '?'].include?(char)
-                signature = char + signature if char.match(/[a-z0-9:\._@\$\?\!]/i) and @source.code[index - 1] != '%'
-                break if char == '$'
-                if char == '@'
-                  index -= 1
-                  if @source.code[index, 1] == '@'
-                    index -= 1
-                    signature = "@#{signature}"
-                  end
-                  break
-                end
-              elsif parens == 1 || brackets == 1 || squares == 1
-                break
-              end
-              in_whitespace = false
-            end
-          end
-          index -= 1
-        end
-        [index + 1, signature]
-      end
-    end
-  end
-end
+module Solargraph
+  class Source
+    # Information about a location in a source, including the location's word
+    # and signature, literal values at the base of signatures, and whether the
+    # location is inside a string or comment. ApiMaps use Fragments to provide
+    # results for completion and definition queries.
+    #
+    class SourceChainer
+      include Source::NodeMethods
+
+      private_class_method :new
+
+      class << self
+        # @param source [Source]
+        # @param position [Position]
+        # @return [Source::Chain]
+        def chain source, position
+          # raise "Not a source" unless source.is_a?(Source)
+          new(source, position).chain
+        end
+      end
+
+      # @param source [Source]
+      # @param position [Position]
+      def initialize source, position
+        @source = source
+        @position = position
+        @calculated_literal = false
+      end
+
+      # @return [Source::Chain]
+      def chain
+        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        begin
+          return Chain.new([]) if phrase.end_with?('..')
+          if !source.repaired? && source.parsed? && source.synchronized?
+            node = source.node_at(position.line, position.column)
+          else
+            node = nil
+            node = source.node_at(fixed_position.line, fixed_position.column) unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
+            # Exception for positions that chain literal nodes in unsynchronized sources
+            node = nil unless source.synchronized? || !infer_literal_node_type(node).nil?
+            node = Source.parse(fixed_phrase) if node.nil?
+          end
+        rescue Parser::SyntaxError
+          return Chain.new([Chain::UNDEFINED_CALL])
+        end
+        return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
+        chain = NodeChainer.chain(node, source.filename)
+        if source.repaired? || !source.parsed? || !source.synchronized?
+          if end_of_phrase.strip == '.'
+            chain.links.push Chain::UNDEFINED_CALL
+          elsif end_of_phrase.strip == '::'
+            chain.links.push Chain::UNDEFINED_CONSTANT
+          end
+        end
+        chain
+      end
+
+      private
+
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Solargraph::Source]
+      attr_reader :source
+
+      # @return [String]
+      def phrase
+        @phrase ||= source.code[signature_data[0]..offset-1]
+      end
+
+      # @return [String]
+      def fixed_phrase
+        @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
+      end
+
+      # @return [Position]
+      def fixed_position
+        @fixed_position ||= Position.from_offset(source.code, offset - end_of_phrase.length)
+      end
+
+      # @return [String]
+      def end_of_phrase
+        @end_of_phrase ||= begin
+          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          if match
+            match[0]
+          else
+            ''
+          end
+        end
+      end
+
+      # True if the current offset is inside a string.
+      #
+      # @return [Boolean]
+      def string?
+        # @string ||= (node.type == :str or node.type == :dstr)
+        @string ||= @source.string_at?(position)
+      end
+
+      # @return [Integer]
+      def offset
+        @offset ||= get_offset(position.line, position.column)
+      end
+
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Integer]
+      def get_offset line, column
+        Position.line_char_to_offset(@source.code, line, column)
+      end
+
+      def signature_data
+        @signature_data ||= get_signature_data_at(offset)
+      end
+
+      def get_signature_data_at index
+        brackets = 0
+        squares = 0
+        parens = 0
+        signature = ''
+        index -=1
+        in_whitespace = false
+        while index >= 0
+          pos = Position.from_offset(@source.code, index)
+          break if index > 0 and @source.comment_at?(pos)
+          unless !in_whitespace and string?
+            break if brackets > 0 or parens > 0 or squares > 0
+            char = @source.code[index, 1]
+            break if char.nil? # @todo Is this the right way to handle this?
+            if brackets.zero? and parens.zero? and squares.zero? and [' ', "\r", "\n", "\t"].include?(char)
+              in_whitespace = true
+            else
+              if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
+                unless char == '.' or @source.code[index+1..-1].strip.start_with?('.')
+                  old = @source.code[index+1..-1]
+                  nxt = @source.code[index+1..-1].lstrip
+                  index += (@source.code[index+1..-1].length - @source.code[index+1..-1].lstrip.length)
+                  break
+                end
+              end
+              if char == ')'
+                parens -=1
+              elsif char == ']'
+                squares -=1
+              elsif char == '}'
+                brackets -= 1
+              elsif char == '('
+                parens += 1
+              elsif char == '{'
+                brackets += 1
+              elsif char == '['
+                squares += 1
+                signature = ".[]#{signature}" if parens.zero? and brackets.zero? and squares.zero? and @source.code[index-2] != '%'
+              end
+              if brackets.zero? and parens.zero? and squares.zero?
+                break if ['"', "'", ',', ';', '%'].include?(char)
+                break if !signature.empty? && ['!', '?'].include?(char)
+                signature = char + signature if char.match(/[a-z0-9:\._@\$\?\!]/i) and @source.code[index - 1] != '%'
+                break if char == '$'
+                if char == '@'
+                  index -= 1
+                  if @source.code[index, 1] == '@'
+                    index -= 1
+                    signature = "@#{signature}"
+                  end
+                  break
+                end
+              elsif parens == 1 || brackets == 1 || squares == 1
+                break
+              end
+              in_whitespace = false
+            end
+          end
+          index -= 1
+        end
+        [index + 1, signature]
+      end
+    end
+  end
+end