yarbs 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad6ad92289f8a7d901231eadb81be04511912ffd65f183d0cd00d4f9d2b9b851
-  data.tar.gz: 1cae1aaf74795fef87a77eafd33b32c7a8252dd3c0660032d11c9985213ab965
+  metadata.gz: 601e10f12020d139a62bd8655f95b6c56bb5037d012265abc5d7adddfda0d60d
+  data.tar.gz: 34d6a692e0d7323d3fba7407b9586c1ddccdcba755c3333673cb520d28b6d762
 SHA512:
-  metadata.gz: dce1a1abee4e2d215abf7fc9ca707c00dc166790d86daa644d2bd43ab29348dade7eda387ada1ac39d0bad428e19f4d19321cf57af465d5490376d06fb02b78d
-  data.tar.gz: 84096e966259189840b11c1e7d02d5e2b1cbd29fe429d262e9e8733d0d503505ae92706ac3effcbdaafe6fb903fe152bb69cad59159d979862f7cbd37726451e
+  metadata.gz: 947060cd7c782f1e3280a12f4ea8e01eb47460d3820c58bcbfd87c6a780907e8d28b5958d2b827bc0d9987ec9f84b9a6010da57310cc7d1878164972eba8b1ee
+  data.tar.gz: fa4fc3e6a0e9d4f2a78d5762aeb841426b0a7bbf23a8d4de60c75ffd6014891aa87868ee3eccb22d6dedbc42ab8e5099b9c00885959bc7580c2efcefe1967477

data/README.md

@@ -1,6 +1,6 @@
 # Yarbs
 
