rbs 0.12.2 → 0.16.0

data/{stdlib/builtin → core}/thread_group.rbs

@@ -1,11 +1,11 @@
 # [ThreadGroup](ThreadGroup) provides a means of
 # keeping track of a number of threads as a group.
-# 
+#
 # A given [Thread](https://ruby-doc.org/core-2.6.3/Thread.html) object can
 # only belong to one [ThreadGroup](ThreadGroup) at a
 # time; adding a thread to a new group will remove it from any previous
 # group.
-# 
+#
 # Newly created threads belong to the same group as the thread from which
 # they were created.
 class ThreadGroup < Object

data/{stdlib/builtin → core}/true_class.rbs

@@ -1,14 +1,14 @@
 # The global value `true` is the only instance of class TrueClass and represents
 # a logically true value in boolean expressions. The class provides operators
 # allowing `true` to be used in logical expressions.
-# 
+#
 class TrueClass
   public
 
   def !: () -> bool
 
   # And---Returns `false` if *obj* is `nil` or `false`, `true` otherwise.
-  # 
+  #
   def &: (nil) -> false
        | (false) -> false
        | (untyped obj) -> bool
@@ -16,12 +16,12 @@ class TrueClass
   # Case Equality -- For class Object, effectively the same as calling `#==`, but
   # typically overridden by descendants to provide meaningful semantics in `case`
   # statements.
-  # 
+  #
   def ===: (true) -> true
          | (untyped obj) -> bool
 
   # Exclusive Or---Returns `true` if *obj* is `nil` or `false`, `false` otherwise.
-  # 
+  #
   def ^: (nil) -> true
        | (false) -> true
        | (untyped obj) -> bool
@@ -29,18 +29,18 @@ class TrueClass
   alias inspect to_s
 
   # The string representation of `true` is "true".
-  # 
+  #
   def to_s: () -> "true"
 
   # Or---Returns `true`. As *obj* is an argument to a method call, it is always
   # evaluated; there is no short-circuit evaluation in this case.
-  # 
+  #
   #     true |  puts("or")
   #     true || puts("logical or")
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     or
-  # 
-  def |: (bool obj) -> bool
+  #
+  def |: (boolish obj) -> bool
 end

data/{stdlib/builtin → core}/warning.rbs

@@ -3,7 +3,7 @@
 # module extends itself, making `Warning.warn` available.
 # [\#warn](Warning#method-i-warn) is called for all
 # warnings issued by Ruby. By default, warnings are printed to $stderr.
-# 
+#
 # By overriding [\#warn](Warning#method-i-warn), you
 # can change how warnings are handled by Ruby, either filtering some
 # warnings, and/or outputting warnings somewhere other than $stderr. When

data/docs/CONTRIBUTING.md

@@ -17,6 +17,7 @@
     - Use `rbs prototype runtime --merge CLASS_NAME` command to generate the missing method definitions.
     - Committing the auto generated signatures is recommended.
 5. Annotate with RDoc.
+    - You'll need RDoc installed. Rvm users should use `rvm docs generate` first.
     - Use `bin/annotate-with-rdoc stdlib/path/to/signature.rbs` to annotate the RBS files.
     - Committing the generated annotations is recommended.
 6. Fix method types and comments.

data/docs/repo.md

