rbs 0.14.0 → 0.18.1

data/sig/constant_table.rbs

@@ -19,7 +19,7 @@ module RBS
 
     def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
 
-    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: bool) -> Constant?
+    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: boolish) -> Constant?
 
     def constant_scopes: (TypeName) -> Array[Namespace]
 

data/sig/declarations.rbs

@@ -14,7 +14,7 @@ module RBS
           attr_reader variance: variance
           attr_reader skip_validation: bool
 
-          def initialize: (name: Symbol, variance: variance, skip_validation: bool) -> void
+          def initialize: (name: Symbol, variance: variance, skip_validation: boolish) -> void
 
           include _ToJson
         end

data/sig/definition.rbs

@@ -18,16 +18,16 @@ module RBS
       class TypeDef
         attr_reader type: MethodType
         attr_reader member: method_member
-        attr_reader defined_in: TypeName?
+        attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName?, implemented_in: TypeName?) -> void
+        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?) -> void
 
         def comment: () -> AST::Comment?
 
         def annotations: () -> Array[AST::Annotation]
 
-        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName?, ?implemented_in: TypeName?) -> TypeDef
+        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
         def overload?: () -> bool
       end
@@ -42,8 +42,13 @@ module RBS
       attr_reader comments: Array[AST::Comment]
       attr_reader annotations: Array[AST::Annotation]
       attr_reader members: Array[method_member]
+      attr_reader alias_of: Method?
 
-      def initialize: (super_method: Method?, defs: Array[TypeDef], accessibility: accessibility, ?annotations: Array[AST::Annotation]) -> void
+      def initialize: (super_method: Method?,
+                       defs: Array[TypeDef],
+                       accessibility: accessibility,
+                       alias_of: Method?,
+                       ?annotations: Array[AST::Annotation]) -> void
 
       def public?: () -> bool
 

data/sig/definition_builder.rbs

@@ -61,6 +61,8 @@ module RBS
 
     def ensure_namespace!: (Namespace, location: Location?) -> void
 
+    def build_singleton: (TypeName) -> Definition
+
     def build_instance: (TypeName) -> Definition
 
     def build_interface: (TypeName) -> Definition
@@ -69,11 +71,12 @@ module RBS
 
     def build_one_singleton: (TypeName) -> Definition
 
+    type ancestors = Definition::InstanceAncestors | Definition::SingletonAncestors | nil
     def merge_definitions: (TypeName,
                             Array[[Definition::Ancestor::t, Definition]],
                             entry: Environment::ModuleEntry | Environment::ClassEntry,
                             self_type: Definition::self_type,
-                            ancestors: Array[Definition::Ancestor::t]) -> Definition
+                            ancestors: ancestors) -> Definition
 
     type method_kind = :instance | :singleton
     def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, kind: method_kind) -> void

data/sig/environment_loader.rbs

@@ -1,58 +1,104 @@
 module RBS
+  # EnvironmentLoader is an object to load RBS files from filesystem.
+  # 
+  # Set up your configuration through repository and `#add` method.
+  # 
+  #   # Set up the repository to load library RBSs from.
+  #   repo = RBS::Repository.default
+  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
+  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # 
+  #   loader = RBS::EnvironmentLoader.new(repository: repo)
+  # 
+  #   # Add libraries to load RBS files.
+  #   loader.add(library: "minitest")
+  #   loader.add(library: "rbs", version: "1.0.0")
+  # 
+  #   # Add dirs to load RBS files from.
+  #   loader.add(path: Pathname("sig"))
+  # 
+  #   # Load RBSs into an environment.
+  #   environment = RBS::Environment.new()
+  #   loader.load(env: environment)
+  # 
   class EnvironmentLoader
-    class UnknownLibraryNameError < StandardError
-      attr_reader name: String
-
-      def initialize: (name: String) -> void
-    end
-
-    class LibraryPath
-      attr_reader name: String
-      attr_reader path: Pathname
+    class UnknownLibraryError < StandardError
+      attr_reader library: Library
 
-      def initialize: (name: String, path: Pathname) -> void
+      def initialize: (lib: Library) -> void
     end
 
-    class GemPath
+    class Library < Struct[String | String?]
       attr_reader name: String
       attr_reader version: String?
-      attr_reader path: Pathname
 
-      def initialize: (name: String, version: String?, path: Pathname) -> void
+      def initialize: (name: String, version: String?) -> void
     end
 
