typeprof 0.21.11 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fe080a0c812f2be50d024eb51bd7c4ba751c2a720aaa99489e4a6271edba1e2
-  data.tar.gz: 6bd7b34c3428855355ff644ecf9987cda4db8645ba3a495a0f412f25c98a9972
+  metadata.gz: 4faf061f0c69941bd42ce81df939d3204319da2891d175ac64b0165d4d660c18
+  data.tar.gz: 4cd3d5666361cfa335f2acc398e8571b8fc38c9ff2911fb55ce394f3df8d1fc9
 SHA512:
-  metadata.gz: ac0242124986985239123f8a15e2cea01c77815cf2a9e5e586178fdece251d0e13172429ea09773d7b5136aed568db4e7e25fadcabb5a7afd000f57454c28b79
-  data.tar.gz: 4b36374f2af922eab5803e77666046896392153475d3dc892cc689e25beb84c83a6b5a164c344768b2d0951ba790832785907d1cf65b1f37cc91d9f1472cf957
+  metadata.gz: af755e8f52cc2c315cb245083b2cef95741c5ccb8dfe98f47ef41e40fd087b6e641746f797d8bfaa68097bcb5aa6f52364e5e69651e7c368da4cd951a34a068c
+  data.tar.gz: ced1fc8642f7020340caac9de194d83c0cffc01515e020f126f081a9f9262ccb6bd522927ce90583415bdfdde5e167a84783c71b907cfaff1c3fac2cd74ed7f2

data/README.md

@@ -1,41 +1,25 @@
-# TypeProf: A type analysis tool for Ruby code based on abstract interpretation
+# TypeProf
 
-## Synopsis
+An experimental type-level Ruby interpreter for testing and understanding Ruby code.
 
-```sh
-gem install typeprof
-typeprof app.rb
-```
+## Development
 
-## Demo
+1. Install Ruby 3.3 or later.
+2. Git clone this repository: `git clone https://github.com/ruby/typeprof.git`
+3. Install VSCode extension: `code --install-extension mame.ruby-typeprof`
+4. Open the repository in VSCode: `code typeprof`
 
-```rb
-# test.rb
-def foo(x)
-  if x > 10
-    x.to_s
-  else
-    nil
-  end
-end
-
-foo(42)
-```
+### Testing
 
+```sh
+$ bundle install
+$ bundle exec rake test
 ```
