Class: Solargraph::Shell

Inherits:

Thor

• Object
• Thor
• Solargraph::Shell

Includes:

ApiMap::SourceToYard, ServerMethods

Defined in:

lib/solargraph/shell.rb

Class Method Summary

• .exit_on_failure? ⇒ Boolean

  Tell Thor to ensure the process exits with status 1 if any error happens.

Instance Method Summary

• #cache(gem, version = nil) ⇒ void
• #clear ⇒ void
• #config(directory = '.') ⇒ void
• #gems(*names) ⇒ void
• #list ⇒ void
• #pin(path) ⇒ void
• #profile(file = nil) ⇒ void
• #rbs ⇒ Object
• #reporters ⇒ void
• #scan ⇒ void
• #socket ⇒ void
• #stdio ⇒ void
• #typecheck(*files) ⇒ void
• #uncache(*gems) ⇒ void
• #version ⇒ void

Methods included from ApiMap::SourceToYard

#code_object_at, #code_object_paths, #rake_yard

Methods included from ServerMethods

#available_port

Class Method Details

.exit_on_failure? ⇒ Boolean

Tell Thor to ensure the process exits with status 1 if any error happens.

Returns:

• (Boolean)

# File 'lib/solargraph/shell.rb', line 17

def self.exit_on_failure?
  true
end

Instance Method Details

#cache(gem, version = nil) ⇒ void

This method returns an undefined value.

Parameters:

• gem (String)
• version (String, nil) (defaults to: nil)

# File 'lib/solargraph/shell.rb', line 111

def cache gem, version = nil
  gemspec = Gem::Specification.find_by_name(gem, version)

  if options[:rebuild] || !PinCache.has_yard?(gemspec)
    pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
    PinCache.serialize_yard_gem(gemspec, pins)
  end

  workspace = Solargraph::Workspace.new(Dir.pwd) if File.exist?('rbs_collection.yaml')
  rbs_map = RbsMap.from_gemspec(gemspec, workspace&.rbs_collection_path, workspace&.rbs_collection_config_path)
  if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
    PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, rbs_map.pins)
  end
rescue Gem::MissingSpecError
  warn "Gem '#{gem}' not found"
end

#clear ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 99

def clear
  puts 'Deleting all cached documentation (gems, core and stdlib)'
  Solargraph::PinCache.clear
end

#config(directory = '.') ⇒ void

This method returns an undefined value.

Parameters:

• directory (String) (defaults to: '.')

# File 'lib/solargraph/shell.rb', line 71

def config directory = '.'
  matches = []
  if options[:extensions]
    Gem::Specification.each do |g|
      if g.name.match(/^solargraph-[A-Za-z0-9_-]*?-ext/)
        require g.name
        matches.push g.name
      end
    end
  end
  conf = Solargraph::Workspace::Config.new.raw_data
  unless matches.empty?
    matches.each do |m|
      conf['extensions'].push m
    end
  end
  # @param file [File]
  File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
    file.puts conf.to_yaml
  end
  $stdout.puts 'Configuration file initialized.'
end

#gems(*names) ⇒ void

This method returns an undefined value.

Parameters:

• names (Array<String>)

# File 'lib/solargraph/shell.rb', line 181

def gems *names
  # print time with ms
  workspace = Solargraph::Workspace.new('.')

  if names.empty?
    Gem::Specification.to_a.each { |spec| do_cache spec, rebuild: options[:rebuild] }
    $stderr.puts "Documentation cached for all #{Gem::Specification.count} gems."
  else
    warn("Caching these gems: #{names}")
    names.each do |name|
      if name == 'core'
        # @sg-ignore cache_core and core? are dynamically defined
        PinCache.cache_core(out: $stdout) # if !PinCache.core? || options[:rebuild]
        next
      end

      gemspec = workspace.find_gem(*name.split('='))
      if gemspec.nil?
        warn "Gem '#{name}' not found"
      else
        if options[:rebuild] || !PinCache.has_yard?(gemspec)
          pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
          PinCache.serialize_yard_gem(gemspec, pins)
        end

        workspace = Solargraph::Workspace.new(Dir.pwd)
        rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
        if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
          # cache pins even if result is zero, so we don't retry building pins
          pins = rbs_map.pins || []
          PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
        end
      end
    rescue Gem::MissingSpecError
      warn "Gem '#{name}' not found"
    rescue Gem::Requirement::BadRequirementError => e
      warn "Gem '#{name}' failed while loading"
      warn e.message
      # @sg-ignore Need to add nil check here
      warn e.backtrace.join("\n")
    end
    warn "Documentation cached for #{names.count} gems."
  end
