jimeh-solargraph 0.40.4.0

data/lib/solargraph/parser/legacy/node_processors/sym_node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class SymNode < Parser::NodeProcessor::Base
+          def process
+            pins.push Solargraph::Pin::Symbol.new(
+              get_node_location(node),
+              ":#{node.children[0]}"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/node_methods.rb

@@ -0,0 +1,43 @@
+module Solargraph
+  module Parser
+    class NodeMethods
+      module_function
+
+      def unpack_name node
+        raise NotImplementedError
+      end
+
+      def infer_literal_type node
+        raise NotImplementedError
+      end
+
+      def calls_from node
+        raise NotImplementedError
+      end
+
+      def returns_from node
+        raise NotImplementedError
+      end
+
+      def process node
+        raise NotImplementedError
+      end
+
+      def references node
+        raise NotImplementedError
+      end
+
+      def chain node, filename = nil, in_block = false
+        raise NotImplementedError
+      end
+
+      def node? node
+        raise NotImplementedError
+      end
+
+      def convert_hash node
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/solargraph/parser/node_processor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    # The processor classes used by SourceMap::Mapper to generate pins from
+    # parser nodes.
+    #
+    module NodeProcessor
+      autoload :Base, 'solargraph/parser/node_processor/base'
+
+      class << self
+        @@processors ||= {}
+
+        # Register a processor for a node type.
+        #
+        # @param type [Symbol]
+        # @param cls [Class<NodeProcessor::Base>]
+        # @return [Class<NodeProcessor::Base>]
+        def register type, cls
+          @@processors[type] = cls
+        end
+      end
+
+      # @param node [Parser::AST::Node]
+      # @param region [Region]
+      # @param pins [Array<Pin::Base>]
+      # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
+      def self.process node, region = Region.new, pins = [], locals = []
+        if pins.empty?
+          pins.push Pin::Namespace.new(
+            location: region.source.location,
+            name: ''
+          )
+        end
+        return [pins, locals] unless Parser.is_ast_node?(node)
+        klass = @@processors[node.type] || NodeProcessor::Base
+        processor = klass.new(node, region, pins, locals)
+        processor.process
+        [processor.pins, processor.locals]
+      end
+    end
+  end
+end

data/lib/solargraph/parser/node_processor/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module NodeProcessor
+      class Base
+        # @todo The base node processor should not include legacy node methods
+        # include Legacy::NodeMethods
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Region]
+        attr_reader :region
+
+        # @return [Array<Pin::Base>]
+        attr_reader :pins
+
+        # @return [Array<Pin::Base>]
+        attr_reader :locals
+
+        # @param node [Parser::AST::Node]
+        # @param region [Region]
+        # @param pins [Array<Pin::Base>]
+        def initialize node, region, pins, locals
+          @node = node
+          @region = region
+          @pins = pins
+          @locals = locals
+          @processed_children = false
+        end
+
+        # Subclasses should override this method to generate new pins.
+        #
+        # @return [void]
+        def process
+          process_children
+        end
+
+        private
+
+        # @param subregion [Region]
+        # @return [void]
+        def process_children subregion = region
+          return if @processed_children
+          @processed_children = true
+          node.children.each do |child|
+            next unless Parser.is_ast_node?(child)
+            NodeProcessor.process(child, subregion, pins, locals)
+          end
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Solargraph::Location]
+        def get_node_location(node)
+          range = Parser.node_range(node)
+          Location.new(region.filename, range)
+        end
+
+        def comments_for(node)
+          region.source.comments_for(node)
+        end
+
+        def named_path_pin position
+          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.path && !pin.path.empty? && pin.location.range.contain?(position)}.last
+        end
+
+        # @todo Candidate for deprecation
+        def block_pin position
+          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+        end
+
+        # @todo Candidate for deprecation
+        def closure_pin position
+          pins.select{|pin| pin.is_a?(Pin::Closure) && pin.location.range.contain?(position)}.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/region.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    # Data used by the parser to track context at various locations in a
+    # source.
+    #
+    class Region
+      # @return [Pin::Closure]
+      attr_reader :closure
+
+      # @return [Symbol]
+      attr_reader :scope
+
+      # @return [Symbol]
+      attr_reader :visibility
+
+      # @return [Solargraph::Source]
+      attr_reader :source
+
+      # @return [Array<Symbol>]
+      attr_reader :lvars
+
+      # @param source [Source]
+      # @param namespace [String]
+      # @param scope [Symbol]
+      # @param visibility [Symbol]
+      def initialize source: Solargraph::Source.load_string(''), closure: nil,
+                     scope: nil, visibility: :public, lvars: []
+        @source = source
+        # @closure = closure
+        @closure = closure || Pin::Namespace.new(name: '', location: source.location)
+        @scope = scope
+        @visibility = visibility
+        @lvars = lvars
+      end
+
+      # @return [String]
+      def filename
+        source.filename
+      end
+
+      # Generate a new Region with the provided attribute changes.
+      #
+      # @param closure [Pin::Closure, nil]
+      # @param scope [Symbol, nil]
+      # @param visibility [Symbol, nil]
+      # @return [Region]
+      def update closure: nil, scope: nil, visibility: nil, lvars: nil
+        Region.new(
+          source: source,
+          closure: closure || self.closure,
+          scope: scope || self.scope,
+          visibility: visibility || self.visibility,
+          lvars: lvars || self.lvars
+        )
+      end
+
+      # @param node [Parser::AST::Node]
+      # @return [String]
+      def code_for node
+        source.code_for(node)
+      end
+    end
+  end
+end

data/lib/solargraph/parser/rubyvm.rb

