cosmicgraph 0.49.0

data/lib/solargraph/convention/rspec.rb

@@ -0,0 +1,30 @@
+# 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/convention.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  # Conventions provide a way to modify an ApiMap based on expectations about
+  # one of its sources.
+  #
+  module Convention
+    autoload :Base,    'solargraph/convention/base'
+    autoload :Gemfile, 'solargraph/convention/gemfile'
+    autoload :Rspec,   'solargraph/convention/rspec'
+    autoload :Gemspec, 'solargraph/convention/gemspec'
+    autoload :Rakefile, 'solargraph/convention/rakefile'
+
+    @@conventions = Set.new
+
+    # @param convention [Class<Convention::Base>]
+    # @return [void]
+    def self.register convention
+      @@conventions.add convention.new
+    end
+
+    # @param source_map [SourceMap]
+    # @return [Environ]
+    def self.for_local(source_map)
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.local(source_map)
+      end
+      result
+    end
+
+    # @param yard_map [YardMap]
+    # @return [Environ]
+    def self.for_global(yard_map)
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.global(yard_map)
+      end
+      result
+    end
+
+    register Gemfile
+    register Gemspec
+    register Rspec
+    register Rakefile
+  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/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,53 @@
+# 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.missing_docs.each do |r|
+          next unless refs.key?(r)
+          result.push docs_error(r, refs[r].location)
+        end
+        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 docs_error path, location
+        {
+          range: location.range.to_hash,
+          severity: Diagnostics::Severities::WARNING,
+          source: 'RequireNotFound',
+          message: "YARD docs not found for #{path}"
+        }
+      end
+
+      # @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,112 @@
+# frozen_string_literal: true
+
+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 = {
+        'info' => Severities::HINT,
+        '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
+        @source = source
+        require_rubocop(rubocop_version)
+        options, paths = generate_options(source.filename, source.code)
+        store = RuboCop::ConfigStore.new
+        runner = RuboCop::Runner.new(options, store)
+        result = redirect_stdout{ runner.run(paths) }
+        
+        return [] if result.empty?
+        
+        make_array JSON.parse(result)
+      rescue RuboCop::ValidationError, RuboCop::ConfigNotFoundError => e
+        raise DiagnosticsError, "Error in RuboCop configuration: #{e.message}"
+      rescue JSON::ParserError => e
+        raise DiagnosticsError, "RuboCop returned invalid data: #{e.message}"
+      end
+
+      private
+
+      # Extracts the rubocop version from _args_
+      #
+      # @return [String]
+      def rubocop_version
+        args.find { |a| a =~ /version=/ }.to_s.split('=').last
+      end
+
+      # @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: 'rubocop',
+          code: 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
+          start_line = off['location']['start_line'] - 1
+          last_column = off['location']['last_column']
+          line = @source.code.lines[start_line]
+          col_off = if line.nil? || line.empty?
+            1
+          else
+            0
+          end
+
+          Position.new(
+            start_line, last_column - col_off
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/rubocop_helpers.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # Utility methods for the RuboCop diagnostics reporter.
+    #
+    module RubocopHelpers
+      module_function
+
+      # Requires a specific version of rubocop, or the latest installed version
+      # if _version_ is `nil`.
+      #
+      # @param version [String, nil]
+      # @raise [InvalidRubocopVersionError] if _version_ is not installed
+      def require_rubocop(version = nil)
+        begin
+          gem_path = Gem::Specification.find_by_name('rubocop', version).full_gem_path
+          gem_lib_path = File.join(gem_path, 'lib')
+          $LOAD_PATH.unshift(gem_lib_path) unless $LOAD_PATH.include?(gem_lib_path)
+        # @todo Gem::MissingSpecVersionError is undocumented for some reason
+        # @sg-ignore
+        rescue Gem::MissingSpecVersionError => e
+          raise InvalidRubocopVersionError,
+                "could not find '#{e.name}' (#{e.requirement}) - "\
+                "did find: [#{e.specs.map { |s| s.version.version }.join(', ')}]"
+        end
+        require 'rubocop'
+      end
+
+      # Generate command-line options for the specified filename and code.
+      #
+      # @param filename [String]
+      # @param code [String]
+      # @return [Array(Array<String>, Array<String>)]
+      def generate_options filename, code
+        args = ['-f', 'j', '--force-exclusion', filename]
+        base_options = RuboCop::Options.new
+        options, paths = base_options.parse(args)
+        options[:stdin] = code
+        [options, paths]
+      end
+
+      # RuboCop internally uses capitalized drive letters for Windows paths,
+      # so we need to convert the paths provided to the command.
+      #
+      # @param path [String]
+      # @return [String]
+      def fix_drive_letter path
+        return path unless path.match(/^[a-z]:/)
+        path[0].upcase + path[1..-1]
+      end
+
+      # @todo This is a smelly way to redirect output, but the RuboCop specs do
+      #   the same thing.
+      # @return [String]
+      def redirect_stdout
+        redir = StringIO.new
+        $stdout = redir
+        yield if block_given?
+        $stdout = STDOUT
+        redir.string
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/severities.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # These severity constants match the DiagnosticSeverity constants in the
+    # language server protocol.
+    #
+    module Severities
+      ERROR = 1
+      WARNING = 2
+      INFORMATION = 3
+      HINT = 4
+    end
+  end
+end

data/lib/solargraph/diagnostics/type_check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # TypeCheck reports methods with undefined return types, untagged
+    # parameters, and invalid param tags.
+    #
+    class TypeCheck < Base
+      def diagnose source, api_map
+        # return [] unless args.include?('always') || api_map.workspaced?(source.filename)
+        severity = Diagnostics::Severities::ERROR
+        level = (args.reverse.find { |a| ['normal', 'typed', 'strict', 'strong'].include?(a) }) || :normal
+        checker = Solargraph::TypeChecker.new(source.filename, api_map: api_map, level: level.to_sym)
+        checker.problems
+          .sort { |a, b| a.location.range.start.line <=> b.location.range.start.line }
+          .map do |problem|
+            {
+              range: extract_first_line(problem.location, source),
+              severity: severity,
+              source: 'Typecheck',
+              message: problem.message
+            }
+          end
+      end
+
+      private
+
+      # @param location [Location]
+      # @param source [Source]
+      # @return [Hash]
+      def extract_first_line location, source
+        return location.range.to_hash if location.range.start.line == location.range.ending.line
+        {
+          start: {
+            line: location.range.start.line,
+            character: location.range.start.character
+          },
+          end: {
+            line: location.range.start.line,
+            character: last_character(location.range.start, source)
+          }
+        }
+      end
+
+      # @param position [Solargraph::Position]
+      # @param source [Solargraph::Source]
+      # @return [Integer]
+      def last_character position, source
+        cursor = Position.to_offset(source.code, position)
+        source.code.index(/[\r\n]/, cursor) || source.code.length
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/update_errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    class UpdateErrors < Base
+      def diagnose source, api_map
+        result = []
+        combine_ranges(source.code, source.error_ranges).each do |range|
+          result.push(
+            range: range.to_hash,
+            severity: Diagnostics::Severities::ERROR,
+            source: 'Solargraph',
+            message: 'Syntax error'
+          )
+        end
+        result
+      end
+
+      private
+
+      # Combine an array of ranges by their starting lines.
+      #
+      # @param code [String]
+      # @param ranges [Array<Range>]
+      # @return [Array<Range>]
+      def combine_ranges code, ranges
+        result = []
+        lines = []
+        ranges.sort{|a, b| a.start.line <=> b.start.line}.each do |rng|
+          next if rng.nil? || lines.include?(rng.start.line)
+          lines.push rng.start.line
+          next if rng.start.line >= code.lines.length
+          scol = code.lines[rng.start.line].index(/[^\s]/) || 0
+          ecol = code.lines[rng.start.line].length
+          result.push Range.from_to(rng.start.line, scol, rng.start.line, ecol)
+        end
+        result
+      end
+    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/documentor.rb

@@ -0,0 +1,76 @@
+# 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/environ.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A collection of additional data, such as map pins and required paths, that
+  # can be added to an ApiMap.
+  #
+  # Conventions are used to add Environs.
+  #
+  class Environ
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @return [Array<String>]
+    attr_reader :domains
+
+    # @return [Array<Pin::Reference::Override>]
+    attr_reader :pins
+
+    # @param requires [Array<String>]
+    # @param domains [Array<String>]
+    # @param pins [Array<Pin::Base>]
+    def initialize requires: [], domains: [], pins: []
+      @requires = requires
+      @domains = domains
+      @pins = pins
+    end
+
+    # @return [self]
+    def clear
+      domains.clear
+      requires.clear
+      pins.clear
+      self
+    end
+
+    # @param other [Environ]
+    # @return [self]
+    def merge other
+      domains.concat other.domains
+      requires.concat other.requires
+      pins.concat other.pins
+      self
+    end
+  end
+end