-[![Ruby](https://github.com/tobidelius/yarbs/actions/workflows/main.yml/badge.svg)](https://github.com/tobidelius/yarbs/actions/workflows/main.yml)
+[![CI](https://github.com/tobidelius/yarbs/actions/workflows/ci.yml/badge.svg)](https://github.com/tobidelius/yarbs/actions/workflows/ci.yml)
 
 *This is still experimental.*
 
@@ -58,14 +58,62 @@ executing:
 gem install yarbs
 ```
 
+## Getting started
+
+In your project, run:
+
+```bash
+bundle exec yarbs init
+```
+
+```
+  create  .yarbs.yml
+  create  Steepfile
+  create  rbs_collection.yaml
+  update  .gitignore (added /.gem_rbs_collection/)
+     run  rbs collection install
+   wrote  23 files to sig/
+```
+
+This sets up everything needed to type-check against the generated
+signatures:
+
+- `.yarbs.yml` — which files yarbs reads and where it writes (see
+  [Configuration](#configuration))
+- `Steepfile` — a Steep target that checks your sources against `sig/`,
+  with lenient diagnostics to start with, since most code stays `untyped`
+  until it's documented
+- `rbs_collection.yaml` — so Steep gets signatures for the gems you
+  depend on; `init` then runs `rbs collection install` to fetch them (skip
+  that with `--no-install`)
+- `.gitignore` — ignores the downloaded `.gem_rbs_collection/`, and, for a
+  gem (a project with a `*.gemspec`), `rbs_collection.lock.yaml` too; an app
+  should commit that lock file, just like `Gemfile.lock`
+
+Then it generates your signatures for the first time.
+
+It's safe to re-run: `init` never overwrites a file that already exists (it
+reports it as skipped), and only adds the `.gitignore` entries that are
+missing. Use `--dry-run` to see what it would do first. By default it sets
+yarbs up for `lib/**/*.rb`; pass your own globs to change that
+(`yarbs init "lib/**/*.rb" "src/**/*.rb"`).
+
+If Steep isn't in your bundle yet, `init` finishes by telling you to add it:
+
+```bash
+bundle add steep --group development
+bundle exec steep check
+```
+
 ## Usage
 
-Point yarbs at your source files with one or more glob patterns; it writes
-one `.rbs` file per source file into `sig/` (or `-o DIR` to choose a
-different output directory), mirroring the source layout with a leading
-`lib/`/`app/` stripped:
+Run `yarbs` to regenerate your signatures. It writes one `.rbs` file per
+source file into `sig/`, mirroring the source layout with a leading
+`lib/`/`app/` stripped. Without arguments it uses the paths in
+`.yarbs.yml`; give it glob patterns to override them:
 
 ```bash
+yarbs
 yarbs "lib/**/*.rb" "app/**/*.rb"
 ```
 
@@ -88,6 +136,26 @@ require "yarbs"
 Yarbs.generate(["lib/**/*.rb"], output_dir: "sig", strict: true)
 ```
 
+### Configuration
+
+`.yarbs.yml` (written by `yarbs init`) holds the defaults for a plain
+`yarbs` run. Anything passed on the command line overrides it:
+
+```yaml
+# Glob patterns for the Ruby files to generate signatures for.
+paths:
+  - "lib/**/*.rb"
+
+# Directory the generated .rbs files are written into.
+output: sig
+
+# Raise instead of falling back to `untyped` when a YARD type can't
+# be converted. Ignored by `yarbs --watch`.
+strict: false
+```
+
+Without a `.yarbs.yml`, `yarbs` uses these same defaults.
+
 ### Docs
 
 For the full picture of what yarbs understands and how to document it —

data/lib/yarbs/cli/init.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "rbs"
+require "rbs/cli"
+require "stringio"
+
+module Yarbs
+  module CLI
+    # `yarbs init`: sets a project up to use yarbs with Steep, so the
+    # signatures it writes are actually checked.
+    #
+    # Every step is safe to re-run: files that already exist are left alone
+    # (and reported as skipped), and `.gitignore` only gets the entries it's
+    # missing.
+    class Init
+      STEEPFILE = "Steepfile"
+      RBS_COLLECTION = "rbs_collection.yaml"
+      GITIGNORE = ".gitignore"
+      GEM_RBS_COLLECTION_DIR = "/.gem_rbs_collection/"
+      RBS_COLLECTION_LOCK = "/rbs_collection.lock.yaml"
+
+      # Runs every setup step in the current directory.
+      #
+      # @param paths [Array<String>, nil] glob patterns to write into a new
+      #   .yarbs.yml (defaults to +lib/**/*.rb+)
+      # @param dry_run [Boolean] report what would change without writing anything
+      # @param install [Boolean] run +rbs collection install+ afterwards
+      # @param out [IO] where to report each step
+      # @return [void]
+      def self.run(paths: nil, dry_run: false, install: true, out: $stdout)
+        new(paths, dry_run, install, out).run
+      end
+
+      def initialize(paths, dry_run, install, out)
+        @paths = paths
+        @dry_run = dry_run
+        @install = install
+        @out = out
+      end
+
+      def run
+        report "dry run", "nothing will be written" if @dry_run
+
+        config = write_config
+        create_file(STEEPFILE, steepfile(config))
+        create_file(RBS_COLLECTION, rbs_collection)
+        update_gitignore
+        install_collection
+        generate(config)
+
+        return if Gem::Specification.find_all_by_name("steep").any?
+
+        report "next", "add Steep to type-check against the signatures: bundle add steep --group development"
+      end
+
+      private
+
+      # An existing .yarbs.yml wins over any paths given to `init`, so the
+      # Steepfile always matches what `yarbs` will actually generate.
+      def write_config
+        if File.exist?(Config::FILE)
+          report "skip", "#{Config::FILE} (already exists)"
+          return Config.load
+        end
+
+        config = @paths ? Config.new(paths: @paths) : Config.new
+        create_file(Config::FILE, config.to_yaml)
+        config
+      end
+
+      # @param config [Config]
+      # @return [String]
+      def steepfile(config)
+        checks = config.paths.map { |pattern| Watcher.base_directory(pattern) }.uniq
+
+        <<~RUBY
+          D = Steep::Diagnostic
+
+          target :app do
+            signature #{config.output.inspect}
+
+            #{checks.map { |dir| "check #{dir.inspect}" }.join("\n  ")}
+
+            # Lenient to start with, since most of a codebase is `untyped` until
+            # it's documented. Tighten this (D::Ruby.default, D::Ruby.strict)
+            # as more of it gets YARD types.
+            configure_code_diagnostics(D::Ruby.lenient)
+          end
+        RUBY
+      end
+
+      # @return [String]
+      def rbs_collection
+        <<~YAML
+          # Where Steep gets type signatures for your gems from.
+          # Run `rbs collection install` after changing your Gemfile.
+          sources:
+            - type: git
+              name: ruby/gem_rbs_collection
+              remote: https://github.com/ruby/gem_rbs_collection.git
+              revision: main
+              repo_dir: gems
+
+          # A directory to install the downloaded RBSs
+          path: .gem_rbs_collection
+
+          # gems:
+          #   # If you want to avoid installing rbs files for gems, you can specify them here.
+          #   - name: GEM_NAME
+          #     ignore: true
+        YAML
+      end
+
+      def create_file(path, contents)
+        if File.exist?(path)
+          report "skip", "#{path} (already exists)"
+          return
+        end
+
+        File.write(path, contents) unless @dry_run
+        report "create", path
+      end
+
+      # A gem's rbs_collection.lock.yaml is conventionally not committed (its
+      # users resolve their own), but an app should commit it, just like its
+      # Gemfile.lock.
+      def gitignore_entries
+        entries = [GEM_RBS_COLLECTION_DIR]
+        entries << RBS_COLLECTION_LOCK if Dir.glob("*.gemspec").any?
+        entries
+      end
+
+      def update_gitignore
+        exists = File.exist?(GITIGNORE)
+        unless exists || Dir.exist?(".git")
+          report "skip", "#{GITIGNORE} (not a git repository)"
+          return
+        end
+
+        contents = exists ? File.read(GITIGNORE) : ""
+        present = contents.lines.map { |line| normalize_ignore(line) }
+        missing = gitignore_entries.reject { |entry| present.include?(normalize_ignore(entry)) }
+
+        if missing.empty?
+          report "skip", "#{GITIGNORE} (already has yarbs' entries)"
+          return
+        end
+
+        unless @dry_run
+          separator = (contents.empty? || contents.end_with?("\n")) ? "" : "\n"
+          File.write(GITIGNORE, contents + separator + missing.join("\n") + "\n")
+        end
+        report exists ? "update" : "create", "#{GITIGNORE} (added #{missing.join(", ")})"
+      end
+
+      # `/.gem_rbs_collection/`, `.gem_rbs_collection/` and
+      # `.gem_rbs_collection` all ignore the same thing at the project root,
+      # so compare them without the leading/trailing slash.
+      def normalize_ignore(line)
+        line.strip.delete_prefix("/").delete_suffix("/")
+      end
+
+      def install_collection
+        return unless @install
+
+        unless File.exist?("Gemfile")
+          report "skip", "rbs collection install (no Gemfile)"
+          return
+        end
+
+        if @dry_run
+          report "run", "rbs collection install"
+          return
+        end
+
+        report "run", "rbs collection install"
+        output = StringIO.new
+        RBS::CLI.new(stdout: output, stderr: output).run(%w[collection install])
+      rescue StandardError, SystemExit => e
+        report "failed", "rbs collection install (#{e.message}); run it yourself once that's fixed"
+      end
+
+      def generate(config)
+        if @dry_run
+          report "run", "yarbs #{config.paths.join(" ")} -o #{config.output}"
+          return
+        end
+
+        written = Yarbs.generate(config.paths, output_dir: config.output, strict: config.strict)
+        if written.empty?
+          report "skip", "generating signatures (no files matched #{config.paths.join(" ")})"
+        else
+          report "wrote", "#{written.size} file#{"s" unless written.size == 1} to #{config.output}/"
+        end
+      end
+
+      def report(action, message)
+        @out.puts "#{action.rjust(8)}  #{message}"
+      end
+    end
+  end
+end

data/lib/yarbs/cli.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "optparse"
+require_relative "cli/init"
 
 module Yarbs
   # The `yarbs` command line executable.
@@ -10,12 +11,19 @@ module Yarbs
     # @param argv [Array<String>]
     # @return [void]
     def self.run(argv)
-      output_dir = "sig"
+      return init(argv.drop(1)) if argv.first == "init"
+
+      output_dir = nil
       watch = false
       strict = false
 
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: yarbs [options] GLOB [GLOB ...]"
+        opts.banner = <<~BANNER
+          Usage: yarbs [options] [GLOB ...]
+                 yarbs init [options] [GLOB ...]
+
+          With no GLOB, uses the paths in #{Config::FILE} (or lib/**/*.rb).
+        BANNER
         opts.on("-o", "--output DIR", "Directory to write .rbs files into (default: sig)") do |dir|
           output_dir = dir
         end
@@ -29,10 +37,17 @@ module Yarbs
 
       patterns = parser.parse(argv)
 
-      if patterns.empty?
-        warn parser.help
+      config = begin
+        Config.load
+      rescue Error => e
+        warn e.message
         exit 1
       end
+      patterns = config.paths if patterns.empty?
+      output_dir ||= config.output
+      # The config's `strict` is ignored in watch mode rather than rejected,
+      # so a project can set it for one-off runs and still use --watch.
+      strict ||= config.strict unless watch
 
       if strict && watch
         warn "yarbs: --strict cannot be combined with --watch"
@@ -55,5 +70,39 @@ module Yarbs
 
       written.each { |path| puts "wrote #{path}" }
     end
+
+    # Runs `yarbs init`.
+    #
+    # @param argv [Array<String>] the arguments after `init`
+    # @return [void]
+    def self.init(argv)
+      dry_run = false
+      install = true
+
+      parser = OptionParser.new do |opts|
+        opts.banner = <<~BANNER
+          Usage: yarbs init [options] [GLOB ...]
+
+          Sets up #{Config::FILE}, a Steepfile, rbs_collection.yaml and .gitignore
+          entries, then generates signatures. Existing files are never overwritten.
+          GLOB defaults to lib/**/*.rb.
+        BANNER
+        opts.on("-n", "--dry-run", "Show what would be done without writing anything") do
+          dry_run = true
+        end
+        opts.on("--no-install", "Don't run `rbs collection install`") do
+          install = false
+        end
+      end
+
+      paths = parser.parse(argv)
+
+      begin
+        Init.run(paths: paths.empty? ? nil : paths, dry_run: dry_run, install: install)
+      rescue Error => e
+        warn e.message
+        exit 1
+      end
+    end
   end
 end

data/lib/yarbs/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Yarbs
+  # The settings in a project's +.yarbs.yml+, so that a plain +yarbs+ (or
+  # +yarbs --watch+) knows what to generate without repeating the globs on
+  # every run. Written by +yarbs init+; anything given on the command line
+  # overrides it.
+  class Config
+    # The config file yarbs looks for in the current directory.
+    FILE = ".yarbs.yml"
+
+    DEFAULT_PATHS = ["lib/**/*.rb"].freeze
+    DEFAULT_OUTPUT = "sig"
+    KEYS = %w[paths output strict].freeze
+
+    # @return [Array<String>] glob patterns for Ruby source files
+    attr_reader :paths
+
+    # @return [String] directory to write generated .rbs files into
+    attr_reader :output
+
+    # @return [Boolean] raise instead of falling back to +untyped+
+    attr_reader :strict
+
+    # Loads the config file, or the defaults if there isn't one.
+    #
+    # @param path [String] the config file to read
+    # @return [Config]
+    # @raise [Error] if the file isn't valid YAML or has an unknown or
+    #   mistyped setting
+    def self.load(path = FILE)
+      return new unless File.exist?(path)
+
+      data = YAML.safe_load_file(path) || {}
+      raise Error, "yarbs: #{path} must be a YAML mapping" unless data.is_a?(Hash)
+
+      unknown = data.keys - KEYS
+      raise Error, "yarbs: unknown setting#{"s" unless unknown.size == 1} in #{path}: #{unknown.join(", ")}" if unknown.any?
+
+      new(
+        paths: Array(data.fetch("paths", DEFAULT_PATHS)),
+        output: data.fetch("output", DEFAULT_OUTPUT),
+        strict: data.fetch("strict", false)
+      ).tap { |config| config.validate!(path) }
+    rescue Psych::Exception => e
+      raise Error, "yarbs: could not parse #{path} (#{e.message})"
+    end
+
+    # @param paths [Array<String>]
+    # @param output [String]
+    # @param strict [Boolean]
+    def initialize(paths: DEFAULT_PATHS, output: DEFAULT_OUTPUT, strict: false)
+      @paths = paths
+      @output = output
+      @strict = strict
+    end
+
+    # @param path [String] the config file, for the error message
+    # @return [void]
+    # @raise [Error]
+    def validate!(path)
+      raise Error, "yarbs: `paths` in #{path} must be a list of glob strings" unless paths.all?(String) && paths.any?
+      raise Error, "yarbs: `output` in #{path} must be a directory name" unless output.is_a?(String)
+      raise Error, "yarbs: `strict` in #{path} must be true or false" unless [true, false].include?(strict)
+    end
+
+    # The YAML written to a new config file.
+    #
+    # @return [String]
+    def to_yaml
+      <<~YAML
+        # Settings for yarbs (https://github.com/tobidelius/yarbs).
+        # Anything passed on the command line overrides these.
+
+        # Glob patterns for the Ruby files to generate signatures for.
+        paths:
+        #{paths.map { |path| "  - #{path.inspect}" }.join("\n")}
+
+        # Directory the generated .rbs files are written into.
+        output: #{output}
+
+        # Raise instead of falling back to `untyped` when a YARD type can't
+        # be converted. Ignored by `yarbs --watch`.
+        strict: #{strict}
+      YAML
+    end
+  end
+end

data/lib/yarbs/version.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
 module Yarbs
-  VERSION = "0.1.1"
+  # The current version of yarbs.
+  #
+  # @return [String]
+  VERSION = "0.2.0"
 end

data/lib/yarbs/watcher.rb

@@ -18,6 +18,23 @@ module Yarbs
       @output_dir = output_dir
     end
 
+    # The directory a glob pattern searches under: everything before its
+    # first glob character, e.g. "lib/**/*.rb" -> "lib". Used both as the
+    # directory to hand to `Listen.to` and by `yarbs init` for the
+    # Steepfile's `check`.
+    #
+    # @param pattern [String]
+    # @return [String]
+    def self.base_directory(pattern)
+      glob_index = pattern.index(/[*?{\[]/)
+      return File.dirname(pattern) unless glob_index
+
+      prefix = pattern[0...glob_index]
+      return "." if prefix.empty?
+
+      prefix.end_with?("/") ? prefix.chomp("/") : File.dirname(prefix)
+    end
+
     # Starts watching and blocks until interrupted (Ctrl-C).
     #
     # @return [void]
@@ -74,19 +91,7 @@ module Yarbs
     end
 
     def watch_directories
-      @patterns.filter_map { |pattern| base_directory(pattern) }.uniq.select { |dir| Dir.exist?(dir) }
-    end
-
-    # The directory to hand to `Listen.to` for a glob pattern: everything
-    # before its first glob character, e.g. "lib/**/*.rb" -> "lib".
-    def base_directory(pattern)
-      glob_index = pattern.index(/[*?{\[]/)
-      return File.dirname(pattern) unless glob_index
-
-      prefix = pattern[0...glob_index]
-      return "." if prefix.empty?
-
-      prefix.end_with?("/") ? prefix.chomp("/") : File.dirname(prefix)
+      @patterns.filter_map { |pattern| self.class.base_directory(pattern) }.uniq.select { |dir| Dir.exist?(dir) }
     end
   end
 end

data/lib/yarbs.rb

@@ -4,6 +4,7 @@ require "yard"
 require "rbs"
 
 require_relative "yarbs/version"
+require_relative "yarbs/config"
 require_relative "yarbs/type_converter"
 require_relative "yarbs/prototype_builder"
 require_relative "yarbs/annotator"

data/sig/yarbs/annotator.rbs

@@ -33,6 +33,17 @@ module Yarbs
 
     def annotate_block: (untyped block, untyped yard_method) -> untyped
 
+    # `rbs prototype rb` marks an explicit `&block` as required unless the
+    # body checks `block_given?` or only uses the block conditionally, so a
+    # block that's merely captured or forwarded (`other(&block)`) comes out
+    # required. Treat the block as optional when:
+    #
+    # - its `@param` tag includes `nil` (`@param block [Proc, nil]`), or
+    # - the body never `yield`s (the block type is an `UntypedFunction`) and
+    #   no `@yield`/`@yieldparam`/`@yieldreturn` tag documents a contract
+    #   for callers to fulfil.
+    def optional_block?: (untyped block, untyped yard_method) -> bool
+
     def annotate_block_function: (untyped function, untyped yield_params, untyped new_return_type) -> untyped
 
     # There's no arity to preserve here, but if `@yieldparam` tags exist we

data/sig/yarbs/cli/init.rbs

@@ -0,0 +1,76 @@
+module Yarbs
+  module CLI
+    # `yarbs init`: sets a project up to use yarbs with Steep, so the
+    # signatures it writes are actually checked.
+    #
+    # Every step is safe to re-run: files that already exist are left alone
+    # (and reported as skipped), and `.gitignore` only gets the entries it's
+    # missing.
+    class Init
+      @paths: untyped
+
+      @dry_run: untyped
+
+      @install: untyped
+
+      @out: untyped
+
+      STEEPFILE: "Steepfile"
+
+      RBS_COLLECTION: "rbs_collection.yaml"
+
+      GITIGNORE: ".gitignore"
+
+      GEM_RBS_COLLECTION_DIR: "/.gem_rbs_collection/"
+
+      RBS_COLLECTION_LOCK: "/rbs_collection.lock.yaml"
+
+      # Runs every setup step in the current directory.
+      #
+      # @param paths [Array<String>, nil] glob patterns to write into a new
+      #   .yarbs.yml (defaults to +lib/**/*.rb+)
+      # @param dry_run [Boolean] report what would change without writing anything
+      # @param install [Boolean] run +rbs collection install+ afterwards
+      # @param out [IO] where to report each step
+      # @return [void]
+      def self.run: (?paths: untyped?, ?dry_run: bool, ?install: bool, ?out: untyped) -> untyped
+
+      def initialize: (untyped paths, untyped dry_run, untyped install, untyped out) -> void
+
+      def run: () -> (nil | untyped)
+
+      private
+
+      # An existing .yarbs.yml wins over any paths given to `init`, so the
+      # Steepfile always matches what `yarbs` will actually generate.
+      def write_config: () -> untyped
+
+      # @param config [Config]
+      # @return [String]
+      def steepfile: (Config config) -> String
+
+      # @return [String]
+      def rbs_collection: () -> String
+
+      def create_file: (untyped path, untyped contents) -> (nil | untyped)
+
+      # A gem's rbs_collection.lock.yaml is conventionally not committed (its
+      # users resolve their own), but an app should commit it, just like its
+      # Gemfile.lock.
+      def gitignore_entries: () -> untyped
+
+      def update_gitignore: () -> (nil | untyped)
+
+      # `/.gem_rbs_collection/`, `.gem_rbs_collection/` and
+      # `.gem_rbs_collection` all ignore the same thing at the project root,
+      # so compare them without the leading/trailing slash.
+      def normalize_ignore: (untyped line) -> untyped
+
+      def install_collection: () -> untyped
+
+      def generate: (untyped config) -> (nil | untyped)
+
+      def report: (untyped action, untyped message) -> untyped
+    end
+  end
+end

data/sig/yarbs/cli.rbs

@@ -6,5 +6,11 @@ module Yarbs
     # @param argv [Array<String>]
     # @return [void]
     def self.run: (Array[String] argv) -> void
+
+    # Runs `yarbs init`.
+    #
+    # @param argv [Array<String>] the arguments after `init`
+    # @return [void]
+    def self.init: (Array[String] argv) -> void
   end
 end

data/sig/yarbs/config.rbs

@@ -0,0 +1,54 @@
+module Yarbs
+  # The settings in a project's +.yarbs.yml+, so that a plain +yarbs+ (or
+  # +yarbs --watch+) knows what to generate without repeating the globs on
+  # every run. Written by +yarbs init+; anything given on the command line
+  # overrides it.
+  class Config
+    @paths: untyped
+
+    @output: untyped
+
+    @strict: untyped
+
+    # The config file yarbs looks for in the current directory.
+    FILE: ".yarbs.yml"
+
+    DEFAULT_PATHS: ::Array["lib/**/*.rb"]
+
+    DEFAULT_OUTPUT: "sig"
+
+    KEYS: ::Array["paths" | "output" | "strict"]
+
+    # @return [Array<String>] glob patterns for Ruby source files
+    attr_reader paths: Array[String]
+
+    # @return [String] directory to write generated .rbs files into
+    attr_reader output: String
+
+    # @return [Boolean] raise instead of falling back to +untyped+
+    attr_reader strict: bool
+
+    # Loads the config file, or the defaults if there isn't one.
+    #
+    # @param path [String] the config file to read
+    # @return [Config]
+    # @raise [Error] if the file isn't valid YAML or has an unknown or
+    #   mistyped setting
+    def self.load: (?String path) -> Config
+
+    # @param paths [Array<String>]
+    # @param output [String]
+    # @param strict [Boolean]
+    def initialize: (?paths: Array[String], ?output: String, ?strict: bool) -> void
+
+    # @param path [String] the config file, for the error message
+    # @return [void]
+    # @raise [Error]
+    def validate!: (String path) -> void
+
+    # The YAML written to a new config file.
+    #
+    # @return [String]
+    def to_yaml: () -> String
+  end
+end

data/sig/yarbs/type_converter.rbs

@@ -13,6 +13,21 @@ module Yarbs
     # @return [RBS::Types::t] the best matching RBS type, or +untyped+
     def self.convert: (Array[String] | nil yard_types, ?strict: bool) -> RBS::Types::t
 
+    # Number of type parameters for the core generic classes, which YARD
+    # lets you write with any number of arguments (or none) but RBS doesn't.
+    GENERIC_ARITY: { Array: 1, Set: 1, Range: 1, Enumerable: 1, Enumerator: 2, Hash: 2 }
+
+    # Fits the arguments of core generics to what RBS expects, recursively:
+    #
+    # - bare `Array`/`Hash` -> `Array[untyped]`/`Hash[untyped, untyped]`
+    # - `Array<String, Regexp>` (YARD for "Strings or Regexps") ->
+    #   `Array[String | Regexp]`
+    # - missing trailing arguments are filled with `untyped`
+    #
+    # @param type [RBS::Types::t]
+    # @return [RBS::Types::t]
+    def self.fit_generic_args: (RBS::Types::t type) -> RBS::Types::t
+
     # `Proc<(ArgType, ...), ReturnType>` -> `^(ArgType, ...) -> ReturnType`,
     # RBS's proc-literal type (a real, typed callable signature).
     #

data/sig/yarbs/version.rbs

@@ -1,3 +1,6 @@
 module Yarbs
-  VERSION: "0.1.0"
+  # The current version of yarbs.
+  #
+  # @return [String]
+  VERSION: String
 end

data/sig/yarbs/watcher.rbs

@@ -14,6 +14,15 @@ module Yarbs
     # @param output_dir [String] directory to write generated .rbs files into
     def initialize: (Array[String] patterns, output_dir: String) -> void
 
+    # The directory a glob pattern searches under: everything before its
+    # first glob character, e.g. "lib/**/*.rb" -> "lib". Used both as the
+    # directory to hand to `Listen.to` and by `yarbs init` for the
+    # Steepfile's `check`.
+    #
+    # @param pattern [String]
+    # @return [String]
+    def self.base_directory: (String pattern) -> String
+
     # Starts watching and blocks until interrupted (Ctrl-C).
     #
     # @return [void]
@@ -32,9 +41,5 @@ module Yarbs
     def relative_path: (untyped path) -> untyped
 
     def watch_directories: () -> untyped
-
-    # The directory to hand to `Listen.to` for a glob pattern: everything
-    # before its first glob character, e.g. "lib/**/*.rb" -> "lib".
-    def base_directory: (untyped pattern) -> (untyped | ".")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yarbs
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - tobidelius
@@ -65,6 +65,8 @@ files:
 - lib/yarbs.rb
 - lib/yarbs/annotator.rb
 - lib/yarbs/cli.rb
+- lib/yarbs/cli/init.rb
+- lib/yarbs/config.rb
 - lib/yarbs/generator.rb
 - lib/yarbs/prototype_builder.rb
 - lib/yarbs/type_converter.rb
@@ -74,6 +76,8 @@ files:
 - sig/yarbs.rbs
 - sig/yarbs/annotator.rbs
 - sig/yarbs/cli.rbs
+- sig/yarbs/cli/init.rbs
+- sig/yarbs/config.rbs
 - sig/yarbs/generator.rbs
 - sig/yarbs/prototype_builder.rbs
 - sig/yarbs/type_converter.rbs