solargraph 0.39.7

data/lib/solargraph/pin/yard_pin/namespace.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    module YardPin
+      class Namespace < Pin::Namespace
+        include YardMixin
+
+        def initialize code_object, spec, closure = nil
+          closure ||= Solargraph::Pin::Namespace.new(
+            name: code_object.namespace.to_s,
+            closure: Pin::ROOT_PIN,
+            gates: [code_object.namespace.to_s]
+          )
+          super(
+            location: object_location(code_object, spec),
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
+            visibility: code_object.visibility,
+            closure: closure
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/yard_pin/yard_mixin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    module YardPin
+      module YardMixin
+        attr_reader :code_object
+
+        attr_reader :spec
+
+        attr_reader :location
+
+        @@gate_cache ||= {}
+
+        private
+
+        # @return [Solargraph::Location, nil]
+        def object_location code_object, spec
+          return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+          file = File.join(spec.full_gem_path, code_object.file)
+          Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/position.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # The zero-based line and column numbers of a position in a string.
+  #
+  class Position
+    # @return [Integer]
+    attr_reader :line
+
+    # @return [Integer]
+    attr_reader :character
+
+    alias column character
+
+    # @param line [Integer]
+    # @param character [Integer]
+    def initialize line, character
+      @line = line
+      @character = character
+    end
+
+    # Get a hash of the position. This representation is suitable for use in
+    # the language server protocol.
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        line: line,
+        character: character
+      }
+    end
+
+    def inspect
+      "#<#{self.class} #{line}, #{character}>"
+    end
+
+    # Get a numeric offset for the specified text and position.
+    #
+    # @param text [String]
+    # @param position [Position]
+    # @return [Integer]
+    def self.to_offset text, position
+      result = 0
+      feed = 0
+      line = position.line
+      column = position.character
+      text.lines.each do |l|
+        line_length = l.length
+        if feed == line
+          result += column
+          break
+        end
+        result += line_length
+        feed += 1
+      end
+      result
+    end
+
+    # Get a numeric offset for the specified text and a position identified
+    # by its line and character.
+    #
+    # @param text [String]
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Integer]
+    def self.line_char_to_offset text, line, character
+      to_offset(text, Position.new(line, character))
+    end
+
+    # Get a position for the specified text and offset.
+    #
+    # @param text [String]
+    # @param offset [Integer]
+    # @return [Position]
+    def self.from_offset text, offset
+      cursor = 0
+      line = 0
+      character = nil
+      text.lines.each do |l|
+        line_length = l.length
+        char_length = l.chomp.length
+        if cursor + char_length >= offset
+          character = offset - cursor
+          break
+        end
+        cursor += line_length
+        line += 1
+      end
+      character = 0 if character.nil? and (cursor - offset).between?(0, 1)
+      raise InvalidOffsetError if character.nil?
+      Position.new(line, character)
+    end
+
+    # A helper method for generating positions from arrays of integers. The
+    # original parameter is returned if it is already a position.
+    #
+    # @raise [ArgumentError] if the object cannot be converted to a position.
+    #
+    # @param object [Position, Array(Integer, Integer)]
+    # @return [Position]
+    def self.normalize object
+      return object if object.is_a?(Position)
+      return Position.new(object[0], object[1]) if object.is_a?(Array)
+      raise ArgumentError, "Unable to convert #{object.class} to Position"
+    end
+
+    def == other
+      return false unless other.is_a?(Position)
+      line == other.line and character == other.character
+    end
+  end
+end

