solargraph 0.28.4 → 0.29.0

data/lib/solargraph/source_map/node_processor.rb

@@ -0,0 +1,75 @@
+module Solargraph
+  class SourceMap
+    # The processor classes used by SourceMap::Mapper to generate pins from
+    # parser nodes.
+    #
+    module NodeProcessor
+      autoload :Base,           'solargraph/source_map/node_processor/base'
+      autoload :BeginNode,      'solargraph/source_map/node_processor/begin_node'
+      autoload :DefNode,        'solargraph/source_map/node_processor/def_node'
+      autoload :DefsNode,       'solargraph/source_map/node_processor/defs_node'
+      autoload :SendNode,       'solargraph/source_map/node_processor/send_node'
+      autoload :NamespaceNode,  'solargraph/source_map/node_processor/namespace_node'
+      autoload :SclassNode,     'solargraph/source_map/node_processor/sclass_node'
+      autoload :ModuleNode,     'solargraph/source_map/node_processor/module_node'
+      autoload :IvasgnNode,     'solargraph/source_map/node_processor/ivasgn_node'
+      autoload :CvasgnNode,     'solargraph/source_map/node_processor/cvasgn_node'
+      autoload :LvasgnNode,     'solargraph/source_map/node_processor/lvasgn_node'
+      autoload :GvasgnNode,     'solargraph/source_map/node_processor/gvasgn_node'
+      autoload :CasgnNode,      'solargraph/source_map/node_processor/casgn_node'
+      autoload :AliasNode,      'solargraph/source_map/node_processor/alias_node'
+      autoload :ArgsNode,       'solargraph/source_map/node_processor/args_node'
+      autoload :BlockNode,      'solargraph/source_map/node_processor/block_node'
+      autoload :OrasgnNode,     'solargraph/source_map/node_processor/orasgn_node'
+      autoload :SymNode,        'solargraph/source_map/node_processor/sym_node'
+
+      class << self
+        @@processors ||= {}
+
+        private
+
+        def register node, cls
+          @@processors[node] = cls
+        end
+      end
+
+      register :source, BeginNode
+      register :begin, BeginNode
+      register :kwbegin, BeginNode
+      # # @todo Is this the best way to handle rescue nodes?
+      register :rescue, BeginNode
+      register :resbody, BeginNode
+      register :def, DefNode
+      register :defs, DefsNode
+      register :send, SendNode
+      register :class, NamespaceNode
+      register :module, NamespaceNode
+      register :sclass, SclassNode
+      register :ivasgn, IvasgnNode
+      register :cvasgn, CvasgnNode
+      register :lvasgn, LvasgnNode
+      register :gvasgn, GvasgnNode
+      register :casgn, CasgnNode
+      register :alias, AliasNode
+      register :args, ArgsNode
+      register :block, BlockNode
+      register :or_asgn, OrasgnNode
+      register :sym, SymNode
+
+      module_function
+
+      # @param node [Parser::AST::Node]
+      # @param region [Region]
+      # @param pins [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def process node, region = Region.new(nil, '', :instance, :public, []), pins = []
+        pins.push Pin::Namespace.new(region.source.location, '', '', nil, :class, :public) if pins.empty?
+        return pins unless node.is_a?(Parser::AST::Node) #&& @@processors.key?(node.type)
+        klass = @@processors[node.type] || BeginNode
+        processor = klass.new(node, region, pins)
+        processor.process
+        processor.pins
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/alias_node.rb

@@ -0,0 +1,21 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class AliasNode < Base
+        def process
+          pin = pins.select{|p| p.name == node.children[1].children[0].to_s && p.namespace == region.namespace && p.scope == region.scope}.first
+          if pin.nil?
+            pins.push Solargraph::Pin::MethodAlias.new(get_node_location(node), region.namespace, node.children[0].children[0].to_s, region.scope, node.children[1].children[0].to_s)
+          else
+            if pin.is_a?(Solargraph::Pin::Method)
+              pins.push Solargraph::Pin::Method.new(get_node_location(node), pin.namespace, node.children[0].children[0].to_s, comments_for(node) || pin.comments, pin.scope, pin.visibility, pin.parameters, pin.node)
+            elsif pin.is_a?(Solargraph::Pin::Attribute)
+              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), pin.namespace, node.children[0].children[0].to_s, comments_for(node) || pin.comments, pin.access, pin.scope, pin.visibility)
+            end
+          end
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/args_node.rb

