steep-relaxed 1.9.3.3

data/lib/steep/drivers/init.rb

@@ -0,0 +1,66 @@
+module Steep
+  module Drivers
+    class Init
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_accessor :force_write
+
+      include Utils::DriverHelper
+
+      TEMPLATE = <<~EOF
+      # D = Steep::Diagnostic
+      #
+      # target :lib do
+      #   signature "sig"
+      #   ignore_signature "sig/test"
+      #
+      #   check "lib"                       # Directory name
+      #   check "path/to/source.rb"         # File name
+      #   check "app/models/**/*.rb"        # Glob
+      #   # ignore "lib/templates/*.rb"
+      #
+      #   # library "pathname"              # Standard libraries
+      #   # library "strong_json"           # Gems
+      #
+      #   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+      #   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+      #   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+      #   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+      #   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+      #   #   hash[D::Ruby::NoMethod] = :information
+      #   # end
+      # end
+
+      # target :test do
+      #   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+      #   signature "sig/test"              # Put RBS files for tests under `sig/test`
+      #   check "test"                      # Type check Ruby scripts under `test`
+      #
+      #   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+      #
+      #   # library "pathname"              # Standard libraries
+      # end
+      EOF
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @force_write = false
+      end
+
+      def run
+        path = steepfile || Pathname("Steepfile")
+
+        if path.file? && !force_write
+          stdout.puts "#{path} already exists, --force to overwrite"
+          return 1
+        end
+
+        stdout.puts "Writing #{path}..."
+        path.write(TEMPLATE)
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/langserver.rb