end

#list ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 324

def list
  workspace = Solargraph::Workspace.new(options[:directory])
  puts workspace.filenames unless options[:count]
  puts "#{workspace.filenames.length} files total."
end

#pin(path) ⇒ void

This method returns an undefined value.

Parameters:

• path (String) —

  The path to the method pin, e.g. ‘Class#method’ or ‘Class.method’

# File 'lib/solargraph/shell.rb', line 341

def pin path
  api_map = Solargraph::ApiMap.load_with_cache('.', $stderr)
  is_method = path.include?('#') || path.include?('.')
  if is_method && options[:stack]
    scope, ns, meth = if path.include? '#'
                        [:instance, *path.split('#', 2)]
                      else
                        [:class, *path.split('.', 2)]
                      end

    # @sg-ignore Wrong argument type for
    #   Solargraph::ApiMap#get_method_stack: rooted_tag
    #   expected String, received Array<String>
    pins = api_map.get_method_stack(ns, meth, scope: scope)
  else
    pins = api_map.get_path_pins path
  end
  # @type [Hash{Symbol => Pin::Base}]
  references = {}
  pin = pins.first
  case pin
  when nil
    warn "Pin not found for path '#{path}'"
    exit 1
  when Pin::Namespace
    if options[:references]
      # @sg-ignore Need to add nil check here
      superclass_tag = api_map.qualify_superclass(pin.return_type.tag)
      superclass_pin = api_map.get_path_pins(superclass_tag).first if superclass_tag
      references[:superclass] = superclass_pin if superclass_pin
    end
  end

  pins.each do |pin|
    if options[:typify] || options[:probe]
      type = ComplexType::UNDEFINED
      type = pin.typify(api_map) if options[:typify]
      type = pin.probe(api_map) if options[:probe] && type.undefined?
      print_type(type)
      next
    end

    print_pin(pin)
  end
  references.each do |key, refpin|
    puts "\n# #{key.to_s.capitalize}:\n\n"
    print_pin(refpin)
  end
end

#profile(file = nil) ⇒ void

This method returns an undefined value.

Parameters:

• file (String, nil) (defaults to: nil)

# File 'lib/solargraph/shell.rb', line 399