@@ -0,0 +1,28 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class ArgsNode < Base
+        def process
+          return if node.children.empty?
+          here = get_node_start_position(node)
+          context = named_path_pin(here)
+          block = block_pin(here)
+          if block.kind == Solargraph::Pin::BLOCK
+            pi = 0
+            node.children.each do |u|
+              pins.push Solargraph::Pin::BlockParameter.new(get_node_location(u), region.namespace, "#{u.children[0]}", comments_for(node), block)
+              block.parameters.push pins.last
+              pi += 1
+            end
+          else
+            node.children.each do |u|
+              presence = Range.new(here, block.location.range.ending)
+              pins.push Solargraph::Pin::MethodParameter.new(get_node_location(u), region.namespace, u.children[0].to_s, comments_for(node), u.children[1], infer_literal_node_type(u.children[1]), context, block, presence)
+            end
+          end
+          process_children
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class Base
+        include Solargraph::Source::NodeMethods
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Region]
+        attr_reader :region
+
+        # @return [Array<Pin::Base>]
+        attr_reader :pins
+
+        # @param node [Parser::AST::Node]
+        # @param region [Region]
+        # @param pins [Array<Pin::Base>]
+        def initialize node, region, pins
+          @node = node
+          @region = region
+          @pins = pins
+        end
+
+        protected
+
+        # Subclasses should override this method to generate new pins.
+        #
+        # @return [void]
+        def process
+          raise NoMethodError, "#{self.class} does not implement the `process` method"
+        end
+
+        private
+
+        # @param subregion [Region]
+        # @return [void]
+        def process_children subregion = region
+          node.children.each do |child|
+            next unless child.is_a?(Parser::AST::Node)
+            NodeProcessor.process(child, subregion, pins)
+          end
+        end
+
+        # @param node [Parser::AST::Node]
+        # @return [Solargraph::Location]
+        def get_node_location(node)
+          st = Position.new(node.loc.line, node.loc.column)
+          en = Position.new(node.loc.last_line, node.loc.last_column)
+          range = Range.new(st, en)
+          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::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
+        end
+
+        def block_pin position
+          pins.select{|pin| [Pin::BLOCK, Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/begin_node.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class BeginNode < Base
+        def process
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/block_node.rb

@@ -0,0 +1,14 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class BlockNode < Base
+        def process
+          here = get_node_start_position(node)
+          named_path = named_path_pin(here)
+          pins.push Solargraph::Pin::Block.new(get_node_location(node), region.namespace, '', comments_for(node), node.children[0], named_path.context)
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/casgn_node.rb

@@ -0,0 +1,14 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class CasgnNode < Base
+        def process
+          here = get_node_start_position(node)
+          block = block_pin(here)
+          pins.push Solargraph::Pin::Constant.new(get_node_location(node), region.namespace, node.children[1].to_s, comments_for(node), node.children[2], infer_literal_node_type(node.children[2]), block.context, :public)
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/cvasgn_node.rb

@@ -0,0 +1,14 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class CvasgnNode < Base
+        def process
+          here = get_node_start_position(node)
+          context = named_path_pin(here)
+          pins.push Solargraph::Pin::ClassVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), context.context)
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/def_node.rb

@@ -0,0 +1,54 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class DefNode < Base
+        def process
+          methpin = Solargraph::Pin::Method.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), region.scope, region.visibility, method_args, node)
+          if methpin.name == 'initialize' and methpin.scope == :instance
+            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, 'new', methpin.comments, :class, :public, methpin.parameters, nil)
+            # @todo Smelly instance variable access.
+            pins.last.instance_variable_set(:@return_complex_type, ComplexType.parse(methpin.namespace))
+            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, methpin.scope, :private, methpin.parameters, methpin.node)
+          elsif region.visibility == :module_function
+            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :class, :public, methpin.parameters, methpin.node)
+            pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :instance, :private, methpin.parameters, methpin.node)
+          else
+            pins.push methpin
+          end
+          process_children
+        end
+
+        private
+
+        def method_args
+          return [] if node.nil?
+          list = nil
+          args = []
+          node.children.each { |c|
+            if c.kind_of?(AST::Node) and c.type == :args
+              list = c
+              break
+            end
+          }
+          return args if list.nil?
+          list.children.each { |c|
+            if c.type == :arg
+              args.push c.children[0].to_s
+            elsif c.type == :restarg
+              args.push "*#{c.children[0]}"
+            elsif c.type == :optarg
+              args.push "#{c.children[0]} = #{region.code_for(c.children[1])}"
+            elsif c.type == :kwarg
+              args.push "#{c.children[0]}:"
+            elsif c.type == :kwoptarg
+              args.push "#{c.children[0]}: #{region.code_for(c.children[1])}"
+            elsif c.type == :blockarg
+              args.push "&#{c.children[0]}"
+            end
+          }
+          args
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/defs_node.rb