data/lib/solargraph/range.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A pair of positions that compose a section of text.
+  #
+  class Range
+    # @return [Position]
+    attr_reader :start
+
+    # @return [Position]
+    attr_reader :ending
+
+    # @param start [Position]
+    # @param ending [Position]
+    def initialize start, ending
+      @start = start
+      @ending = ending
+    end
+
+    # Get a hash of the range. This representation is suitable for use in
+    # the language server protocol.
+    #
+    # @return [Hash<Symbol, Position>]
+    def to_hash
+      {
+        start: start.to_hash,
+        end: ending.to_hash
+      }
+    end
+
+    # True if the specified position is inside the range.
+    #
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [Boolean]
+    def contain? position
+      position = Position.normalize(position)
+      return false if position.line < start.line || position.line > ending.line
+      return false if position.line == start.line && position.character < start.character
+      return false if position.line == ending.line && position.character > ending.character
+      true
+    end
+
+    # True if the range contains the specified position and the position does not precede it.
+    #
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [Boolean]
+    def include? position
+      position = Position.normalize(position)
+      contain?(position) && !(position.line == start.line && position.character == start.character)
+    end
+
+    # Create a range from a pair of lines and characters.
+    #
+    # @param l1 [Integer] Starting line
+    # @param c1 [Integer] Starting character
+    # @param l2 [Integer] Ending line
+    # @param c2 [Integer] Ending character
+    # @return [Range]
+    def self.from_to l1, c1, l2, c2
+      Range.new(Position.new(l1, c1), Position.new(l2, c2))
+    end
+
+    # Get a range from a node.
+    #
+    # @param node [RubyVM::AbstractSyntaxTree::Node, Parser::AST::Node]
+    # @return [Range]
+    def self.from_node node
+      if defined?(RubyVM::AbstractSyntaxTree::Node)
+        if node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          Solargraph::Range.from_to(node.first_lineno - 1, node.first_column, node.last_lineno - 1, node.last_column)
+        end
+      elsif node.loc && node.loc.expression
+        from_expr(node.loc.expression)
+      end
+    end
+
+    # Get a range from a Parser range, usually found in
+    # Parser::AST::Node#location#expression.
+    #
+    # @param expr [Parser::Source::Range]
+    # @return [Range]
+    def self.from_expr expr
+      from_to(expr.line, expr.column, expr.last_line, expr.last_column)
+    end
+
+    def == other
+      return false unless other.is_a?(Range)
+      start == other.start && ending == other.ending
+    end
+
+    def inspect
+      "#<#{self.class} #{start.inspect} to #{ending.inspect}>"
+    end
+  end
+end

data/lib/solargraph/server_methods.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Solargraph
+  module ServerMethods
+    # @return [Integer]
+    def available_port
+      socket = Socket.new(:INET, :STREAM, 0)
+      socket.bind(Addrinfo.tcp("127.0.0.1", 0))
+      port = socket.local_address.ip_port
+      socket.close
+      port
+    end
+  end
+end