def profile file = nil
  begin
    require 'vernier'
  rescue LoadError
    $stderr.puts 'vernier gem not found. Please install this dependency:'
    $stderr.puts
    $stderr.puts "  gem 'vernier', '>1.0', '<2'"

    return
  end

  hooks = []
  hooks << :memory_usage if options[:memory]

  directory = File.realpath(options[:directory])
  FileUtils.mkdir_p(options[:output_dir])

  host = Solargraph::LanguageServer::Host.new
  host.client_capabilities.merge!({ 'window' => { 'workDoneProgress' => true } })
  # @param method [String] The message method
  # @param params [Hash] The method parameters
  # @return [void]
  def host.send_notification method, params
    puts "Notification: #{method} - #{params}"
  end

  parse_path = File.join(options[:output_dir], 'parse_benchmark.json.gz')
  catalog_path = File.join(options[:output_dir], 'catalog_benchmark.json.gz')
  definition_path = File.join(options[:output_dir], 'definition_benchmark.json.gz')

  prepare_time = catalog_time = definition_time = nil

  # Trap CTRL-C so the in-progress Vernier.profile block can unwind through
  # its ensure clause and still write its output file. A second CTRL-C
  # restores default handling for a hard exit.
  interrupted = false
  previous_int_trap = Signal.trap('INT') do
    if interrupted
      Signal.trap('INT', 'DEFAULT')
      Process.kill('INT', Process.pid)
    else
      interrupted = true
      puts "\nInterrupted. Finishing current profile (CTRL-C again to force exit)..."
      raise Interrupt
    end
  end

  begin
    puts 'Parsing and mapping source files...'
    prepare_start = Time.now
    Vernier.profile(out: parse_path, hooks: hooks) do
      puts 'Mapping libraries'
      host.prepare(directory)
      sleep 0.2 until host.libraries.all?(&:mapped?)
    end
    prepare_time = Time.now - prepare_start

    puts 'Building the catalog...'
    catalog_start = Time.now
    Vernier.profile(out: catalog_path, hooks: hooks) do
      host.catalog
    end
    catalog_time = Time.now - catalog_start

    # Determine test file
    if file
      test_file = File.join(directory, file)
    else
      test_file = File.join(directory, 'lib', 'other.rb')
      unless File.exist?(test_file)
        # Fallback to any Ruby file in the workspace
        workspace = Solargraph::Workspace.new(directory)
        test_file = workspace.filenames.find { |f| f.end_with?('.rb') }
        unless test_file
          puts 'No Ruby files found in workspace'
          return
        end
      end
    end

    file_uri = Solargraph::LanguageServer::UriHelpers.file_to_uri(File.absolute_path(test_file))

    puts "Profiling go-to-definition for #{test_file}"
    puts "Position: line #{options[:line]}, column #{options[:column]}"

    definition_start = Time.now
    Vernier.profile(out: definition_path, hooks: hooks) do
      message = Solargraph::LanguageServer::Message::TextDocument::Definition.new(
        host, {
          'params' => {
            'textDocument' => { 'uri' => file_uri },
            'position' => { 'line' => options[:line], 'character' => options[:column] }
          }
        }
      )
      puts 'Processing go-to-definition request...'
      result = message.process

      puts "Result: #{result.inspect}"
    end
    definition_time = Time.now - definition_start
  rescue Interrupt
    puts "\nProfile run interrupted; partial profile(s) have been written."
  ensure
    Signal.trap('INT', previous_int_trap || 'DEFAULT')

    puts "\n=== Timing Results ==="
    puts "Parsing & mapping: #{(prepare_time * 1000).round(2)}ms" if prepare_time
    puts "Catalog building: #{(catalog_time * 1000).round(2)}ms" if catalog_time
    puts "Go-to-definition: #{(definition_time * 1000).round(2)}ms" if definition_time
    if prepare_time && catalog_time && definition_time
      total_time = prepare_time + catalog_time + definition_time
      puts "Total time: #{(total_time * 1000).round(2)}ms"
    end

    saved = [parse_path, catalog_path, definition_path].select { |p| File.exist?(p) }
    unless saved.empty?
      puts "\nProfiles saved to:"
      saved.each { |p| puts "  - #{File.expand_path(p)}" }

      puts "\nUpload the JSON files to https://vernier.prof/ to view the profiles."
      puts 'Or use https://rubygems.org/gems/profile-viewer to view them locally.'
    end
  end
end

#rbs ⇒ Object

# File 'lib/solargraph/shell.rb', line 528

def rbs
  api_map = Solargraph::ApiMap.load('.')
  pins = api_map.source_maps.flat_map(&:pins)
  store = Solargraph::ApiMap::Store.new(pins)
  if options[:inference]
    puts 'Inferring untyped methods...'
    store.method_pins.each do |pin|
      next unless pin.return_type.undefined?
      type = pin.typify(api_map)
      type = pin.probe(api_map) if type.undefined?
      pin.docstring.add_tag YARD::Tags::Tag.new('return', nil, type.items.map(&:to_s))
      pin.instance_variable_set(:@return_type, type)
    end
  end
  puts 'Generating yardocs...'
  rake_yard(store)
  work_dir = Dir.pwd
  Dir.mktmpdir do |tmpdir|
    Dir.chdir tmpdir do
      yardoc = File.join(tmpdir, '.yardoc')
      YARD::Registry.save(false, yardoc)
      YARD::Registry.load(yardoc)
      rel_dir = File.join('sig', options[:filename])
      puts "Writing #{rel_dir}..."
      target = File.join(work_dir, rel_dir)
      FileUtils.mkdir_p(File.join(work_dir, 'sig'))
      `sord #{target} --rbs --no-regenerate`
    end
  end
  puts 'Done.'
