rbs 2.8.4 → 3.8.1

data/lib/rbs/cli.rb

@@ -3,9 +3,14 @@
 require "open3"
 require "optparse"
 require "shellwords"
+require "stringio"
 
 module RBS
   class CLI
+    autoload :ColoredIO, 'rbs/cli/colored_io'
+    autoload :Diff, 'rbs/cli/diff'
+    autoload :Validate, 'rbs/cli/validate'
+
     class LibraryOptions
       attr_accessor :core_root
       attr_accessor :config_path
@@ -29,7 +34,12 @@ module RBS
         end
 
         loader = EnvironmentLoader.new(core_root: core_root, repository: repository)
-        lock = config_path&.then { |p| Collection::Config.lockfile_of(p) }
+        if config_path
+          lock_path = Collection::Config.to_lockfile_path(config_path)
+          if lock_path.file?
+            lock = Collection::Config::Lockfile.from_lockfile(lockfile_path: lock_path, data: YAML.load_file(lock_path.to_s))
+          end
+        end
         loader.add_collection(lock) if lock
 
         dirs.each do |dir|
@@ -83,7 +93,7 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :annotate, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection]
+    COMMANDS = [:ast, :annotate, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection, :subtract, :diff]
 
     def parse_logging_options(opts)
       opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
@@ -99,7 +109,7 @@ module RBS
     end
 
     def has_parser?
-      defined?(RubyVM::AbstractSyntaxTree)
+      defined?(RubyVM::AbstractSyntaxTree) ? true : false
     end
 
     def run(args)
@@ -225,6 +235,19 @@ EOB
             end
           end
         end
+
+        env.class_alias_decls.each do |name, entry|
+          case entry
+          when Environment::ModuleAliasEntry
+            if list.include?(:module)
+              stdout.puts "#{name} (module alias)"
+            end
+          when Environment::ClassAliasEntry
+            if list.include?(:class)
+              stdout.puts "#{name} (class alias)"
+            end
+          end
+        end
       end
 
       if list.include?(:interface)
@@ -255,14 +278,22 @@ EOU
         opts.on("--singleton", "Ancestors of singleton of the given type_name") { kind = :singleton }
       end.order!(args)
 
+      unless args.size == 1
+        stdout.puts "Expected one argument."
+        return
+      end
+
       loader = options.loader()
 
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder::AncestorBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
+
+      case env.constant_entry(type_name)
+      when Environment::ClassEntry, Environment::ModuleEntry, Environment::ClassAliasEntry, Environment::ModuleAliasEntry
+        type_name = env.normalize_module_name(type_name)
 
-      if env.class_decls.key?(type_name)
         ancestors = case kind
                     when :instance
                       builder.instance_ancestors(type_name)
@@ -322,9 +353,9 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
 
-      if env.class_decls.key?(type_name)
+      if env.module_name?(type_name)
         definition = case kind
                      when :instance
                        builder.build_instance(type_name)
@@ -375,10 +406,10 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
       method_name = args[1].to_sym
 
-      unless env.class_decls.key?(type_name)
+      unless env.module_name?(type_name)
         stdout.puts "Cannot find class: #{type_name}"
         return
       end
@@ -405,101 +436,15 @@ EOU
       stdout.puts "  accessibility: #{method.accessibility}"
       stdout.puts "  types:"
       separator = " "
-      for type in method.method_types
-        stdout.puts "    #{separator} #{type}"
+      length_max = method.method_types.map { |type| type.to_s.length }.max or raise
+      method.method_types.each do |type|
+        stdout.puts format("    %s %-#{length_max}s   at %s", separator, type, type.location)
         separator = "|"
       end
     end
 
     def run_validate(args, options)
