steep 0.11.1 → 0.12.0

data/lib/steep/drivers/print_project.rb

@@ -0,0 +1,56 @@
+module Steep
+  module Drivers
+    class PrintProject
+      attr_reader :stdout
+      attr_reader :stderr
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        project = load_config()
+
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources([])
+        loader.load_signatures()
+
+        project.targets.each do |target|
+          stdout.puts "Target:"
+          stdout.puts "  #{target.name}:"
+          stdout.puts "    sources:"
+          stdout.puts "      patterns:"
+          target.source_patterns.each do |pattern|
+            stdout.puts "        - #{pattern}"
+          end
+          stdout.puts "      ignores:"
+          target.ignore_patterns.each do |pattern|
+            stdout.puts "        - #{pattern}"
+          end
+          stdout.puts "      files:"
+          target.source_files.each_key do |path|
+            stdout.puts "        - #{path}"
+          end
+          stdout.puts "    signatures:"
+          stdout.puts "      patterns:"
+          target.signature_patterns.each do |pattern|
+            stdout.puts "        - #{pattern}"
+          end
+          stdout.puts "      files:"
+          target.signature_files.each_key do |path|
+            stdout.puts "        - #{path}"
+          end
+          stdout.puts "    libraries:"
+          target.options.libraries.each do |lib|
+            stdout.puts "      - #{lib}"
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/signature_error_printer.rb

@@ -0,0 +1,25 @@
+module Steep
+  module Drivers
+    class SignatureErrorPrinter
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def print_syntax_errors(errors)
+        errors.each do |error|
+          stderr.puts error.message
+        end
+      end
+
+      def print_semantic_errors(errors)
+        errors.each do |error|
+          error.puts stderr
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/trace_printer.rb

@@ -0,0 +1,25 @@
+module Steep
+  module Drivers
+    class TracePrinter
+      attr_reader :io
+
+      def initialize(io)
+        @io = io
+      end
+
+      def print(trace, level: 0)
+        trace.each.with_index do |t, i|
+          prefix = " " * (i + level)
+          case t[0]
+          when :type
+            io.puts "#{prefix}#{t[1]} <: #{t[2]}"
+          when :method
+            io.puts "#{prefix}(#{t[3]}) #{t[1]} <: #{t[2]}"
+          when :method_type
+            io.puts "#{prefix}#{t[1]} <: #{t[2]}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Steep
+  module Drivers
+    module Utils
+      module DriverHelper
+        attr_accessor :steepfile
+
+        def load_config(path: steepfile || Pathname("Steepfile"))
+          raise "Cannot find a configuration at #{path}: `steep init` to scaffold" unless path.file?
+
+          steep_file_path = path.absolute? ? path : Pathname.pwd + path
+          Project.new(base_dir: steep_file_path.parent).tap do |project|
+            Project::DSL.parse(project, path.read, filename: path.to_s)
+          end
+        end
+
+        def type_check(project)
+          project.targets.each do |target|
+            Steep.logger.tagged "target=#{target.name}" do
+              target.type_check
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/validate.rb

@@ -1,58 +1,38 @@
 module Steep
   module Drivers
     class Validate
-      attr_reader :signature_dirs
       attr_reader :stdout
       attr_reader :stderr
 
-      def initialize(signature_dirs:, stdout:, stderr:)
-        @signature_dirs = signature_dirs
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
       end
 
-      include Utils::EachSignature
-
       def run
-        project = Project.new
+        project = load_config()
 
-        signature_dirs.each do |path|
-          each_file_in_path(".rbi", path) do |file_path|
-            file = Project::SignatureFile.new(path: file_path)
-            file.content = file_path.read
-            project.signature_files[file_path] = file
-          end
-        end
+        loader = Project::FileLoader.new(project: project)
+        loader.load_signatures()
 
-        project.type_check
+        type_check(project)
 
-        case project.signature
-        when Project::SignatureHasError
-          project.signature.errors.each do |error|
-            case error
-            when Interface::Instantiated::InvalidMethodOverrideError
-              stdout.puts "😱 #{error.message}"
-              error.result.trace.each do |s, t|
-                case s
-                when Interface::Method
-                  stdout.puts "  #{s.name}(#{s.type_name}) <: #{t.name}(#{t.type_name})"
-                when Interface::MethodType
-                  stdout.puts "  #{s} <: #{t} (#{s.location&.name||"?"}:#{s.location&.start_line||"?"})"
-                else
-                  stdout.puts "  #{s} <: #{t}"
-                end
-              end
-              stdout.puts "  🚨 #{error.result.error.message}"
-            when Interface::Instantiated::InvalidIvarOverrideError
-              stdout.puts "😱 #{error.message}"
-            else
-              stdout.puts "😱 #{error.inspect}"
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
+            case (status = target.status)
+            when Project::Target::SignatureSyntaxErrorStatus
+              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
+              printer.print_syntax_errors(status.errors)
+            when Project::Target::SignatureValidationErrorStatus
+              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
+              printer.print_semantic_errors(status.errors)
             end
           end