end

#reporters ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 228

def reporters
  puts Solargraph::Diagnostics.reporters
end

#scan ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 292

def scan
  directory = File.realpath(options[:directory])
  # @type [Solargraph::ApiMap, nil]
  api_map = nil
  time = Benchmark.measure do
    api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
    # @sg-ignore flow sensitive typing should be able to handle redefinition
    api_map.pins.each do |pin|
      puts pin_description(pin) if options[:verbose]
      pin.typify api_map
      pin.probe api_map
    rescue StandardError => e
      # @todo to add nil check here
      # @todo should warn on nil dereference below
      warn "Error testing #{pin_description(pin)} #{if pin.location
                                                      "at #{pin.location.filename}:#{pin.location.range.start.line + 1}"
                                                    end}"
      warn "[#{e.class}]: #{e.message}"
      # @todo Need to add nil check here
      # @todo flow sensitive typing should be able to handle redefinition
      warn e.backtrace.join("\n")
      exit 1
    end
  end
  # @sg-ignore Need to add nil check here
  puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
end

#socket ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 33

def socket
  require 'backport'
  port = options[:port]
  port = available_port if port.zero?
  Backport.run do
    Signal.trap('INT') do
      Backport.stop
    end
    Signal.trap('TERM') do
      Backport.stop
    end
    # @sg-ignore Wrong argument type for Backport.prepare_tcp_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
    Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
    $stderr.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
  end
end

#stdio ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 52

def stdio
  require 'backport'
  Backport.run do
    Signal.trap('INT') do
      Backport.stop
    end
    Signal.trap('TERM') do
      Backport.stop
    end
    # @sg-ignore Wrong argument type for Backport.prepare_stdio_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
    Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
    $stderr.puts "Solargraph is listening on stdio PID=#{Process.pid}"
  end
end

#typecheck(*files) ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 242

def typecheck *files
  directory = File.realpath(options[:directory])
  workspace = Solargraph::Workspace.new(directory)
  level = options[:level].to_sym
  rules = workspace.rules(level)
  api_map =
    Solargraph::ApiMap.load_with_cache(directory, $stdout,
                                       loose_unions:
                                         !rules.require_all_unique_types_support_call?)
  probcount = 0
  if files.empty?
    files = api_map.source_maps.map(&:filename)
  else
    files.map! { |file| File.realpath(file) }
  end
  filecount = 0
  time = Benchmark.measure do
    files.each do |file|
      checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym,
                                      workspace: workspace)
      problems = checker.problems
      next if problems.empty?
      problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
      puts problems.map { |prob|
        "#{prob.location.filename}:#{prob.location.range.start.line + 1}: #{prob.message}"
      }.join("\n")
      filecount += 1
      probcount += problems.length
    end
  end
  puts "Typecheck finished in #{time.real} seconds."
  puts "#{probcount} problem#{if probcount != 1
                                's'
                              end} found#{if files.length != 1
                                                              " in #{filecount} of #{files.length} files"
                                                            end}."
  # "
  exit 1 if probcount.positive?
end

#uncache(*gems) ⇒ void

This method returns an undefined value.

Parameters:

• gems (Array<String>)

Raises:

• (ArgumentError)

# File 'lib/solargraph/shell.rb', line 136

def uncache *gems
  raise ArgumentError, 'No gems specified.' if gems.empty?
  gems.each do |gem|
    if gem == 'core'
      PinCache.uncache_core
      next
    end

    if gem == 'stdlib'
      PinCache.uncache_stdlib
      next
    end

    spec = Gem::Specification.find_by_name(gem)
    PinCache.uncache_gem(spec, out: $stdout)
  end
end

#version ⇒ void

This method returns an undefined value.

# File 'lib/solargraph/shell.rb', line 25

def version
  puts Solargraph::VERSION
end