-$ typeprof test.rb
-# Classes
-class Object
-  def foo : (Integer) -> String?
-end
-```
-
-## Documentation
 
-[English](doc/doc.md) / [日本語](doc/doc.ja.md)
+## More details
 
-## Playground
+https://speakerdeck.com/mame/good-first-issues-of-typeprof
 
-You can try typeprof gem on the Web via the URL below.
+## LICENSE
 
-https://mame.github.io/typeprof-playground/
+See [LICENSE](LICENSE) file.

data/bin/typeprof

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/typeprof"
+
+TypeProf::CLI::CLI.new(ARGV).run

data/doc/doc.ja.md

@@ -0,0 +1,134 @@
+# TypeProf: 抽象解釈に基づくRubyの型解析器
+
+## TypeProfの使い方 - CLIツールとして
+
+app.rb を解析する。
+
+```
+$ typeprof app.rb
+```
+
+一部のメソッドの型を指定した sig/app.rbs とともに app.rb を解析する。
+
+```
+$ typeprof sig/app.rbs app.rb
+```
+
+典型的な使用法は次の通り。
+
+```
+$ typeprof sig/app.rbs app.rb -o sig/app.gen.rbs
+```
+
+## TypeProfの使い方 - Language Serverとして
+
+[RubyKaigi 2024の発表資料](https://speakerdeck.com/mame/good-first-issues-of-typeprof)を参照ください。
+
+## TypeProfの解析方法
+
+TypeProfは、Rubyプログラムを型レベルで抽象的に実行するインタプリタです。
+解析対象のプログラムを実行し、メソッドが受け取ったり返したりする型、インスタンス変数に代入される型を集めて出力します。
+すべての値はオブジェクトそのものではなく、原則としてオブジェクトの所属するクラスに抽象化されます（次節で詳説）。
+
+メソッドを呼び出す例を用いて説明します。
+
+```
+def foo(n)
+  p n      #=> Integer
+  n.to_s
+end
+
+p foo(42)  #=> String
+```
+
+TypeProfの解析結果は次の通り。
+
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:2 #=> Integer
+#  test.rb:6 #=> String
+
+# Classes
+class Object
+  def foo : (Integer) -> String
+end
+```
+
+`foo(42)`というメソッド呼び出しが実行されると、`Integer`オブジェクトの`42`ではなく、「`Integer`」という型（抽象値）が渡されます。
+メソッド`foo`は`n.to_s`が実行します。
+すると、組み込みメソッドの`Integer#to_s`が呼び出され、「String」という型が得られるので、メソッド`foo`はそれを返します。
+これらの実行結果の観察を集めて、TypeProfは「メソッド`foo`は`Integer`を受け取り、`String`を返す」という情報をRBSの形式で出力します。
+また、`p`の引数は`Revealed types`として出力されます。
+
+インスタンス変数は、通常のRubyではオブジェクトごとに記憶される変数ですが、TypeProfではクラス単位に集約されます。
+
+```
+class Foo
+  def initialize
+    @a = 42
+  end
+
+  attr_accessor :a
+end
+
+Foo.new.a = "str"
+
+p Foo.new.a #=> Integer | String
+```
+
+```
+$ typeprof test.rb
+# Revealed types
+#  test.rb:11 #=> Integer | String
+
+# Classes
+class Foo
+  attr_accessor a : Integer | String
+  def initialize : -> Integer
+end
+```
+
+## TypeProfの扱う抽象値
+
+前述の通り、TypeProfはRubyの値を型のようなレベルに抽象化して扱います。
+ただし、クラスオブジェクトなど、一部の値は抽象化しません。
+紛らわしいので、TypeProfが使う抽象化された値のことを「抽象値」と呼びます。
+
+TypeProfが扱う抽象値は次のとおりです。
+
+* クラスのインスタンス
+* クラスオブジェクト
+* シンボル
+* `untyped`
+* 抽象値のユニオン
+* コンテナクラスのインスタンス
+* Procオブジェクト
+
+クラスのインスタンスはもっとも普通の値です。
+`Foo.new`というRubyコードが返す抽象値は、クラス`Foo`のインスタンスで、少し紛らわしいですがこれはRBS出力の中で`Foo`と表現されます。
+`42`という整数リテラルは`Integer`のインスタンス、`"str"`という文字列リテラルは`String`のインスタンスになります。
+
+クラスオブジェクトは、クラスそのものを表す値で、たとえば定数`Integer`や`String`に入っているオブジェクトです。
+このオブジェクトは厳密にはクラス`Class`のインスタンスですが、`Class`に抽象化はされません。
+抽象化してしまうと、定数の参照やクラスメソッドが使えなくなるためです。
+
+シンボルは、`:foo`のようなSymbolリテラルが返す値です。
+シンボルは、キーワード引数、JSONデータのキー、`Module#attr_reader`の引数など、具体的な値が必要になることが多いので、抽象化されません。
+ただし、`String#to_sym`で生成されるSymbolや、式展開を含むSymbolリテラル（`:"foo_#{ x }"`など）はクラス`Symbol`のインスタンスとして扱われます。
+
+`untyped`は、解析の限界や制限などによって追跡ができない場合に生成される抽象値です。
+`untyped`に対する演算やメソッド呼び出しは無視され、評価結果は`untyped`となります。
+
+抽象値のユニオンは、抽象値に複数の可能性があることを表現する値です。
+人工的ですが、`rand < 0.5 ? 42 : "str"`の結果は`Integer | String`という抽象値になります。
+
+コンテナクラスのインスタンスは、ArrayやHashのように他の抽象値を要素とするオブジェクトです。
+いまのところ、ArrayとEnumeratorとHashのみ対応しています。
+詳細は後述します。
+
+Procオブジェクトは、ラムダ式（`-> { ... }`）やブロック仮引数（`&blk`）で作られるクロージャです。
+これらは抽象化されず、コード片と結びついた具体的な値として扱われます。
+これらに渡された引数や返された値によってRBS出力されます。
+
+TBD

