rbs-relaxed 3.9.0.1

data/sig/cli.rbs

@@ -0,0 +1,87 @@
+module RBS
+  class CLI
+    class LibraryOptions
+      attr_accessor core_root: Pathname?
+      attr_accessor config_path: Pathname?
+
+      attr_reader libs: Array[String]
+      attr_reader dirs: Array[String]
+      attr_reader repos: Array[String]
+
+      def initialize: () -> void
+
+      def loader: () -> EnvironmentLoader
+
+      def setup_library_options: (OptionParser) -> OptionParser
+    end
+
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def tty?: () -> bool
+
+      def print: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    attr_reader stdout: _IO
+    attr_reader stderr: _IO
+
+    # The copy of `args` passed to `run`.
+    #
+    # `OptionParser#order!` mutates given `arg`, the `run_***` actions should read `original_args` to get the original commandline arguments.
+    #
+    # Returns `nil` if called before `#run` call.
+    #
+    attr_reader original_args: Array[String]
+
+    def initialize: (stdout: IO, stderr: IO) -> void
+
+    COMMANDS: Array[Symbol]
+
+    def library_parse: (OptionParser, options: LibraryOptions) -> void
+
+    def parse_logging_options: (OptionParser) -> void
+
+    def has_parser?: () -> bool
+
+    def run: (Array[String] args) -> void
+
+    def run_ast: (Array[String], LibraryOptions) -> void
+
+    def run_list: (Array[String], LibraryOptions) -> void
+
+    def run_ancestors: (Array[String], LibraryOptions) -> void
+
+    def run_methods: (Array[String], LibraryOptions) -> void
+
+    def run_method: (Array[String], LibraryOptions) -> void
+
+    def run_validate: (Array[String], LibraryOptions) -> void
+
+    def run_constant: (Array[String], LibraryOptions) -> void
+
+    def run_paths: (Array[String], LibraryOptions) -> void
+
+    def run_prototype: (Array[String], LibraryOptions) -> void
+
+    def run_prototype_file: (String format, Array[String]) -> void
+
+    def run_vendor: (Array[String], LibraryOptions) -> void
+
+    def run_parse: (Array[String], LibraryOptions) -> void
+
+    def run_test: (Array[String], LibraryOptions) -> void
+
+    def run_collection: (Array[String], LibraryOptions) -> void
+
+    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
+  end
+end

data/sig/collection/cleaner.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module Collection
+    class Cleaner
+      attr_reader lock: Config
+
+      def initialize: (lockfile_path: Pathname) -> void
+
+      def clean: () -> void
+
+      def needed?: (String gem_name, String version) -> bool
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module RBS
+  module Collection
+    # This class represent the configuration file.
+    class Config
+      class CollectionNotAvailable < StandardError
+        def initialize: () -> void
+      end
+
+      PATH: Pathname
+
+      type gem_entry = {
+        'name' => String,
+        'version' => String?,
+        'ignore' => boolish,
+        'source' => Sources::source_entry?
+      }
+
+      attr_reader config_path: Pathname
+
+      attr_reader data: untyped
+
+      @sources: Array[Sources::_Source]
+
+      def self.find_config_path: () -> Pathname?
+
+      def self.generate_lockfile: (config_path: Pathname, definition: Bundler::Definition, ?with_lockfile: boolish) -> [Config, Lockfile]
+
+      def self.from_path: (Pathname 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 gem: (String gem_name) -> gem_entry?
+
+      def repo_path: () -> Pathname
+
+      def repo_path_data: () -> Pathname
+
+      def sources: () -> Array[Sources::t]
+
+      def gems: () -> Array[gem_entry]
+    end
+  end
+end

data/sig/collection/installer.rbs

@@ -0,0 +1,17 @@
+module RBS
+  module Collection
+    class Installer
+      attr_reader lockfile: Config::Lockfile
+      attr_reader stdout: CLI::_IO
+
+      def initialize: (lockfile_path: Pathname, ?stdout: CLI::_IO) -> void
+      def install_from_lockfile: () -> void
+
+      private
+
+      @source_for: Hash[Sources::source_entry, Sources::_Source]
+
+      def source_for: (Config::gem_entry) -> Sources::_Source
+    end
+  end
+end

data/sig/collection/sources.rbs

@@ -0,0 +1,214 @@
+module RBS
+  module Collection
+    module Sources
+      def self.from_config_entry: (Git::source_entry, base_directory: Pathname) -> Git
+                                | (source_entry, base_directory: Pathname) -> t
+
+      interface _Source
+        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?
+        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[manifest_dependency]?,
+      }
+
+      type manifest_dependency = { "name" => String }
+
+      module Base : _Source
+        def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
+      end
+
+      class Git
+        include Base
+
+        METADATA_FILENAME: String
+
+        type source_entry = {
+          'type' => 'git',
+          'name' => String,
+          'remote' => String,
+          'revision' => String,
+          'repo_dir' => String?,
+        }
+
+        class CommandError < StandardError
+        end
+
+        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?: (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?
+
+        def resolved_revision: () -> String
+
+        private
+
+        @need_setup: bool
+
+        @git_dir: Pathname?
+
+        @resolved_revision: String?
+
+        @gems_versions: Hash[String, Set[String]]?
+
+        def _install: (dest: Pathname , name: String, version: String) -> void
+
+        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
+
+        # 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: (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
+      class Stdlib
+
+        REPO: Repository
+
+        include Base
+
+        type source_entry =  {
+          'type' => 'stdlib',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        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 lookup: (String name, String? version) -> Pathname?
+      end
+
+      # sig/ directory
+      class Rubygems
+        include Base
+
+        type source_entry = {
+          'type' => 'rubygems',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        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 gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
+      end
+    end
+  end
+end

data/sig/collection.rbs

@@ -0,0 +1,4 @@
+module RBS
+  module Collection
+  end
+end

data/sig/comment.rbs

@@ -0,0 +1,26 @@
+module RBS
+  module AST
+    # RBS allows writing documentation of declarations and members.
+    #
+    # ```
+    # # This is a doc for class.
+    # class Hello
+    # end
+    # ```
+    #
+    class Comment
+      attr_reader string: String
+      attr_reader location: Location[bot, bot]?
+
+      def initialize: (string: String, location: Location[bot, bot]?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      include _ToJson
+    end
+  end
+end

data/sig/constant.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class Constant
+    type constant_entry = Environment::ClassEntry
+                        | Environment::ModuleEntry
+                        | Environment::ConstantEntry
+
+    attr_reader name: TypeName
+
+    attr_reader type: Types::t
+
+    attr_reader entry: constant_entry
+
+    def initialize: (name: TypeName, type: Types::t, entry: constant_entry) -> void
+
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    def hash: () -> Integer
+  end
+end