rbs 2.8.4 → 3.8.1

data/sig/cli/diff.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class CLI
+    class Diff
+      @format: String
+      @stdout: _IO
+      @stderr: _IO
+      @diff: RBS::Diff
+
+      def initialize: (
+        argv: Array[String],
+        library_options: RBS::CLI::LibraryOptions,
+        ?stdout: _IO,
+        ?stderr: _IO,
+      ) -> void
+
+      def run: () -> void
+      def run_diff: () -> void
+      def run_markdown: () -> void
+    end
+  end
+end

data/sig/cli/validate.rbs

@@ -0,0 +1,43 @@
+module RBS
+  class CLI
+    class Validate
+      class Errors
+        @limit: Integer?
+        @exit_error: boolish
+        @has_syntax_error: bool
+        @errors: Array[BaseError]
+
+        def initialize: (limit: Integer?, exit_error: boolish) -> void
+
+        def add: (BaseError) -> void
+
+        def finish: () -> void
+
+        private
+
+        def build_message: (BaseError) -> String
+      end
+
+      @env: Environment
+      @builder: RBS::DefinitionBuilder
+      @validator: RBS::Validator
+      @errors: Errors
+
+      def initialize: (args: Array[String], options: LibraryOptions) -> void
+
+      def run: () -> void
+
+      private
+
+      def validate_class_module_definition: () -> void
+      def validate_class_module_alias_definition: () -> void
+      def validate_interface: () -> void
+      def validate_constant: () -> void
+      def validate_global: () -> void
+      def validate_type_alias: () -> void
+      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
+    end
+  end
+end

data/sig/cli.rbs

@@ -18,6 +18,8 @@ module RBS
     interface _IO
       def puts: (*untyped) -> void
 
+      def tty?: () -> bool
+
       def print: (*untyped) -> void
 
       def flush: () -> void
@@ -76,6 +78,8 @@ module RBS
 
     def run_annotate: (Array[String], top) -> void
 
+    def run_subtract: (Array[String], top) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/collection/config/lockfile.rbs

@@ -0,0 +1,74 @@
+module RBS
+  module Collection
+    class Config
+      # Lockfile represents the `rbs_collection.lock.yaml`, that contains configurations and *resolved* gems with their sources
+      #
+      class Lockfile
+        # Data structure stored in `rbs_collection.lock.yaml`
+        #
+        type lockfile_data = {
+          "path" => String,
+          "gems" => Array[library_data]?,         # null if empty
+          "gemfile_lock_path" => String?          # gemfile_lock_path is optional because older versions doesn't have it
+        }
+
+        type library_data = {
+          'name' => String,
+          'version' => String,
+          'source' => Sources::source_entry
+        }
+
+        # In-memory data structure that represents a library
+        #
+        type library = {
+          name: String,
+          version: String,
+          source: Sources::t
+        }
+
+        attr_reader lockfile_path: Pathname
+
+        # Path of the directory where lockfile is saved in
+        #
+        # `lockfile_path.parent`
+        #
+        attr_reader lockfile_dir: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader path: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader gemfile_lock_path: Pathname?
+
+        attr_reader gems: Hash[String, library]
+
+        def initialize: (lockfile_path: Pathname, path: Pathname, gemfile_lock_path: Pathname?) -> void
+
+        # `lockfile_dir` + `path`
+        #
+        def fullpath: () -> Pathname
+
+        # `lockfile_dir` + `gemfile_lock_path`
+        #
+        %a{pure} def gemfile_lock_fullpath: () -> Pathname?
+
+        def to_lockfile: () -> lockfile_data
+
+        def self.from_lockfile: (lockfile_path: Pathname, data: lockfile_data) -> Lockfile
+
+        # Validates if directories are set up correctly
+        #
+        # * Ensures if `path` is a directory
+        # * Ensures if `git` sources are set up correctly
+        #
+        def check_rbs_availability!: () -> void
+
+        private
+
+        def library_data: (library) -> library_data
+      end
+    end
+  end
+end

data/sig/collection/config/lockfile_generator.rbs