-      OptionParser.new do |opts|
-        opts.banner = <<EOU
-Usage: rbs validate
-
-Validate RBS files. It ensures the type names in RBS files are present and the type applications have correct arity.
-
-Examples:
-
-  $ rbs validate
-EOU
-
-        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)
-      validator = Validator.new(env: env, resolver: TypeNameResolver.from_env(env))
-
-      env.class_decls.each do |name, decl|
-        stdout.puts "Validating class/module definition: `#{name}`..."
-        builder.build_instance(name).each_type do |type|
-          validator.validate_type type, context: [Namespace.root]
-        end
-        builder.build_singleton(name).each_type do |type|
-          validator.validate_type type, context: [Namespace.root]
-        end
-
-        d = decl.primary.decl
-
-        validator.validate_type_params(
-          d.type_params,
-          type_name: name,
-          location: d.location&.aref(:type_params)
-        )
-
-        decl.decls.each do |d|
-          d.decl.each_member do |member|
-            case member
-            when AST::Members::MethodDefinition
-              validator.validate_method_definition(member, type_name: name)
-            end
-          end
-        end
-      end
-
-      env.interface_decls.each do |name, decl|
-        stdout.puts "Validating interface: `#{name}`..."
-        builder.build_interface(name).each_type do |type|
-          validator.validate_type type, context: [Namespace.root]
-        end
-
-        validator.validate_type_params(
-          decl.decl.type_params,
-          type_name: name,
-          location: decl.decl.location&.aref(:type_params)
-        )
-
-        decl.decl.members.each do |member|
-          case member
-          when AST::Members::MethodDefinition
-            validator.validate_method_definition(member, type_name: name)
-          end
-        end
-      end
-
-      env.constant_decls.each do |name, const|
-        stdout.puts "Validating constant: `#{name}`..."
-        validator.validate_type const.decl.type, context: const.context
-        builder.ensure_namespace!(name.namespace, location: const.decl.location)
-      end
-
-      env.global_decls.each do |name, global|
-        stdout.puts "Validating global: `#{name}`..."
-        validator.validate_type global.decl.type, context: [Namespace.root]
-      end
-
-      env.alias_decls.each do |name, decl|
-        stdout.puts "Validating alias: `#{name}`..."
-        builder.expand_alias1(name).tap do |type|
-          validator.validate_type type, context: [Namespace.root]
-        end
-        validator.validate_type_alias(entry: decl)
-      end
+      CLI::Validate.new(args: args, options: options).run
     end
 
     def run_constant(args, options)
@@ -532,14 +477,26 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      table = ConstantTable.new(builder: builder)
+      resolver = Resolver::ConstantResolver.new(builder: builder)
 
-      namespace = context ? Namespace.parse(context).absolute! : Namespace.root
-      stdout.puts "Context: #{namespace}"
-      name = Namespace.parse(args[0]).to_type_name
-      stdout.puts "Constant name: #{name}"
+      resolver_context = context ? [nil, TypeName.parse(context).absolute!] : nil #: Resolver::context
+      stdout.puts "Context: #{context}"
+      const_name = TypeName.parse(args[0])
+      stdout.puts "Constant name: #{const_name}"
 
-      constant = table.resolve_constant_reference(name, context: namespace.ascend.to_a)
+      if const_name.absolute?
+        constant = resolver.table.constant(const_name)
+      else
+        head, *components = const_name.to_namespace.path
+        head or raise
+
+        constant = resolver.resolve(head, context: resolver_context)
+        constant = components.inject(constant) do |const, component|
+          if const
+            resolver.resolve_child(const.name, component)
+          end
+        end
+      end
 
       if constant
         stdout.puts " => #{constant.name}: #{constant.type}"
@@ -597,10 +554,13 @@ EOU
       when "rbi", "rb"
         run_prototype_file(format, args)
       when "runtime"
-        require_libs = []
-        relative_libs = []
+        require_libs = [] #: Array[String]
+        relative_libs = [] #: Array[String]
         merge = false
-        owners_included = []
+        todo = false
+        owners_included = [] #: Array[Symbol]
+        outline = false
+        autoload = false
 
         OptionParser.new do |opts|
           opts.banner = <<EOU
@@ -613,7 +573,7 @@ Examples:
 
   $ rbs prototype runtime String
   $ rbs prototype runtime --require set Set
-  $ rbs prototype runtime -R lib/rbs RBS::*
+  $ rbs prototype runtime -R lib/rbs RBS RBS::*
 
 Options:
 EOU
@@ -626,23 +586,65 @@ EOU
           opts.on("--merge", "Merge generated prototype RBS with existing RBS") do
             merge = true
           end
