solargraph 0.47.2 → 0.53.3

data/.travis.yml

@@ -1,19 +0,0 @@
-language: ruby
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - 3.0
-  - jruby-head
-matrix:
-  include:
-    - rvm: 2.7
-      os: osx
-  allow_failures:
-    - rvm: jruby-head
-before_install:
-- gem update --system
-- gem install bundler
-before_script: yard gems
-script: rspec

data/lib/solargraph/api_map/bundler_methods.rb

@@ -1,22 +0,0 @@
-require 'bundler'
-require 'shellwords'
-
-module Solargraph
-  class ApiMap
-    module BundlerMethods
-      module_function
-
-      # @param directory [String]
-      # @return [Hash]
-      def require_from_bundle directory
-        begin
-          Solargraph.logger.info "Loading gems for bundler/require"
-          Documentor.specs_from_bundle(directory)
-        rescue BundleNotFoundError => e
-          Solargraph.logger.warn e.message
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/compat.rb

@@ -1,37 +0,0 @@
-unless Hash.method_defined?(:transform_keys)
-  class Hash
-    def transform_keys &block
-      result = {}
-      each_pair do |k, v|
-        result[block.call(k)] = v
-      end
-      result
-    end
-  end
-end
-
-unless Hash.method_defined?(:transform_values)
-  class Hash
-    def transform_values &block
-      result = {}
-      each_pair do |k, v|
-        result[k] = block.call(v)
-      end
-      result
-    end
-  end
-end
-
-unless Array.method_defined?(:sum)
-  class Array
-    def sum &block
-      inject(0) do |s, x|
-        if block
-          s + block.call(x)
-        else
-          s + x
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/convention/rspec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    class Rspec < Base
-      def local source_map
-        return EMPTY_ENVIRON unless File.basename(source_map.filename) =~ /_spec\.rb$/
-        @environ ||= Environ.new(
-          requires: ['rspec'],
-          domains: ['RSpec::Matchers', 'RSpec::ExpectationGroups'],
-          pins: [
-            # This override is necessary due to an erroneous @return tag in
-            # rspec's YARD documentation.
-            # @todo The return types have been fixed (https://github.com/rspec/rspec-expectations/pull/1121)
-            Solargraph::Pin::Reference::Override.method_return('RSpec::Matchers#expect', 'RSpec::Expectations::ExpectationTarget')
-          ].concat(extras)
-        )
-      end
-
-      private
-
-      def extras
-        @@extras ||= SourceMap.load_string(%(
-          def describe(*args); end
-          def it(*args); end
-        )).pins
-      end
-    end
-  end
-end

data/lib/solargraph/documentor.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-require 'json'
-require 'open3'
-require 'shellwords'
-require 'yard'
-require 'fileutils'
-
-module Solargraph
-  class Documentor
-    RDOC_GEMS = %w[
-      actioncable actionmailbox actionmailer actionpack actiontext actionview
-      activejob activemodel activerecord activestorage activesupport railties
-    ]
-
-    def initialize directory, rebuild: false, out: File.new(File::NULL, 'w')
-      @directory = directory
-      @rebuild = rebuild
-      @out = out
-    end
-
-    # @return [Boolean] True if all specs were found and documented.
-    def document
-      failures = 0
-      Documentor.specs_from_bundle(@directory).each_pair do |name, version|
-        yd = YARD::Registry.yardoc_file_for_gem(name, "= #{version}")
-        if !yd || @rebuild
-          FileUtils.safe_unlink File.join(YardMap::CoreDocs.cache_dir, 'gems', "#{name}-#{version}.ser")
-          @out.puts "Documenting #{name} #{version}"
-          `yard gems #{name} #{version} #{@rebuild ? '--rebuild' : ''}`
-          yd = YARD::Registry.yardoc_file_for_gem(name, "= #{version}")
-          # HACK: Ignore errors documenting bundler
-          if !yd && name != 'bundler'
-            @out.puts "#{name} #{version} YARD documentation failed"
-            failures += 1
-          end
-        end
-        if yd && RDOC_GEMS.include?(name)
-          cache = File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{name}-#{version}", 'yardoc')
-          if !File.exist?(cache) || @rebuild
-            @out.puts "Caching custom documentation for #{name} #{version}"
-            spec = Gem::Specification.find_by_name(name, "= #{version}")
-            Solargraph::YardMap::RdocToYard.run(spec)
-          end
-        end
-      end
-      if failures > 0
-        @out.puts "#{failures} gem#{failures == 1 ? '' : 's'} could not be documented. You might need to run `bundle install`."
-      end
-      failures == 0
-    rescue Solargraph::BundleNotFoundError => e
-      @out.puts "[#{e.class}] #{e.message}"
-      @out.puts "No bundled gems are available in #{@directory}"
-      false
-    end
-
-    # @param directory [String]
-    # @return [Hash]
-    def self.specs_from_bundle directory
-      Solargraph.with_clean_env do
-        cmd = [
-          'ruby', '-e',
-          "require 'bundler'; require 'json'; Dir.chdir('#{directory}') { puts Bundler.definition.specs_for([:default]).map { |spec| [spec.name, spec.version] }.to_h.to_json }"
-        ]
-        o, e, s = Open3.capture3(*cmd)
-        if s.success?
-          o && !o.empty? ? JSON.parse(o.split("\n").last) : {}
-        else
-          Solargraph.logger.warn e
-          raise BundleNotFoundError, "Failed to load gems from bundle at #{directory}"
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/parser/legacy/node_methods.rb