data/doc/doc.md

@@ -0,0 +1,136 @@
+# TypeProf: A type analysis tool for Ruby code based on abstract interpretation
+
+## How to use TypeProf as a CLI tool
+
+Analyze app.rb:
+
+```
+$ typeprof app.rb
+```
+
+Analyze app.rb with sig/app.rbs that specifies some method types:
+
+```
+$ typeprof sig/app.rbs app.rb
+```
+
+Here is a typical use case:
+
+```
+$ typeprof sig/app.rbs app.rb -o sig/app.gen.rbs
+```
+
+## How to use TypeProf as a Language Server
+
+See [the slide deck of my talk in RubyKaigi 2024](https://speakerdeck.com/mame/good-first-issues-of-typeprof) for now.
+
+## What is a TypeProf?
+
+TypeProf is a Ruby interpreter that *abstractly* executes Ruby programs at the type level.
+It executes a given program and observes what types are passed to and returned from methods and what types are assigned to instance variables.
+All values are, in principle, abstracted to the class to which the object belongs, not the object itself (detailed in the next section).
+
+Here is an example of a method call.
+
+```
+def foo(n)
+  p n      #=> Integer
+  n.to_s
+end
+
+p foo(42)  #=> String
+```
+
+The analysis results of TypeProf are as follows.
+
+```
+$ ruby exe/typeprof test.rb
+# Revealed types
+#  test.rb:2 #=> Integer
+#  test.rb:6 #=> String
+
+# Classes
+class Object
+  def foo : (Integer) -> String
+end
+```
+
+When the method call `foo(42)` is executed, the type (abstract value) "`Integer`" is passed instead of the `Integer` object 42.
+The method `foo` executes `n.to_s`.
+Then, the built-in method `Integer#to_s` is called and you get the type "`String`", which the method `foo` returns.
+Collecting observations of these execution results, TypeProf outputs, "the method `foo` receives `Integer` and returns `String`" in the RBS format.
+Also, the argument of `p` is output in the `Revealed types` section.
+
+Instance variables are stored in each object in Ruby, but are aggregated in class units in TypeProf.
+
+```
+class Foo
+  def initialize
+    @a = 42
+  end
+
+  attr_accessor :a
+end
+
+Foo.new.a = "str"
+
+p Foo.new.a #=> Integer | String
+```
+
+```
+$ ruby exe/typeprof test.rb
+# Revealed types
+#  test.rb:11 #=> Integer | String
+
+# Classes
+class Foo
+  attr_accessor a : Integer | String
+  def initialize : -> Integer
+end
+```
+
+
+## Abstract values
+
+As mentioned above, TypeProf abstracts almost all Ruby values to the type level, with some exceptions like class objects.
+To avoid confusion with normal Ruby values, we use the word "abstract value" to refer the values that TypeProf handles.
+
+TypeProf handles the following abstract values.
+
+* Instance of a class
+* Class object
+* Symbol
+* `untyped`
+* Union of abstract values
+* Instance of a container class
+* Proc object
+
+Instances of classes are the most common values.
+A Ruby code `Foo.new` returns an instance of the class `Foo`.
+This abstract value is represented as `Foo` in the RBS format, though it is a bit confusing.
+The integer literal `42` generates an instance of `Integer` and the string literal `"str"` generates an instance of `String`.
+
+A class object is a value that represents the class itself.
+For example, the constants `Integer` and `String` has class objects.
+In Ruby semantics, a class object is an instance of the class `Class`, but it is not abstracted into `Class` in TypeProf.
+This is because, if it is abstracted, TypeProf cannot handle constant references and class methods correctly.
+
+A symbol is an abstract value returned by Symbol literals like `:foo`.
+A symbol object is not abstracted to an instance of the class `Symbol` because its concrete value is often required in many cases, such as keyword arguments, JSON data keys, the argument of `Module#attr_reader`, etc.
+Note that some Symbol objects are handled as instances of the class `Symbol`, for example, the return value of `String#to_sym` and Symbol literals that contains interpolation like `:"foo_#{ x }"`.
+
+`untyped` is an abstract value generated when TypeProf fails to trace values due to analysis limits or restrictions.
+Any operations and method calls on `untyped` are ignored, and the evaluation result is also `untyped`.
+
+A union of abstract values is a value that represents multiple possibilities.,
+For (a bit artificial) example, the result of `rand < 0.5 ? 42 : "str"` is a union, `Integer | String`.
+
+An instance of a container class, such as Array and Hash, is an object that contains other abstract values as elements.
+At present, only Array, Enumerator and Hash are supported.
+Details will be described later.
+
+A Proc object is a closure produced by lambda expressions (`-> {... }`) and block parameters (`&blk`).
+During the interpretation, these objects are not abstracted but treated as concrete values associated with a piece of code.
+In the RBS result, they are represented by using anonymous proc type, whose types they accepted and returned.
+
+TODO: write more

data/lib/typeprof/cli/cli.rb

@@ -0,0 +1,180 @@
+require "io/console"
+
+module TypeProf::CLI
+  class CLI
+    def initialize(argv)
+      opt = OptionParser.new
+
+      opt.banner = "Usage: #{ opt.program_name } [options] files_or_dirs..."
+
+      core_options = {}
+      lsp_options = {}
+      cli_options = {}
+
+      output = nil
+      rbs_collection_path = nil
+
+      opt.separator ""
+      opt.separator "Options:"
+      opt.on("-o OUTFILE", "Output to OUTFILE instead of stdout") {|v| output = v }
+      opt.on("-q", "--quiet", "Quiet mode") do
+        core_options[:display_indicator] = false
+      end
+      opt.on("-v", "--verbose", "Verbose mode") do
+        core_options[:show_errors] = true
+      end
+      opt.on("--version", "Display typeprof version") { cli_options[:display_version] = true }
+      opt.on("--collection PATH", "File path of collection configuration") { |v| rbs_collection_path = v }
+      opt.on("--no-collection", "Ignore collection configuration") { rbs_collection_path = :no }
+      opt.on("--lsp", "LSP server mode") do |v|
+        core_options[:display_indicator] = false
+        cli_options[:lsp] = true
+      end
+
+      opt.separator ""
+      opt.separator "Analysis output options:"
+      opt.on("--[no-]show-typeprof-version", "Display TypeProf version in a header") {|v| core_options[:output_typeprof_version] = v }
+      opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| core_options[:output_diagnostics] = v }
+      opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| core_options[:output_parameter_names] = v }
+      opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| core_options[:output_source_locations] = v }
+
+      opt.separator ""
+      opt.separator "Advanced options:"
+      opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| cli_options[:stackprof] = v.to_sym }
+
+      opt.separator ""
+      opt.separator "LSP options:"
+      opt.on("--port PORT", Integer, "Specify a port number to listen for requests on") {|v| lsp_options[:port] = v }
+      opt.on("--stdio", "Use stdio for LSP transport") {|v| lsp_options[:stdio] = v }
+
+      opt.parse!(argv)
+
+      if cli_options[:lsp] && !lsp_options.empty?
+        raise OptionParser::InvalidOption.new("lsp options with non-lsp mode")
+      end
+
+      @core_options = {
+        rbs_collection: setup_rbs_collection(rbs_collection_path),
+        display_indicator: $stderr.tty?,
+        output_typeprof_version: true,
+        output_errors: false,
+        output_parameter_names: false,
+        output_source_locations: false,
+      }.merge(core_options)
+
+      @lsp_options = {
+        port: 0,
+        stdio: false,
+      }.merge(lsp_options)
+
+      @cli_options = {
+        argv:,
+        output: output ? open(output, "w") : $stdout.dup,
+        display_version: false,
+        stackprof: nil,
+        lsp: false,
+      }.merge(cli_options)
+
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+      puts $!
+      exit 1
+    end
+
+    def setup_rbs_collection(path)
+      return nil if path == :no
+
+      unless path
+        path = RBS::Collection::Config::PATH.exist? ? RBS::Collection::Config::PATH.to_s : nil
+        return nil unless path
+      end
+
+      if !File.readable?(path)
+        raise OptionParser::InvalidOption.new("file not found: #{ path }")
+      end
+
+      lock_path = RBS::Collection::Config.to_lockfile_path(Pathname(path))
+      if !File.readable?(lock_path)
+        raise OptionParser::InvalidOption.new("file not found: #{ lock_path.to_s }; please run 'rbs collection install")
+      end
+
+      RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: lock_path, data: YAML.load_file(lock_path))
+    end
+
+    attr_reader :core_options, :lsp_options, :cli_options
+
+    def run
+      core = TypeProf::Core::Service.new(@core_options)
+
+      if @cli_options[:lsp]
+        run_lsp(core)
+      else
+        run_cli(core)
+      end
+    end
+
+    def run_lsp(core)
+      if @lsp_options[:stdio]
+        TypeProf::LSP::Server.start_stdio(core)
+      else
+        TypeProf::LSP::Server.start_socket(core)
+      end
+    rescue Exception
+      puts $!.detailed_message(highlight: false).gsub(/^/, "---")
+      raise
+    end
+
+    def run_cli(core)
+      puts "typeprof #{ TypeProf::VERSION }" if @cli_options[:display_version]
+
+      files = find_files
+
+      set_profiler do
+        output = @cli_options[:output]
+
+        core.batch(files, @cli_options[:output])
+
+        output.close
+      end
+
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+      puts $!
+      exit 1
+    end
+
+    def find_files
+      files = []
+      @cli_options[:argv].each do |path|
+        if File.directory?(path)
+          files.concat(Dir.glob("#{ path }/**/*.{rb,rbs}"))
+        elsif File.file?(path)
+          files << path
+        else
+          raise OptionParser::InvalidOption.new("no such file or directory -- #{ path }")
+        end
+      end
+
+      if files.empty?
+        exit if @cli_options[:display_version]
+        raise OptionParser::InvalidOption.new("no input files")
+      end
+
+      files
+    end
+
+    def set_profiler
+      if @cli_options[:stackprof]
+        require "stackprof"
+        out = "typeprof-stackprof-#{ @cli_options[:stackprof] }.dump"
+        StackProf.start(mode: @cli_options[:stackprof], out: out, raw: true)
+      end
+
+      yield
+
+    ensure
+      if @cli_options[:stackprof] && defined?(StackProf)
+        StackProf.stop
+        StackProf.results
+      end
+    end
+  end
+end

