steep 0.11.1 → 0.12.0

data/lib/steep/ast/types/name.rb

@@ -48,7 +48,7 @@ module Steep
             if args.empty?
               "#{name}"
             else
-              "#{name}<#{args.join(", ")}>"
+              "#{name}[#{args.join(", ")}]"
             end
           end
 
@@ -105,7 +105,7 @@ module Steep
                 when nil
                   ""
                 end
-            "#{name.to_s}.class#{k}"
+            "singleton(#{name.to_s})"
           end
 
           def with_location(new_location)
@@ -140,7 +140,7 @@ module Steep
           end
 
           def to_s
-            "#{name.to_s}.module"
+            "singleton(#{name.to_s})"
           end
 
           def with_location(new_location)

data/lib/steep/ast/types/var.rb

@@ -33,7 +33,7 @@ module Steep
         end
 
         def to_s
-          "'#{name}"
+          name.to_s
         end
 
         def subst(s)

data/lib/steep/cli.rb

@@ -2,122 +2,6 @@ require 'optparse'
 
 module Steep
   class CLI
-    BUILTIN_PATH = Pathname(__dir__).join("../../stdlib").realpath
-
-    class SignatureOptions
-      class MissingGemError < StandardError
-        attr_reader :name
-        attr_reader :version
-
-        def initialize(name:, version:)
-          @name = name
-          @version = version
-          super "Requested gem not found: name=#{name}, version=#{version}"
-        end
-      end
-
-      class NoTypeDefinitionFromGemError < StandardError
-        attr_reader :gemspec
-
-        def initialize(gemspec:)
-          @gemspec = gemspec
-          super "Gem does not provide Steep type: gem=#{gemspec.name}"
-        end
-      end
-
-      attr_reader :no_builtin
-      attr_reader :no_bundler
-
-      def initialize
-        @options = []
-      end
-
-      def no_builtin!
-        @no_builtin = true
-      end
-
-      def no_bundler!
-        @no_bundler = true
-      end
-
-      def <<(option)
-        @options << option
-      end
-
-      def find_gem_dir(gem)
-        name, version = gem.split(/:/)
-        spec =
-          begin
-            Gem::Specification.find_by_name(name, version)
-          rescue Gem::MissingSpecError
-            raise MissingGemError.new(name: name, version: version)
-          end
-
-        dirs_from_spec(spec).tap do |dirs|
-          if dirs.empty?
-            raise NoTypeDefinitionFromGemError.new(gemspec: spec)
-          end
-        end
-      end
-
-      def dirs_from_spec(spec)
-        type_dirs = spec.metadata["steep_types"].yield_self do |types|
-          case types
-          when nil
-            []
-          when String
-            types.split(/:/).map do |type|
-              Pathname(type)
-            end
-          end
-        end
-
-        base_dir = Pathname(spec.gem_dir)
-        type_dirs.map do |dir|
-          base_dir + dir
-        end.select(&:directory?)
-      end
-
-      def add_bundler_gems(options)
-        if defined?(Bundler)
-          Steep.logger.info "Bundler detected!"
-          Bundler.load.gems.each do |spec|
-            dirs = dirs_from_spec(spec)
-            options.unshift *dirs
-          end
-        end
-      end
-
-      def paths
-        options = if @options.none? {|option| option.is_a?(Pathname) } && Pathname("sig").directory?
-                    @options + [Pathname("sig")]
-                  else
-                    @options
-                  end
-
-        unless no_bundler
-          add_bundler_gems(options)
-        end
-
-        paths = options.flat_map do |option|
-          case option
-          when Pathname
-            # Dir
-            [option]
-          when String
-            # gem name
-            find_gem_dir(option)
-          end
-        end
-
-        unless no_builtin
-          paths.unshift BUILTIN_PATH
-        end
-
-        paths.reverse.uniq(&:realpath).reverse
-      end
-    end
-
     attr_reader :argv
     attr_reader :stdout
     attr_reader :stdin
@@ -132,7 +16,7 @@ module Steep
     end
 
     def self.available_commands
-      [:check, :validate, :annotations, :scaffold, :interface, :version, :paths, :watch, :langserver]
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :vendor]
     end
 
     def process_global_options
@@ -167,181 +51,113 @@ module Steep
     end
 
     def handle_logging_options(opts)
