steep 0.40.0 → 0.44.0

data/lib/steep/drivers/diagnostic_printer.rb

@@ -50,28 +50,33 @@ module Steep
         Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
       end
 
-      def print(diagnostic)
+      def print(diagnostic, prefix: "", source: true)
         header, *rest = diagnostic[:message].split(/\n/)
 
-        stdout.puts "#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+        stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
 
         unless rest.empty?
           rest.each do |message|
-            stdout.puts "│ #{message}"
+            stdout.puts "#{prefix}│ #{message}"
           end
         end
 
         if diagnostic[:code]
-          stdout.puts "│" unless rest.empty?
-          stdout.puts "│ Diagnostic ID: #{diagnostic[:code]}"
+          stdout.puts "#{prefix}│" unless rest.empty?
+          stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
         end
 
-        stdout.puts "│"
+        stdout.puts "#{prefix}│"
 
-        print_source_line(diagnostic)
+        if source
+          print_source_line(diagnostic, prefix: prefix)
+        else
+          stdout.puts "#{prefix}└ (no source code available)"
+          stdout.puts "#{prefix}"
+        end
       end
 
-      def print_source_line(diagnostic)
+      def print_source_line(diagnostic, prefix: "")
         start_pos = diagnostic[:range][:start]
         end_pos = diagnostic[:range][:end]
 
@@ -80,14 +85,18 @@ module Steep
         leading = line[0...start_pos[:character]]
         if start_pos[:line] == end_pos[:line]
           subject = line[start_pos[:character]...end_pos[:character]]
-          trailing = line[end_pos[:character]...].chomp
+          trailing = (line[end_pos[:character]...] || "").chomp
         else
           subject = line[start_pos[:character]...].chomp
           trailing = ""
         end
 
-        stdout.puts "└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
-        stdout.puts "  #{" " * leading.size}#{"~" * subject.size}"
+        unless subject.valid_encoding?
+          subject.scrub!
+        end
+
+        stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+        stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
       end
     end
   end

data/lib/steep/drivers/langserver.rb

@@ -10,6 +10,7 @@ module Steep
       attr_reader :type_check_thread
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       TypeCheckRequest = Struct.new(:version, keyword_init: true)
 
@@ -36,22 +37,17 @@ module Steep
       def run
         @project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources([])
-        loader.load_signatures()
-
         interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path)
-        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path)
-        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: [], count: jobs_count)
 
         master = Server::Master.new(
           project: project,
           reader: reader,
           writer: writer,
           interaction_worker: interaction_worker,
-          signature_worker: signature_worker,
-          code_workers: code_workers
+          typecheck_workers: typecheck_workers
         )
+        master.typecheck_automatically = true
 
         master.start()
 

data/lib/steep/drivers/print_project.rb

@@ -14,33 +14,34 @@ module Steep
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources([])
-        loader.load_signatures()
+        loader = Services::FileLoader.new(base_dir: project.base_dir)
 
         project.targets.each do |target|
+          source_changes = loader.load_changes(target.source_pattern, changes: {})
+          signature_changes = loader.load_changes(target.signature_pattern, changes: {})
+
           stdout.puts "Target:"
           stdout.puts "  #{target.name}:"
           stdout.puts "    sources:"
           stdout.puts "      patterns:"
-          target.source_patterns.each do |pattern|
+          target.source_pattern.patterns.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      ignores:"
-          target.ignore_patterns.each do |pattern|
+          target.source_pattern.ignores.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      files:"
-          target.source_files.each_key do |path|
+          source_changes.each_key do |path|
             stdout.puts "        - #{path}"
           end
           stdout.puts "    signatures:"
           stdout.puts "      patterns:"
-          target.signature_patterns.each do |pattern|
+          target.signature_pattern.patterns.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      files:"
-          target.signature_files.each_key do |path|
+          signature_changes.each_key do |path|
             stdout.puts "        - #{path}"
           end
           stdout.puts "    libraries:"
@@ -48,7 +49,7 @@ module Steep
             stdout.puts "      - #{lib}"
           end
           stdout.puts "    library dirs:"
-          Project::Target.construct_env_loader(options: target.options).tap do |loader|
+          target.new_env_loader(project: project).tap do |loader|
             loader.each_dir do |lib, path|
               case lib
               when :core

data/lib/steep/drivers/stats.rb

