solargraph 0.32.1 → 0.32.2

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

@@ -1,19 +1,19 @@
-module Solargraph
-  class SourceMap
-    module NodeProcessor
-      class AliasNode < Base
-        def process
-          pin = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && 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)
-          elsif 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
-          process_children
-        end
-      end
-    end
-  end
-end
+module Solargraph
+  class SourceMap
+    module NodeProcessor
+      class AliasNode < Base
+        def process
+          pin = pins.select{|p| [Solargraph::Pin::Method, Solargraph::Pin::Attribute].include?(p.class) && 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)
+          elsif 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
+          process_children
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +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
+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

@@ -1,68 +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
+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

@@ -1,11 +1,11 @@
-module Solargraph
-  class SourceMap
-    module NodeProcessor
-      class BeginNode < Base
-        def process
-          process_children
-        end
-      end
-    end
-  end
-end
+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

@@ -1,14 +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
+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

@@ -1,14 +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
+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

@@ -1,14 +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
+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

@@ -1,54 +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.try_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
+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.try_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