rbs 0.13.0 → 0.17.0

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

@@ -1,6 +1,6 @@
 module RBS
   # Namespace instance represents a _prefix of module names_.
-  # 
+  #
   #    vvvvvvvvvvvvvv  TypeName
   #    RBS::Namespace
   #    ^^^^^           Namespace
@@ -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
@@ -44,7 +44,7 @@ module RBS
     # If `other` is an absolute namespace, it returns `other`.
     #
     #   Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
-    # 
+    #
     def +: (Namespace other) -> Namespace
 
     # Add one path component to self.
@@ -62,7 +62,7 @@ module RBS
 
     # Returns true if self is absolute namespace.
     def absolute?: () -> bool
-    
+
     # Returns true if self is relative namespace.
     def relative?: () -> bool
 

data/sig/parser.rbs

@@ -0,0 +1,25 @@
+module RBS
+  class Parser
+    class SyntaxError < StandardError
+      attr_reader token_str: String
+      attr_reader error_value: untyped
+      attr_reader value_stack: untyped?
+
+      def initialize: (token_str: String, error_value: untyped, ?value_stack: untyped?) -> void
+    end
+
+    class SemanticsError < StandardError
+      attr_reader subject: untyped
+      attr_reader location: Location
+      attr_reader original_message: String
+
+      def initialize: (String message, subject: untyped, location: Location) -> void
+    end
+
+    def self.parse_method_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> MethodType
+                              
+    def self.parse_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> Types::t
+                       
+    def self.parse_signature: (String | Buffer, ?eof_re: Regexp?) -> Array[AST::Declarations::t]
+  end
+end

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/substitution.rbs

@@ -1,6 +1,6 @@
 module RBS
   # Substitution from type variables to types.
-  # 
+  #
   # The substitution construction is in _destructive_ manner.
   #
   #    sub = Substitution.new
@@ -25,7 +25,7 @@ module RBS
     # Utility method to construct a substitution.
     # Raises an error when `variables.size != types.size`.
     # `instance_type` defaults to `nil`.
-    # 
+    #
     # Yields types in `types` and the block value is used if block is given.
     #
     def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
@@ -36,4 +36,4 @@ module RBS
     # Returns a substitution without variables given in `vars`.
     def without: (*Symbol vars) -> Substitution
   end
-end
+end

data/sig/typename.rbs

@@ -1,6 +1,6 @@
 module RBS
   # TypeName represents name of types in RBS.
-  # 
+  #
   # TypeNames are one of the three kind, class, alias, and interface.
   # *class* type names corresponds to Ruby classes and modules.
   # There are no corresponding Ruby value to *alias* and *interface* type names.

data/sig/types.rbs

@@ -154,7 +154,7 @@ module RBS
 
       include NoFreeVariables
       include NoSubst
-      include EmptyEachType      
+      include EmptyEachType
     end
 
     module Application

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

data/sig/writer.rbs

@@ -4,37 +4,37 @@ module RBS
     attr_reader indentation: Array[String]
 
     def initialize: (out: IO) -> void
-                  
+
     def indent: (?Integer size) { () -> void } -> void
-              
+
     def prefix: () -> String
-              
+
     def puts: (?String) -> void
-            
+
     def write_annotation: (Array[AST::Annotation]) -> void
-                        
+
     def write_comment: (AST::Comment?) -> void
-                     
+
     def write: (Array[AST::Declarations::t]) -> void
-             
+
     def write_decl: (AST::Declarations::t) -> void
-                  
+
     def write_member: (AST::Declarations::Module::member) -> void
-                  
+
     def name_and_params: (TypeName, AST::Declarations::ModuleTypeParams) -> String?
-                       
+
     def name_and_args: (TypeName, Array[Types::t]) -> String?
-                     
+
     def method_name: (Symbol) -> String
-                   
+
     def write_def: (AST::Members::MethodDefinition) -> void
-                 
+
     def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
-                 
+
     interface _Located
       def location: () -> Location?
     end
-                 
+
     def preserve_empty_line: (_Located?, _Located) -> void
   end
 end

data/stdlib/base64/{base64.rbs → 0/base64.rbs}

@@ -67,5 +67,5 @@ module Base64
   # 64 Encoding with URL and Filename Safe Alphabet'' in RFC 4648. The alphabet
   # uses '-' instead of '+' and '_' instead of '/'. Note that the result can still
   # contain '='. You can remove the padding by setting `padding` as false.
-  def self?.urlsafe_encode64: (String bin, ?padding: bool) -> String
+  def self?.urlsafe_encode64: (String bin, ?padding: boolish) -> String
 end