@@ -3,11 +3,106 @@ 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"
+                  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
+                  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 = []
+          stats_result.sort_by {|row| row[:path] }.each do |row|
+            if row[:type] == "success"
+              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
+              rows << [
+                row[:target],
+                row[:path],
+                row[:type],
+                0,
+                0,
+                0,
+                "N/A"
+              ]
+            end
+          end
+
+          table = Terminal::Table.new(
+            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
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
@@ -18,10 +113,6 @@ module Steep
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(command_line_patterns)
-        loader.load_signatures()
-
         stderr.puts Rainbow("# Calculating stats:").bold
         stderr.puts
 
@@ -34,147 +125,72 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, delay_shutdown: true)
-        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path, delay_shutdown: true)
-        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path, delay_shutdown: true)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+          steepfile: project.steepfile_path,
+          delay_shutdown: true,
+          args: command_line_patterns,
+          count: jobs_count
+        )
 
         master = Server::Master.new(
           project: project,
           reader: server_reader,
           writer: server_writer,
-          interaction_worker: interaction_worker,
-          signature_worker: signature_worker,
-          code_workers: code_workers
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
         )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*command_line_patterns)
 
         main_thread = Thread.start do
           master.start()
         end
         main_thread.abort_on_exception = true
 
-        client_writer.write({ method: :initialize, id: 0 })
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        typecheck_guid = SecureRandom.uuid
+        client_writer.write({ method: "$/typecheck", params: { guid: typecheck_guid }})
+        wait_for_message(reader: client_reader) do |message|
+          message[:method] == "$/progress" &&
+            message[:params][:token] == typecheck_guid &&
+            message[:params][:value][:kind] == "end"
+        end
 
-        stats_id = -1
+        stats_id = request_id()
         client_writer.write(
           {
             id: stats_id,
             method: "workspace/executeCommand",
-            params: {
-              command: "steep/stats",
-              arguments: project.all_source_files.map {|path| project.absolute_path(path) }
-            }
+            params: { command: "steep/stats", arguments: [] }
           })
 
-        stats_result = []
-        client_reader.read do |response|
-          if response[:id] == stats_id
-            stats_result.push(*response[:result])
-            break
-          end
-        end
-
-        shutdown_id = -2
-        client_writer.write({ method: :shutdown, id: shutdown_id })
-
-        client_reader.read do |response|
-          if response[:id] == shutdown_id
-            break
-          end
-        end
+        stats_response = wait_for_response_id(reader: client_reader, id: stats_id)
+        stats_result = stats_response[:result]
 
-        client_writer.write({ method: "exit" })
+        shutdown_exit(reader: client_reader, writer: client_writer)
         main_thread.join()
 
-        stdout.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"
-                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
+        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
-                    100
+                    raise ArgumentError.new("Invalid format: #{format}")
                   end
-                ]
-              else
-                csv << [
-                  row[:target],
-                  row[:path],
-                  row[:type],
-                  0,
-                  0,
-                  0,
-                  0
-                ]
-              end
-            end
-          end
-        )
-        #
-        # type_check(project)
-        #
-        # stdout.puts(
-        #   CSV.generate do |csv|
-        #     csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
-        #
-        #     project.targets.each do |target|
-        #       case (status = target.status)
-        #       when Project::Target::TypeCheckStatus
-        #         status.type_check_sources.each do |source_file|
-        #           case source_file.status
-        #           when Project::SourceFile::TypeCheckStatus
-        #             typing = source_file.status.typing
-        #
-        #             typed = 0
-        #             untyped = 0
-        #             total = 0
-        #             typing.method_calls.each_value do |call|
-        #               case call
-        #               when TypeInference::MethodCall::Typed
-        #                 typed += 1
-        #               when TypeInference::MethodCall::Untyped
-        #                 untyped += 1
-        #               end
-        #
-        #               total += 1
-        #             end
-        #
-        #             csv << format_stats(target, source_file.path, "success", typed, untyped, total)
-        #           when Project::SourceFile::TypeCheckErrorStatus
-        #             csv << format_stats(target, source_file.path, "error", 0, 0, 0)
-        #           else
-        #             csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
-        #           end
-        #         end
-        #       end
-        #     end
-        #   end
-        # )
 
-        0
-      end
+        printer.print(stats_result)
 
-      def format_stats(target, path, status, typed, untyped, total)
-        [
-          target.name,
-          path.to_s,
-          status,
-          typed,
-          untyped,
-          total,
-          if total.nonzero?
-            format("%.2f", (typed.to_f/total)*100)
-          else
-            0
-          end
-        ]
+        0
       end
     end
   end