@@ -0,0 +1,21 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class DefsNode < DefNode
+        def process
+          s_visi = region.visibility
+          s_visi = :public if s_visi == :module_function || region.scope != :class
+          if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
+            dfqn = region.namespace
+          else
+            dfqn = unpack_name(node.children[0])
+          end
+          unless dfqn.nil?
+            pins.push Solargraph::Pin::Method.new(get_node_location(node), dfqn, "#{node.children[1]}", comments_for(node), :class, s_visi, method_args, node)
+            process_children region.update(namespace: dfqn)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/gvasgn_node.rb

@@ -0,0 +1,12 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class GvasgnNode < Base
+        def process
+          pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), pins.first.context)
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/ivasgn_node.rb

@@ -0,0 +1,18 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class IvasgnNode < Base
+        def process
+          here = get_node_start_position(node)
+          named_path = named_path_pin(here)
+          pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(node), region.namespace,node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), named_path.context)
+          if region.visibility == :module_function and named_path.kind == Pin::METHOD
+            other = ComplexType.parse("Module<#{named_path.context.namespace}>")
+            pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(node), region.namespace,node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), other)
+          end
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/lvasgn_node.rb

@@ -0,0 +1,16 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class LvasgnNode < Base
+        def process
+          here = get_node_start_position(node)
+          context = named_path_pin(here)
+          block = block_pin(here)
+          presence = Range.new(here, block.location.range.ending)
+          pins.push Solargraph::Pin::LocalVariable.new(get_node_location(node), region.namespace, node.children[0].to_s, comments_for(node), node.children[1], infer_literal_node_type(node.children[1]), context.context, block, presence)
+          process_children
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/namespace_node.rb

@@ -0,0 +1,26 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class NamespaceNode < Base
+        def process
+          visibility = :public
+          if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
+            tree = pack_name(node.children[0])
+            tree.shift if tree.first.empty?
+          else
+            tree = region.namespace.empty? ? [] : [region.namespace]
+            tree.concat pack_name(node.children[0])
+          end
+          fqn = tree.join('::')
+          sc = nil
+          if node.type == :class and !node.children[1].nil?
+            sc = unpack_name(node.children[1])
+          end
+          pins.push Solargraph::Pin::Namespace.new(get_node_location(node), tree[0..-2].join('::') || '', pack_name(node.children[0]).last.to_s, comments_for(node), node.type, visibility)
+          pins.push Pin::Reference::Superclass.new(pins.last.location, pins.last.path, sc) unless sc.nil?
+          process_children region.update(namespace: fqn, scope: :instance, visibility: :public)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/orasgn_node.rb

@@ -0,0 +1,12 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class OrasgnNode < Base
+        def process
+          new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
+          NodeProcessor.process(new_node, region, pins)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/sclass_node.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class SclassNode < Base
+        def process
+          process_children region.update(visibility: :public, scope: :class)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/node_processor/send_node.rb