@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-
-require 'parser'
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeMethods
-        module_function
-
-        # @param node [Parser::AST::Node]
-        # @return [String]
-        def unpack_name(node)
-          pack_name(node).join("::")
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Array<String>]
-        def pack_name(node)
-          parts = []
-          if node.is_a?(AST::Node)
-            node.children.each { |n|
-              if n.is_a?(AST::Node)
-                if n.type == :cbase
-                  parts = [''] + pack_name(n)
-                else
-                  parts += pack_name(n)
-                end
-              else
-                parts.push n unless n.nil?
-              end
-            }
-          end
-          parts
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [String, nil]
-        def infer_literal_node_type node
-          return nil unless node.is_a?(AST::Node)
-          if node.type == :str || node.type == :dstr
-            return '::String'
-          elsif node.type == :array
-            return '::Array'
-          elsif node.type == :hash
-            return '::Hash'
-          elsif node.type == :int
-            return '::Integer'
-          elsif node.type == :float
-            return '::Float'
-          elsif node.type == :sym
-            return '::Symbol'
-          elsif node.type == :regexp
-            return '::Regexp'
-          elsif node.type == :irange
-            return '::Range'
-          elsif node.type == :true || node.type == :false
-            return '::Boolean'
-            # @todo Support `nil` keyword in types
-          # elsif node.type == :nil
-          #   return 'NilClass'
-          end
-          nil
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Position]
-        def get_node_start_position(node)
-          Position.new(node.loc.line, node.loc.column)
-        end
-
-        # @param node [Parser::AST::Node]
-        # @return [Position]
-        def get_node_end_position(node)
-          Position.new(node.loc.last_line, node.loc.last_column)
-        end
-
-        def drill_signature node, signature
-          return signature unless node.is_a?(AST::Node)
-          if node.type == :const or node.type == :cbase
-            unless node.children[0].nil?
-              signature += drill_signature(node.children[0], signature)
-            end
-            signature += '::' unless signature.empty?
-            signature += node.children[1].to_s
-          elsif node.type == :lvar or node.type == :ivar or node.type == :cvar
-            signature += '.' unless signature.empty?
-            signature += node.children[0].to_s
-          elsif node.type == :send
-            unless node.children[0].nil?
-              signature += drill_signature(node.children[0], signature)
-            end
-            signature += '.' unless signature.empty?
-            signature += node.children[1].to_s
-          end
-          signature
-        end
-
-        def convert_hash node
-          return {} unless Parser.is_ast_node?(node)
-          return convert_hash(node.children[0]) if node.type == :kwsplat
-          return convert_hash(node.children[0]) if Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
-          return {} unless node.type == :hash
-          result = {}
-          node.children.each do |pair|
-            result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
-          end
-          result
-        end
-
-        NIL_NODE = ::Parser::AST::Node.new(:nil)
-
-        def const_nodes_from node
-          return [] unless Parser.is_ast_node?(node)
-          result = []
-          if node.type == :const
-            result.push node
-          else
-            node.children.each { |child| result.concat const_nodes_from(child) }
-          end
-          result
-        end
-
-        def splatted_hash? node
-          Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
-        end
-
-        def splatted_call? node
-          return false unless Parser.is_ast_node?(node)
-          Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat && node.children[0].children[0].type != :hash
-        end
-
-        def any_splatted_call?(nodes)
-          nodes.any? { |n| splatted_call?(n) }
-        end
-
-        # @todo Temporarily here for testing. Move to Solargraph::Parser.
-        def call_nodes_from node
-          return [] unless node.is_a?(::Parser::AST::Node)
-          result = []
-          if node.type == :block
-            result.push node
-            if Parser.is_ast_node?(node.children[0]) && node.children[0].children.length > 2
-              node.children[0].children[2..-1].each { |child| result.concat call_nodes_from(child) }
-            end
-            node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
-          elsif node.type == :send
-            result.push node
-            node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
-          elsif [:super, :zsuper].include?(node.type)
-            result.push node
-            node.children.each { |child| result.concat call_nodes_from(child) }
-          elsif node.type == :masgn
-            # @todo We're treating a mass assignment as a call node, but the
-            #   type checker still needs the logic to handle it.
-            result.push node
-          else
-            node.children.each { |child| result.concat call_nodes_from(child) }
-          end
-          result
-        end
-
-        # Find all the nodes within the provided node that potentially return a
-        # value.
-        #
-        # The node parameter typically represents a method's logic, e.g., the
-        # second child (after the :args node) of a :def node. A simple one-line
-        # method would typically return itself, while a node with conditions
-        # would return the resulting node from each conditional branch. Nodes
-        # that follow a :return node are assumed to be unreachable. Nil values
-        # are converted to nil node types.
-        #
-        # @param node [Parser::AST::Node]
-        # @return [Array<Parser::AST::Node>]
-        def returns_from node
-          DeepInference.get_return_nodes(node).map { |n| n || NIL_NODE }
-        end
-
-        # @param cursor [Solargraph::Source::Cursor]
-        def find_recipient_node cursor
-          return repaired_find_recipient_node(cursor) if cursor.source.repaired? && cursor.source.code[cursor.offset - 1] == '('
-          source = cursor.source
-          position = cursor.position
-          offset = cursor.offset
-          tree = if source.synchronized?
-            match = source.code[0..offset-1].match(/,\s*\z/)
-            if match
-              source.tree_at(position.line, position.column - match[0].length)
-            else
-              source.tree_at(position.line, position.column)
-            end
-          else
-            source.tree_at(position.line, position.column - 1)
-          end
-          prev = nil
-          tree.each do |node|
-            if node.type == :send
-              args = node.children[2..-1]
-              if !args.empty?
-                return node if prev && args.include?(prev)
-              else
-                if source.synchronized?
-                  return node if source.code[0..offset-1] =~ /\(\s*\z/ && source.code[offset..-1] =~ /^\s*\)/
-                else
-                  return node if source.code[0..offset-1] =~ /\([^\(]*\z/
-                end
-              end
-            end
-            prev = node
-          end
-          nil
-        end
-
-        def repaired_find_recipient_node cursor
-          cursor = cursor.source.cursor_at([cursor.position.line, cursor.position.column - 1])
-          node = cursor.source.tree_at(cursor.position.line, cursor.position.column).first
-          return node if node && node.type == :send
-        end
-
-        module DeepInference
-          class << self
-            CONDITIONAL = [:if, :unless]
-            REDUCEABLE = [:begin, :kwbegin]
-            SKIPPABLE = [:def, :defs, :class, :sclass, :module]
-
-            # @param node [Parser::AST::Node]
-            # @return [Array<Parser::AST::Node>]
-            def get_return_nodes node
-              return [] unless node.is_a?(::Parser::AST::Node)
-              result = []
-              if REDUCEABLE.include?(node.type)
-                result.concat get_return_nodes_from_children(node)
-              elsif CONDITIONAL.include?(node.type)
-                result.concat reduce_to_value_nodes(node.children[1..-1])
-                # result.push NIL_NODE unless node.children[2]
-              elsif node.type == :or
-                result.concat reduce_to_value_nodes(node.children)
-              elsif node.type == :return
-                result.concat reduce_to_value_nodes([node.children[0]])
-              elsif node.type == :block
-                result.push node
-                result.concat get_return_nodes_only(node.children[2])
-              elsif node.type == :case
-                node.children[1..-1].each do |cc|
-                  if cc.nil?
-                    result.push NIL_NODE
-                  else
-                    result.concat reduce_to_value_nodes(cc.children[1..-2]) unless cc.children.length < 1
-                    result.concat reduce_to_value_nodes([cc.children.last])
-                  end
-                end
-              else
-                result.push node
-              end
-              result
-            end
-
-            private
-
-            def get_return_nodes_from_children parent
-              result = []
-              nodes = parent.children.select{|n| n.is_a?(AST::Node)}
-              nodes.each_with_index do |node, idx|
-                if node.type == :block
-                  result.concat get_return_nodes_only(node.children[2])
-                elsif SKIPPABLE.include?(node.type)
-                  next
-                elsif node.type == :return
-                  result.concat reduce_to_value_nodes([node.children[0]])
-                  # Return the result here because the rest of the code is
-                  # unreachable
-                  return result
-                else
-                  result.concat get_return_nodes_only(node)
-                end
-                result.concat reduce_to_value_nodes([nodes.last]) if idx == nodes.length - 1
-              end
-              result
-            end
-
-            def get_return_nodes_only parent
-              return [] unless parent.is_a?(::Parser::AST::Node)
-              result = []
-              nodes = parent.children.select{|n| n.is_a?(::Parser::AST::Node)}
-              nodes.each do |node|
-                next if SKIPPABLE.include?(node.type)
-                if node.type == :return
-                  result.concat reduce_to_value_nodes([node.children[0]])
-                  # Return the result here because the rest of the code is
-                  # unreachable
-                  return result
-                else
-                  result.concat get_return_nodes_only(node)
-                end
-              end
-              result
-            end
-
-            def reduce_to_value_nodes nodes
-              result = []
-              nodes.each do |node|
-                if !node.is_a?(::Parser::AST::Node)
-                  result.push nil
-                elsif REDUCEABLE.include?(node.type)
-                  result.concat get_return_nodes_from_children(node)
-                elsif CONDITIONAL.include?(node.type)
-                  result.concat reduce_to_value_nodes(node.children[1..-1])
-                elsif node.type == :return
-                  result.concat reduce_to_value_nodes([node.children[0]])
-                elsif node.type == :or
-                  result.concat reduce_to_value_nodes(node.children)
-                elsif node.type == :block
-                  result.concat get_return_nodes_only(node.children[2])
-                else
-                  result.push node
-                end
-              end
-              result
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        class AliasNode < Parser::NodeProcessor::Base
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::MethodAlias.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].children[0].to_s,
-              original: node.children[1].children[0].to_s,
-              scope: region.scope || :instance
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        class ArgsNode < Parser::NodeProcessor::Base
-          def process
-            node.children.each do |u|
-              loc = get_node_location(u)
-              locals.push Solargraph::Pin::Parameter.new(
-                location: loc,
-                closure: region.closure,
-                comments: comments_for(node),
-                name: u.children[0].to_s,
-                assignment: u.children[1],
-                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
-                presence: region.closure.location.range,
-                decl: get_decl(u)
-              )
-              region.closure.parameters.push locals.last
-            end
-            process_children
-          end
-
-          private
-
-          def get_decl node
-            node.type
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        class BeginNode < Parser::NodeProcessor::Base
-          def process
-            process_children
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        class DefNode < Parser::NodeProcessor::Base
-          def process
-            methpin = Solargraph::Pin::Method.new(
-              location: get_node_location(node),
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
-              visibility: region.visibility,
-              node: node
-            )
-            if methpin.name == 'initialize' and methpin.scope == :instance
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: 'new',
-                comments: methpin.comments,
-                scope: :class,
-                parameters: methpin.parameters
-              )
-              # @todo Smelly instance variable access.
-              pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
-              pins.push methpin
-              # @todo Smelly instance variable access.
-              methpin.instance_variable_set(:@visibility, :private)
-              methpin.instance_variable_set(:@return_type, ComplexType::VOID)
-            elsif region.visibility == :module_function
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: methpin.name,
-                comments: methpin.comments,
-                scope: :class,
-                visibility: :public,
-                parameters: methpin.parameters,
-                node: methpin.node
-              )
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: methpin.name,
-                comments: methpin.comments,
-                scope: :instance,
-                visibility: :private,
-                parameters: methpin.parameters,
-                node: methpin.node
-              )
-            else
-              pins.push methpin
-            end
-            process_children region.update(closure: methpin, scope: methpin.scope)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module Legacy
-      module NodeProcessors
-        class SclassNode < Parser::NodeProcessor::Base
-          def process
-            # @todo Temporarily skipping remote metaclasses
-            return unless node.children[0].is_a?(AST::Node) && node.children[0].type == :self
-            pins.push Solargraph::Pin::Singleton.new(
-              location: get_node_location(node),
-              closure: region.closure
-            )
-            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
-          end
-        end
-      end
-    end
-  end
-end