-      opts.on("--verbose") do
-        Steep.logger.level = Logger::DEBUG
-      end
-
       opts.on("--log-level=[debug,info,warn,error,fatal]") do |level|
-        lv = {
-          "debug" => Logger::DEBUG,
-          "info" => Logger::INFO,
-          "warn" => Logger::WARN,
-          "error" => Logger::ERROR,
-          "fatal" => Logger::FATAL
-        }[level.downcase] or raise "Unknown error level: #{level}"
-
-        Steep.logger.level = lv
+        Steep.logger.level = level
       end
 
       opts.on("--log-output=[PATH]") do |file|
         Steep.log_output = file
       end
-    end
 
-    def handle_dir_options(opts, options)
-      opts.on("-I [PATH]") {|path| options << Pathname(path) }
-      opts.on("-G [GEM]") {|gem| options << gem }
-      opts.on("--no-builtin") { options.no_builtin! }
-      opts.on("--no-bundler") { options.no_bundler! }
+      opts.on("--verbose") do
+        Steep.logger.level = Logger::DEBUG
+      end
     end
 
-    def with_signature_options
-      yield SignatureOptions.new
-    rescue SignatureOptions::MissingGemError => exn
-      stderr.puts Rainbow("Gem not found: name=#{exn.name}, version=#{exn.version}").red
-      1
-    rescue SignatureOptions::NoTypeDefinitionFromGemError => exn
-      stderr.puts Rainbow("Type definition directory not found: #{exn.gemspec.name} (#{exn.gemspec.version})").red
-      1
+    def process_init
+      Drivers::Init.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep init [options]"
+
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--force") { command.force_write = true }
+
+          handle_logging_options opts
+        end.parse!(argv)
+      end.run()
     end
 
     def process_check
-      with_signature_options do |signature_options|
-        dump_all_types = false
-        fallback_any_is_error = false
-        strict = false
-
+      Drivers::Check.new(stdout: stdout, stderr: stderr).tap do |check|
         OptionParser.new do |opts|
+          opts.banner = "Usage: steep check [options] [sources]"
+
+          opts.on("--steepfile=PATH") {|path| check.steepfile = Pathname(path) }
+          opts.on("--dump-all-types") { check.dump_all_types = true }
           handle_logging_options opts
-          handle_dir_options opts, signature_options
-          opts.on("--dump-all-types") { dump_all_types = true }
-          opts.on("--strict") { strict = true }
-          opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
         end.parse!(argv)
 
-        source_paths = argv.map {|path| Pathname(path) }
-        if source_paths.empty?
-          source_paths << Pathname(".")
-        end
-
-        Drivers::Check.new(source_paths: source_paths, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).tap do |check|
-          check.dump_all_types = dump_all_types
-          check.fallback_any_is_error = fallback_any_is_error || strict
-          check.allow_missing_definitions = false if strict
-        end.run
-      end
+        check.command_line_patterns.push *argv
+      end.run
     end
 
     def process_validate
-      with_signature_options do |signature_options|
+      Drivers::Validate.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|
           handle_logging_options opts
-          handle_dir_options opts, signature_options
         end.parse!(argv)
-
-        Drivers::Validate.new(signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).run
-      end
+      end.run
     end
 
     def process_annotations
-      OptionParser.new do |opts|
-        handle_logging_options opts
-      end.parse!(argv)
-
-      source_paths = argv.map {|file| Pathname(file) }
-      Drivers::Annotations.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
-    end
-
-    def process_scaffold
-      OptionParser.new do |opts|
-        handle_logging_options opts
-      end.parse!(argv)
+      Drivers::Annotations.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep annotations [options] [sources]"
+          handle_logging_options opts
+        end.parse!(argv)
 
-      source_paths = argv.map {|file| Pathname(file) }
-      Drivers::Scaffold.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
+        command.command_line_patterns.push *argv
+      end.run
     end
 
-    def process_interface
-      with_signature_options do |signature_options|
+    def process_project
+      Drivers::PrintProject.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|
+          opts.banner = "Usage: steep project [options]"
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
           handle_logging_options opts
-          handle_dir_options opts, signature_options
         end.parse!(argv)
-
-        Drivers::PrintInterface.new(type_name: argv.first, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).run
-      end
+      end.run
     end
 
     def process_watch