+          opts.on("--todo", "Generates only undefined methods compared to objects") do
+            Warning.warn("Geneating prototypes with `--todo` option is experimental\n", category: :experimental)
+            todo = true
+          end
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
-            owners_included << klass
+            owners_included << klass.to_sym
+          end
+          opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
+            outline = true
+          end
+          opts.on("--autoload", "Load all autoload path") do
+            autoload = true
           end
         end.parse!(args)
 
         loader = options.loader()
         env = Environment.from_loader(loader).resolve_type_names
 
-        require_libs.each do |lib|
-          require(lib)
+        # @type var autoloader: ^() { () -> void } -> void
+        autoloader = ->(&block) {
+          if autoload
+            hook = Module.new do
+              def autoload(name, path)
+                super
+              end
+            end
+            ::Module.prepend(hook)
+            ::Kernel.prepend(hook)
+
+            arguments = [] #: Array[[Module, interned]]
+            TracePoint.new(:call) do |tp|
+              base = tp.self.kind_of?(Module) ? tp.self : Kernel #: Module
+              name = (tp.binding or raise).local_variable_get(:name)
+              arguments << [base, name]
+            end.enable(target: hook.instance_method(:autoload), &block)
+
+            arguments.each do |(base, name)|
+              begin
+                base.const_get(name)
+              rescue LoadError, StandardError
+              end
+            end
+          else
+            block.call
+          end
+        }
+        autoloader.call do
+          require_libs.each do |lib|
+            require(lib)
+          end
+          relative_libs.each do |lib|
+            eval("require_relative(lib)", binding, "rbs")
+          end
         end
 
-        relative_libs.each do |lib|
-          eval("require_relative(lib)", binding, "rbs")
-        end
+        runtime = Prototype::Runtime.new(patterns: args, env: env, merge: merge, todo: todo, owners_included: owners_included)
+        runtime.outline = outline
 
-        decls = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included).decls
+        decls = runtime.decls
 
         writer = Writer.new(out: stdout)
         writer.write decls
@@ -776,7 +778,12 @@ EOU
             output_path = (output_dir + relative_path).sub_ext(".rbs")
 
             parser = new_parser[]
-            parser.parse file_path.read()
+            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
@@ -877,6 +884,10 @@ Options:
     end
 
     def run_parse(args, options)
+      parse_method = :parse_signature
+      # @type var e_code: String?
+      e_code = nil
+
       OptionParser.new do |opts|
         opts.banner = <<-EOB
 Usage: rbs parse [files...]
@@ -886,22 +897,35 @@ Parse given RBS files and print syntax errors.
 Examples:
 
   $ rbs parse sig/app/models.rbs sig/app/controllers.rbs
+
+Options:
         EOB
-      end.parse!(args)
 
-      loader = options.loader()
+        opts.on('-e CODE', 'One line RBS script to parse') { |e| e_code = e }
+        opts.on('--type', 'Parse code as a type') { |e| parse_method = :parse_type }
+        opts.on('--method-type', 'Parse code as a method type') { |e| parse_method = :parse_method_type }
+      end.parse!(args)
 
       syntax_error = false
-      args.each do |path|
+      bufs = args.flat_map do |path|
         path = Pathname(path)
-        loader.each_file(path, skip_hidden: false, immediate: true) do |file_path|
-          RBS.logger.info "Parsing #{file_path}..."
-          buffer = Buffer.new(content: file_path.read, name: file_path)
-          Parser.parse_signature(buffer)
-        rescue RBS::ParsingError => ex
-          stdout.puts ex.message
-          syntax_error = true
+        FileFinder.each_file(path, skip_hidden: false).map do |file_path|
+          Buffer.new(content: file_path.read, name: file_path)
+        end
+      end
+      bufs << Buffer.new(content: e_code, name: '-e') if e_code
+
+      bufs.each do |buf|
+        RBS.logger.info "Parsing #{buf.name}..."
+        case parse_method
+        when :parse_signature
+          Parser.parse_signature(buf)
+        else
+          Parser.public_send(parse_method, buf, require_eof: true)
         end
