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

data/lib/solargraph/location.rb

@@ -17,18 +17,14 @@ module Solargraph
     # @param filename [String, nil]
     # @param range [Solargraph::Range]
     def initialize filename, range
-      raise "Use nil to represent no-file" if filename&.empty?
+      raise 'Use nil to represent no-file' if filename&.empty?
 
       @filename = filename
       @range = range
     end
 
-    protected def equality_fields
-      [filename, range]
-    end
-
     # @param other [self]
-    def <=>(other)
+    def <=> other
       return nil unless other.is_a?(Location)
       if filename == other.filename
         range <=> other.range
@@ -46,10 +42,6 @@ module Solargraph
       range.contain?(location.range.start) && range.contain?(location.range.ending) && filename == location.filename
     end
 
-    def inspect
-      "<#{self.class.name}: filename=#{filename}, range=#{range.inspect}>"
-    end
-
     def to_s
       inspect
     end
@@ -64,14 +56,14 @@ module Solargraph
 
     # @param node [Parser::AST::Node, nil]
     # @return [Location, nil]
-    def self.from_node(node)
+    def self.from_node node
       return nil if node.nil? || node.loc.nil?
       filename = node.loc.expression.source_buffer.name
       # @sg-ignore flow sensitive typing needs to create separate ranges for postfix if
       filename = nil if filename.empty?
       range = Range.from_node(node)
       # @sg-ignore Need to add nil check here
-      self.new(filename, range)
+      new(filename, range)
     end
 
     # @param other [BasicObject]
@@ -83,5 +75,11 @@ module Solargraph
     def inspect
       "#<#{self.class} #{filename}, #{range.inspect}>"
     end
+
+    protected
+
+    def equality_fields
+      [filename, range]
+    end
   end
 end

data/lib/solargraph/logging.rb

@@ -10,7 +10,7 @@ module Solargraph
       'warn' => Logger::WARN,
       'info' => Logger::INFO,
       'debug' => Logger::DEBUG
-    }
+    }.freeze
     configured_level = ENV.fetch('SOLARGRAPH_LOG', nil)
     level = if LOG_LEVELS.keys.include?(configured_level)
               LOG_LEVELS.fetch(configured_level)
@@ -21,9 +21,9 @@ module Solargraph
               end
               DEFAULT_LOG_LEVEL
             end
-    @@logger = Logger.new(STDERR, level: level)
+    @@logger = Logger.new($stderr, level: level)
     # @sg-ignore Fix cvar issue
-    @@logger.formatter = proc do |severity, datetime, progname, msg|
+    @@logger.formatter = proc do |severity, _datetime, _progname, msg|
       "[#{severity}] #{msg}\n"
     end
 
@@ -45,7 +45,7 @@ module Solargraph
         @@logger
       else
         new_log_level = LOG_LEVELS[log_level.to_s]
-        logger = Logger.new(STDERR, level: new_log_level)
+        logger = Logger.new($stderr, level: new_log_level)
 
         # @sg-ignore Wrong argument type for Logger#formatter=: arg_0
         #   expected nil, received Logger::_Formatter, nil

data/lib/solargraph/page.rb