data/stdlib/benchmark/{benchmark.rbs → 0/benchmark.rbs}

@@ -53,9 +53,9 @@
 #     times:    1.000000   0.000000   1.000000 (  1.003611)
 #     upto:     1.030000   0.000000   1.030000 (  1.028098)
 #
-# *   The times for some benchmarks depend on the order in which items are run. 
+# *   The times for some benchmarks depend on the order in which items are run.
 #     These differences are due to the cost of memory allocation and garbage
-#     collection. To avoid these discrepancies, the #bmbm method is provided. 
+#     collection. To avoid these discrepancies, the #bmbm method is provided.
 #     For example, to compare ways to sort an array of floats:
 #
 #         require 'benchmark'

data/stdlib/coverage/{coverage.rbs → 0/coverage.rbs}

@@ -49,7 +49,7 @@ module Coverage
   # `clear` is true, it clears the counters to zero. If `stop` is true, it
   # disables coverage measurement.
   #
-  def self.result: (?stop: bool, ?clear: bool) -> Hash[String, untyped]
+  def self.result: (?stop: boolish, ?clear: boolish) -> Hash[String, untyped]
 
   # Returns true if coverage stats are currently being collected (after
   # Coverage.start call, but before Coverage.result call)
@@ -58,5 +58,5 @@ module Coverage
 
   # Enables coverage measurement.
   #
-  def self.start: (?lines: bool, ?branches: bool, ?methods: bool, ?oneshot_lines: bool) -> nil
+  def self.start: (?lines: boolish, ?branches: boolish, ?methods: boolish, ?oneshot_lines: boolish) -> nil
 end

data/stdlib/csv/{csv.rbs → 0/csv.rbs}

@@ -159,7 +159,7 @@
 # with it.
 #
 class CSV < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # This method is intended as the primary interface for reading CSV files. You
   # pass a `path` and any `options` you wish to set for the read. Each row of file
@@ -407,7 +407,7 @@ CSV::VERSION: String
 # processing is activated.
 #
 class CSV::Row < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # If a two-element Array is provided, it is assumed to be a header and field and
   # the pair is appended. A Hash works the same way with the key being the header
@@ -578,7 +578,7 @@ end
 # processing is activated.
 #
 class CSV::Table[out Elem] < Object
-  include Enumerable[untyped, untyped]
+  include Enumerable[untyped]
 
   # Constructs a new CSV::Table from `array_of_rows`, which are expected to be
   # CSV::Row objects. All rows are assumed to have the same headers.
@@ -755,7 +755,7 @@ class CSV::Table[out Elem] < Object
   # This method assumes you want the Table.headers(), unless you explicitly pass
   # `:write_headers => false`.
   #
-  def to_csv: (?write_headers: bool, **untyped) -> untyped
+  def to_csv: (?write_headers: boolish, **untyped) -> untyped
 
   alias to_s to_csv
 

data/stdlib/date/{date.rbs → 0/date.rbs}

@@ -178,7 +178,7 @@ class Date
   #
   #     Date._parse('2001-02-03') #=> {:year=>2001, :mon=>2, :mday=>3}
   #
-  def self._parse: (String str, ?bool complete) -> Hash[Symbol, Integer]
+  def self._parse: (String str, ?boolish complete) -> Hash[Symbol, Integer]
 
   # Returns a hash of parsed elements.
   #
@@ -318,7 +318,7 @@ class Date
   #
   def self.ordinal: (?Integer year, ?Integer yday, ?Integer start) -> Date
 
-  # Parses the given representation of date and time, and creates a date object. 
+  # Parses the given representation of date and time, and creates a date object.
   # This method does not function as a validator.
   #
   # If the optional second argument is true and the detected year is in the range
@@ -328,7 +328,7 @@ class Date
   #     Date.parse('20010203')            #=> #<Date: 2001-02-03 ...>
   #     Date.parse('3rd Feb 2001')        #=> #<Date: 2001-02-03 ...>
   #
-  def self.parse: (String str, ?bool complete, ?Integer start) -> Date
+  def self.parse: (String str, ?boolish complete, ?Integer start) -> Date
 
   # Creates a new Date object by parsing from a string according to some typical
   # RFC 2822 formats.
@@ -448,7 +448,7 @@ class Date
   #
   def +: (Integer | Rational other) -> Date
 
-  # Returns the difference between the two dates if the other is a date object. 
+  # Returns the difference between the two dates if the other is a date object.
   # If the other is a numeric value, returns a date object pointing `other` days
   # before self.  If the other is a fractional number, assumes its precision is at
   # most nanosecond.