@@ -0,0 +1,40 @@
+module Solargraph
+  module Parser
+    module Rubyvm
+      autoload :ClassMethods, 'solargraph/parser/rubyvm/class_methods'
+      autoload :NodeChainer,  'solargraph/parser/rubyvm/node_chainer'
+      autoload :NodeMethods,  'solargraph/parser/rubyvm/node_methods'
+    end
+  end
+end
+
+require 'solargraph/parser/rubyvm/node_processors'
+
+class RubyVM::AbstractSyntaxTree::Node
+  def to_sexp
+    sexp self
+  end
+
+  def == other
+    return false unless other.is_a?(self.class)
+    here = Solargraph::Range.from_node(self)
+    there = Solargraph::Range.from_node(other)
+    here == there && to_sexp == other.to_sexp
+  end
+
+  private
+
+  def sexp node, depth = 0
+    result = ''
+    if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      result += "#{'  ' * depth}(:#{node.type}"
+      node.children.each do |child|
+        result += "\n" + sexp(child, depth + 1)
+      end
+      result += ")"
+    else
+      result += "#{'  ' * depth}#{node.inspect}"
+    end
+    result
+  end
+end

data/lib/solargraph/parser/rubyvm/class_methods.rb

@@ -0,0 +1,150 @@
+require 'solargraph/parser/rubyvm/node_processors'
+
+module Solargraph
+  module Parser
+    module Rubyvm
+      module ClassMethods
+        # @param code [String]
+        # @param filename [String]
+        # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
+        def parse_with_comments code, filename = nil
+          node = RubyVM::AbstractSyntaxTree.parse(code).children[2]
+          comments = CommentRipper.new(code).parse
+          [node, comments]
+        rescue ::SyntaxError => e
+          raise Parser::SyntaxError, e.message
+        end
+
+        # @param code [String]
+        # @param filename [String, nil]
+        # @param line [Integer]
+        # @return [Parser::AST::Node]
+        def parse code, filename = nil, line = 0
+          RubyVM::AbstractSyntaxTree.parse(code).children[2]
+        rescue ::SyntaxError => e
+          raise Parser::SyntaxError, e.message
+        end
+
+        def map source
+          NodeProcessor.process(source.node, Region.new(source: source))
+        end
+
+        # def returns_from node
+        #   return [] unless Parser.is_ast_node?(node)
+        #   if node.type == :SCOPE
+        #     # node.children.select { |n| n.is_a?(RubyVM::AbstractSyntaxTree::Node) }.map { |n| DeepInference.get_return_nodes(n) }.flatten
+        #     DeepInference.get_return_nodes(node.children[2])
+        #   else
+        #     DeepInference.get_return_nodes(node)
+        #   end
+        # end
+
+        def references source, name
+          inner_node_references(name, source.node).map do |n|
+            rng = Range.from_node(n)
+            offset = Position.to_offset(source.code, rng.start)
+            soff = source.code.index(name, offset)
+            eoff = soff + name.length
+            Location.new(
+              source.filename,
+              Range.new(
+                Position.from_offset(source.code, soff),
+                Position.from_offset(source.code, eoff)
+              )
+            )
+          end
+        end
+
+        # @param name [String]
+        # @param top [AST::Node]
+        # @return [Array<AST::Node>]
+        def inner_node_references name, top
+          result = []
+          if Parser.rubyvm?
+            if Parser.is_ast_node?(top)
+              result.push top if match_rubyvm_node_to_ref(top, name)
+              top.children.each { |c| result.concat inner_node_references(name, c) }
+            end
+          else
+            if Parser.is_ast_node?(top) && top.to_s.include?(":#{name}")
+              result.push top if top.children.any? { |c| c.to_s == name }
+              top.children.each { |c| result.concat inner_node_references(name, c) }
+            end
+          end
+          result
+        end
+
+        def match_rubyvm_node_to_ref(top, name)
+          top.children.select { |c| c.is_a?(Symbol) }.any? { |c| c.to_s == name } ||
+            top.children.select { |c| c.is_a?(Array) }.any? { |c| c.include?(name.to_sym) }
+        end
+
+        def chain *args
+          NodeChainer.chain *args
+        end
+
+        def chain_string *args
+          NodeChainer.load_string *args
+        end
+
+        def process_node *args
+          Solargraph::Parser::NodeProcessor.process *args
+        end
+
+        def infer_literal_node_type node
+          # NodeMethods.infer_literal_node_type node
+        end
+
+        def version
+          Ruby::VERSION
+        end
+
+        def is_ast_node? node
+          if Parser.rubyvm?
+            node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          else
+            node.is_a?(::Parser::AST::Node)
+          end
+        end
+
+        def node_range node
+          st = Position.new(node.first_lineno - 1, node.first_column)
+          en = Position.new(node.last_lineno - 1, node.last_column)
+          Range.new(st, en)
+        end
+
+        def recipient_node tree
+          tree.each_with_index do |node, idx|
+            return tree[idx + 1] if [:ARRAY, :ZARRAY, :LIST].include?(node.type) && tree[idx + 1] && [:FCALL, :VCALL, :CALL].include?(tree[idx + 1].type)
+          end
+          nil
+        end
+
+        def string_ranges node
+          return [] unless is_ast_node?(node)
+          result = []
+          if node.type == :STR
+            result.push Range.from_node(node)
+          elsif node.type == :DSTR
+            here = Range.from_node(node)
+            there = Range.from_node(node.children[1])
+            result.push Range.new(here.start, there.start)
+          end
+          node.children.each do |child|
+            result.concat string_ranges(child)
+          end
+          if node.type == :DSTR && node.children.last.nil?
+            # result.push Range.new(result.last.ending, result.last.ending)
+            last = node.children[-2]
+            unless last.nil?
+              rng = Range.from_node(last)
+              pos = Position.new(rng.ending.line, rng.ending.column - 1)
+              result.push Range.new(pos, pos)
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end