solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/parser/parser_gem/node_processors/send_node.rb

@@ -14,16 +14,17 @@ module Solargraph
             method_name = node.children[1]
             # :nocov:
             unless method_name.instance_of?(Symbol)
-              Solargraph.assert_or_log(:parser_method_name, "Expected method name to be a Symbol, got #{method_name.class} for node #{node.inspect}")
+              Solargraph.assert_or_log(:parser_method_name,
+                                       "Expected method name to be a Symbol, got #{method_name.class} for node #{node.inspect}")
               return process_children
             end
             # :nocov:
             if node.children[0].nil?
-              if [:private, :public, :protected].include?(method_name)
+              if %i[private public protected].include?(method_name)
                 process_visibility
               elsif method_name == :module_function
                 process_module_function
-              elsif [:attr_reader, :attr_writer, :attr_accessor].include?(method_name)
+              elsif %i[attr_reader attr_writer attr_accessor].include?(method_name)
                 process_attribute
               elsif method_name == :include
                 process_include
@@ -44,7 +45,10 @@ module Solargraph
                 return if process_private_class_method
               end
             elsif method_name == :require && node.children[0].to_s == '(const nil :Bundler)'
-              pins.push Pin::Reference::Require.new(Solargraph::Location.new(region.filename, Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser)
+              pins.push Pin::Reference::Require.new(
+                Solargraph::Location.new(region.filename,
+                                         Solargraph::Range.from_to(0, 0, 0, 0)), 'bundler/require', source: :parser
+              )
             end
             process_children
           end
@@ -53,21 +57,22 @@ module Solargraph
 
           # @return [void]
           def process_visibility
-            if (node.children.length > 2)
+            if node.children.length > 2
               # @sg-ignore Need to add nil check here
-              node.children[2..-1].each do |child|
+              node.children[2..].each do |child|
                 # @sg-ignore Variable type could not be inferred for method_name
                 # @type [Symbol]
                 visibility = node.children[1]
                 # :nocov:
                 unless visibility.instance_of?(Symbol)
-                  Solargraph.assert_or_log(:parser_visibility, "Expected visibility name to be a Symbol, got #{visibility.class} for node #{node.inspect}")
+                  Solargraph.assert_or_log(:parser_visibility,
+                                           "Expected visibility name to be a Symbol, got #{visibility.class} for node #{node.inspect}")
                   return process_children
                 end
                 # :nocov:
-                if child.is_a?(::Parser::AST::Node) && (child.type == :sym || child.type == :str)
+                if child.is_a?(::Parser::AST::Node) && %i[sym str].include?(child.type)
                   name = child.children[0].to_s
-                  matches = pins.select{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance)}
+                  matches = pins.select { |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == region.closure.full_context.namespace && pin.context.scope == (region.scope || :instance) }
                   matches.each do |pin|
                     # @todo Smelly instance variable access
                     pin.instance_variable_set(:@visibility, visibility)
@@ -85,11 +90,11 @@ module Solargraph
           # @return [void]
           def process_attribute
             # @sg-ignore Need to add nil check here
-            node.children[2..-1].each do |a|
+            node.children[2..].each do |a|
               loc = get_node_location(node)
               clos = region.closure
               cmnt = comments_for(node)
-              if node.children[1] == :attr_reader || node.children[1] == :attr_accessor
+              if %i[attr_reader attr_accessor].include?(node.children[1])
                 pins.push Solargraph::Pin::Method.new(
                   location: loc,
                   closure: clos,
@@ -101,63 +106,62 @@ module Solargraph
                   source: :parser
                 )
               end
