core-async 0.6.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32453e0ff3a28813b566b881be5fc88da0143249ac9164a332218a4c94799574
-  data.tar.gz: cb436adf5261d76f982b032996044ac379b1487b8e504a80641cc6c80aa5ba7a
+  metadata.gz: ad38e4e865f4be308699dde8ff3bfe22cf4873a7de3b2841d235d8a02c6a33f7
+  data.tar.gz: 04b405d8f2dbc07fcba33cb76871748165ac1b01c1337e21ea19e2dc225170af
 SHA512:
-  metadata.gz: 55253a5d64873e32794e5fa9fbc7497e1db49c99eeb0f673ce4ebdc70f33360ef547d5f676c1f13b3bef1f376493659305d1329753d758e5e3fd9ea0c20794c8
-  data.tar.gz: 80a4872f6d51426a1518f5b904413f5ed6296382a3d508268c04df3011bc7e28feb11f01f9df58e3998bc41db9afc53597a7d117df484f8eba35011aff019ce2
+  metadata.gz: e97c567a1f930b83302321229038a8cddb4c1be04dacc7986c78f8def3792adfc4e9b65e398dfc48ca482e4fb710de2189f9a09aec7e433495c5f8089ae9ecd5
+  data.tar.gz: 6fa8167bf7345e5b3d61f55a47938bc81cd84fa5c59156c0bd4c99456b632942c7b95f549add6ae9905da155479fb6950841f2a53170ce688b6b10fa69f3f9ed

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [v0.9.0](https://github.com/metabahn/corerb/releases/tag/2021-10-24)
+
+*released on 2021-10-24*
+
+  * `chg` [#82](https://github.com/metabahn/corerb/pull/82) Refactor to use a new fiber scheduler ([bryanp](https://github.com/bryanp))
+
+## [v0.8.0](https://github.com/metabahn/corerb/releases/tag/2021-07-15)
+
+*released on 2021-07-15*
+
+  * `add` [#50](https://github.com/metabahn/corerb/pull/50) Make all async objects inspectable ([bryanp](https://github.com/bryanp))
+
+## [v0.7.0](https://github.com/metabahn/corerb/releases/tag/2021-07-07)
+
+*released on 2021-07-07*
+
+  * `chg` [#38](https://github.com/metabahn/corerb/pull/38) Drop Ruby 2.6 support from core-async ([bryanp](https://github.com/bryanp))
+
+## [v0.6.1](https://github.com/metabahn/corerb/releases/tag/2021-05-20.1)
+
+*released on 2021-05-20*
+
+  * `fix` [#29](https://github.com/metabahn/corerb/pull/29) Actually disable the console logger ([bryanp](https://github.com/bryanp))
+
 ## [v0.6.0](https://github.com/metabahn/corerb/releases/tag/2021-05-20)
 
 *released on 2021-05-20*

data/lib/core/async/bootstrap.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
-require "async"
+require_relative "scheduler"
 
-# Turn the console logger off everywhere.
+# Define a top-level scheduler.
 #
-ENV["CONSOLE_LOGGER"] ||= "5"
+scheduler = Core::Async::Scheduler.new
+Fiber.set_scheduler(scheduler)
+
+# Automatically run the top-level scheduler at exit, blocking until all fibers are complete.
+#
+at_exit { scheduler.run }

data/lib/core/async/cancel.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "is/inspectable"
+
+module Core
+  module Async
+    # [public] Raised when the fiber is canceled.
+    #
+    class Cancel < RuntimeError
+      include Is::Inspectable
+    end
+  end
+end

data/lib/core/async/channel.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "is/inspectable"
+
+module Core
+  module Async
+    # [public] Channels let fibers wait on future published values.
+    #
+    class Channel
+      include Is::Inspectable
+      inspects without: [:@subscribers]
+
+      def initialize
+        @subscribers = []
+      end
+
+      # [public] Subscribe the current fiber, blocking until a value is published.
+      #
+      def subscribe
+        @subscribers << Fiber.current
+        Fiber.scheduler.transfer
+      end
+
+      # [public] Publish the given value to all subscribers.
+      #
+      def publish(value = nil)
+        subscribers = @subscribers
+        @subscribers = []
+
+        while (fiber = subscribers.shift)
+          if fiber.alive?
+            Fiber.scheduler.resume(fiber, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/async/collection.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "is/inspectable"
+
 require_relative "../../is/async"
 
 module Core
@@ -11,13 +13,13 @@ module Core
         # [public] Builds a collection from an enumerable object.
         #
         def build(object)
-          aware do
-            errored, stopped = false
-
-            values = object.map { |value|
-              break if errored || stopped
+          errored = false
+          stopped = false
+          values = []
 
-              async do
+          object.each do |value|
+            future = async {
+              begin
                 if block_given?
                   yield value
                 else
@@ -31,13 +33,22 @@ module Core
               end
             }
 
-            new(values) if values
+            unless stopped
+              values << future
+            end
+
+            if errored || stopped
+              break
+            end
           end
+
+          new(values)
         end
       end
 
       include Enumerable
       include Is::Async
+      include Is::Inspectable
 
       def initialize(values = [])
         unless values.respond_to?(:each)

data/lib/core/async/enumerator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "is/inspectable"
+
 require_relative "../../is/async"
 
 module Core
@@ -7,6 +9,7 @@ module Core
     class Enumerator
       include Enumerable
       include Is::Async
+      include Is::Inspectable
 
       def initialize(object)
         unless object.respond_to?(:each)
@@ -23,22 +26,24 @@ module Core
           return to_enum(:each)
         end
 
-        await do
-          errored, stopped = false
+        errored = false
+        stopped = false
+        futures = []
 
-          @object.each do |value|
-            break if errored || stopped
+        @object.each do |value|
+          break if errored || stopped
 
-            async do
-              yield value
-            rescue LocalJumpError
-              stopped = true
-            rescue => error
-              errored = true
-              raise error
-            end
+          futures << async do
+            yield value
+          rescue LocalJumpError
+            stopped = true
+          rescue => error
+            errored = true
+            raise error
           end
         end
+
+        futures.each(&:wait)
       end
     end
   end

data/lib/core/async/failure.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "is/inspectable"
+
+module Core
+  module Async
+    # [public] Raised internally to communicate a fiber error.
+    #
+    class Failure
+      include Is::Inspectable
+
+      def initialize(error)
+        @error = error
+      end
+
+      # [public] The original error.
+      #
+      attr_reader :error
+    end
+  end
+end

data/lib/core/async/filament.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "is/inspectable"
+
+require_relative "channel"
+
+module Core
+  module Async
+    # Internal object that wraps a fiber.
+    #
+    class Filament
+      include Is::Inspectable
+      inspects without: [:@object, :@channel, :@children, :@resolved]
+
+      def initialize
+        @object = nil
+        @channel = nil
+        @children = nil
+        @resolved = false
+        @value = nil
+      end
+
+      attr_accessor :object
+      attr_reader :children
+
+      def add_child(fiber)
+        (@children ||= []) << fiber
+      end
+
+      def resolve(value = nil)
+        unless @resolved
+          @value = value
+          @resolved = true
+          @channel&.publish(value)
+        end
+      end
+
+      def wait
+        if @resolved == false && @object&.alive?
+          (@channel ||= Channel.new).subscribe
+        else
+          @value
+        end
+      end
+    end
+  end
+end

data/lib/core/async/future.rb

@@ -1,51 +1,133 @@
 # frozen_string_literal: true
 
+require "is/inspectable"
+
+require_relative "cancel"
+require_relative "failure"
+require_relative "scheduler"
+
 module Core
   module Async
     # [public] Represents a future result.
     #
     class Future
-      def initialize(task)
-        @task = task
+      include Is::Inspectable
+      inspects without: [:@fiber, :@raised, :@scheduler, :@filament]
+
+      def initialize(&block)
         @error = nil
+        @result = nil
+        @status = :pending
+        @raised = false
+        @fiber = Fiber.schedule { |filament|
+          begin
+            @filament = filament
+            value = block.call
+            @result = resolve_value(value)
+            @status = :complete
+            @result
+          rescue Cancel
+            @status = :canceled
+            nil
+          rescue => error
+            @error = error
+            @status = :failed
+            raise error
+          end
+        }
       end
 
-      # [public] Wait on the future to resolve, returning self.
+      # [public] The current status; one of :pending, :failed, :canceled, or :complete.
+      #
+      attr_reader :status
+
+      # [public] Wait on the future to resolve (including children), returning self.
       #
       def wait
-        unless @error
-          resolve
-        end
+        resolve
 
         self
       end
 
-      # [public] Attempt to cancel the future, returns true if successful.
+      # [public] Attempt to cancel the future, returning true if successful.
       #
       def cancel
         if pending?
-          @task.stop
+          Fiber.scheduler.cancel(@fiber)
         end
 
         self
       end
 
-      # [public] Return the result, blocking until available.
+      # [public] Wait until the result is available, returning the result. Only awaits explicitly awaited children.
       #
       def result
-        @error || @result ||= resolve
-      end
-
-      private def resolve
-        wait_all(@task)
+        resolve(false)
+      end
+
+      private def resolve(children = true)
+        case @status
+        when :pending
+          scheduler = Fiber.scheduler
+
+          result = catch :__corerb_async_future_failed do
+            if scheduler.running?
+              if children
+                resolve_all(@filament)
+              else
+                resolve_value(@filament.wait)
+              end
+            else
+              result = nil
+              finished = false
+
+              scheduler.fiber do
+                result = catch :__corerb_async_future_failed do
+                  if children
+                    resolve_all(@filament)
+                  else
+                    resolve_value(@filament.wait)
+                  end
+                end
+
+                finished = true
+              end
+
+              scheduler.observe do
+                break if finished
+              end
+
+              resolve_value(result)
+            end
+          end
 
-        resolve_value(@task.result)
+          case result
+          when Failure
+            @raised = true
+            raise result.error
+          else
+            result
+          end
+        when :failed
+          if @raised
+            @error
+          else
+            @raised = true
+            raise @error
+          end
+        else
+          @result
+        end
       rescue UncaughtThrowError => error
         throw error.tag, error.value
-      rescue => error
-        @error = error
+      end
+
+      private def resolve_all(filament)
+        filament.children&.each do |child|
+          resolve_all(child)
+        end
 
-        raise error
+        resolve_value(filament.wait)
       end
 
       # [public] Return any error that occurred without re-raising, blocking until available.
@@ -61,60 +143,28 @@ module Core
         error
       end
 
-      # [public] Return the status; one of :pending, :failed, or :complete.
-      #
-      def status
-        if defined?(@status)
-          @status
-        else
-          status = find_status
-          if terminal_status?(status)
-            @status = status
-          end
-
-          status
-        end
-      end
-
-      private def find_status
-        case @task.status
-        when :running
-          :pending
-        when :stopped
-          :canceled
-        when :failed
-          :failed
-        when :complete
-          :complete
-        end
-      end
-
-      private def terminal_status?(status)
-        status == :failed || status == :complete
-      end
-
       # [public] Return `true` if pending.
       #
       def pending?
-        status == :pending
+        @status == :pending
       end
 
       # [public] Return `true` if failed.
       #
       def failed?
-        status == :failed
+        @status == :failed
       end
 
       # [public] Return `true` if canceled.
       #
       def canceled?
-        status == :canceled
+        @status == :canceled
       end
 
       # [public] Return `true` if complete.
       #
       def complete?
-        status == :complete
+        @status == :complete
       end
 
       # [public] Return `true` if failed or complete.
@@ -124,20 +174,15 @@ module Core
       end
 
       private def resolve_value(value)
-        if value.is_a?(self.class)
+        case value
+        when self.class
           resolve_value(value.result)
+        when Failure
+          throw :__corerb_async_future_failed, value
         else
           value
         end
       end
-
-      private def wait_all(task)
-        task.children&.each do |child|
-          wait_all(child)
-        end
-
-        task.wait
-      end
     end
   end
 end

data/lib/core/async/reactor.rb

@@ -1,50 +1,31 @@
 # frozen_string_literal: true
 
+require "is/inspectable"
+
 require_relative "../../is/async"
+require_relative "scheduler"
 
 module Core
   module Async
-    # [public] The top-level async context. Runs until all scheduled work is complete.
+    # [public] Creates a top-level async context that runs until all scheduled work is complete.
     #
-    class Reactor
+    class Reactor < Scheduler
       include Is::Async
+      include Is::Inspectable
+      inspects without: [:@runnable]
 
       class << self
         # [public] Create a new reactor and immediately run it.
         #
         def run(&block)
           instance = new
+          original_scheduler = Fiber.scheduler
+          Fiber.set_scheduler(instance)
           instance.run(&block)
+        ensure
+          Fiber.set_scheduler(original_scheduler)
         end
       end
-
-      # [public] Run the reactor, yielding within the async context.
-      #
-      def run
-        if (task = ::Async::Task.current?)
-          reference = task.async { |child|
-            @runnable = child
-
-            yield self
-          }
-
-          wait_all(reference)
-        else
-          @runnable = ::Async::Reactor.new
-
-          @runnable.run {
-            async {
-              yield self
-            }.result
-          }.wait
-        end
-      end
-
-      # [public] Stop the reactor.
-      #
-      def stop
-        @runnable&.stop
-      end
     end
   end
 end

data/lib/core/async/scheduler.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "event"
+require "fiber"
+require "timers/group"
+require "is/inspectable"
+
+require_relative "cancel"
+require_relative "failure"
+require_relative "filament"
+require_relative "timeout"
+
+module Core
+  module Async
+    # [public] The fiber scheduler.
+    #
+    class Scheduler
+      include Is::Inspectable
+      inspects without: [:@selector, :@timers, :@fibers]
+
+      extend Forwardable
+
+      # [public] Transfer from the current fiber to the selector.
+      #
+      def_delegator :@selector, :transfer
+
+      # [public] Yield the current fiber, resuming on the next tick.
+      #
+      def_delegator :@selector, :yield
+
+      # [public] Raise an error in the given fiber.
+      #
+      def_delegator :@selector, :raise
+
+      # [public] Resume the given fiber with the given value.
+      #
+      def_delegator :@selector, :resume
+
+      def initialize
+        @selector = Event::Selector.new(Fiber.current)
+        @timers = Timers::Group.new
+        @closed = false
+        @running = false
+        @fibers = {}
+      end
+
+      # [public] Run until there's no more work to do.
+      #
+      def run
+        @running = true
+
+        yield self if block_given?
+
+        result = nil
+        until result == :finished
+          result = tick
+        end
+      ensure
+        @running = false
+      end
+
+      # [public] Run until there's no more work to do, yielding before each tick.
+      #
+      def observe
+        @running = true
+
+        result = nil
+        until result == :finished
+          yield self
+          result = tick
+        end
+      ensure
+        @running = false
+      end
+
+      # [public] Returns `true` if the scheduler is running.
+      #
+      def running?
+        @running == true
+      end
+
+      # [public] Run one tick.
+      #
+      def tick
+        interval = @timers.wait_interval
+
+        if interval.nil?
+          if @fibers.empty?
+            return :finished
+          end
+        elsif interval < 0
+          interval = 0
+        end
+
+        @selector.select(interval)
+
+        @timers.fire
+      rescue Errno::EINTR
+        stop
+      end
+
+      # [public] Stop the scheduler, canceling each scheduled fiber.
+      #
+      def stop
+        signal = Cancel.new
+
+        @fibers.each_key do |fiber|
+          @selector.raise(fiber, signal)
+        end
+      end
+
+      # [public] Cancel the given fiber.
+      #
+      def cancel(fiber = Thread.current[:__corerb_async_current_fiber])
+        self.raise(fiber, Cancel) if fiber
+      end
+
+      # [public] Yields to the given block, timing out after the given seconds.
+      #
+      def timeout(seconds)
+        if seconds && seconds > 0
+          fiber = Fiber.current
+
+          timer = @timers.after(seconds) {
+            if fiber.alive?
+              fiber.raise(Timeout)
+            end
+          }
+        end
+
+        yield
+      ensure
+        timer&.cancel
+      end
+
+      #######################
+      ### Scheduler Interface
+      #######################
+
+      def block(blocker, timeout = nil)
+        if timeout
+          timer = create_timer(timeout)
+        end
+
+        @selector.transfer
+      ensure
+        timer&.cancel
+      end
+
+      def close
+        run
+      ensure
+        unless @closed
+          @closed = true
+
+          Fiber.set_scheduler(nil)
+        end
+      end
+
+      def fiber(&block)
+        filament = Filament.new
+
+        fiber = Fiber.new(blocking: false) {
+          begin
+            Thread.current[:__corerb_async_current_fiber] = filament
+            filament.object = fiber
+            result = block.call(filament)
+          rescue Cancel
+            result = nil
+          rescue => error
+            result = Failure.new(error)
+          ensure
+            @fibers.delete(fiber)
+            filament.resolve(result)
+          end
+        }
+
+        @fibers[fiber] = filament
+
+        if (parent = @fibers[Fiber.current])
+          parent.add_child(filament)
+        end
+
+        @selector.resume(fiber)
+
+        fiber
+      end
+
+      def io_wait(io, events, timeout = nil)
+        fiber = Fiber.current
+
+        if timeout
+          timer = @timers.after(timeout) {
+            fiber.raise(Timeout)
+          }
+        end
+
+        @selector.io_wait(fiber, io, events)
+      rescue Timeout
+        false
+      ensure
+        timer&.cancel
+      end
+
+      def kernel_sleep(duration = nil)
+        if duration
+          timer = create_timer(duration)
+        end
+
+        @selector.transfer
+      ensure
+        timer&.cancel
+      end
+
+      def process_wait(...)
+        @selector.process_wait(Fiber.current, ...)
+      end
+
+      def unblock(blocker, fiber)
+        @selector.push(fiber)
+      end
+
+      private def create_timer(duration)
+        fiber = Fiber.current
+
+        @timers.after(duration) {
+          if fiber.alive?
+            fiber.transfer(false)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/core/async/timeout.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "is/inspectable"
+
 module Core
   module Async
     # [public] Raised when execution times out.
     #
     class Timeout < RuntimeError
+      include Is::Inspectable
     end
   end
 end

data/lib/core/async/version.rb

@@ -2,8 +2,10 @@
 
 module Core
   module Async
-    VERSION = "0.6.0"
+    VERSION = "0.9.0"
 
+    # [public]
+    #
     def self.version
       VERSION
     end

data/lib/core/async/wrapper.rb

@@ -13,15 +13,13 @@ module Core
         @target = target
       end
 
-      def method_missing(name, *args, &block)
+      def method_missing(...)
         @target.async do
-          @target.public_send(name, *args, &block)
+          @target.public_send(...)
         end
       end
 
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords)
-
-      def respond_to_missing?(name, *)
+      def respond_to_missing?(...)
         true
       end
     end

data/lib/is/async.rb

@@ -6,22 +6,14 @@ require_relative "../core/async/timeout"
 require_relative "../core/async/wrapper"
 
 module Is
-  # [public] Makes Ruby objects async-aware.
+  # [public] Makes objects async-aware.
   #
   module Async
     # [public] Call behavior asychronously, returning a future.
     #
-    def async
-      if block_given?
-        task = ::Async::Reactor.run { |current|
-          begin
-            yield
-          ensure
-            current.yield
-          end
-        }
-
-        Core::Async::Future.new(task)
+    def async(&block)
+      if block
+        Core::Async::Future.new(&block)
       else
         Core::Async::Wrapper.new(self)
       end
@@ -30,85 +22,31 @@ module Is
     # [public] Call behavior synchronously but within an async context, waiting on the result.
     #
     private def await
-      if (task = ::Async::Task.current?)
-        reference = task.async { |current|
-          begin
-            yield
-          ensure
-            current.yield
-          end
-        }
-
-        wait_all(reference)
-      else
-        ::Async::Reactor.run { |task|
-          async {
-            yield
-          }.result
-        }.wait
-      end
-    rescue UncaughtThrowError => error
-      throw error.tag, error.value
-    end
-
-    # [public] Call behavior within an async context without additional nesting.
-    #
-    private def aware
-      if ::Async::Task.current?
+      async {
         yield
-      else
-        await do
-          yield
-        end
-      end
-    end
-
-    # [public] Sleeps for `seconds` in a proper async context.
-    #
-    private def sleep(seconds)
-      internal_await do |task|
-        task.sleep(seconds)
-      end
+      }.wait.result
     end
 
     # [public] Call asynchonous behavior in a proper async context, wrapped in a timeout.
     #
     # Raises `Core::Async::Timeout` if execution exceeds `seconds`.
     #
-    private def timeout(seconds)
-      internal_await do |task|
-        timed_task = internal_async {
-          yield
-        }
-
-        if seconds && seconds > 0
-          task.with_timeout(seconds, Core::Async::Timeout) do
-            timed_task.wait
-          end
-        else
-          timed_task.wait
-        end
-      ensure
-        timed_task&.stop
-      end
-    rescue UncaughtThrowError => error
-      throw error.tag, error.value
+    private def timeout(seconds, &block)
+      async {
+        Fiber.scheduler.timeout(seconds, &block)
+      }.wait
     end
 
     # [public] Yields control to allow other fibers to execute.
     #
     private def defer
-      if (task = ::Async::Task.current?)
-        task.yield
-      end
+      Fiber.scheduler.yield
     end
 
     # [public] Cancels the current async behavior if in progress.
     #
     private def cancel
-      if (task = ::Async::Task.current?)
-        task.stop
-      end
+      Fiber.scheduler.cancel
     end
 
     # [public] Resolves a potential future to a final result.
@@ -116,38 +54,10 @@ module Is
     private def resolve(value)
       case value
       when Core::Async::Future
-        value.result
+        resolve(value.result)
       else
         value
       end
     end
-
-    private def internal_async
-      ::Async::Reactor.run do |task|
-        yield task
-      end
-    end
-
-    private def internal_await
-      if (task = ::Async::Task.current?)
-        reference = task.async {
-          yield task
-        }
-
-        wait_all(reference)
-      else
-        ::Async::Reactor.run { |task|
-          yield task
-        }.wait
-      end
-    end
-
-    private def wait_all(task)
-      task.children&.each do |child|
-        wait_all(child)
-      end
-
-      task.wait
-    end
   end
 end

metadata

@@ -1,29 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: core-async
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-20 00:00:00.000000000 Z
+date: 2021-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: async
+  name: event
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.28'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.28'
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: timers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: core-inspect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 description: Makes Ruby objects async-aware.
 email: bryan@metabahn.com
 executables: []
@@ -34,10 +62,15 @@ files:
 - LICENSE
 - lib/core/async.rb
 - lib/core/async/bootstrap.rb
+- lib/core/async/cancel.rb
+- lib/core/async/channel.rb
 - lib/core/async/collection.rb
 - lib/core/async/enumerator.rb
+- lib/core/async/failure.rb
+- lib/core/async/filament.rb
 - lib/core/async/future.rb
 - lib/core/async/reactor.rb
+- lib/core/async/scheduler.rb
 - lib/core/async/timeout.rb
 - lib/core/async/version.rb
 - lib/core/async/wrapper.rb
@@ -54,14 +87,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.7
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Makes Ruby objects async-aware.