data/lib/solargraph/shell.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Solargraph
+  class Shell < Thor
+    include Solargraph::ServerMethods
+
+    map %w[--version -v] => :version
+
+    desc "--version, -v", "Print the version"
+    def version
+      puts Solargraph::VERSION
+    end
+
+    desc 'socket', 'Run a Solargraph socket server'
+    option :host, type: :string, aliases: :h, desc: 'The server host', default: '127.0.0.1'
+    option :port, type: :numeric, aliases: :p, desc: 'The server port', default: 7658
+    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
+        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
+
+    desc 'stdio', 'Run a Solargraph stdio server'
+    def stdio
+      require 'backport'
+      Backport.run do
+        Signal.trap("INT") do
+          Backport.stop
+        end
+        Signal.trap("TERM") do
+          Backport.stop
+        end
+        Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
+        STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
+      end
+    end
+
+    desc 'config [DIRECTORY]', 'Create or overwrite a default configuration file'
+    option :extensions, type: :boolean, aliases: :e, desc: 'Add installed extensions', default: true
+    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
+      File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
+        file.puts conf.to_yaml
+      end
+      STDOUT.puts "Configuration file initialized."
+    end
+
+    desc 'download-core [VERSION]', 'Download core documentation'
+    def download_core version = nil
+      ver = version || Solargraph::YardMap::CoreDocs.best_download
+      puts "Downloading docs for #{ver}..."
+      Solargraph::YardMap::CoreDocs.download ver
+      # Clear cached documentation if it exists
+      FileUtils.rm_rf Dir.glob(File.join(Solargraph::YardMap::CoreDocs.cache_dir, ver, '*.ser'))
+    rescue ArgumentError => e
+      STDERR.puts "ERROR: #{e.message}"
+      STDERR.puts "Run `solargraph available-cores` for a list."
+      exit 1
+    end
+
+    desc 'list-cores', 'List the local documentation versions'
+    def list_cores
+      puts Solargraph::YardMap::CoreDocs.versions.join("\n")
+    end
+
+    desc 'available-cores', 'List available documentation versions'
+    def available_cores
+      puts Solargraph::YardMap::CoreDocs.available.join("\n")
+    end
+
+    desc 'clear', 'Delete all cached documentation'
+    long_desc %(
+      This command will delete all core and gem documentation from the cache.
+      You can also delete specific gem caches with the `uncache` command or
+      update documentation for specific Ruby versions with the `download-core`
+      command.
+    )
+    def clear
+      puts "Deleting the cached documentation"
+      Solargraph::YardMap::CoreDocs.clear
+    end
+    map 'clear-cache' => :clear
+    map 'clear-cores' => :clear
+
+    desc 'uncache GEM [...GEM]', "Delete cached gem documentation"
+    def uncache *gems
+      raise ArgumentError, 'No gems specified.' if gems.empty?
+      gems.each do |gem|
+        Dir[File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{gem}-*")].each do |dir|
+          puts "Deleting cache: #{dir}"
+          FileUtils.remove_entry_secure dir
+        end
+      end
+    end
+
+    desc 'reporters', 'Get a list of diagnostics reporters'
+    def reporters
+      puts Solargraph::Diagnostics.reporters
+    end
+
+    desc 'typecheck [FILE(s)]', 'Run the type checker'
+    long_desc %(
+      Perform type checking on one or more files in a workspace. Check the
+      entire workspace if no files are specified.
+
+      Type checking levels are normal, typed, strict, and strong.
+    )
+    option :level, type: :string, aliases: [:mode, :m, :l], desc: 'Type checking level', default: 'normal'
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    def typecheck *files
+      directory = File.realpath(options[:directory])
+      api_map = Solargraph::ApiMap.load(directory)
+      if files.empty?
+        files = api_map.source_maps.map(&:filename)
+      else
+        files.map! { |file| File.realpath(file) }
+      end
+      probcount = 0
+      filecount = 0
+      files.each do |file|
+        checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
+        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
+      puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+    end
+
+    desc 'scan', 'Test the workspace for problems'
+    long_desc %(
+      A scan loads the entire workspace to make sure that the ASTs and
+      maps do not raise errors during analysis. It does not perform any type
+      checking or validation; it only confirms that the analysis itself is
+      error-free.
+    )
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
+    def scan
+      require 'benchmark'
+      directory = File.realpath(options[:directory])
+      api_map = nil
+      time = Benchmark.measure {
+        api_map = Solargraph::ApiMap.load(directory)
+        api_map.pins.each do |pin|
+          begin
+            puts pin_description(pin) if options[:verbose]
+            pin.typify api_map
+            pin.probe api_map
+          rescue StandardError => e
+            STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
+            STDERR.puts "[#{e.class}]: #{e.message}"
+            STDERR.puts e.backtrace.join("\n")
+            exit 1
+          end
+        end
+      }
+      puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
+    end
+
+    desc 'bundle', 'Generate documentation for bundled gems'
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :rebuild, type: :boolean, aliases: :r, desc: 'Rebuild existing documentation', default: false
+    def bundle
+      Documentor.new(options[:directory], rebuild: options[:rebuild], out: STDOUT).document
+    end
+
+    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation'
+    def rdoc gem, version = '>= 0'
+      spec = Gem::Specification.find_by_name(gem, version)
+      puts "Caching #{spec.name} #{spec.version} from RDoc"
+      Solargraph::YardMap::RdocToYard.run(spec)
+    end
+
+    private
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [String]
+    def pin_description pin
+      desc = if pin.path.nil? || pin.path.empty?
+        if pin.closure
+          "#{pin.closure.path} | #{pin.name}"
+        else
+          "#{pin.context.namespace} | #{pin.name}"
+        end
+      else
+        pin.path
+      end
+      desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
+      desc
+    end
+  end
+end