-          1
-        else
-          0
         end
+
+        project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) } ? 0 : 1
       end
     end
   end

data/lib/steep/drivers/vendor.rb

@@ -0,0 +1,46 @@
+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 "Vendoring into #{vendor_dir}..."
+
+        vendorer = Ruby::Signature::Vendorer.new(vendor_dir: vendor_dir)
+
+        if clean_before
+          stdout.puts "  Cleaning directory..."
+          vendorer.clean!
+        end
+
+        stdout.puts "  Vendoring standard libraries..."
+        vendorer.stdlib!
+
+        if defined?(Bundler)
+          Bundler.locked_gems.specs.each do |spec|
+            if Ruby::Signature::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
+              stdout.puts "  Vendoring rubygem: #{spec.full_name}..."
+              vendorer.gem! spec.name, spec.version.to_s
+            end
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/watch.rb

@@ -1,187 +1,125 @@
 module Steep
   module Drivers
     class Watch
-      class Options
-        attr_accessor :fallback_any_is_error
-        attr_accessor :allow_missing_definitions
-
-        def initialize
-          self.fallback_any_is_error = false
-          self.allow_missing_definitions = true
-        end
-      end
-
-      attr_reader :source_dirs
-      attr_reader :signature_dirs
+      attr_reader :dirs
       attr_reader :stdout
       attr_reader :stderr
-      attr_reader :options
       attr_reader :queue
 
-      include Utils::EachSignature
+      include Utils::DriverHelper
 
-      def initialize(source_dirs:, signature_dirs:, stdout:, stderr:)
-        @source_dirs = source_dirs
-        @signature_dirs = signature_dirs
+      def initialize(stdout:, stderr:)
+        @dirs = []
         @stdout = stdout
         @stderr = stderr
-        @options = Options.new
         @queue = Thread::Queue.new
       end
 
-      def project_options
-        Project::Options.new.tap do |opt|
-          opt.fallback_any_is_error = options.fallback_any_is_error
-          opt.allow_missing_definitions = options.allow_missing_definitions
-        end
-      end
-
-      def source_listener
-        @source_listener ||= yield_self do
-          Listen.to(*source_dirs.map(&:to_s), only: /\.rb$/) do |modified, added, removed|
-            queue << [:source, modified, added, removed]
+      def listener
+        @listener ||= begin
+          Steep.logger.info "Watching #{dirs.join(", ")}..."
+          Listen.to(*dirs.map(&:to_s)) do |modified, added, removed|
+            Steep.logger.tagged "watch" do
+              Steep.logger.info "Received file system updates: modified=[#{modified.join(",")}], added=[#{added.join(",")}], removed=[#{removed.join(",")}]"
+            end
+            queue << [modified, added, removed]
           end
         end
       end
 
-      def signature_listener
-        @signature_listener ||= yield_self do
-          Listen.to(*signature_dirs.map(&:to_s), only: /\.rbi$/) do |modified, added, removed|
-            queue << [:signature, modified, added, removed]
-          end
-        end
-      end
+      def type_check_loop(project)
+        until queue.closed?
+          stdout.puts "🚥 Waiting for updates..."
 
-      def type_check_thread(project)
-        Thread.new do
-          until queue.closed?
-            begin
-              events = []
-              events << queue.deq
-              until queue.empty?
-                events << queue.deq(nonblock: true)
-              end
+          events = []
+          events << queue.deq
+          until queue.empty?
+              events << queue.deq(nonblock: true)
+          end
 