@@ -0,0 +1,125 @@
+# Third-party RBS Repository
+
+This is the spec of the directory structure for RBS files of gems without RBS files. It allows distributing RBS type definitions of gems separately from the `.gemspec` files so that the Ruby developers can type check their Ruby programs even if the dependent gems don't ship with their type definitions.
+
+The spec includes:
+
+* The directory structure, and
+* The RBS file lookup rules given _repository root_, gem name, and version.
+
+## Motivating Example
+
+Assume there is a rubygem called `bug-free-doodle` and our application depends on the library. We are trying to type check our application and we need RBS files of `bug-free-doodle`. The problem is that the `bug-free-doodle` gem doesn't ship with RBS files. The type checkers cannot resolve the type of constant `Bug::Free::Doodle` and its methods.
+
+One workaround is to add type definitions of the library in the application signatures.
+
+```
+# sig/polyfill/bug-free-doodle.rbs
+
+module Bug
+  module Free
+    class Doodle
+      attr_reader name: Symbol
+      attr_reader strokes: Array[Stroke]
+
+      def initialize: (name: Symbol) -> void
+    end
+  end
+end
+```
+
+You may want to distribute the RBS file to anyone who needs it. Which version do we support? Testing it? How to load the RBS files? This is the spec you need!
+
+### Third-party RBS repository
+
+Make a directory (or you may want to `git init`) to put your _third party RBSs_.
+
+```sh
+$ make my-rbs      # Or you may want a git repository: git init my-rbs
+$ cd my-rbs
+$ mkdir gems
+```
+
+We call the `my-rbs/gems` directory _repository root_. Note that it is different from the root of the git repository. The RBS repository root is the directory that contains directories of gem names.
+
+Make a directory for the gem and the version.
+
+```sh
+$ mkdir gems/bug-free-doodle
+$ mkdir gems/bug-free-doodle/1.2.3
+```
+
+And copy the RBS file in it.
+
+```sh
+$ cp your-app/sig/polyfill/bug-free-doodle.rbs gems/bug-free-doodle/1.2.3
+```
+
+### Reading Third-party RBS
+
+`rbs` command accepts `--repo` option which points to a _repository root_. You can specify `-r` option to let the command know which gems you want to load.
+
+In this case, the _repository root_ is `./gems` and we are trying to load `bug-free-doodle` gem.
+
+```sh
+$ rbs --repo=gems -r bug-free-doodle paths
+```
+
+The `-r` option also accepts gem name with version.
+
+```sh
+$ rbs --repo=gems -r bug-free-doodle:1.2.3 paths
+```
+
+Note that the version resolution is not compatible with semantic versioning. It is optimistic. It resolves to some version unless no version for the gem is available.
+
+## Directory Structure
+
+There are directories for each gem under _repository root_. We also have directories for each version of each gem.
+
+- $REPO_ROOT/bug-free-doodle/0.2.0
+- $REPO_ROOT/bug-free-doodle/1.0
+- $REPO_ROOT/bug-free-doodle/1.2.3
+- $REPO_ROOT/bug-free-doodle/2.0
+
+Note that we assume that we have git repositories for each RBS repository, and we have a directory at the root of the git repository for _repository root_.
+
+So the git repository structure would be something like the following:
+
+- /Gemfile
+- /Gemfile.lock
+- /README.md
+- /LICENSE
+- /gems/bug-free-doodle/1.2.3/bug-free-doodle.rbs
+
+You should have `Gemfile` and `Gemfile.lock` to manage dependencies, `README.md` and `LICENSE` to documentation, and `gems` directory as _repository root_.
+
+(We call _repository root_ `gems` in this doc, but the name can be anything you like.)
+
+## Version Resolution
+
+The version resolution in RBS is optimistic. We don't block loading RBS files for _incompatible_ version in terms of semantic versioning.
+
+It tries to resolve version _n_ as follows:
+
+1. It resolves to _m_ such that _m_ is the latest version available and _m_ <= _n_ holds.
+2. It resolves to the oldest version when rule 1 cannot find version _m_.
+
+If two versions, `0.4.0`, `1.0.0` are available for a gem:
+
+| Requested version | Resolved version |
+|-------------------|------------------|
+| `0.3.0`           | `0.4.0` (Rule 2) |
+| `0.4.0`           | `0.4.0`          |
+| `0.5.0`           | `0.4.0`          |
+| `1.0.0`           | `1.0.0`          |
+| `2.0.0`           | `1.0.0`          |
+
+This is not compatible with the concept of semantic versioning. We don't want to block users to load RBS even for incompatible versions of gems.
+
+We believe this makes more sense because:
+
+* Using (potentially) incompatible type definitions are better than no type definition.
+* Users can stop loading RBS if incompatibility causes an issue and falling back to hand-written polyfills.
+
+