-    STDLIB_ROOT: Pathname
-
-    type path = Pathname | LibraryPath | GemPath
-
-    attr_reader paths: Array[path]
-    attr_reader stdlib_root: Pathname
-    attr_reader gem_vendor_path: Pathname?
-
-    def self.gem_sig_path: (String, String?) -> Pathname?
-
-    def initialize: (?stdlib_root: Pathname, ?gem_vendor_path: Pathname?) -> void
-
-    def add: (path: Pathname?) -> void
-           | (library: String?) -> void
-
-    def self.parse_library: (String) -> [String, String?]
-
-    def stdlib?: (String) -> Pathname?
-
-    def gem?: (String, String?) -> Pathname?
-
-    def each_signature: (Pathname, ?immediate: bool) { (Pathname) -> void } -> void
-                      | (Pathname, ?immediate: bool) -> Enumerator[Pathname, void]
-
-    def each_library_path: { (path, Pathname) -> void } -> void
-
-    def no_builtin!: (?bool) -> self
-
-    def no_builtin?: () -> bool
-
-    def each_decl: () { (AST::Declarations::t, Buffer, Pathname, path | :stdlib) -> void } -> void
-
-    def load: (env: Environment) -> Array[[AST::Declarations::t, Pathname, path | :stdlib]]
+    DEFAULT_CORE_ROOT: Pathname
+
+    attr_reader core_root: Pathname?
+    attr_reader repository: Repository
+
+    attr_reader libs: Array[Library]
+    attr_reader dirs: Array[Pathname]
+
+    # The source where the RBS comes from.
+    # 
+    # `:core` means it is part of core library.
+    # `Library` means it is from library.
+    # `Pathname` means it is loaded from a directory.
+    # 
+    type source = :core
+                | Library
+                | Pathname
+
+    # Accepts two optional keyword arguments.
+    # 
+    # `core_root` is the path to the directory with RBSs for core classes.
+    # The default value is the core library included in RBS gem. (EnvironmentLoader::DEFAULT_CORE_ROOT)
+    # Passing `nil` means it skips loading core class definitions.
+    # 
+    # `repository` is the repository for library classes.
+    # The default value is repository only with stdlib classes. (Repository.new)
+    # 
+    def initialize: (?core_root: Pathname?, ?repository: Repository) -> void
+    
+    # Add a path or library to load RBSs from.
+    # 
+    # `path` can be a file or a directory.
+    # All `.rbs` files from the given directory will be loaded.
+    # Specifying a file will load the file regardless the extension of the file is.
+    # 
+    # `library` can be a name of a gem.
+    # Specifying `nil` to `version` will load any version available.
+    # It first tries to load RBS files from gem with specified version.
+    # If RBS files cannot be found in the gem, it tries to load RBSs from repository.
+    # 
+    def add: (path: Pathname) -> void
+           | (library: String, version: String?) -> void
+
+    # This is helper function to test if RBS for a library is available or not.
+    # 
+    def has_library?: (library: String, version: String?) -> bool
+
+    # Add all declarations to environment.
+    # 
+    # Raises `UnknownLibraryError` if RBS cannot be loaded from a library.
+    # 
+    # Returns an array of tuples of the declaration, path to the file, and the source.
+    # 
+    def load: (env: Environment) -> Array[[AST::Declarations::t, Pathname, source]]
+
+    # Returns a pair of spec and path for a gem with RBS.
+    # Returns nil if the gem is not installed, or the gem doesn't provide RBS.
+    # 
+    def self.gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
+
+    def each_decl: () { (AST::Declarations::t, Buffer, source, Pathname) -> void } -> void
+                 
+    def each_dir: { (source, Pathname) -> void } -> void
+                
+    def each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
   end
 end

data/sig/members.rbs

@@ -23,7 +23,7 @@ module RBS
         attr_reader comment: Comment?
         attr_reader overload: bool
 
-        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: Location?, comment: Comment?, overload: bool) -> void
+        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: Location?, comment: Comment?, overload: boolish) -> void
 
         include _HashEqual
         include _ToJson
@@ -34,7 +34,7 @@ module RBS
 
         def overload?: () -> bool
 
-        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: Location?, ?comment: Comment?, ?overload: bool) -> MethodDefinition
+        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: Location?, ?comment: Comment?, ?overload: boolish) -> MethodDefinition
       end
 
       module Var

data/sig/method_types.rbs

@@ -4,7 +4,7 @@ module RBS
       attr_reader type: Types::Function
       attr_reader required: bool
 
-      def initialize: (type: Types::Function, required: bool) -> void
+      def initialize: (type: Types::Function, required: boolish) -> void
 
       def ==: (untyped other) -> bool
 

data/sig/namespace.rbs

@@ -28,7 +28,7 @@ module RBS
   class Namespace
     attr_reader path: Array[Symbol]
 
-    def initialize: (path: Array[Symbol], absolute: bool) -> void
+    def initialize: (path: Array[Symbol], absolute: boolish) -> void
 
     # Returns new _empty_ namespace.
     def self.empty: () -> Namespace

data/sig/polyfill.rbs

@@ -1,3 +1,45 @@
 module Kernel
   def to_json: (*untyped) -> String
 end