-      with_signature_options do |signature_options|
-        strict = false
-        fallback_any_is_error = false
-
+      Drivers::Watch.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|
+          opts.banner = "Usage: steep watch [options] [dirs]"
           handle_logging_options opts
-          handle_dir_options opts, signature_options
-          opts.on("--strict") { strict = true }
-          opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
         end.parse!(argv)
 
-        source_dirs = argv.map {|path| Pathname(path) }
-        if source_dirs.empty?
-          source_dirs << Pathname(".")
-        end
-
-        Drivers::Watch.new(source_dirs: source_dirs, signature_dirs: signature_options.paths, stdout: stdout, stderr: stderr).tap do |driver|
-          driver.options.fallback_any_is_error = fallback_any_is_error || strict
-          driver.options.allow_missing_definitions = false if strict
-        end.run
-
-        0
-      end
+        command.dirs.push *argv
+      end.run
     end
 
     def process_langserver
-      with_signature_options do |signature_options|
-        strict = false
-        fallback_any_is_error = false
-
+      Drivers::Langserver.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
         OptionParser.new do |opts|
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
           handle_logging_options opts
-          handle_dir_options opts, signature_options
-          opts.on("--strict") { strict = true }
-          opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
         end.parse!(argv)
+      end.run
+    end
 
-        source_dirs = argv.map { |path| Pathname(path) }
-        if source_dirs.empty?
-          source_dirs << Pathname(".")
-        end
+    def process_vendor
+      Drivers::Vendor.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep vendor [options] [dir]"
+          handle_logging_options opts
 
-        Drivers::Langserver.new(source_dirs: source_dirs, signature_dirs: signature_options.paths).tap do |driver|
-          driver.options.fallback_any_is_error = fallback_any_is_error || strict
-          driver.options.allow_missing_definitions = false if strict
-        end.run
+          opts.on("--[no-]clean") do |v|
+            command.clean_before = v
+          end
+        end.parse!(argv)
 
-        0
-      end
+        command.vendor_dir = Pathname(argv[0] || "vendor/sigs")
+      end.run
     end
 
     def process_version
       stdout.puts Steep::VERSION
       0
     end
-
-    def process_paths
-      with_signature_options do |signature_options|
-        OptionParser.new do |opts|
-          handle_logging_options opts
-          handle_dir_options opts, signature_options
-        end.parse!(argv)
-
-        signature_options.paths.each do |path|
-          stdout.puts path
-        end
-
-        0
-      end
-    end
   end
 end

data/lib/steep/drivers/annotations.rb

@@ -1,44 +1,61 @@
 module Steep
   module Drivers
     class Annotations
-      attr_reader :source_paths
+      attr_reader :command_line_patterns
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :labeling
 
-      include Utils::EachSignature
+      include Utils::DriverHelper
 
-      def initialize(source_paths:, stdout:, stderr:)
-        @source_paths = source_paths
+      def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
 
+        @command_line_patterns = []
         @labeling = ASTUtils::Labeling.new
       end
 
       def run
-        project = Project.new()
+        project = load_config()
 
-        source_paths.each do |path|
-          each_file_in_path(".rb", path) do |file_path|
-            file = Project::SourceFile.new(path: file_path, options: Project::Options.new)
-            file.content = file_path.read
-            project.source_files[file_path] = file
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources(command_line_patterns)
+        loader.load_signatures()
+
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
+            target.load_signatures do |_, subtyping, _|
+              case (status = target.status)
+              when nil     # status set on error cases
+                target.source_files.each_value do |file|
+                  file.parse(subtyping.factory) do |source|
+                    source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
+                      loc = node.loc
+                      stdout.puts "#{file.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
+                      annotations.each do |annotation|
+                        stdout.puts "  #{annotation.location.source}"
+                      end
+                    end
+                  end
+                end
+              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
           end
         end
 
-        project.source_files.each_value do |file|
-          file.parse
-          file.source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
-            loc = node.loc
-            stdout.puts "#{file.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
-            annotations.each do |annotation|
-              stdout.puts "  #{annotation.location.source}"
-            end
+        project.targets.each do |target|
+          Steep.logger.tagged "target=#{target.name}" do
           end
         end
 
-        0
+        project.targets.all? {|target| !target.status } ? 0 : 1
       end
     end
   end