+      rescue RBS::ParsingError => ex
+        stdout.print ex.detailed_message(highlight: true)
+        syntax_error = true
       end
 
       exit 1 if syntax_error
@@ -955,7 +979,7 @@ Options:
     end
 
     def test_opt options
-      opts = []
+      opts = [] #: Array[String]
 
       opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
       opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
@@ -1029,24 +1053,23 @@ EOB
     end
 
     def run_collection(args, options)
+      require 'bundler'
+
       opts = collection_options(args)
-      params = {}
+      params = {} #: Hash[Symbol, untyped]
       opts.order args.drop(1), into: params
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)
 
       case args[0]
-      when 'install'
+      when 'install', 'instal', 'insta', 'inst', 'ins', 'in', 'i'
         unless params[:frozen]
-          gemfile_lock_path = Bundler.default_lockfile
-          Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path)
+          Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition)
         end
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
-      when 'update'
-        gemfile_lock_path = Bundler.default_lockfile
-
+      when 'update', 'updat', 'upda', 'upd', 'up', 'u'
         # TODO: Be aware of argv to update only specified gem
-        Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: false)
+        Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition, with_lockfile: false)
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'init'
         if config_path.exist?
@@ -1057,19 +1080,23 @@ EOB
         config_path.write(<<~'YAML')
           # Download sources
           sources:
-            - name: ruby/gem_rbs_collection
+            - type: git
+              name: ruby/gem_rbs_collection
               remote: https://github.com/ruby/gem_rbs_collection.git
               revision: main
               repo_dir: gems
 
+          # You can specify local directories as sources also.
+          # - type: local
+          #   path: path/to/your/local/repository
+
           # A directory to install the downloaded RBSs
           path: .gem_rbs_collection
 
-          gems:
-            # Skip loading rbs gem's RBS.
-            # It's unnecessary if you don't use rbs as a library.
-            - name: rbs
-              ignore: true
+          # gems:
+          #   # If you want to avoid installing rbs files for gems, you can specify them here.
+          #   - name: GEM_NAME
+          #     ignore: true
         YAML
         stdout.puts "created: #{config_path}"
       when 'clean'
@@ -1078,7 +1105,7 @@ EOB
           exit 1
         end
         Collection::Cleaner.new(lockfile_path: lock_path)
-      when 'help'
+      when 'help', 'hel', 'he', 'h'
         puts opts.help
       else
         puts opts.help
@@ -1109,5 +1136,88 @@ EOB
         opts.on('--frozen') if args[0] == 'install'
       end
     end
+
+    def run_subtract(args, _)
+      write_to_file = false
+      # @type var subtrahend_paths: Array[String]
+      subtrahend_paths = []
+
+      opts = OptionParser.new do |opts|
+        opts.banner = <<~HELP
+          Usage:
+            rbs subtract [options...] minuend.rbs [minuend2.rbs, ...] subtrahend.rbs
+            rbs subtract [options...] minuend.rbs [minuend2.rbs, ...] --subtrahend subtrahend_1.rbs --subtrahend subtrahend_2.rbs
+
+          Remove duplications between RBS files.
+
+          Examples:
+
+            # Generate RBS files from the codebase.
+            $ rbs prototype rb lib/ > generated.rbs
+
+            # Write more descrictive types by hand.
+            $ $EDITOR handwritten.rbs
+
+            # Remove hand-written method definitions from generated.rbs.
+            $ rbs subtract --write generated.rbs handwritten.rbs
+
+          Options:
+        HELP
+        opts.on('-w', '--write', 'Overwrite files directry') { write_to_file = true }
+        opts.on('--subtrahend=PATH', '') { |path| subtrahend_paths << path }
+        opts.parse!(args)
+      end
+
+      if subtrahend_paths.empty?
+        *minuend_paths, subtrahend_path = args
+        unless subtrahend_path
+          stdout.puts opts.help
+          exit 1
+        end
+        subtrahend_paths << subtrahend_path
+      else
+        minuend_paths = args
+      end
+
+      if minuend_paths.empty?
+        stdout.puts opts.help
+        exit 1
+      end
+
+      subtrahend = Environment.new.tap do |env|
+        loader = EnvironmentLoader.new(core_root: nil)
+        subtrahend_paths.each do |path|
+          loader.add(path: Pathname(path))
+        end
+        loader.load(env: env)
+      end
+
+      minuend_paths.each do |minuend_path|
+        FileFinder.each_file(Pathname(minuend_path), skip_hidden: true) do |rbs_path|
+          buf = Buffer.new(name: rbs_path, content: rbs_path.read)
+          _, dirs, decls = Parser.parse_signature(buf)
+          subtracted = Subtractor.new(decls, subtrahend).call
+
+          io = StringIO.new
+          w = Writer.new(out: io)
+          w.write(dirs)
+          w.write(subtracted)
+
+          if write_to_file
+            if io.string.empty?
+              rbs_path.delete
+            else
+              rbs_path.write(io.string)
+            end
+          else
+            stdout.puts(io.string)
+          end
+        end
+      end
+    end
+
+    def run_diff(argv, library_options)
+      Diff.new(argv: argv, library_options: library_options, stdout: stdout, stderr: stderr).run
+    end
   end
 end