-              if node.children[1] == :attr_writer || node.children[1] == :attr_accessor
-                method_pin = Solargraph::Pin::Method.new(
-                  location: loc,
-                  closure: clos,
-                  name: "#{a.children[0]}=",
-                  comments: cmnt,
-                  scope: region.scope || :instance,
-                  visibility: region.visibility,
-                  attribute: true,
-                  source: :parser
-                )
-                pins.push method_pin
-                method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :parser)
-                if method_pin.return_type.defined?
-                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.items.map(&:rooted_tags), 'value')
-                end
+              next unless %i[attr_writer attr_accessor].include?(node.children[1])
+              method_pin = Solargraph::Pin::Method.new(
+                location: loc,
+                closure: clos,
+                name: "#{a.children[0]}=",
+                comments: cmnt,
+                scope: region.scope || :instance,
+                visibility: region.visibility,
+                attribute: true,
+                source: :parser
+              )
+              pins.push method_pin
+              method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last,
+                                                            source: :parser)
+              if method_pin.return_type.defined?
+                pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '',
+                                                                pins.last.return_type.items.map(&:rooted_tags), 'value')
               end
             end
           end
 
           # @return [void]
           def process_include
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :const
-              cp = region.closure
-              # @sg-ignore Need to add nil check here
-              node.children[2..-1].each do |i|
-                type = region.scope == :class ? Pin::Reference::Extend : Pin::Reference::Include
-                pins.push type.new(
-                  location: get_node_location(i),
-                  closure: cp,
-                  name: unpack_name(i),
-                  source: :parser
-                )
-              end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :const
+            cp = region.closure
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |i|
+              type = region.scope == :class ? Pin::Reference::Extend : Pin::Reference::Include
+              pins.push type.new(
+                location: get_node_location(i),
+                closure: cp,
+                name: unpack_name(i),
+                source: :parser
+              )
             end
           end
 
           # @return [void]
           def process_prepend
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :const
-              cp = region.closure
-              # @sg-ignore Need to add nil check here
-              node.children[2..-1].each do |i|
-                pins.push Pin::Reference::Prepend.new(
-                  location: get_node_location(i),
-                  closure: cp,
-                  name: unpack_name(i),
-                  source: :parser
-                )
-              end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :const
+            cp = region.closure
+            # @sg-ignore Need to add nil check here
+            node.children[2..].each do |i|
+              pins.push Pin::Reference::Prepend.new(
+                location: get_node_location(i),
+                closure: cp,
+                name: unpack_name(i),
+                source: :parser
+              )
             end
           end
 
           # @return [void]
           def process_extend
             # @sg-ignore Need to add nil check here
