solargraph 0.39.7

data/lib/solargraph/convention/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Base
+      EMPTY_ENVIRON = Environ.new
+
+      # True if the source qualifies for this convention.
+      # Subclasses should override this method.
+      #
+      # @param source [Source]
+      def match? source
+        false
+      end
+
+      # The Environ for this convention.
+      # Subclasses should override this method.
+      #
+      # @return [Environ]
+      def environ
+        EMPTY_ENVIRON
+      end
+    end
+  end
+end

data/lib/solargraph/convention/gemfile.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Gemfile < Base
+      def match? source
+        File.basename(source.filename) == 'Gemfile'
+      end
+
+      def environ
+        @environ ||= Environ.new(
+          requires: ['bundler'],
+          domains: ['Bundler::Dsl']
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/convention/gemspec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Gemspec < Base
+      def match? source
+        File.basename(source.filename).end_with?('.gemspec')
+      end
+
+      def environ
+        @environ ||= Environ.new(
+          requires: ['rubygems'],
+          overrides: [
+            Solargraph::Pin::Reference::Override.from_comment(
+              'Gem::Specification.new',
+              %(
+@yieldparam [self]
+              )
+            )
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/convention/rspec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Rspec < Base
+      def match? source
+        File.basename(source.filename) =~ /_spec\.rb$/
+      end
+
+      def environ
+        @environ ||= Environ.new(
+          requires: ['rspec'],
+          domains: ['RSpec::Matchers', 'RSpec::ExpectationGroups'],
+          # 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)
+          overrides: [
+            Solargraph::Pin::Reference::Override.method_return('RSpec::Matchers#expect', 'RSpec::Expectations::ExpectationTarget')
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/converters/dd.rb

@@ -0,0 +1,12 @@
+module ReverseMarkdown
+  module Converters
+    class Dd < Base
+      def convert node, state = {}
+        content = treat_children(node, state)
+        ": #{content.strip}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dd, ReverseMarkdown::Converters::Dd.new

data/lib/solargraph/converters/dl.rb

@@ -0,0 +1,12 @@
+module ReverseMarkdown
+  module Converters
+    class Dl < Base
+      def convert node, state = {}
+        content = treat_children(node, state).strip
+        "\n\n#{content}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dl, ReverseMarkdown::Converters::Dl.new

data/lib/solargraph/converters/dt.rb

@@ -0,0 +1,12 @@
+module ReverseMarkdown
+  module Converters
+    class Dt < Base
+      def convert node, state = {}
+        content = treat_children(node, state)
+        "\n#{content.strip}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dt, ReverseMarkdown::Converters::Dt.new

data/lib/solargraph/converters/misc.rb

@@ -0,0 +1 @@
+ReverseMarkdown::Converters.register :tt, ReverseMarkdown::Converters::Code.new

data/lib/solargraph/core_fills.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # Overrides for the Ruby core.
+  #
+  # The YardMap uses this module to add type information to core methods.
+  #
+  module CoreFills
+    Override = Pin::Reference::Override
+
+    KEYWORDS = [
+      '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+      'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+      'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
+      'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
+      'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
+    ].freeze
+
+    methods_with_yieldparam_subtypes = %w[
+      Array#each Array#map Array#map! Array#any? Array#all? Array#index
+      Array#keep_if Array#delete_if
+      Enumerable#each_entry Enumerable#map Enumerable#any? Enumerable#all?
+      Enumerable#select Enumerable#reject
+      Set#each
+    ]
+
+    OVERRIDES = [
+      Override.method_return('Array#keep_if', 'self'),
+      Override.method_return('Array#delete_if', 'self'),
+      Override.from_comment('Array#reject', %(
+@overload reject(&block)
+  @return [self]
+@overload reject()
+  @return [Enumerator]
+              )),
+      Override.method_return('Array#reverse', 'self', delete: ['overload']),
+      Override.from_comment('Array#select', %(
+@overload select(&block)
+  @return [self]
+@overload select()
+  @return [Enumerator]
+      )),
+      Override.from_comment('Array#[]', %(
+@overload [](range)
+  @param range [Range]
+  @return [self]
+@overload [](num1, num2)
+  @param num1 [Integer]
+  @param num2 [Integer]
+  @return [self]
+@overload [](num)
+  @param num [Integer]
+  @return_single_parameter
+@return_single_parameter
+      )),
+      Override.from_comment('Array#first', %(
+@overload first(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+      )),
+      Override.from_comment('Array#last', %(
+@overload last(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+      )),
+      Override.method_return('Array#uniq', 'self'),
+
+      Override.from_comment('BasicObject#==', %(
+@param other [BasicObject]
+@return [Boolean]
+      )),
+      Override.method_return('BasicObject#initialize', 'void'),
+
+      Override.method_return('Class#new', 'self'),
+      Override.method_return('Class.new', 'Class<Object>'),
+      Override.method_return('Class#allocate', 'self'),
+      Override.method_return('Class.allocate', 'Class<Object>'),
+
+      Override.method_return('Enumerable#select', 'self'),
+
+      Override.method_return('File.absolute_path', 'String'),
+      Override.method_return('File.basename', 'String'),
+      Override.method_return('File.dirname', 'String'),
+      Override.method_return('File.extname', 'String'),
+      Override.method_return('File.join', 'String'),
+
+      Override.from_comment('Float#+', %(
+@param y [Numeric]
+@return [Numeric]
+      )),
+
+      Override.from_comment('Hash#[]', %(
+@return_value_parameter
+      )),
+
+      # @todo This override isn't robust enough. It needs to allow for
+      #   parameterized Hash types, e.g., [Hash{Symbol => String}].
+      Override.from_comment('Hash#[]=', %(
+@param_tuple
+      )),
+
+      Override.from_comment('Integer#+', %(
+@param y [Numeric]
+@return [Numeric]
+      )),
+
+      Override.method_return('Kernel#puts', 'nil'),
+
+      # Override.method_return('Module#attr_reader', 'void'),
+      # Override.method_return('Module#attr_writer', 'void'),
+      # Override.method_return('Module#attr_accessor', 'void'),
+
+      Override.from_comment('Numeric#+', %(
+@param y [Numeric]
+@return [Numeric]
+      )),
+
+      Override.method_return('Object#!', 'Boolean'),
+      Override.method_return('Object#clone', 'self', delete: [:overload]),
+      Override.method_return('Object#dup', 'self', delete: [:overload]),
+      Override.method_return('Object#freeze', 'self', delete: [:overload]),
+      Override.method_return('Object#inspect', 'String'),
+      Override.method_return('Object#taint', 'self'),
+      Override.method_return('Object#to_s', 'String'),
+      Override.method_return('Object#untaint', 'self'),
+      Override.from_comment('Object#tap', %(
+@return [self]
+@yieldparam [self]
+      )),
+
+      Override.from_comment('STDERR', %(
+@type [IO]
+      )),
+
+      Override.from_comment('STDIN', %(
+@type [IO]
+      )),
+
+      Override.from_comment('STDOUT', %(
+@type [IO]
+      )),
+
+      Override.method_return('String#freeze', 'self'),
+      Override.method_return('String#split', 'Array<String>'),
+      Override.method_return('String#lines', 'Array<String>'),
+      Override.from_comment('String#each_line', %(
+@yieldparam [String]
+      ))
+    ].concat(
+      methods_with_yieldparam_subtypes.map do |path|
+        Override.from_comment(path, %(
+@yieldparam_single_parameter
+          ))
+      end
+    )
+  end
+end

data/lib/solargraph/diagnostics.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # The Diagnostics library provides reporters for analyzing problems in code
+  # and providing the results to language server clients.
+  #
+  module Diagnostics
+    autoload :Base,            'solargraph/diagnostics/base'
+    autoload :Severities,      'solargraph/diagnostics/severities'
+    autoload :Rubocop,         'solargraph/diagnostics/rubocop'
+    autoload :RubocopHelpers,  'solargraph/diagnostics/rubocop_helpers'
+    autoload :RequireNotFound, 'solargraph/diagnostics/require_not_found'
+    autoload :UpdateErrors,    'solargraph/diagnostics/update_errors'
+    autoload :TypeCheck,       'solargraph/diagnostics/type_check'
+
+    class << self
+      # Add a reporter with a name to identify it in .solargraph.yml files.
+      #
+      # @param name [String] The name
+      # @param klass [Class<Solargraph::Diagnostics::Base>] The class implementation
+      # @return [void]
+      def register name, klass
+        reporter_hash[name] = klass
+      end
+
+      # Get an array of reporter names.
+      #
+      # @return [Array<String>]
+      def reporters
+        reporter_hash.keys - ['type_not_defined'] # @todo Hide type_not_defined for now
+      end
+
+      # Find a reporter by name.
+      #
+      # @param name [String] The name with which the reporter was registered
+      # @return [Class<Solargraph::Diagnostics::Base>]
+      def reporter name
+        reporter_hash[name]
+      end
+
+      private
+
+      # @return [Hash]
+      def reporter_hash
+        @reporter_hash ||= {}
+      end
+    end
+
+    register 'rubocop', Rubocop
+    register 'require_not_found', RequireNotFound
+    register 'typecheck', TypeCheck
+    register 'update_errors', UpdateErrors
+    register 'type_not_defined', TypeCheck # @todo Retained for backwards compatibility
+  end
+end

data/lib/solargraph/diagnostics/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # The base class for diagnostics reporters.
+    #
+    class Base
+      # @return [Array<String>]
+      attr_reader :args
+
+      def initialize *args
+        @args = args
+      end
+
+      # Perform a diagnosis on a Source within the context of an ApiMap.
+      # The result is an array of hash objects that conform to the LSP's
+      # Diagnostic specification.
+      #
+      # Subclasses should override this method.
+      #
+      # @param source [Solargraph::Source]
+      # @param api_map [Solargraph::ApiMap]
+      # @return [Array<Hash>]
+      def diagnose source, api_map
+        []
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # RequireNotFound reports required paths that could not be resolved to
+    # either a file in the workspace or a gem.
+    #
+    class RequireNotFound < Base
+      def diagnose source, api_map
+        return [] unless source.parsed? && source.synchronized?
+        result = []
+        refs = {}
+        map = api_map.source_map(source.filename)
+        map.requires.each { |ref| refs[ref.name] = ref }
+        api_map.unresolved_requires.each do |r|
+          next unless refs.key?(r)
+          result.push require_error(r, refs[r].location)
+        end
+        result
+      end
+
+      private
+
+      # @param path [String]
+      # @param location [Location]
+      # @return [Hash]
+      def require_error path, location
+        {
+          range: location.range.to_hash,
+          severity: Diagnostics::Severities::WARNING,
+          source: 'RequireNotFound',
+          message: "Required path #{path} could not be resolved."
+        }
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/rubocop.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'stringio'
+
+module Solargraph
+  module Diagnostics
+    # This reporter provides linting through RuboCop.
+    #
+    class Rubocop < Base
+      include RubocopHelpers
+
+      # Conversion of RuboCop severity names to LSP constants
+      SEVERITIES = {
+        'refactor' => Severities::HINT,
+        'convention' => Severities::INFORMATION,
+        'warning' => Severities::WARNING,
+        'error' => Severities::ERROR,
+        'fatal' => Severities::ERROR
+      }
+
+      # @param source [Solargraph::Source]
+      # @param _api_map [Solargraph::ApiMap]
+      # @return [Array<Hash>]
+      def diagnose source, _api_map
+        options, paths = generate_options(source.filename, source.code)
+        store = RuboCop::ConfigStore.new
+        runner = RuboCop::Runner.new(options, store)
+        result = redirect_stdout{ runner.run(paths) }
+        make_array JSON.parse(result)
+      rescue RuboCop::ValidationError, RuboCop::ConfigNotFoundError => e
+        raise DiagnosticsError, "Error in RuboCop configuration: #{e.message}"
+      rescue JSON::ParserError
+        raise DiagnosticsError, 'RuboCop returned invalid data'
+      end
+
+      private
+
+      # @param resp [Hash]
+      # @return [Array<Hash>]
+      def make_array resp
+        diagnostics = []
+        resp['files'].each do |file|
+          file['offenses'].each do |off|
+            diagnostics.push offense_to_diagnostic(off)
+          end
+        end
+        diagnostics
+      end
+
+      # Convert a RuboCop offense to an LSP diagnostic
+      #
+      # @param off [Hash] Offense received from Rubocop
+      # @return [Hash] LSP diagnostic
+      def offense_to_diagnostic off
+        {
+          range: offense_range(off).to_hash,
+          # 1 = Error, 2 = Warning, 3 = Information, 4 = Hint
+          severity: SEVERITIES[off['severity']],
+          source: off['cop_name'],
+          message: off['message'].gsub(/^#{off['cop_name']}\:/, '')
+        }
+      end
+
+      # @param off [Hash]
+      # @return [Range]
+      def offense_range off
+        Range.new(offense_start_position(off), offense_ending_position(off))
+      end
+
+      # @param off [Hash]
+      # @return [Position]
+      def offense_start_position off
+        Position.new(off['location']['start_line'] - 1, off['location']['start_column'] - 1)
+      end
+
+      # @param off [Hash]
+      # @return [Position]
+      def offense_ending_position off
+        if off['location']['start_line'] != off['location']['last_line']
+          Position.new(off['location']['start_line'], 0)
+        else
+          Position.new(
+            off['location']['start_line'] - 1, off['location']['last_column']
+          )
+        end
+      end
+    end
+  end
+end