rbs 0.3.1 → 0.4.0

data/stdlib/builtin/encoding.rbs

@@ -173,6 +173,8 @@ Encoding::Big5_HKSCS_2008: Encoding
 
 Encoding::Big5_UAO: Encoding
 
+Encoding::CESU_8: Encoding
+
 Encoding::CP1250: Encoding
 
 Encoding::CP1251: Encoding

data/stdlib/builtin/enumerable.rbs

@@ -385,7 +385,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
                 | () { (Elem arg0) -> untyped } -> self
 
   # variadic type parameter is not supported yet
-  # https://github.com/ruby/ruby-signature/issues/21
+  # https://github.com/ruby/rbs/issues/21
   def zip: [Elem2, Return2] (::Enumerable[Elem2, Return2] enum) -> ::Array[[Elem, Elem2 | nil]]
          | [U, Elem2, Return2] (::Enumerable[Elem2, Return2]) { ([Elem, Elem2 | nil]) -> U } -> nil
 

data/stdlib/builtin/enumerator.rbs

@@ -250,9 +250,11 @@ class Enumerator::Lazy[out Elem, out Return] < Enumerator[Elem, Return]
 end
 
 class Enumerator::Yielder < Object
-  def <<: (*untyped arg0) -> void
+  def <<: (untyped arg0) -> void
 
   def yield: (*untyped arg0) -> void
+
+  def to_proc: () -> Proc
 end
 
 class Enumerator::Chain[out Elem, out Return] < Object

data/stdlib/builtin/fiber.rbs

@@ -62,7 +62,11 @@
 class Fiber < Object
   def self.yield: (*untyped args) -> untyped
 
-  def initialize: () { () -> void } -> Fiber
+  def initialize: () { () -> untyped } -> void
 
   def resume: (*untyped args) -> untyped
+
+  def raise: () -> untyped
+           | (string message) -> untyped
+           | (_Exception exception, ?string message, ?Array[String] backtrace) -> untyped
 end

data/stdlib/builtin/symbol.rbs

@@ -152,7 +152,7 @@ class Symbol
   # In general, `to_sym` returns the Symbol corresponding to an object. As *sym*
   # is already a symbol, `self` is returned in this case.
   #
-  def intern: () -> self
+  def intern: () -> Symbol
 
   # Same as `sym.to_s.length`.
   #

data/stdlib/fiber/fiber.rbs

@@ -0,0 +1,117 @@
+# Fibers are primitives for implementing light weight cooperative concurrency in
+# Ruby. Basically they are a means of creating code blocks that can be paused
+# and resumed, much like threads. The main difference is that they are never
+# preempted and that the scheduling must be done by the programmer and not the
+# VM.
+#
+# As opposed to other stackless light weight concurrency models, each fiber
+# comes with a stack.  This enables the fiber to be paused from deeply nested
+# function calls within the fiber block.  See the ruby(1) manpage to configure
+# the size of the fiber stack(s).
+#
+# When a fiber is created it will not run automatically. Rather it must be
+# explicitly asked to run using the Fiber#resume method. The code running inside
+# the fiber can give up control by calling Fiber.yield in which case it yields
+# control back to caller (the caller of the Fiber#resume).
+#
+# Upon yielding or termination the Fiber returns the value of the last executed
+# expression
+#
+# For instance:
+#
+#     fiber = Fiber.new do
+#       Fiber.yield 1
+#       2
+#     end
+#
+#     puts fiber.resume
+#     puts fiber.resume
+#     puts fiber.resume
+#
+# *produces*
+#
+#     1
+#     2
+#     FiberError: dead fiber called
+#
+# The Fiber#resume method accepts an arbitrary number of parameters, if it is
+# the first call to #resume then they will be passed as block arguments.
+# Otherwise they will be the return value of the call to Fiber.yield
+#
+# Example:
+#
+#     fiber = Fiber.new do |first|
+#       second = Fiber.yield first + 2
+#     end
+#
+#     puts fiber.resume 10
+#     puts fiber.resume 1_000_000
+#     puts fiber.resume "The fiber will be dead before I can cause trouble"
+#
+# *produces*
+#
+#     12
+#     1000000
+#     FiberError: dead fiber called
+#
+extension Fiber (Fiber)
+  # Returns the current fiber. You need to `require 'fiber'` before using this
+  # method. If you are not running in the context of a fiber this method will
+  # return the root fiber.
+  #
+  def self.current: () -> Fiber
+
+  public
+
+  # Returns true if the fiber can still be resumed (or transferred to). After
+  # finishing execution of the fiber block this method will always return false.
+  # You need to `require 'fiber'` before using this method.
+  #
+  def alive?: () -> bool
+
+  # Transfer control to another fiber, resuming it from where it last stopped or
+  # starting it if it was not resumed before. The calling fiber will be suspended
+  # much like in a call to Fiber.yield. You need to `require 'fiber'` before using
+  # this method.
+  #
+  # The fiber which receives the transfer call is treats it much like a resume
+  # call. Arguments passed to transfer are treated like those passed to resume.
+  #
+  # You cannot call `resume` on a fiber that has been transferred to. If you call
+  # `transfer` on a fiber, and later call `resume` on the the fiber, a
+  # `FiberError` will be raised. Once you call `transfer` on a fiber, the only way
+  # to resume processing the fiber is to call `transfer` on it again.
+  #
+  # Example:
+  #
+  #     fiber1 = Fiber.new do
+  #       puts "In Fiber 1"
+  #       Fiber.yield
+  #       puts "In Fiber 1 again"
+  #     end
+  #
+  #     fiber2 = Fiber.new do
+  #       puts "In Fiber 2"
+  #       fiber1.transfer
+  #       puts "Never see this message"
+  #     end
+  #
+  #     fiber3 = Fiber.new do
+  #       puts "In Fiber 3"
+  #     end
+  #
+  #     fiber2.resume
+  #     fiber3.resume
+  #     fiber1.resume rescue (p $!)
+  #     fiber1.transfer
+  #
+  # *produces*
+  #
+  #     In Fiber 2
+  #     In Fiber 1
+  #     In Fiber 3
+  #     #<FiberError: cannot resume transferred Fiber>
+  #     In Fiber 1 again
+  #
+  def transfer: (*untyped) -> untyped
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-22 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
 email:
@@ -191,6 +205,14 @@ files:
 - lib/rbs/writer.rb
 - lib/ruby/signature.rb
 - rbs.gemspec
+- schema/annotation.json
+- schema/comment.json
+- schema/decls.json
+- schema/function.json
+- schema/location.json
+- schema/members.json
+- schema/methodType.json
+- schema/types.json
 - stdlib/abbrev/abbrev.rbs
 - stdlib/base64/base64.rbs
 - stdlib/benchmark/benchmark.rbs
@@ -253,6 +275,7 @@ files:
 - stdlib/coverage/coverage.rbs
 - stdlib/csv/csv.rbs
 - stdlib/erb/erb.rbs
+- stdlib/fiber/fiber.rbs
 - stdlib/find/find.rbs
 - stdlib/ipaddr/ipaddr.rbs
 - stdlib/json/json.rbs