@@ -0,0 +1,56 @@
+module Steep
+  module Drivers
+    class Langserver
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :stdin
+      attr_reader :write_mutex
+      attr_reader :type_check_queue
+      attr_reader :type_check_thread
+      attr_reader :jobs_option
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:, stdin:)
+        @stdout = stdout
+        @stderr = stderr
+        @stdin = stdin
+        @write_mutex = Mutex.new
+        @type_check_queue = Queue.new
+        @jobs_option = Utils::JobsOption.new(jobs_count_modifier: -1)
+      end
+
+      def writer
+        @writer ||= LanguageServer::Protocol::Transport::Io::Writer.new(stdout)
+      end
+
+      def reader
+        @reader ||= LanguageServer::Protocol::Transport::Io::Reader.new(stdin)
+      end
+
+      def project
+        @project or raise "Empty #project"
+      end
+
+      def run
+        @project = load_config()
+
+        interaction_worker = Server::WorkerProcess.start_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, steep_command: jobs_option.steep_command)
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(steepfile: project.steepfile_path, args: [], steep_command: jobs_option.steep_command, count: jobs_option.jobs_count_value)
+
+        master = Server::Master.new(
+          project: project,
+          reader: reader,
+          writer: writer,
+          interaction_worker: interaction_worker,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = true
+
+        master.start()
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/print_project.rb

@@ -0,0 +1,113 @@
+require "active_support/core_ext/hash/keys"
+
+module Steep
+  module Drivers
+    class PrintProject
+      attr_reader :stdout
+      attr_reader :stderr
+
+      attr_accessor :print_files
+      attr_reader :files
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @print_files = false
+      end
+
+      def as_json(project)
+        {
+          steepfile: project.steepfile_path.to_s,
+          targets: project.targets.map do |target|
+            target_as_json(target)
+          end
+        }.stringify_keys
+      end
+
+      def target_as_json(target)
+        json = {
+          "name" => target.name.to_s,
+          "source_pattern" => pattern_as_json(target.source_pattern),
+          "signature_pattern" => pattern_as_json(target.signature_pattern),
+          "groups" => target.groups.map do |group|
+            group_as_json(group)
+          end,
+          "libraries" => target.new_env_loader().yield_self do |loader|
+            libs = [] #: Array[library_json]
+            loader.each_dir do |lib, path|
+              case lib
+              when :core
+                libs << { "name" => "__core__", "path" => path.to_s }
+              when Pathname
+                raise "Unexpected pathname from loader: path=#{path}"
+              else
+                libs << { "name" => lib.name, "version" => lib.version, "path" => path.to_s }
+              end
+            end
+            libs
+          end,
+          "unreferenced" => target.unreferenced
+        } #: target_json
+
+        if files
+          files.each_group_signature_path(target, true) do |path|
+            (json["signature_paths"] ||= []) << path.to_s
+          end
+          files.each_group_source_path(target, true) do |path|
+            (json["source_paths"] ||= []) << path.to_s
+          end
+        end
+
+        json
+      end
+
+      def group_as_json(group)
+        json = {
+          "name" => group.name.to_s,
+          "source_pattern" => pattern_as_json(group.source_pattern),
+          "signature_pattern" => pattern_as_json(group.signature_pattern)
+        } #: group_json
+
+        if files
+          files.each_group_signature_path(group, true) do |path|
+            (json["signature_paths"] ||= []) << path.to_s
+
+          end
+          files.each_group_source_path(group, true) do |path|
+            (json["source_paths"] ||= []) << path.to_s
+          end
+        end
+
+        json
+      end
+
+      def pattern_as_json(pattern)
+        {
+          "pattern" => pattern.patterns,
+          "ignore" => pattern.ignores
+        }
+      end
+
+      def run
+        project = load_config()
+        if print_files
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+          @files = files = Server::TargetGroupFiles.new(project)
+          project.targets.each do |target|
+            loader.each_path_in_target(target) do |path|
+              files.add_path(path)
+            end
+          end
+        else
+          @files = nil
+        end
+
+        stdout.puts YAML.dump(as_json(project))
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/stats.rb

@@ -0,0 +1,203 @@
+require "csv"
+
+module Steep
+  module Drivers
+    class Stats
+      class CSVPrinter
+        attr_reader :io
+
+        def initialize(io:)
+          @io = io
+        end
+
+        def print(stats_result)
+          io.puts(
+            CSV.generate do |csv|
+              csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
+              stats_result.each do |row|
+                if row[:type] == "success"
+                  # @type var row: Steep::Services::StatsCalculator::SuccessStats::json
+                  csv << [
+                    row[:target],
+                    row[:path],
+                    row[:type],
+                    row[:typed_calls],
+                    row[:untyped_calls],
+                    row[:total_calls],
+                    if row[:total_calls].nonzero?
+                      (row[:typed_calls].to_f / row[:total_calls] * 100).to_i
+                    else
+                      100
+                    end
+                  ]
+                else
+                  # @type var row: Steep::Services::StatsCalculator::ErrorStats::json
+                  csv << [
+                    row[:target],
+                    row[:path],
+                    row[:type],
+                    0,
+                    0,
+                    0,
+                    0
+                  ]
+                end
+              end
+            end
+          )
+        end
+      end
+
+      class TablePrinter
+        attr_reader :io
+
+        def initialize(io:)
+          @io = io
+        end
+
+        def print(stats_result)
+          rows = [] #: Array[Array[untyped]]
+          stats_result.sort_by {|row| row[:path] }.each do |row|
+            if row[:type] == "success"
+                # @type var row: Steep::Services::StatsCalculator::SuccessStats::json
+                rows << [
+                row[:target],
+                row[:path] + "  ",
+                row[:type],
+                row[:typed_calls],
+                row[:untyped_calls],
+                row[:total_calls],
+                if row[:total_calls].nonzero?
+                  "#{(row[:typed_calls].to_f / row[:total_calls] * 100).to_i}%"
+                else
+                  "100%"
+                end
+              ]
+            else
+              # @type var row: Steep::Services::StatsCalculator::ErrorStats::json
+              rows << [
+                row[:target],
+                row[:path],
+                row[:type],
+                0,
+                0,
+                0,
+                "N/A"
+              ]
+            end
+          end
+
+          table = Terminal::Table.new( # steep:ignore UnknownConstant
+            headings: ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"],
+            rows: rows
+          )
+          table.align_column(3, :right)
+          table.align_column(4, :right)
+          table.align_column(5, :right)
+          table.align_column(6, :right)
+          table.style = { border_top: false, border_bottom: false, border_y: "", border_i: "" }
+          io.puts(table)
+        end
+      end
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_patterns
+      attr_accessor :format
+      attr_reader :jobs_option
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_patterns = []
+        @jobs_option = Utils::JobsOption.new()
+      end
+
+      def run
+        project = load_config()
+
+        stderr.puts Rainbow("# Calculating stats:").bold
+        stderr.puts
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
+
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
+          steepfile: project.steepfile_path,
+          delay_shutdown: true,
+          args: command_line_patterns,
+          steep_command: jobs_option.steep_command,
+          count: jobs_option.jobs_count_value
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*command_line_patterns)
+
+        main_thread = Thread.start do
+          Thread.current.abort_on_exception = true
+          master.start()
+        end
+
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        typecheck_guid = SecureRandom.uuid
+
+        master.job_queue << -> do
+          Steep.logger.info { "Type checking for stats..." }
+          progress = master.work_done_progress(typecheck_guid)
+          master.start_type_check(last_request: nil, progress: progress, include_unchanged: true, report_progress_threshold: 0, needs_response: true)
+        end
+        wait_for_message(reader: client_reader) do |message|
+          message[:id] == typecheck_guid
+        end
+
+        Steep.logger.info { "Finished type checking for stats" }
+
+        stats_id = request_id()
+        client_writer.write(Server::CustomMethods::Stats.request(stats_id))
+
+        stats_response = wait_for_response_id(reader: client_reader, id: stats_id)
+        stats_result = stats_response[:result] #: Server::CustomMethods::Stats::result
+
+        shutdown_exit(reader: client_reader, writer: client_writer)
+        main_thread.join()
+
+        printer = case format
+                  when "csv"
+                    CSVPrinter.new(io: stdout)
+                  when "table"
+                    TablePrinter.new(io: stdout)
+                  when nil
+                    if stdout.tty?
+                      TablePrinter.new(io: stdout)
+                    else
+                      CSVPrinter.new(io: stdout)
+                    end
+                  else
+                    raise ArgumentError.new("Invalid format: #{format}")
+                  end
+
+        printer.print(stats_result)
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/utils/driver_helper.rb