data/lib/rbs/collection/cleaner.rb

@@ -16,7 +16,14 @@ module RBS
           version or raise
           next if needed? gem_name, version
 
-          FileUtils.remove_entry_secure(dir.to_s)
+          case
+          when dir.symlink?
+            dir.unlink
+          when dir.directory?
+            FileUtils.remove_entry_secure(dir.to_s)
+          else
+            raise
+          end
         end
       end
 

data/lib/rbs/collection/config/lockfile.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Config
+      class Lockfile
+        attr_reader :lockfile_path, :lockfile_dir, :path, :gemfile_lock_path, :sources, :gems
+
+        def initialize(lockfile_path:, path:, gemfile_lock_path:)
+          @lockfile_path = lockfile_path
+          @lockfile_dir = lockfile_path.parent
+          @path = path
+          @gemfile_lock_path = gemfile_lock_path
+
+          @gems = {}
+        end
+
+        def fullpath
+          lockfile_dir + path
+        end
+
+        def gemfile_lock_fullpath
+          if gemfile_lock_path
+            lockfile_dir + gemfile_lock_path
+          end
+        end
+
+        def to_lockfile
+          # @type var data: lockfile_data
+
+          data = {
+            "path" => path.to_s,
+            "gems" => gems.each_value.sort_by {|g| g[:name] }.map {|hash| library_data(hash) },
+            "gemfile_lock_path" => gemfile_lock_path.to_s
+          }
+
+          data.delete("gems") if gems.empty?
+
+          data
+        end
+
+        def self.from_lockfile(lockfile_path:, data:)
+          path = Pathname(data["path"])
+          if p = data["gemfile_lock_path"]
+            gemfile_lock_path = Pathname(p)
+          end
+
+          lockfile = Lockfile.new(lockfile_path: lockfile_path, path: path, gemfile_lock_path: gemfile_lock_path)
+
+          if gems = data["gems"]
+            gems.each do |gem|
+              src = gem["source"]
+              source = Sources.from_config_entry(src, base_directory: lockfile_path.dirname)
+              lockfile.gems[gem["name"]] = {
+                name: gem["name"],
+                version: gem["version"],
+                source: source
+              }
+            end
+          end
+
+          lockfile
+        end
+
+        def library_data(lib)
+          {
+            "name" => lib[:name],
+            "version" => lib[:version],
+            "source" => lib[:source].to_lockfile
+          }
+        end
+
+        def check_rbs_availability!
+          raise CollectionNotAvailable unless fullpath.exist?
+
+          gems.each_value do |gem|
+            source = gem[:source]
+
+            case source
+            when Sources::Git
+              meta_path = fullpath.join(gem[:name], gem[:version], Sources::Git::METADATA_FILENAME)
+              raise CollectionNotAvailable unless meta_path.exist?
+              raise CollectionNotAvailable unless library_data(gem) == YAML.load(meta_path.read)
+            when Sources::Local
+              raise CollectionNotAvailable unless fullpath.join(gem[:name], gem[:version]).symlink?
+            end
+          end
+        end
+      end
+    end
+  end
+end