data/docs/syntax.md

@@ -179,7 +179,7 @@ Proc type denotes type of procedures, `Proc` instances.
 
 `instance` denotes the type of instance of the class. `class` is the singleton of the class.
 
-`bool` is an abstract type for truth value.
+`bool` is an alias of `true | false`.
 
 `untyped` is for _a type without type checking_. It is `?` in gradual typing, _dynamic_ in some languages like C#, and _any_ in TypeScript. It is both subtype _and_ supertype of all of the types. (The type was `any` but renamed to `untyped`.)
 
@@ -193,15 +193,34 @@ Proc type denotes type of procedures, `Proc` instances.
 
 We recommend using `nil`.
 
-#### `bool` or `TrueClass | FalseClass`
+#### `bool` or `boolish`
 
-We recommend using `bool` because it is more close to Ruby's semantics. If the type of a parameter of a method is `bool`, we usually pass `true` and `false`, and also `nil` or any other values. `TrueClass | FalseClass` rejects other values than `true` and `false`.
+We have a builtin type alias called `boolish`.
+It is an alias of `top` type, and you can use `boolish` if we want to allow any object of any type.
 
-#### `void`, `bool`, or `top`?
+We can see an example at the definition of `Enumerable#find`:
+
+```
+module Enumerable[Elem, Return]
+  def find: () { (Elem) -> boolish } -> Elem?
+  ...
+end
+```
+
+We want to write something like:
+
+```
+array.find {|x| x && x.some_test? }               # The block will return (bool | nil)
+```
+
+We recommend using `boolish` for method arguments and block return values, if you only use the values for conditions.
+You can write `bool` if you strictly want `true | false`.
+
+#### `void`, `boolish`, or `top`?
 
 They are all equivalent for the type system; they are all _top type_.
 
-`void` tells developers a hint that _the value should not be used_. `bool` implies the value is used as a truth value. `top` is anything else.
+`void` tells developers a hint that _the value should not be used_. `boolish` implies the value is used as a truth value. `top` is anything else.
 
 ## Method Types
 
@@ -433,8 +452,10 @@ _global-name_ ::= /$[a-zA-Z]\w+/ | ...
 _module-type-parameters_ ::=                                                  # Empty
                            | `[` _module-type-parameter_ `,` ... `]`
 
-_module-type-parameter_ ::= _variance_ _type-variable_
+_module-type-parameter_ ::= _check_ _variance_ _type-variable_
 _variance_ ::= `out` | `in`
+_check_ ::= # Empty
+          | `unchecked`
 ```
 
 ### Class declaration
@@ -448,6 +469,29 @@ class Ref[A] < Object
 end
 ```
 
+For classes with type parameters, you may specify if they are "invariant" (default), "covariant" (`out`) or "contravariant" (`in`). See [this definition of covariance and contravariance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)).
+
+For example, an `Array` of `String` can almost be considered to be an `Array` of `Object`, but not the reverse, so we can think of:
+
+```
+class Array[out T]
+  # ...
+end
+```
+
+There's a limitation with this is for mutable objects (like arrays): a mutation could invalidate this.
+If an array of String is passed to a method as an array of Objects, and that method adds an Integer to the array, the promise is broken.
+
+In those cases, one must use the `unchecked` keyword:
+
+```
+class Array[unchecked out T]
+  # ...
+end
+```
+
+This is how `Array` is actually defined in RBS.
+
 ### Module declaration
 
 Module declaration takes optional _self type_ parameter, which defines a constraint about a class when the module is mixed.

data/goodcheck.yml

@@ -6,12 +6,12 @@ rules:
       - "stdlib/**/*.rbs"
     fail:
       - |
-        # arglists 💪👽🚨 << Delete this section   
-        #    File.absolute_path?(file_name)  ->  true or false    
+        # arglists 💪👽🚨 << Delete this section
+        #    File.absolute_path?(file_name)  ->  true or false
         #
 
   - id: rbs.no_arg