@@ -0,0 +1,150 @@
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class SendNode < Base
+        def process
+          if node.children[0].nil?
+            if [:private, :public, :protected].include?(node.children[1])
+              # @todo Smelly instance variable access
+              region.instance_variable_set(:@visibility, node.children[1])
+            elsif node.children[1] == :module_function
+              process_module_function
+            elsif [:attr_reader, :attr_writer, :attr_accessor].include?(node.children[1])
+              process_attribute
+            elsif node.children[1] == :include
+              process_include
+            elsif node.children[1] == :extend
+              process_extend
+            elsif node.children[1] == :require 
+              process_require
+            elsif node.children[1] == :private_constant
+              process_private_constant
+            elsif node.children[1] == :alias_method && node.children[2] && node.children[2] && node.children[2].type == :sym && node.children[3] && node.children[3].type == :sym
+              process_alias_method
+            elsif node.children[1] == :private_class_method && node.children[2].kind_of?(AST::Node)
+              # Processing a private class can potentially handle children on its own
+              return if process_private_class_method
+            end
+          end
+          process_children
+        end
+
+        private
+
+        def process_attribute
+          node.children[2..-1].each do |a|
+            if node.children[1] == :attr_reader || node.children[1] == :attr_accessor
+              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), region.namespace, "#{a.children[0]}", comments_for(node), :reader, region.scope, region.visibility)
+            end
+            if node.children[1] == :attr_writer || node.children[1] == :attr_accessor
+              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), region.namespace, "#{a.children[0]}=", comments_for(node), :writer, region.scope, region.visibility)
+            end
+          end
+        end
+
+        def process_include
+          if node.children[2].kind_of?(AST::Node) && node.children[2].type == :const
+            node.children[2..-1].each do |i|
+              nspin = pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == region.namespace}.last
+              unless nspin.nil?
+                pins.push Pin::Reference::Include.new(get_node_location(node), nspin.path, unpack_name(i))
+              end
+            end
+          end
+        end
+
+        def process_extend
+          node.children[2..-1].each do |i|
+            nspin = pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == region.namespace}.last
+            unless nspin.nil?
+              ref = nil
+              if i.type == :self
+                ref = Pin::Reference::Extend.new(get_node_location(node), nspin.path, nspin.path)
+              elsif i.type == :const
+                ref = Pin::Reference::Extend.new(get_node_location(node), nspin.path, unpack_name(i))
+              end
+              pins.push ref unless ref.nil?
+            end
+          end
+        end
+
+        def process_require
+          if node.children[2].kind_of?(AST::Node) && node.children[2].type == :str
+            pins.push Pin::Reference::Require.new(get_node_location(node), node.children[2].children[0].to_s)
+          end
+        end
+
+        def process_module_function
+          if node.children[2].nil?
+            # @todo Smelly instance variable access
+            region.instance_variable_set(:@visibility, :module_function)
+          elsif node.children[2].type == :sym || node.children[2].type == :str
+            # @todo What to do about references?
+            node.children[2..-1].each do |x|
+              cn = x.children[0].to_s
+              ref = pins.select{|p| p.namespace == region.namespace and p.name == cn}.first
+              unless ref.nil?
+                pins.delete ref
+                mm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :class, :public, ref.parameters, ref.node)
+                cm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :instance, :private, ref.parameters, ref.node)
+                pins.push mm, cm
+                pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context == ref.context}.each do |ivar|
+                  pins.delete ivar
+                  pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), mm)
+                  pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), cm)
+                end
+              end
+            end
+          elsif node.children[2].type == :def
+            NodeProcessor.process node.children[2], region.update(visibility: :module_function), pins
+          end
+        end
+
+        def process_private_constant
+          if node.children[2] && (node.children[2].type == :sym || node.children[2].type == :str)
+            # @todo What to do about references?
+            cn = node.children[2].children[0].to_s
+            ref = pins.select{|p| p.namespace == region.namespace and p.name == cn}.first
+            unless ref.nil?
+              pins.delete ref
+              # Might be either a namespace or constant
+              if ref.kind == Pin::CONSTANT
+                pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.signature, ref.return_type, ref.context, :private)
+              else
+                # pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private, (ref.superclass_reference.nil? ? nil : ref.superclass_reference.name))
+                pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private)
+              end
+            end
+          end
+        end
+
+        def process_alias_method
+          pin = pins.select{|p| p.name == node.children[3].children[0].to_s && p.namespace == region.namespace && p.scope == region.scope}.first
+          if pin.nil?
+            pins.push Solargraph::Pin::MethodAlias.new(get_node_location(node), region.namespace, node.children[2].children[0].to_s, region.scope, node.children[3].children[0].to_s)
+          else
+            if pin.is_a?(Solargraph::Pin::Method)
+              pins.push Solargraph::Pin::Method.new(get_node_location(node), pin.namespace, node.children[2].children[0].to_s, comments_for(node) || pin.comments, pin.scope, pin.visibility, pin.parameters, pin.node)
+            elsif pin.is_a?(Solargraph::Pin::Attribute)
+              pins.push Solargraph::Pin::Attribute.new(get_node_location(node), pin.namespace, node.children[2].children[0].to_s, comments_for(node) || pin.comments, pin.access, pin.scope, pin.visibility)
+            end
+          end
+        end
+
+        def process_private_class_method
+          if node.children[2].type == :sym || node.children[2].type == :str
+            ref = pins.select{|p| p.namespace == region.namespace and p.name == node.children[2].children[0].to_s}.first
+            unless ref.nil?
+              pins.delete ref
+              pins.push Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, ref.scope, :private, ref.parameters, ref.node)
+            end
+            false
+          else
+            process_children region.update(scope: :class, visibility: :private)
+            true
+          end
+        end
+      end
+    end
+  end
+end