@@ -0,0 +1,66 @@
+module RBS
+  module Collection
+    class Config
+      class LockfileGenerator
+        # Name of stdlibs that was rbs-bundled stdlib but is now a gem.
+        #
+        ALUMNI_STDLIBS: Hash[String, String]
+
+        class GemfileLockMismatchError < StandardError
+          @expected: Pathname
+
+          @actual: Pathname
+
+          def initialize: (expected: Pathname, actual: Pathname) -> void
+
+          def message: () -> String
+        end
+
+        attr_reader config: Config
+
+        attr_reader lockfile: Lockfile
+        attr_reader existing_lockfile: Lockfile?
+
+        attr_reader definition: Bundler::Definition
+
+        # A hash table to look up a spec from name of the gem
+        attr_reader gem_hash: Hash[String, Bundler::LazySpecification]
+
+        # A hash table to look up a gem entry in collection config from the name of the gem
+        attr_reader gem_entries: Hash[String, gem_entry?]
+
+        def self.generate: (config: Config, definition: Bundler::Definition, ?with_lockfile: boolish) -> Lockfile
+
+        def initialize: (config: Config, definition: Bundler::Definition, with_lockfile: boolish) -> void
+
+        def generate: () -> void
+
+        private
+
+        # Ensure if current `gemfile_lock_path` is the same with the path saved in `lock`
+        #
+        def validate_gemfile_lock_path!: (lock: Lockfile?, gemfile_lock_path: Pathname) -> void
+
+        # Inserts a entry to lockfile of a gem and its dependencies, if not included in `ignored_gems:`
+        #
+        # * If `skip:` is true, it skips adding the gem, but adds it's dependencies.
+        #
+        def assign_gem: (name: String, version: String?, ?skip: bool) -> void
+
+        # Assign a gem from stdlib to lockfile
+        #
+        # `from_gem` is a String when the stdlib is assigned through the `dependencies:` in `manifest.yaml` of a gem.
+        #
+        def assign_stdlib: (name: String, ?from_gem: String) -> void
+
+        # Find a source of a gem from ones registered in `config.sources`
+        #
+        # Returns `nil` if no source contains the definition of the gem.
+        #
+        def find_source: (name: String) -> Sources::t?
+
+        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
+      end
+    end
+  end
+end

data/sig/collection/config.rbs

@@ -6,39 +6,6 @@ module RBS
         def initialize: () -> void
       end
 