@@ -0,0 +1,143 @@
+module Steep
+  module Drivers
+    module Utils
+      module DriverHelper
+        attr_accessor :steepfile
+        attr_accessor :disable_install_collection
+
+        def load_config(path: steepfile || Pathname("Steepfile"))
+          if path.file?
+            steep_file_path = path.absolute? ? path : Pathname.pwd + path
+            Project.new(steepfile_path: steep_file_path).tap do |project|
+              Project::DSL.parse(project, path.read, filename: path.to_s)
+            end
+          else
+            Steep.ui_logger.error { "Cannot find a configuration at #{path}: `steep init` to scaffold. Using current directory..." }
+            Project.new(steepfile_path: nil, base_dir: Pathname.pwd).tap do |project|
+              Project::DSL.eval(project) do
+                target :'.' do
+                  check '.'
+                  signature '.'
+                end
+              end
+            end
+          end.tap do |project|
+            project.targets.each do |target|
+              case result = target.options.load_collection_lock
+              when nil, RBS::Collection::Config::Lockfile
+                # ok
+              when Pathname
+                # File is missing
+                if result == target.options.collection_config_path
+                  # Config file is missing
+                  Steep.ui_logger.error { "rbs-collection configuration is missing: `#{result}`" }
+                else
+                  # Lockfile is missing
+                  Steep.ui_logger.error { "Run `rbs collection install` to generate missing lockfile: `#{result}`" }
+                end
+              when YAML::SyntaxError
+                # File is broken
+                Steep.ui_logger.error { "rbs-collection setup is broken:\nsyntax error #{result.inspect}" }
+              when RBS::Collection::Config::CollectionNotAvailable
+                unless disable_install_collection
+                  install_collection(target, target.options.collection_config_path || raise)
+                else
+                  Steep.ui_logger.error { "Run `rbs collection install` to set up RBS files for gems" }
+                end
+              end
+            end
+          end
+        end
+
+        def install_collection(target, config_path)
+          Steep.ui_logger.info { "Installing RBS files for collection: #{config_path}" }
+          lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
+          io = StringIO.new
+          begin
+            RBS::Collection::Installer.new(lockfile_path: lockfile_path, stdout: io).install_from_lockfile()
+            target.options.load_collection_lock(force: true)
+            Steep.ui_logger.debug { "Finished setting up RBS collection: " + io.string }
+
+            result = target.options.load_collection_lock(force: true)
+            unless result.is_a?(RBS::Collection::Config::Lockfile)
+              raise "Failed to set up RBS collection: #{result.inspect}"
+            end
+          rescue => exn
+            Steep.ui_logger.error { "Failed to set up RBS collection: #{exn.inspect}" }
+          end
+        end
+
+        def request_id
+          SecureRandom.alphanumeric(10)
+        end
+
+        def wait_for_response_id(reader:, id:, unknown_responses: nil, &block)
+          reader.read do |message|
+            Steep.logger.debug { "Received message waiting for #{id}: #{message.inspect}" }
+
+            response_id = message[:id]
+
+            if response_id == id
+              return message
+            end
+
+            if block
+              yield message
+            else
+              case unknown_responses
+              when :ignore, nil
+                # nop
+              when :log
+                Steep.logger.error { "Unexpected message: #{message.inspect}" }
+              when :raise
+                raise "Unexpected message: #{message.inspect}"
+              end
+            end
+          end
+        end
+
+        def shutdown_exit(writer:, reader:)
+          request_id().tap do |id|
+            writer.write({ method: :shutdown, id: id })
+            wait_for_response_id(reader: reader, id: id)
+          end
+          writer.write({ method: :exit })
+        end
+
+        def wait_for_message(reader:, unknown_messages: :ignore, &block)
+          reader.read do |message|
+            if yield(message)
+              return message
+            else
+              case unknown_messages
+              when :ignore
+                # nop
+              when :log
+                Steep.logger.error { "Unexpected message: #{message.inspect}" }
+              when :raise
+                raise "Unexpected message: #{message.inspect}"
+              end
+            end
+          end
+        end
+
+        def keep_diagnostic?(diagnostic, severity_level:)
+          severity = diagnostic[:severity]
+
+          case severity_level
+          when nil, :hint
+            true
+          when :error
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR
+          when :warning
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING
+          when :information
+            severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION
+          end
+        end
+
+        (DEFAULT_CLI_LSP_INITIALIZE_PARAMS = {}).freeze
+      end
+    end
+  end
+end

data/lib/steep/drivers/utils/jobs_option.rb

@@ -0,0 +1,26 @@
+module Steep
+  module Drivers
+    module Utils
+      class JobsOption
+        attr_accessor :jobs_count, :steep_command, :jobs_count_modifier
+
+        def initialize(jobs_count_modifier: 0)
+          @jobs_count_modifier = jobs_count_modifier
+        end
+
+        def default_jobs_count
+          Concurrent.physical_processor_count + jobs_count_modifier
+        end
+
+        def jobs_count_value
+          count = jobs_count || default_jobs_count
+          if count >= 1
+            count
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/vendor.rb

@@ -0,0 +1,27 @@
+module Steep
+  module Drivers
+    class Vendor
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :stdin
+
+      attr_accessor :vendor_dir
+      attr_accessor :clean_before
+
+      def initialize(stdout:, stderr:, stdin:)
+        @stdout = stdout
+        @stderr = stderr
+        @stdin = stdin
+
+        @clean_before = false
+        @vendor_dir = nil
+      end
+
+      def run
+        stdout.puts "`steep vendor` is deprecated. Use `rbs vendor` command directly"
+
+        0
+      end
+    end
+  end
+end