-    pattern: 
+    pattern:
       regexp: arg\d+
     message: |
       Stop using parameter names like `arg0` or `arg1`
@@ -23,7 +23,7 @@ rules:
       - Documents (comments) may contain that pattern.
     glob:
       - "stdlib/**/*.rbs"
-    fail: 
+    fail:
       - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
     pass:
       - "def `send`: (String | Symbol, *untyped) -> untyped"
@@ -62,4 +62,21 @@ rules:
           end
         end
 
-
+  - id: no_trailing_whitespace
+    pattern:
+      regexp: '[ \t]+$'
+    message: |
+      Trim trailing whitespaces
+    glob:
+      - '**/*.rb'
+      - '**/*.rbs'
+      - '**/*.md'
+    justification:
+      - Let the maintainers know if it is an autogenerated files.
+    pass:
+      - "Hello world"
+      - "Hello\nworld"
+      - "Hello\n\nworld"
+    fail:
+      - "Hello world  "
+      - "Hello \nworld"

data/lib/rbs.rb

@@ -37,6 +37,7 @@ require "rbs/environment_walker"
 require "rbs/vendorer"
 require "rbs/validator"
 require "rbs/factory"
+require "rbs/repository"
 
 begin
   require "rbs/parser"

data/lib/rbs/ast/comment.rb

@@ -23,7 +23,7 @@ module RBS
         { string: string, location: location }.to_json(*a)
       end
 
-      def concat(string:, location:)  
+      def concat(string:, location:)
         @string.concat string
 
         if loc = @location

data/lib/rbs/cli.rb

@@ -1,32 +1,63 @@
+require "open3"
 require "optparse"
 require "shellwords"
 
 module RBS
   class CLI
     class LibraryOptions
+      attr_accessor :core_root
+      attr_reader :repos
       attr_reader :libs
       attr_reader :dirs
-      attr_accessor :no_stdlib
 
       def initialize()
+        @core_root = EnvironmentLoader::DEFAULT_CORE_ROOT
+        @repos = []
+
         @libs = []
         @dirs = []
-        @no_stdlib = false
       end
 
-      def setup(loader)
-        libs.each do |lib|
-          loader.add(library: lib)
+      def loader
+        repository = Repository.new(no_stdlib: core_root.nil?)
+        repos.each do |repo|
+          repository.add(Pathname(repo))
         end
 
+        loader = EnvironmentLoader.new(core_root: core_root, repository: repository)
+        
         dirs.each do |dir|
           loader.add(path: Pathname(dir))
         end
 
-        loader.no_builtin! if no_stdlib
+        libs.each do |lib|
+          name, version = lib.split(/:/, 2)
+          next unless name
+          loader.add(library: name, version: version)
+        end
 
         loader
       end
+
+      def setup_library_options(opts)
+        opts.on("-r LIBRARY", "Load RBS files of the library") do |lib|
+          libs << lib
+        end
+  
+        opts.on("-I DIR", "Load RBS files from the directory") do |dir|
+          dirs << dir
+        end
+  
+        opts.on("--no-stdlib", "Skip loading standard library signatures") do
+          self.core_root = nil
+        end
+  
+        opts.on("--repo DIR", "Add RBS repository") do |dir|
+          repos << dir
+        end
+  
+        opts
+      end  
     end
 
     attr_reader :stdout
@@ -39,29 +70,14 @@ module RBS
 
     COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test]
 
-    def library_parse(opts, options:)
-      opts.on("-r LIBRARY", "Load RBS files of the library") do |lib|
-        options.libs << lib
-      end
-
-      opts.on("-I DIR", "Load RBS files from the directory") do |dir|
-        options.dirs << dir
-      end
-
-      opts.on("--no-stdlib", "Skip loading standard library signatures") do
-        options.no_stdlib = true
-      end
-
-      opts
-    end
-
     def parse_logging_options(opts)
       opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
         RBS.logger_level = level
       end
 
       opts.on("--log-output OUTPUT", "Specify the file to output log (defaults to stderr)") do |output|