-      class LockfileGenerator
-        attr_reader config: Config
-        attr_reader lock: Config?
-        attr_reader lock_path: Pathname
-        attr_reader gemfile_lock: Bundler::LockfileParser
-
-        type gem_queue_entry = { name: String, version: String? }
-
-        @gem_queue: Array[gem_queue_entry]
-
-        def self.generate: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
-
-        def initialize: (config_path: Pathname, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
-
-        def generate: () -> Config
-
-        private
-
-        def validate_gemfile_lock_path!: (lock: Config?, gemfile_lock_path: Pathname) -> void
-
-        def assign_gem: (name: String, version: String?) -> void
-
-        def upsert_gem: (gem_entry? old, gem_entry new) -> void
-
-        def gemfile_lock_gems: () { (untyped) -> void } -> void
-
-        def remove_ignored_gems!: () -> void
-
-        def find_source: (name: String) -> Sources::_Source?
-
-        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
-      end
-
       PATH: Pathname
 
       type gem_entry = {
@@ -48,42 +15,32 @@ module RBS
         'source' => Sources::source_entry?
       }
 
-      @config_path: Pathname
+      attr_reader config_path: Pathname
 
-      @data: untyped
+      attr_reader data: untyped
 
       @sources: Array[Sources::_Source]
 
       def self.find_config_path: () -> Pathname?
 
-      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
+      def self.generate_lockfile: (config_path: Pathname, definition: Bundler::Definition, ?with_lockfile: boolish) -> [Config, Lockfile]
 
       def self.from_path: (Pathname path) -> Config
 
-      def self.lockfile_of: (Pathname config_path) -> Config?
-
       def self.to_lockfile_path: (Pathname config_path) -> Pathname
 
       # config_path is necessary to resolve relative repo_path
       def initialize: (untyped data, config_path: Pathname) -> void
 
-      def add_gem: (gem_entry gem) -> void
-
       def gem: (String gem_name) -> gem_entry?
 
       def repo_path: () -> Pathname
 
-      def sources: () -> Array[Sources::_Source]
+      def repo_path_data: () -> Pathname
 
-      def dump_to: (Pathname) -> void
+      def sources: () -> Array[Sources::t]
 
       def gems: () -> Array[gem_entry]
-
-      def gemfile_lock_path=: (Pathname) -> Pathname
-
-      def gemfile_lock_path: () -> Pathname?
-
-      def check_rbs_availability!: () -> void
     end
   end
 end

data/sig/collection/installer.rbs

@@ -1,7 +1,7 @@
 module RBS
   module Collection
     class Installer
-      attr_reader lockfile: Config
+      attr_reader lockfile: Config::Lockfile
       attr_reader stdout: CLI::_IO
 
       def initialize: (lockfile_path: Pathname, ?stdout: CLI::_IO) -> void

data/sig/collection/sources.rbs

@@ -1,27 +1,33 @@
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry: (source_entry) -> _Source
+      def self.from_config_entry: (Git::source_entry, base_directory: Pathname) -> Git
+                                | (source_entry, base_directory: Pathname) -> t
 
       interface _Source
-        def has?: (Config::gem_entry) -> boolish
-        def versions: (Config::gem_entry) -> Array[String]
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def has?: (String name, String? version) -> boolish
+        def versions: (String name) -> Array[String]
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
-        def dependencies_of: (Config::gem_entry) -> Array[{"name" => String}]?
+        def manifest_of: (String name, String version) -> manifest_entry?
+        def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
+      type t = Git | Stdlib | Rubygems | Local
+
       type source_entry = Git::source_entry
                         | Stdlib::source_entry
                         | Rubygems::source_entry
+                        | Local::source_entry
 
       type manifest_entry = {
-        "dependencies" => Array[{"name" => String}]?,
+        "dependencies" => Array[manifest_dependency]?,
       }
 
+      type manifest_dependency = { "name" => String }
+
       module Base : _Source
-        def dependencies_of: (Config::gem_entry config_entry) -> Array[{"name" => String}]?
+        def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
       class Git
@@ -43,48 +49,110 @@ module RBS
         attr_reader name: String
         attr_reader remote: String
         attr_reader repo_dir: String
+        attr_reader revision: String
 
         def initialize: (name: String, revision: String, remote: String, repo_dir: String?) -> untyped
 
-        def has?: (Config::gem_entry) -> bool
+        def has?: (String name, String? version) -> boolish
 
-        def versions: (Config::gem_entry) -> Array[String]
+        def versions: (String name) -> Array[String]
 
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
 
         def to_lockfile: () -> source_entry
 
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+        def manifest_of: (String name, String version) -> manifest_entry?
+
+        def resolved_revision: () -> String
 
         private
 
+        @need_setup: bool
+
         @git_dir: Pathname?
 
         @resolved_revision: String?
 
-        def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
+        @gems_versions: Hash[String, Set[String]]?
 
-        def cp_r: (Pathname, Pathname) -> void
-
-        def setup!: (revision: String) -> void
+        def _install: (dest: Pathname , name: String, version: String) -> void
 
-        def need_to_fetch?: (String revision ) -> bool
+        def cp_r: (Pathname, Pathname) -> void
 
+        # Ensure the git repository exists, and
+        #
+        # * When `revision` is a commit hash, the commit exists in the local repository, or
+        # * When `revision` is a branch name, the latest version is fetched from `origin`
+        #
+        # It may require a network connection to fetch or clone the repository from remote.
+        #
+        # * If `revision` is a commit hash and the commit doesn't exists in the local repository, it runs `git fetch`
+        # * If `revision` is a branch name, it runs `git fetch` once per instance
+        #
+        def setup!: [T] () { () -> T } -> T
+                  | () -> void
+
+        def need_to_fetch?: (String revision) -> bool
+
+        # The full path of local git repository
         def git_dir: () -> Pathname
 
+        # The full path of `repo_dir` in the local git repository
         def gem_repo_dir: () -> Pathname
 
-        def with_revision: [T] () { () -> T } -> T
-
-        def resolved_revision: () -> String
-
-        def resolve_revision: () -> String
+        # Returns `true` if `revision` looks like a commit hash
+        def commit_hash?: () -> bool
 
+        # Executes a git command, raises an error if failed
         def git: (*String cmd, **untyped opt) -> String
 
+        # Executes a git command, returns `nil` if failed
+        def git?: (*String cmd, **untyped opt) -> String?
+
         def sh!: (*String cmd, **untyped opt) -> String
 
-        def format_config_entry: (Config::gem_entry) -> String
+        def format_config_entry: (String name, String version) -> String
+
+        type metadata = { 'name' => String, 'version' => String, 'source' => source_entry }
+
+        def metadata_content: (name: String, version: String) -> metadata
+
+        # Write `.rbs_meta.yaml`
+        def write_metadata: (dir: Pathname, name: String, version: String) -> void
+
+        # Load `.rbs_meta.yaml` from the `dir`, where is the destination of the RBS file installation, and return the cleaned up content
+        #
+        def load_metadata: (dir: Pathname) -> metadata
+
+        def gems_versions: () -> Hash[String, Set[String]]
+      end
+
+      class Local
+        include Base
+
+        type source_entry = {
+          'type' => 'local',
+          'path' => String,
+        }
+
+        attr_reader path: Pathname
+        attr_reader full_path: Pathname
+
+        def initialize: (path: String, base_directory: Pathname) -> void
+
+        def has?: (String name, String? version) -> boolish
+
+        def versions: (String name) -> Array[String]
+
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        def manifest_of: (String name, String version) -> manifest_entry?
+
+        private
+
+        def _install: (Pathname src, Pathname dest) -> void
       end
 
       # signatures that are bundled in rbs gem under the stdlib/ directory
@@ -101,19 +169,19 @@ module RBS
         # polyfill of singleton module
         def self.instance: () -> instance
 
-        def has?: (Config::gem_entry) -> boolish
+        def has?: (String name, String? version) -> boolish
 
-        def versions: (Config::gem_entry) -> Array[String]
+        def versions: (String name) -> Array[String]
 
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
 
         def to_lockfile: () -> source_entry
 
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+        def manifest_of: (String name, String version) -> manifest_entry?
 
         private
 
-        def lookup: (Config::gem_entry) -> Pathname?
+        def lookup: (String name, String? version) -> Pathname?
       end
 
       # sig/ directory
@@ -127,15 +195,19 @@ module RBS
         # polyfill of singleton module
         def self.instance: () -> instance
 
-        def has?: (Config::gem_entry) -> boolish
-        def versions: (Config::gem_entry) -> Array[String]
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def has?: (String name, String? version) -> boolish
+
+        def versions: (String name) -> Array[String]
+
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
+
         def to_lockfile: () -> source_entry
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
+        def manifest_of: (String name, String version) -> manifest_entry?
 
         private
 
-        def gem_sig_path: (Config::gem_entry) -> [Gem::Specification, Pathname]?
+        def gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
       end
     end
   end

data/sig/constant.rbs

@@ -2,7 +2,7 @@ module RBS
   class Constant
     type constant_entry = Environment::ClassEntry
                         | Environment::ModuleEntry
-                        | Environment::SingleEntry[TypeName, AST::Declarations::Constant]
+                        | Environment::ConstantEntry
 
     attr_reader name: TypeName
 

data/sig/declarations.rbs

@@ -1,7 +1,7 @@
 module RBS
   module AST
     module Declarations
-      type t = Class | Module | Interface | Constant | Global | Alias
+      type t = Class | Module | Interface | Constant | Global | TypeAlias | ClassAlias | ModuleAlias
 
       class Base
       end
@@ -77,6 +77,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?super_class: Super?, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Class
+
         include _HashEqual
         include _ToJson
       end
@@ -131,11 +133,13 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?location: loc?, ?annotations: Array[Annotation], ?self_types: Array[Self], ?comment: Comment?) -> Declarations::Module
+
         include _HashEqual
         include _ToJson
       end
 
-      class Interface
+      class Interface < Base
         type member = Members::t
 
         # interface _Foo end
@@ -160,13 +164,15 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Interface
+
         include MixinHelper
 
         include _HashEqual
         include _ToJson
       end
 
-      class Alias < Base
+      class TypeAlias < Base
         # type loc[T] = Location[T, bot]
         # ^^^^                            keyword
         #      ^^^                        name
@@ -223,6 +229,39 @@ module RBS
         include _HashEqual
         include _ToJson
       end
+
+      class AliasDecl < Base
+        # module Foo = Bar
+        # ^^^^^^             keyword
+        #        ^^^         new_name
+        #            ^       eq
+        #              ^^^   old_name
+        #
+        # class Foo = Bar
+        # ^^^^^              keyword
+        #
+        type loc = Location[:keyword | :new_name | :eq | :old_name, bot]
+
+        attr_reader new_name: TypeName
+
+        attr_reader old_name: TypeName
+
+        attr_reader location: loc?
+
+        attr_reader comment: Comment?
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class ClassAlias < AliasDecl
+        include _ToJson
+      end
+
+      class ModuleAlias < AliasDecl
+        include _ToJson
+      end
     end
   end
 end