data/lib/typeprof/cli.rb

@@ -1,135 +1,4 @@
 require "optparse"
+require "pathname"
 
-module TypeProf
-  module CLI
-    module_function
-
-    def parse(argv)
-      opt = OptionParser.new
-
-      opt.banner = "Usage: #{ opt.program_name } [options] files..."
-
-      output = nil
-
-      # Verbose level:
-      # * 0: none
-      # * 1: default level
-      # * 2: debugging level
-      verbose = 1
-
-      options = {}
-      lsp_options = {}
-      dir_filter = nil
-      gem_rbs_features = []
-      show_version = false
-      max_sec = max_iter = nil
-      collection_path = nil
-      no_collection = false
-
-      load_path_ext = []
-
-      opt.separator ""
-      opt.separator "Options:"
-      opt.on("-o OUTFILE", "Output to OUTFILE instead of stdout") {|v| output = v }
-      opt.on("-q", "--quiet", "Do not display progress indicator") { options[:show_indicator] = false }
-      opt.on("-v", "--verbose", "Alias to --show-errors") { options[:show_errors] = true }
-      opt.on("--version", "Display typeprof version") { show_version = true }
-      opt.on("-I DIR", "Add DIR to the load/require path") {|v| load_path_ext << v }
-      opt.on("-r FEATURE", "Require RBS of the FEATURE gem") {|v| gem_rbs_features << v }
-      opt.on("--collection PATH", "File path of collection configuration") { |v| collection_path = Pathname(v) }
-      opt.on("--no-collection", "Ignore collection configuration") { no_collection = true }
-      opt.on("--lsp", "LSP mode") {|v| options[:lsp] = true }
-
-      opt.separator ""
-      opt.separator "Analysis output options:"
-      opt.on("--include-dir DIR", "Include the analysis result of .rb file in DIR") do |dir|
-        # When `--include-dir` option is specified as the first directory option,
-        # typeprof will exclude any files by default unless a file path matches the explicit option
-        dir_filter ||= [[:exclude]]
-        dir_filter << [:include, File.expand_path(dir)]
-      end
-      opt.on("--exclude-dir DIR", "Exclude the analysis result of .rb file in DIR") do |dir|
-        # When `--exclude-dir` option is specified as the first directory option,
-        # typeprof will include any files by default, except Ruby's install directory and Gem directories
-        dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
-        dir_filter << [:exclude, File.expand_path(dir)]
-      end
-      opt.on("--exclude-untyped", "Exclude (comment out) all entries including untyped") {|v| options[:exclude_untyped] = v }
-      opt.on("--[no-]show-typeprof-version", "Display TypeProf version in a header") {|v| options[:show_typeprof_version] = v }
-      opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| options[:show_errors] = v }
-      opt.on("--[no-]show-untyped", "Display \"Foo | untyped\" instead of \"Foo\"") {|v| options[:show_untyped] = v }
-      opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| options[:show_parameter_names] = v }
-      opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| options[:show_source_locations] = v }
-
-      opt.separator ""
-      opt.separator "Analysis limit options:"
-      opt.on("--max-second SECOND", Float, "Limit the maxium time of analysis (in second)") {|v| max_sec = v }
-      opt.on("--max-iteration TIMES", Integer, "Limit the maxium instruction count of analysis") {|v| max_iter = v }
-
-      opt.separator ""
-      opt.separator "Advanced options:"
-      opt.on("--[no-]stub-execution", "Force to call all unreachable methods with \"untyped\" arguments") {|v| options[:stub_execution] = v }
-      opt.on("--type-depth-limit DEPTH", Integer, "Limit the maximum depth of nested types") {|v| options[:type_depth_limit] = v }
-      opt.on("--union-width-limit WIDTH", Integer, "Limit the maximum count of class instances in one union type") {|v| options[:union_width_limit] = v }
-      opt.on("--debug", "Display analysis log (for debugging purpose)") { verbose = 2 }
-      opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| options[:stackprof] = v.to_sym }
-
-      opt.separator ""
-      opt.separator "LSP options:"
-      opt.on("--port PORT", Integer, "Specify a port number to listen for requests on") {|v| lsp_options[:port] = v }
-      opt.on("--stdio", "Use stdio for LSP transport") {|v| lsp_options[:stdio] = v }
-
-      opt.parse!(argv)
-
-      $LOAD_PATH.unshift(*load_path_ext)
-
-      dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
-      rb_files = []
-      rbs_files = []
-      argv.each do |path|
-        if File.extname(path) == ".rbs"
-          rbs_files << path
-        else
-          rb_files << path
-        end
-      end
-
-      puts "typeprof #{ VERSION }" if show_version
-      if rb_files.empty? && !options[:lsp]
-        exit if show_version
-        raise OptionParser::InvalidOption.new("no input files")
-      end
-
-      if !options[:lsp] && !lsp_options.empty?
-        exit if show_version
-        raise OptionParser::InvalidOption.new("lsp options with non-lsp mode")
-      end
-
-      if !no_collection && collection_path && !collection_path.exist?
-        exit if show_version
-        raise OptionParser::InvalidOption.new("collection path not found (#{collection_path})")
-      end
-
-      collection_path ||= RBS::Collection::Config::PATH
-      collection_path = nil if no_collection
-
-      ConfigData.new(
-        rb_files: rb_files,
-        rbs_files: rbs_files,
-        output: output,
-        gem_rbs_features: gem_rbs_features,
-        collection_path: collection_path,
-        verbose: verbose,
-        dir_filter: dir_filter,
-        max_sec: max_sec,
-        max_iter: max_iter,
-        options: options,
-        lsp_options: lsp_options,
-      )
-
-    rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-      puts $!
-      exit 1
-    end
-  end
-end
+require_relative "cli/cli"