-              events.compact.each do |name, modified, added, removed|
-                case name
-                when :source
-                  (modified + added).each do |name|
-                    path = Pathname(name).relative_path_from(Pathname.pwd)
-                    file = project.source_files[path] || Project::SourceFile.new(path: path, options: project_options)
-                    file.content = path.read
-                    project.source_files[path] = file
-                  end
-
-                  removed.each do |name|
-                    path = Pathname(name).relative_path_from(Pathname.pwd)
-                    project.source_files.delete(path)
-                  end
-
-                when :signature
-                  (modified + added).each do |name|
-                    path = Pathname(name).relative_path_from(Pathname.pwd)
-                    file = project.signature_files[path] || Project::SignatureFile.new(path: path)
-                    file.content = path.read
-                    project.signature_files[path] = file
-                  end
-
-                  removed.each do |name|
-                    path = Pathname(name).relative_path_from(Pathname.pwd)
-                    project.signature_files.delete(path)
-                  end
-                end
-              end
+          events.compact.each do |modified, added, removed|
+            modified.each do |name|
+              path = Pathname(name).relative_path_from(Pathname.pwd)
 
-              begin
-                project.type_check
-              rescue Racc::ParseError => exn
-                stderr.puts exn.message
-                project.clear
+              project.targets.each do |target|
+                target.update_source path, path.read if target.source_file?(path)
+                target.update_signature path, path.read if target.signature_file?(path)
               end
             end
-          end
-        rescue ClosedQueueError
-          # nop
-        end
-      end
 
-      class WatchListener < Project::NullListener
-        attr_reader :stdout
-        attr_reader :stderr
-
-        def initialize(stdout:, stderr:, verbose:)
-          @stdout = stdout
-          @stderr = stderr
-        end
+            added.each do |name|
+              path = Pathname(name).relative_path_from(Pathname.pwd)
 
-        def check(project:)
-          yield.tap do
-            if project.success?
-              if project.has_type_error?
-                stdout.puts "Detected #{project.errors.size} errors... 🔥"
-              else
-                stdout.puts "No error detected. 🎉"
+              project.targets.each do |target|
+                target.add_source path, path.read if target.possible_source_file?(path)
+                target.add_signature path, path.read if target.possible_signature_file?(path)
               end
-            else
-              stdout.puts "Type checking failed... 🔥"
             end
-          end
-        end
 
-        def type_check_source(project:, file:)
-          yield.tap do
-            case
-            when file.source.is_a?(Source) && file.errors
-              file.errors.each do |error|
-                error.print_to stdout
+            removed.each do |name|
+              path = Pathname(name).relative_path_from(Pathname.pwd)
+
+              project.targets.each do |target|
+                target.remove_source path if target.source_file?(path)
+                target.remove_signature path if target.signature_file?(path)
               end
             end
           end
+
+          stdout.puts "🔬 Type checking..."
+          type_check project
+          print_project_result project
         end
+      rescue ClosedQueueError
+        # nop
+      end
 
-        def load_signature(project:)
-          # @type var project: Project
-          yield.tap do
-            case sig = project.signature
-            when Project::SignatureHasError
-            when Project::SignatureHasSyntaxError
-              sig.errors.each do |path, exn|
-                stdout.puts "#{path} has a syntax error: #{exn.inspect}"
+      def print_project_result(project)
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
+            case (status = target.status)
+            when Project::Target::SignatureSyntaxErrorStatus
+              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
+              printer.print_syntax_errors(status.errors)
+            when Project::Target::SignatureValidationErrorStatus
+              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
+              printer.print_semantic_errors(status.errors)
+            when Project::Target::TypeCheckStatus
+              status.type_check_sources.each do |source_file|
+                source_file.errors.each do |error|
+                  error.print_to stdout
+                end
               end
             end
           end
         end
       end
 
-      def run(block: true)
-        project = Project.new(WatchListener.new(stdout: stdout, stderr: stderr, verbose: false))
-
-        source_dirs.each do |path|
-          each_file_in_path(".rb", path) do |file_path|
-            file = Project::SourceFile.new(path: file_path, options: options)
-            file.content = file_path.read
-            project.source_files[file_path] = file
-          end
+      def run()
+        if dirs.empty?
+          stdout.puts "Specify directories to watch"
+          return 1
         end
 
-        signature_dirs.each do |path|
-          each_file_in_path(".rbi", path) do |file_path|
-            file = Project::SignatureFile.new(path: file_path)
-            file.content = file_path.read
-            project.signature_files[file_path] = file
-          end
-        end
+        project = load_config()
 
-        project.type_check
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources([])
+        loader.load_signatures()
 
-        source_listener.start
-        signature_listener.start
-        t = type_check_thread(project)
+        type_check project
+        print_project_result project
 
-        binding.pry(quiet: true) if block
+        listener.start
+
+        stdout.puts "👀 Watching directories, Ctrl-C to stop."
+        begin
+          type_check_loop project
+        rescue Interrupt
+          # bye
+        end
 
-        queue.close
-        t.join
+        0
       end
     end
   end