-        RBS.logger_output = File.open(output, "a")
+        io = File.open(output, "a") or raise
+        RBS.logger_output = io
       end
 
       opts
@@ -82,7 +98,7 @@ module RBS
 
         Options:
       USAGE
-      library_parse(opts, options: options)
+      options.setup_library_options(opts)
       parse_logging_options(opts)
       opts.version = RBS::VERSION
 
@@ -128,13 +144,14 @@ EOB
         end
       end
 
-      loader = EnvironmentLoader.new()
-      options.setup(loader)
+      loader = options.loader()
 
       env = Environment.from_loader(loader).resolve_type_names
 
       decls = env.declarations.select do |decl|
-        name = decl.location.buffer.name
+        loc = decl.location or raise
+        # @type var name: String
+        name = loc.buffer.name
 
         patterns.empty? || patterns.any? do |pat|
           case pat
@@ -151,6 +168,7 @@ EOB
     end
 
     def run_list(args, options)
+      # @type var list: Set[:class | :module | :interface]
       list = Set[]
 
       OptionParser.new do |opts|
@@ -171,10 +189,9 @@ EOB
         opts.on("--interface", "List interfaces") { list << :interface }
       end.order!(args)
 
-      list.merge([:class, :module, :interface]) if list.empty?
+      list.merge(_ = [:class, :module, :interface]) if list.empty?
 
-      loader = EnvironmentLoader.new()
-      options.setup(loader)
+      loader = options.loader()
 
       env = Environment.from_loader(loader).resolve_type_names
 
@@ -201,6 +218,7 @@ EOB
     end
 
     def run_ancestors(args, options)
+      # @type var kind: :instance | :singleton
       kind = :instance
 
       OptionParser.new do |opts|
@@ -220,13 +238,12 @@ EOU
         opts.on("--singleton", "Ancestors of singleton of the given type_name") { kind = :singleton }
       end.order!(args)
 
-      loader = EnvironmentLoader.new()
-      options.setup(loader)
+      loader = options.loader()
 
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = parse_type_name(args[0]).absolute!
+      type_name = TypeName(args[0]).absolute!
 
       if env.class_decls.key?(type_name)
         ancestors = case kind
@@ -234,6 +251,8 @@ EOU
                       builder.instance_ancestors(type_name)
                     when :singleton
                       builder.singleton_ancestors(type_name)
+                    else
+                      raise
                     end
 
         ancestors.ancestors.each do |ancestor|
@@ -254,6 +273,7 @@ EOU
     end
 
     def run_methods(args, options)
+      # @type var kind: :instance | :singleton
       kind = :instance
       inherit = true
 
@@ -280,13 +300,12 @@ EOU
         return
       end
 
-      loader = EnvironmentLoader.new()
-      options.setup(loader)
+      loader = options.loader()
 
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = parse_type_name(args[0]).absolute!
+      type_name = TypeName(args[0]).absolute!
 
       if env.class_decls.key?(type_name)
         definition = case kind
@@ -294,6 +313,8 @@ EOU
                        builder.build_instance(type_name)
                      when :singleton
                        builder.build_singleton(type_name)
+                     else
+                       raise
                      end
 
         definition.methods.keys.sort.each do |name|
@@ -308,6 +329,7 @@ EOU
     end
 
     def run_method(args, options)
+      # @type var kind: :instance | :singleton
       kind = :instance
 
       OptionParser.new do |opts|
@@ -332,13 +354,11 @@ EOU
         return
       end
 
-      loader = EnvironmentLoader.new()
-      options.setup(loader)
-
+      loader = options.loader()
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = parse_type_name(args[0]).absolute!
+      type_name = TypeName(args[0]).absolute!
       method_name = args[1].to_sym
 
       unless env.class_decls.key?(type_name)