@@ -1,92 +1,92 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-require 'tilt'
-require 'yard'
-require 'cgi'
-
-module Solargraph
-  class Page
-    # @todo This method directive is necessary because OpenStruct.new confuses
-    #   the typechecker.
-    # @!method self.new(locals, render_method)
-    #   @param locals[Hash]
-    #   @param render_method [Proc]
-    #   @return [Binder]
-    class Binder < OpenStruct
-      # @param locals [Hash]
-      # @param render_method [Proc]
-      def initialize locals, render_method
-        super(locals)
-        define_singleton_method :render do |template, layout: false, locals: {}|
-          render_method.call(template, layout: layout, locals: locals)
-        end
-        define_singleton_method :erb do |template, layout: false, locals: {}|
-          render_method.call(template, layout: layout, locals: locals)
-        end
-      end
-
-      # @param text [String]
-      # @return [String]
-      def htmlify text
-        # @type [String]
-        YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
-      end
-
-      # @param text [String]
-      # @return [String]
-      def escape text
-        CGI.escapeHTML(text)
-      end
-
-      # @param code [String]
-      # @return [String]
-      def ruby_to_html code
-        code
-      end
-    end
-    private_constant :Binder
-
-    # @param directory [String]
-    def initialize directory = VIEWS_PATH
-      directory = VIEWS_PATH if directory.nil? or !File.directory?(directory)
-      directories = [directory]
-      directories.push VIEWS_PATH if directory != VIEWS_PATH
-      # @type [Proc]
-      # @param template [String]
-      # @param layout [Boolean]
-      # @param locals [Hash]
-      @render_method = proc { |template, layout: false, locals: {}|
-        binder = Binder.new(locals, @render_method)
-        if layout
-          Tilt::ERBTemplate.new(Page.select_template(directories, 'layout')).render(binder) do
-            Tilt::ERBTemplate.new(Page.select_template(directories, template)).render(binder)
-          end
-        else
-          Tilt::ERBTemplate.new(Page.select_template(directories, template)).render(binder)
-        end
-      }
-    end
-
-    # @param template [String]
-    # @param layout [Boolean]
-    # @param locals [Hash]
-    # @sg-ignore
-    # @return [String]
-    def render template, layout: true, locals: {}
-      # @type [String]
-      @render_method.call(template, layout: layout, locals: locals)
-    end
-
-    # @param directories [Array<String>]
-    # @param name [String]
-    # @return [String]
-    def self.select_template directories, name
-      directories.each do |dir|
-        path = File.join(dir, "#{name}.erb")
-        return path if File.file?(path)
-      end
-      raise FileNotFoundError, "Template not found: #{name}"
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'tilt'
+require 'yard'
+require 'cgi'
+
+module Solargraph
+  class Page
+    # @todo This method directive is necessary because OpenStruct.new confuses
+    #   the typechecker.
+    # @!method self.new(locals, render_method)
+    #   @param locals[Hash]
+    #   @param render_method [Proc]
+    #   @return [Binder]
+    class Binder < OpenStruct
+      # @param locals [Hash]
+      # @param render_method [Proc]
+      def initialize locals, render_method
+        super(locals)
+        define_singleton_method :render do |template, layout: false, locals: {}|
+          render_method.call(template, layout: layout, locals: locals)
+        end
+        define_singleton_method :erb do |template, layout: false, locals: {}|
+          render_method.call(template, layout: layout, locals: locals)
+        end
+      end
+
+      # @param text [String]
+      # @return [String]
+      def htmlify text
+        # @type [String]
+        YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
+      end
+
+      # @param text [String]
+      # @return [String]
+      def escape text
+        CGI.escapeHTML(text)
+      end
+
+      # @param code [String]
+      # @return [String]
+      def ruby_to_html code
+        code
+      end
+    end
+    private_constant :Binder
+
+    # @param directory [String]
+    def initialize directory = VIEWS_PATH
+      directory = VIEWS_PATH if directory.nil? || !File.directory?(directory)
+      directories = [directory]
+      directories.push VIEWS_PATH if directory != VIEWS_PATH
+      # @type [Proc]
+      # @param template [String]
+      # @param layout [Boolean]
+      # @param locals [Hash]
+      @render_method = proc { |template, layout: false, locals: {}|
+        binder = Binder.new(locals, @render_method)
+        if layout
+          Tilt::ERBTemplate.new(Page.select_template(directories, 'layout')).render(binder) do
+            Tilt::ERBTemplate.new(Page.select_template(directories, template)).render(binder)
+          end
+        else
+          Tilt::ERBTemplate.new(Page.select_template(directories, template)).render(binder)
+        end
+      }
+    end
+
+    # @param template [String]
+    # @param layout [Boolean]
+    # @param locals [Hash]
+    # @sg-ignore
+    # @return [String]
+    def render template, layout: true, locals: {}
+      # @type [String]
+      @render_method.call(template, layout: layout, locals: locals)
+    end
+
+    # @param directories [Array<String>]
+    # @param name [String]
+    # @return [String]
+    def self.select_template directories, name
+      directories.each do |dir|
+        path = File.join(dir, "#{name}.erb")
+        return path if File.file?(path)
+      end
+      raise FileNotFoundError, "Template not found: #{name}"
+    end
+  end
+end

data/lib/solargraph/parser/comment_ripper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ripper'
 
 module Solargraph
@@ -26,19 +28,25 @@ module Solargraph
         # @sg-ignore Need to add nil check here
         if @buffer_lines[result[2][0]][0..result[2][1]].strip =~ /^#/
           chomped = result[1].chomp
