Method: RBS::CLI#run_prototype_file

Defined in:

lib/rbs/cli.rb

#run_prototype_file(format, args) ⇒ Object

# File 'lib/rbs/cli.rb', line 668

def run_prototype_file(format, args)
  availability = unless has_parser?
                   "\n** This command does not work on this interpreter (#{RUBY_ENGINE}) **\n"
                 end

  # @type var output_dir: Pathname?
  output_dir = nil
  # @type var base_dir: Pathname?
  base_dir = nil
  # @type var force: bool
  force = false

  opts = OptionParser.new
  opts.banner = "Usage: rbs prototype \#{format} [files...]\n\#{availability}\nGenerate RBS prototype from source code.\nIt parses specified Ruby code and and generates RBS prototypes.\n\nIt only works on MRI because it parses Ruby code with `RubyVM::AbstractSyntaxTree`.\n\nExamples:\n\n  $ rbs prototype rb lib/foo.rb\n  $ rbs prototype rbi sorbet/rbi/foo.rbi\n\nYou can run the tool in *batch* mode by passing `--out-dir` option.\n\n  $ rbs prototype rb --out-dir=sig lib/foo.rb\n  $ rbs prototype rbi --out-dir=sig/models --base-dir=app/models app/models\n"

  opts.on("--out-dir=DIR", "Specify the path to save the generated RBS files") do |path|
    output_dir = Pathname(path)
  end

  opts.on("--base-dir=DIR", "Specify the path to calculate the relative path to save the generated RBS files") do |path|
    base_dir = Pathname(path)
  end

  opts.on("--force", "Overwrite existing RBS files") do
    force = true
  end

  opts.parse!(args)

  unless has_parser?
    stdout.puts "Not supported on this interpreter (#{RUBY_ENGINE})."
    exit 1
  end

  if args.empty?
    stdout.puts opts
    return nil
  end

  new_parser = -> do
    case format
    when "rbi"
      Prototype::RBI.new()
    when "rb"
      Prototype::RB.new()
    else
      raise
    end
  end

  input_paths = args.map {|arg| Pathname(arg) }

  if output_dir
    # @type var skip_paths: Array[Pathname]
    skip_paths = []

    # batch mode
    input_paths.each do |path|
      stdout.puts "Processing `#{path}`..."
      ruby_files =
        if path.file?
          [path]
        else
          path.glob("**/*.rb").sort
        end

      ruby_files.each do |file_path|
        stdout.puts "  Generating RBS for `#{file_path}`..."

        relative_path =
          if base_dir
            file_path.relative_path_from(base_dir)
          else
            if top = file_path.descend.first
              case
              when top == Pathname("lib")
                file_path.relative_path_from(top)
              when top == Pathname("app")
                file_path.relative_path_from(top)
              else
                file_path
              end
            else
              file_path
            end
          end
        relative_path = relative_path.cleanpath()

        if relative_path.absolute? || relative_path.descend.first&.to_s == ".."
          stdout.puts "  ⚠️  Cannot write the RBS to outside of the output dir: `#{relative_path}`"
          next
        end

        output_path = (output_dir + relative_path).sub_ext(".rbs")

        parser = new_parser[]
        begin
          parser.parse file_path.read()
        rescue SyntaxError
          stdout.puts "  ⚠️  Unable to parse due to SyntaxError: `#{file_path}`"
          next
        end

        if output_path.file?
          if force
            stdout.puts "    - Writing RBS to existing file `#{output_path}`..."
          else
            stdout.puts "    - Skipping existing file `#{output_path}`..."
            skip_paths << file_path
            next
          end
        else
          stdout.puts "    - Writing RBS to `#{output_path}`..."
        end

        (output_path.parent).mkpath
        output_path.open("w") do |io|
          writer = Writer.new(out: io)
          writer.write(parser.decls)
        end
      end
    end

    unless skip_paths.empty?
      stdout.puts
      stdout.puts ">>>> Skipped existing #{skip_paths.size} files. Use `--force` option to update the files."
      command = original_args.take(original_args.size - input_paths.size)

      skip_paths.take(10).each do |path|
        stdout.puts "  #{defined?(Bundler) ? "bundle exec " : ""}rbs #{Shellwords.join(command)} --force #{Shellwords.escape(path.to_s)}"
      end
      if skip_paths.size > 10
        stdout.puts "  ..."
      end
    end
  else
    # file mode
    parser = new_parser[]

    input_paths.each do |file|
      parser.parse file.read()
    end

    writer = Writer.new(out: stdout)
    writer.write parser.decls
  end
end