@@ -351,6 +371,8 @@ EOU
                      builder.build_instance(type_name)
                    when :singleton
                      builder.build_singleton(type_name)
+                   else
+                     raise
                    end
 
       method = definition.methods[method_name]
@@ -383,12 +405,14 @@ Examples:
 
   $ rbs validate
 EOU
-      end.parse!(args)
-
-      loader = EnvironmentLoader.new()
 
-      options.setup(loader)
+        opts.on("--silent") do
+          require "stringio"
+          @stdout = StringIO.new
+        end
+      end.parse!(args)
 
+      loader = options.loader()
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
@@ -431,6 +455,7 @@ EOU
     end
 
     def run_constant(args, options)
+      # @type var context: String?
       context = nil
 
       OptionParser.new do |opts|
@@ -455,10 +480,7 @@ EOU
         return
       end
 
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
+      loader = options.loader()
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
@@ -488,15 +510,14 @@ Show paths to directories where the RBS files are loaded from.
 Examples:
 
   $ rbs paths
-  $ tbs -r set paths
+  $ rbs -r set paths
 EOU
       end.parse!(args)
 
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
+      loader = options.loader()
 
       kind_of = -> (path) {
+        # @type var path: Pathname
         case
         when path.file?
           "file"
@@ -509,19 +530,14 @@ EOU
         end
       }
 
-      if loader.stdlib_root
-        path = loader.stdlib_root
-        stdout.puts "#{path}/builtin (#{kind_of[path]}, stdlib)"
-      end
-
-      loader.paths.each do |path|
-        case path
+      loader.each_dir do |source, dir|
+        case source
+        when :core
+          stdout.puts "#{dir} (#{kind_of[dir]}, core)"
         when Pathname
-          stdout.puts "#{path} (#{kind_of[path]})"
-        when EnvironmentLoader::GemPath
-          stdout.puts "#{path.path} (#{kind_of[path.path]}, gem, name=#{path.name}, version=#{path.version})"
-        when EnvironmentLoader::LibraryPath
-          stdout.puts "#{path.path} (#{kind_of[path.path]}, library, name=#{path.name})"
+          stdout.puts "#{dir} (#{kind_of[dir]})"
+        when EnvironmentLoader::Library
+          stdout.puts "#{dir} (#{kind_of[dir]}, library, name=#{source.name})"
         end
       end
     end
@@ -543,7 +559,7 @@ EOU
 Usage: rbs prototype runtime [options...] [pattern...]
 
 Generate RBS prototype based on runtime introspection.
-It loads Ruby code specified in [options] and generates RBS prototypes for classes matches to [pattern]. 
+It loads Ruby code specified in [options] and generates RBS prototypes for classes matches to [pattern].
 
 Examples:
 
@@ -567,10 +583,7 @@ EOU
           end
         end.parse!(args)
 
-        loader = EnvironmentLoader.new()
-
-        options.setup(loader)
-
+        loader = options.loader()
         env = Environment.from_loader(loader).resolve_type_names
 
         require_libs.each do |lib|
@@ -653,7 +666,6 @@ EOU
 
     def run_vendor(args, options)
       clean = false
-      vendor_stdlib = false
       vendor_dir = Pathname("vendor/sigs")
 
       OptionParser.new do |opts|
@@ -676,10 +688,6 @@ Options:
           clean = v
         end
 
-        opts.on("--[no-]stdlib", "Vendor stdlib signatures or not (default: no)") do |v|
-          vendor_stdlib = v
-        end
-
         opts.on("--vendor-dir [DIR]", "Specify the directory for vendored signatures (default: vendor/sigs)") do |path|
           vendor_dir = Pathname(path)
         end
@@ -687,28 +695,26 @@ Options:
 
       stdout.puts "Vendoring signatures to #{vendor_dir}..."
 
-      vendorer = Vendorer.new(vendor_dir: vendor_dir)
+      loader = options.loader()
 