-          if result[2][0] == 0 && chomped.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '').match(/^#\s*frozen_string_literal:/)
+          if result[2][0].zero? && chomped.encode('UTF-8', 'binary', invalid: :replace, undef: :replace,
+                                                                     replace: '').match(/^#\s*frozen_string_literal:/)
             chomped = '#'
           end
-          @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
+          @comments[result[2][0]] =
+            Snippet.new(Range.from_to(result[2][0], result[2][1], result[2][0], result[2][1] + chomped.length), chomped)
         end
         result
       end
 
       # @param result [Array(Symbol, String, Array([Integer, nil], [Integer, nil]))]
       # @return [void]
-      def create_snippet(result)
+      def create_snippet result
         chomped = result[1].chomp
-        @comments[result[2][0]] = Snippet.new(Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0, (result[2][1] || 0) + chomped.length), chomped)
+        @comments[result[2][0]] =
+          Snippet.new(
+            Range.from_to(result[2][0] || 0, result[2][1] || 0, result[2][0] || 0,
+                          (result[2][1] || 0) + chomped.length), chomped
+          )
       end
 
       # @sg-ignore @override is adding, not overriding

data/lib/solargraph/parser/flow_sensitive_typing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Parser
     class FlowSensitiveTyping
@@ -7,7 +9,7 @@ module Solargraph
       # @param ivars [Array<Solargraph::Pin::InstanceVariable>]
       # @param enclosing_breakable_pin [Solargraph::Pin::Breakable, nil]
       # @param enclosing_compound_statement_pin [Solargraph::Pin::CompoundStatement, nil]
-      def initialize(locals, ivars, enclosing_breakable_pin, enclosing_compound_statement_pin)
+      def initialize locals, ivars, enclosing_breakable_pin, enclosing_compound_statement_pin
         @locals = locals
         @ivars = ivars
         @enclosing_breakable_pin = enclosing_breakable_pin
@@ -19,7 +21,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_and(and_node, true_ranges = [], false_ranges = [])
+      def process_and and_node, true_ranges = [], false_ranges = []
         return unless and_node.type == :and
 
         # @type [Parser::AST::Node]
@@ -45,7 +47,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_or(or_node, true_ranges = [], false_ranges = [])
+      def process_or or_node, true_ranges = [], false_ranges = []
         return unless or_node.type == :or
 
         # @type [Parser::AST::Node]
@@ -74,7 +76,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_calls(node, true_presences, false_presences)
+      def process_calls node, true_presences, false_presences
         return unless node.type == :send
 
         process_isa(node, true_presences, false_presences)
@@ -87,7 +89,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_if(if_node, true_ranges = [], false_ranges = [])
+      def process_if if_node, true_ranges = [], false_ranges = []
         return if if_node.type != :if
 
         #
@@ -111,13 +113,9 @@ module Solargraph
           rest_of_breakable_body = Range.new(get_node_end_position(if_node),
                                              get_node_end_position(enclosing_breakable_pin.node))
 
-          if always_breaks?(then_clause)
-            false_ranges << rest_of_breakable_body
-          end
+          false_ranges << rest_of_breakable_body if always_breaks?(then_clause)
 
-          if always_breaks?(else_clause)
-            true_ranges << rest_of_breakable_body
-          end
+          true_ranges << rest_of_breakable_body if always_breaks?(else_clause)
         end
 
         unless enclosing_compound_statement_pin.node.nil?
@@ -129,13 +127,9 @@ module Solargraph
           # statement, we can assume things about the rest of the
           # compound statement
           #
-          if always_leaves_compound_statement?(then_clause)
-            false_ranges << rest_of_returnable_body
-          end
+          false_ranges << rest_of_returnable_body if always_leaves_compound_statement?(then_clause)
 
-          if always_leaves_compound_statement?(else_clause)
-            true_ranges << rest_of_returnable_body
-          end
+          true_ranges << rest_of_returnable_body if always_leaves_compound_statement?(else_clause)
         end
 
         unless then_clause.nil?
@@ -166,7 +160,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_while(while_node, true_ranges = [], false_ranges = [])
+      def process_while while_node, true_ranges = [], false_ranges = []
         return if while_node.type != :while
 
         #
@@ -210,7 +204,7 @@ module Solargraph
       # @param downcast_not_type [ComplexType, nil]
       #
       # @return [void]
-      def add_downcast_var(pin, presence:, downcast_type:, downcast_not_type:)
+      def add_downcast_var pin, presence:, downcast_type:, downcast_not_type:
         new_pin = pin.downcast(exclude_return_type: downcast_not_type,
                                intersection_return_type: downcast_type,
                                source: :flow_sensitive_typing,
@@ -228,7 +222,7 @@ module Solargraph
       # @param presences [Array<Range>]
       #
       # @return [void]
-      def process_facts(facts_by_pin, presences)
+      def process_facts facts_by_pin, presences
         #
         # Add specialized vars for the rest of the block
         #
@@ -251,7 +245,7 @@ module Solargraph
       # @param false_ranges [Array<Range>]
       #
       # @return [void]
-      def process_expression(expression_node, true_ranges, false_ranges)
+      def process_expression expression_node, true_ranges, false_ranges
         process_calls(expression_node, true_ranges, false_ranges)
         process_and(expression_node, true_ranges, false_ranges)
         process_or(expression_node, true_ranges, false_ranges)
@@ -263,7 +257,7 @@ module Solargraph
       # @return [Array(String, String), nil] Tuple of rgument to
       #   function, then receiver of function if it's a variable,
       #   otherwise nil if no simple variable receiver
-      def parse_call(call_node, method_name)
+      def parse_call call_node, method_name
         return unless call_node&.type == :send && call_node.children[1] == method_name
         # Check if conditional node follows this pattern:
         #   s(:send,
@@ -282,7 +276,7 @@ module Solargraph
         # or like this:
         # (lvar :repr)
         # @sg-ignore Need to look at Tuple#include? handling
-        variable_name = call_receiver.children[0].to_s if [:lvar, :ivar].include?(call_receiver&.type)
+        variable_name = call_receiver.children[0].to_s if %i[lvar ivar].include?(call_receiver&.type)
         return unless variable_name
 
         [call_arg, variable_name]
@@ -290,7 +284,7 @@ module Solargraph
 
       # @param isa_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_isa(isa_node)
+      def parse_isa isa_node
         call_type_name, variable_name = parse_call(isa_node, :is_a?)
 
         return unless call_type_name
@@ -304,7 +298,7 @@ module Solargraph
       # @sg-ignore Solargraph::Parser::FlowSensitiveTyping#find_var
       #   return type could not be inferred
       # @return [Solargraph::Pin::LocalVariable, Solargraph::Pin::InstanceVariable, nil]
-      def find_var(variable_name, position)
+      def find_var variable_name, position
         if variable_name.start_with?('@')
           # @sg-ignore flow sensitive typing needs to handle attrs
           ivars.find { |ivar| ivar.name == variable_name && (!ivar.presence || ivar.presence.include?(position)) }
@@ -319,7 +313,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_isa(isa_node, true_presences, false_presences)
+      def process_isa isa_node, true_presences, false_presences
         isa_type_name, variable_name = parse_isa(isa_node)
         return if variable_name.nil? || variable_name.empty?
         # @sg-ignore Need to add nil check here
@@ -343,7 +337,7 @@ module Solargraph
 
       # @param nilp_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_nilp(nilp_node)
+      def parse_nilp nilp_node
         parse_call(nilp_node, :nil?)
       end
 
@@ -352,7 +346,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_nilp(nilp_node, true_presences, false_presences)
+      def process_nilp nilp_node, true_presences, false_presences
         nilp_arg, variable_name = parse_nilp(nilp_node)
         return if variable_name.nil? || variable_name.empty?
         # if .nil? got an argument, move on, this isn't the situation
@@ -380,7 +374,7 @@ module Solargraph
 
       # @param bang_node [Parser::AST::Node]
       # @return [Array(String, String), nil]
-      def parse_bang(bang_node)
+      def parse_bang bang_node
         parse_call(bang_node, :!)
       end
 
@@ -389,7 +383,7 @@ module Solargraph
       # @param false_presences [Array<Range>]
       #
       # @return [void]
-      def process_bang(bang_node, true_presences, false_presences)
+      def process_bang bang_node, true_presences, false_presences
         # pry(main)> require 'parser/current'; Parser::CurrentRuby.parse("!2")
         # => s(:send,
         #   s(:int, 2), :!)
@@ -405,7 +399,7 @@ module Solargraph
       # @param var_node [Parser::AST::Node]
       #
       # @return [String, nil] Variable name referenced
-      def parse_variable(var_node)
+      def parse_variable var_node
         return if var_node.children.length != 1
 
         var_node.children[0]&.to_s
@@ -415,8 +409,8 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @param true_presences [Array<Range>]
       # @param false_presences [Array<Range>]
-      def process_variable(node, true_presences, false_presences)
-        return unless [:lvar, :ivar, :cvar, :gvar].include?(node.type)
+      def process_variable node, true_presences, false_presences
+        return unless %i[lvar ivar cvar gvar].include?(node.type)
 
         variable_name = parse_variable(node)
         return if variable_name.nil?
@@ -443,7 +437,7 @@ module Solargraph
       # @param node [Parser::AST::Node]
       #
       # @return [String, nil]
-      def type_name(node)
+      def type_name node
         # e.g.,
         #  s(:const, nil, :Baz)
         return unless node&.type == :const
@@ -462,22 +456,18 @@ module Solargraph
 
       # @param clause_node [Parser::AST::Node, nil]
       # @sg-ignore need boolish support for ? methods
-      def always_breaks?(clause_node)
+      def always_breaks? clause_node
         clause_node&.type == :break
       end
 
       # @param clause_node [Parser::AST::Node, nil]
-      def always_leaves_compound_statement?(clause_node)
+      def always_leaves_compound_statement? clause_node
         # https://docs.ruby-lang.org/en/2.2.0/keywords_rdoc.html
         # @sg-ignore Need to look at Tuple#include? handling
-        [:return, :raise, :next, :redo, :retry].include?(clause_node&.type)
+        %i[return raise next redo retry].include?(clause_node&.type)
       end
 
-      attr_reader :locals
-
-      attr_reader :ivars
-
-      attr_reader :enclosing_breakable_pin, :enclosing_compound_statement_pin
+      attr_reader :locals, :ivars, :enclosing_breakable_pin, :enclosing_compound_statement_pin
     end
   end
 end

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

@@ -58,13 +58,13 @@ module Solargraph
         # @sg-ignore downcast output of Enumerable#select
         # @return [Solargraph::Pin::Breakable, nil]
         def enclosing_breakable_pin
-          pins.select{|pin| pin.is_a?(Pin::Breakable) && pin.location&.range&.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::Breakable) && pin.location&.range&.contain?(position) }.last
         end
 
         # @todo downcast output of Enumerable#select
         # @return [Solargraph::Pin::CompoundStatement, nil]
         def enclosing_compound_statement_pin
-          pins.select{|pin| pin.is_a?(Pin::CompoundStatement) && pin.location&.range&.contain?(position)}.last
+          pins.select { |pin| pin.is_a?(Pin::CompoundStatement) && pin.location&.range&.contain?(position) }.last
         end
 
         # @param subregion [Region]
@@ -80,14 +80,14 @@ module Solargraph
 
         # @param node [Parser::AST::Node]
         # @return [Solargraph::Location]
-        def get_node_location(node)
+        def get_node_location node
           range = Parser.node_range(node)
           Location.new(region.filename, range)
         end
 
         # @param node [Parser::AST::Node]
         # @return [String, nil]
-        def comments_for(node)
+        def comments_for node
           region.source.comments_for(node)
         end
 

data/lib/solargraph/parser/node_processor.rb

@@ -43,7 +43,7 @@ module Solargraph
           pins.push Pin::Namespace.new(
             location: region.source.location,
             name: '',
-            source: :parser,
+            source: :parser
           )
         end
         return [pins, locals, ivars] unless Parser.is_ast_node?(node)

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

@@ -54,7 +54,7 @@ module Solargraph
         # @param name [String]
         # @return [Array<Location>]
         def references source, name
-          if name.end_with?("=")
+          if name.end_with?('=')
             reg = /#{Regexp.escape name[0..-2]}\s*=/
             # @param code [String]
             # @param offset [Integer]
@@ -98,17 +98,17 @@ module Solargraph
 
         # @return [Source::Chain]
         def chain *args
-          NodeChainer.chain *args
+          NodeChainer.chain(*args)
         end
 
         # @return [Source::Chain]
         def chain_string *args
-          NodeChainer.load_string *args
+          NodeChainer.load_string(*args)
         end
 
         # @return [Array(Array<Pin::Base>, Array<Pin::Base>)]
         def process_node *args
-          Solargraph::Parser::NodeProcessor.process *args
+          Solargraph::Parser::NodeProcessor.process(*args)
         end
 
         # @param node [Parser::AST::Node, nil]

data/lib/solargraph/parser/parser_gem/flawed_builder.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      # A custom builder for source parsers that ignores character encoding
-      # issues in literal strings.
-      #
-      class FlawedBuilder < ::Parser::Builders::Default
-        # @param token [::Parser::AST::Node]
-        # @return [String]
-        # @sg-ignore
-        def string_value(token)
-          value(token)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      # A custom builder for source parsers that ignores character encoding
+      # issues in literal strings.
+      #
+      class FlawedBuilder < ::Parser::Builders::Default
+        # @param token [::Parser::AST::Node]
+        # @return [String]
+        # @sg-ignore
+        def string_value token
+          value(token)
+        end
+      end
+    end
+  end
+end