-            node.children[2..-1].each do |i|
+            node.children[2..].each do |i|
               loc = get_node_location(node)
               if i.type == :self
                 pins.push Pin::Reference::Extend.new(
@@ -179,18 +183,16 @@ module Solargraph
 
           # @return [void]
           def process_require
-            if node.children[2].is_a?(AST::Node) && node.children[2].type == :str
-              path = node.children[2].children[0].to_s
-              pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
-            end
+            return unless node.children[2].is_a?(AST::Node) && node.children[2].type == :str
+            path = node.children[2].children[0].to_s
+            pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
           end
 
           # @return [void]
           def process_autoload
-            if node.children[3].is_a?(AST::Node) && node.children[3].type == :str
-              path = node.children[3].children[0].to_s
-              pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
-            end
+            return unless node.children[3].is_a?(AST::Node) && node.children[3].type == :str
+            path = node.children[3].children[0].to_s
+            pins.push Pin::Reference::Require.new(get_node_location(node), path, source: :parser)
           end
 
           # @return [void]
@@ -198,55 +200,55 @@ module Solargraph
             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
+            elsif %i[sym str].include?(node.children[2].type)
               # @sg-ignore Need to add nil check here
-              node.children[2..-1].each do |x|
+              node.children[2..].each do |x|
                 cn = x.children[0].to_s
                 # @type [Pin::Method, nil]
                 ref = pins.find { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == cn }
-                unless ref.nil?
-                  pins.delete ref
-                  mm = Solargraph::Pin::Method.new(
-                    location: ref.location,
-                    closure: ref.closure,
-                    name: ref.name,
-                    parameters: ref.parameters,
-                    comments: ref.comments,
-                    scope: :class,
-                    visibility: :public,
-                    node: ref.node,
+                next if ref.nil?
+                pins.delete ref
+                mm = Solargraph::Pin::Method.new(
+                  location: ref.location,
+                  closure: ref.closure,
+                  name: ref.name,
+                  parameters: ref.parameters,
+                  comments: ref.comments,
+                  scope: :class,
+                  visibility: :public,
+                  node: ref.node,
+                  source: :parser
+                )
+                cm = Solargraph::Pin::Method.new(
+                  location: ref.location,
+                  closure: ref.closure,
+                  name: ref.name,
+                  parameters: ref.parameters,
+                  comments: ref.comments,
+                  scope: :instance,
+                  visibility: :private,
+                  node: ref.node,
+                  source: :parser
+                )
+                pins.push mm, cm
+                ivars.select { |pin| pin.is_a?(Pin::InstanceVariable) && pin.closure.path == ref.path }.each do |ivar|
+                  ivars.delete ivar
+                  ivars.push Solargraph::Pin::InstanceVariable.new(
+                    location: ivar.location,
+                    closure: cm,
+                    name: ivar.name,
+                    comments: ivar.comments,
+                    assignment: ivar.assignment,
+                    source: :parser
+                  )
+                  ivars.push Solargraph::Pin::InstanceVariable.new(
+                    location: ivar.location,
+                    closure: mm,
+                    name: ivar.name,
+                    comments: ivar.comments,
+                    assignment: ivar.assignment,
                     source: :parser
                   )
-                  cm = Solargraph::Pin::Method.new(
-                    location: ref.location,
-                    closure: ref.closure,
-                    name: ref.name,
-                    parameters: ref.parameters,
-                    comments: ref.comments,
-                    scope: :instance,
-                    visibility: :private,
-                    node: ref.node,
-                    source: :parser)
-                  pins.push mm, cm
-                  ivars.select{|pin| pin.is_a?(Pin::InstanceVariable) && pin.closure.path == ref.path}.each do |ivar|
-                    ivars.delete ivar
-                    ivars.push Solargraph::Pin::InstanceVariable.new(
-                      location: ivar.location,
-                      closure: cm,
-                      name: ivar.name,
-                      comments: ivar.comments,
-                      assignment: ivar.assignment,
-                      source: :parser
-                    )
-                    ivars.push Solargraph::Pin::InstanceVariable.new(
-                      location: ivar.location,
-                      closure: mm,
-                      name: ivar.name,
-                      comments: ivar.comments,
-                      assignment: ivar.assignment,
-                      source: :parser
-                    )
-                  end
                 end
               end
             elsif node.children[2].type == :def
@@ -256,17 +258,19 @@ module Solargraph
 
           # @return [void]
           def process_private_constant
-            if node.children[2] && (node.children[2].type == :sym || node.children[2].type == :str)
-              cn = node.children[2].children[0].to_s
-              ref = pins.select{|p| [Solargraph::Pin::Namespace, Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn}.first
-              # HACK: Smelly instance variable access
-              ref.instance_variable_set(:@visibility, :private) unless ref.nil?
-            end
+            return unless node.children[2] && %i[sym str].include?(node.children[2].type)
+            cn = node.children[2].children[0].to_s
+            ref = pins.select do |p|
+              [Solargraph::Pin::Namespace,
+               Solargraph::Pin::Constant].include?(p.class) && p.namespace == region.closure.full_context.namespace && p.name == cn
+            end.first
+            # HACK: Smelly instance variable access
+            ref&.instance_variable_set(:@visibility, :private)
           end
 
           # @return [void]
           def process_alias_method
-            loc = get_node_location(node)
+            get_node_location(node)
             pins.push Solargraph::Pin::MethodAlias.new(
               location: get_node_location(node),
               closure: region.closure,
@@ -279,10 +283,12 @@ module Solargraph
 
           # @return [Boolean]
           def process_private_class_method
-            if node.children[2].type == :sym || node.children[2].type == :str
-              ref = pins.select { |p| p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == node.children[2].children[0].to_s }.first
+            if %i[sym str].include?(node.children[2].type)
+              ref = pins.select do |p|
+                p.is_a?(Pin::Method) && p.namespace == region.closure.full_context.namespace && p.name == node.children[2].children[0].to_s
+              end.first
               # HACK: Smelly instance variable access
-              ref.instance_variable_set(:@visibility, :private) unless ref.nil?
+              ref&.instance_variable_set(:@visibility, :private)
               false
             else
               process_children region.update(scope: :class, visibility: :private)

data/lib/solargraph/parser/parser_gem/node_processors/until_node.rb

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class UntilNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            location = get_node_location(node)
-            # Note - this should not be considered a block, as the
-            # until statement doesn't create a closure - e.g.,
-            # variables created inside can be seen from outside as
-            # well
-            pins.push Solargraph::Pin::Until.new(
-              location: location,
-              closure: region.closure,
-              node: node,
-              comments: comments_for(node),
-              source: :parser,
-            )
-            process_children region
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class UntilNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            # Note - this should not be considered a block, as the
+            # until statement doesn't create a closure - e.g.,
+            # variables created inside can be seen from outside as
+            # well
+            pins.push Solargraph::Pin::Until.new(
+              location: location,
+              closure: region.closure,
+              node: node,
+              comments: comments_for(node),
+              source: :parser
+            )
+            process_children region
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/when_node.rb

@@ -12,7 +12,7 @@ module Solargraph
               location: get_node_location(node),
               closure: region.closure,
               node: node,
-              source: :parser,
+              source: :parser
             )
             process_children
           end

data/lib/solargraph/parser/parser_gem/node_processors/while_node.rb

@@ -22,7 +22,7 @@ module Solargraph
               closure: region.closure,
               node: node,
               comments: comments_for(node),
-              source: :parser,
+              source: :parser
             )
             process_children region
           end

data/lib/solargraph/parser/parser_gem.rb

@@ -1,12 +1,14 @@
-module Solargraph
-  module Parser
-    module ParserGem
-      autoload :FlawedBuilder, 'solargraph/parser/parser_gem/flawed_builder'
-      autoload :ClassMethods, 'solargraph/parser/parser_gem/class_methods'
-      autoload :NodeMethods, 'solargraph/parser/parser_gem/node_methods'
-      autoload :NodeChainer, 'solargraph/parser/parser_gem/node_chainer'
-    end
-  end
-end
-
-require 'solargraph/parser/parser_gem/node_processors'
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      autoload :FlawedBuilder, 'solargraph/parser/parser_gem/flawed_builder'
+      autoload :ClassMethods, 'solargraph/parser/parser_gem/class_methods'
+      autoload :NodeMethods, 'solargraph/parser/parser_gem/node_methods'
+      autoload :NodeChainer, 'solargraph/parser/parser_gem/node_chainer'
+    end
+  end
+end
+
+require 'solargraph/parser/parser_gem/node_processors'

data/lib/solargraph/parser/snippet.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     class Snippet

data/lib/solargraph/parser.rb

@@ -1,23 +1,25 @@
-module Solargraph
-  module Parser
-    autoload :CommentRipper, 'solargraph/parser/comment_ripper'
-    autoload :ParserGem, 'solargraph/parser/parser_gem'
-    autoload :Region, 'solargraph/parser/region'
-    autoload :NodeProcessor, 'solargraph/parser/node_processor'
-    autoload :FlowSensitiveTyping, 'solargraph/parser/flow_sensitive_typing'
-    autoload :Snippet, 'solargraph/parser/snippet'
-
-    class SyntaxError < StandardError
-    end
-
-    # @deprecated
-    Legacy = ParserGem
-
-    ClassMethods = ParserGem::ClassMethods
-    # @todo should be able to just 'extend ClassMethods' here and
-    #   typecheck things off it in strict mode
-    extend ParserGem::ClassMethods
-
-    NodeMethods = ParserGem::NodeMethods
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    autoload :CommentRipper, 'solargraph/parser/comment_ripper'
+    autoload :ParserGem, 'solargraph/parser/parser_gem'
+    autoload :Region, 'solargraph/parser/region'
+    autoload :NodeProcessor, 'solargraph/parser/node_processor'
+    autoload :FlowSensitiveTyping, 'solargraph/parser/flow_sensitive_typing'
+    autoload :Snippet, 'solargraph/parser/snippet'
+
+    class SyntaxError < StandardError
+    end
+
+    # @deprecated
+    Legacy = ParserGem
+
+    ClassMethods = ParserGem::ClassMethods
+    # @todo should be able to just 'extend ClassMethods' here and
+    #   typecheck things off it in strict mode
+    extend ParserGem::ClassMethods
+
+    NodeMethods = ParserGem::NodeMethods
+  end
+end