-      if clean
-        stdout.puts "  Deleting #{vendor_dir}..."
-        vendorer.clean!
-      end
+      args.each do |gem|
+        name, version = gem.split(/:/, 2)
+
+        next unless name
 
-      if vendor_stdlib
-        stdout.puts "  Vendoring standard libraries..."
-        vendorer.stdlib!
+        stdout.puts "  Loading library: #{name}, version=#{version}..."
+        loader.add(library: name, version: version)
       end
 
-      args.each do |gem|
-        name, version = EnvironmentLoader.parse_library(gem)
+      vendorer = Vendorer.new(vendor_dir: vendor_dir, loader: loader)
 
-        unless EnvironmentLoader.gem_sig_path(name, version)
-          stdout.puts "  ⚠️ Cannot find rubygem: name=#{name}, version=#{version} 🚨"
-        else
-          stdout.puts "  Vendoring gem: name=#{name}, version=#{version}..."
-          vendorer.gem!(name, version)
-        end
+      if clean
+        stdout.puts "  Deleting #{vendor_dir}..."
+        vendorer.clean!
       end
+
+      stdout.puts "  Copying RBS files..."
+      vendorer.copy!
     end
 
     def run_parse(args, options)
@@ -724,20 +730,20 @@ Examples:
         EOB
       end.parse!(args)
 
-      loader = EnvironmentLoader.new()
+      loader = options.loader()
 
       syntax_error = false
       args.each do |path|
         path = Pathname(path)
-        loader.each_signature(path) do |sig_path|
-          Parser.parse_signature(sig_path.read)
+        loader.each_file(path, skip_hidden: false, immediate: true) do |file_path| 
+          Parser.parse_signature(file_path.read)
         rescue RBS::Parser::SyntaxError => ex
           loc = ex.error_value.location
-          stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
+          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
           syntax_error = true
         rescue RBS::Parser::SemanticsError => ex
           loc = ex.location
-          stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
+          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
           syntax_error = true
         end
       end
@@ -745,22 +751,24 @@ Examples:
       exit 1 if syntax_error
     end
 
-    def parse_type_name(string)
-      Namespace.parse(string).yield_self do |namespace|
-        last = namespace.path.last
-        TypeName.new(name: last, namespace: namespace.parent)
-      end
-    end
-
     def test_opt options
-      opt_string = options.dirs.map { |dir| "-I #{Shellwords.escape(dir)}"}.concat(options.libs.map { |lib| "-r#{Shellwords.escape(lib)}"}).join(' ')
-      opt_string.empty? ? nil : opt_string
+      opts = []
+
+      opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
+      opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
+      opts.push(*options.libs.map {|lib| "-r#{Shellwords.escape(lib)}"})
+      
+      opts.empty? ? nil : opts.join(" ")
     end
 
     def run_test(args, options)
+      # @type var unchecked_classes: Array[String]
       unchecked_classes = []
+      # @type var targets: Array[String]
       targets = []
+      # @type var sample_size: String?
       sample_size = nil
+      # @type var double_suite: String?
       double_suite = nil
 
       (opts = OptionParser.new do |opts|
@@ -790,7 +798,6 @@ EOB
         opts.on("--double-suite DOUBLE_SUITE", "Sets the double suite in use (currently supported: rspec | minitest)") do |suite|
           double_suite = suite
         end
-
       end).order!(args)
 
       if args.length.zero?
@@ -798,6 +805,7 @@ EOB
         exit 1
       end
 
+      # @type var env_hash: Hash[String, String?]
       env_hash = {
         'RUBYOPT' => "#{ENV['RUBYOPT']} -rrbs/test/setup",
         'RBS_TEST_OPT' => test_opt(options),
@@ -808,8 +816,10 @@ EOB
         'RBS_TEST_TARGET' => (targets.join(',') unless targets.empty?)
       }
 
-      system(env_hash, *args)
-      $?
+      out, err, status = Open3.capture3(env_hash, *args)
+      stdout.print(out)
+      stderr.print(err)
+      status
     end
   end
 end