+
+module Gem
+  class Version
+    def self.correct?: (String) -> bool
+
+    def self.create: (String?) -> instance?
+
+    include Comparable
+
+    def prerelease?: () -> bool
+
+    def release: () -> self
+
+    def version: () -> String
+  end
+
+  class Specification
+    attr_reader version (): Version
+
+    attr_reader gem_dir (): String
+
+    def self.find_by_name: (String name, ?String? version) -> instance
+  end
+end
+
+class OptionParser
+  def initialize: () ?{ (instance) -> void } -> void
+                
+  def on: (*String) { (String) -> void } -> void
+        
+  attr_accessor version: String
+  
+  attr_accessor banner: String
+
+  def order!: (Array[String]) -> void
+            
+  def parse!: (Array[String]) -> void
+            
+  def ver: () -> String
+         
+  def help: () -> String
+end

data/sig/rbs.rbs

@@ -1,3 +1,11 @@
 module RBS
   def self.logger: () -> Logger
+                 
+  def self.logger_level: () -> untyped
+                  
+  def self.logger_level=: (untyped) -> untyped
+                   
+  def self.logger_output: () -> IO
+                   
+  def self.logger_output=: (IO) -> IO
 end

data/sig/repository.rbs

@@ -0,0 +1,79 @@
+module RBS
+  # Set of RBS repositories.
+  #
+  # A repository object can handle multiple repository roots.
+  #
+  #   repo = RBS::Repository.new()
+  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
+  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  #   repo.add(Pathname("vendor/rbs/definitely-rbs"))
+  #
+  #   repo.lookup("minitest", "2.1.3") => Pathname or nil
+  #
+  # If one gem version can resolve to several directories, the last added dir wins.
+  #
+  class Repository
+    class GemRBS
+      attr_reader name: String
+
+      # Array of gem dirs.
+      # Gem dir contains directories for each version.
+      attr_reader paths: Array[Pathname]
+
+      # Hash from a version to VersionPath object.
+      attr_reader versions(): Hash[Gem::Version, VersionPath]
+
+      @versions: Hash[Gem::Version, VersionPath]?
+
+      def initialize: (name: String) -> void
+
+      def load!: () -> void
+
+      def version_names: () -> Array[Gem::Version]
+
+      def oldest_version: () -> VersionPath
+
+      def latest_version: () -> VersionPath
+
+      def find_best_version: (Gem::Version?) -> VersionPath
+
+      # Returns true if versions is empty.
+      def empty?: () -> bool
+    end
+
+    class VersionPath
+      attr_reader gem: GemRBS
+      attr_reader version: Gem::Version
+      attr_reader path: Pathname
+
+      def initialize: (gem: GemRBS, version: Gem::Version, path: Pathname) -> void
+    end
+
+    DEFAULT_STDLIB_ROOT: Pathname
+
+    # Array of _root dir_s of repositories.
+    #
+    attr_reader dirs: Array[Pathname]
+
+    attr_reader gems: Hash[String, GemRBS]
+
+    # An optional keyword argument `no_stdlib` is to skip adding directory for stdlib classes.
+    # Passing truthy value will skip loading stdlib. (You can add the stdlib root by yourself.)
+    #
+    def initialize: (?no_stdlib: bool) -> void
+
+    # Add new _root dir_ to the repository set.
+    # If two repository dirs have exactly same gem-version definitions, the latter overwrites the prior.
+    #
+    def add: (Pathname dir) -> void
+
+    # Returns a directory for given `gem` name and `version`.
+    # `version` can be `nil` for _any version_.
+    #
+    # If the given gem cannot be found, it returns `nil`.
+    #
+    def lookup: (String gem, String? version) -> Pathname?
+
+    def lookup_path: (String gem, String? version) -> [GemRBS, VersionPath]?
+  end
+end

data/sig/vendorer.rbs

@@ -0,0 +1,44 @@
+module RBS
+  # Copies RBS files loaded through `loader` under `vendor_dir`.
+  # 
+  # Core libraries and library RBS files will be copied.
+  # 
+  #   loader = RBS::EnvironmentLoader.new()
+  # 
+  #   loader.add(library: set)               # Libraries will be copied.
+  #   loader.add(library: "minitest", version: "1.2.3")
+  # 
+  #   loader.add(path: Pathname("sig"))      # Dirs will be ignored.
+  # 
+  #   vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
+  #   vendorer.clearn!
+  #   vendorer.copy!
+  # 
+  # The result will be:
+  #   vendor/rbs/core            => Will include core RBSs
+  #   vendor/rbs/set-0           => Will include `set` library RBSs.
+  #   vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
+  # 
+  # The vendorerd RBSs will be loaded through :dir source.
+  # 
+  #   loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
+  #   loader.add(path: Pathname("vendor/rbs"))
+  #   loader.add(path: Pathname("sig"))
+  # 
+  class Vendorer
+    attr_reader vendor_dir: Pathname
+    attr_reader loader: EnvironmentLoader
+
+    def initialize: (vendor_dir: Pathname, loader: EnvironmentLoader) -> void
+    
+    # Copy RBS files into `vendor_dir`.
+    # Ensures the `vendor_dir` exists.
+    def copy!: () -> void
+
+    # Deletes `vendor_dir` and its content if exists.
+    # 
+    def clean!: () -> void
+    
+    def ensure_dir: [A] () { () -> A } -> A
+  end
+end