ori-rb 0.4

data/lib/ori/task.rb

@@ -0,0 +1,78 @@
+# typed: true
+
+module Ori
+  class Task
+    include(Ori::Selectable)
+
+    EMPTY = :empty
+
+    attr_reader :fiber
+
+    def initialize(&block)
+      @fiber = Fiber.new(&block)
+      @killed = false
+      @value = EMPTY
+    end
+
+    def alive?
+      @fiber.alive?
+    end
+
+    def value
+      @value unless @value == EMPTY
+    end
+
+    def raise_error(error)
+      @fiber.raise(error)
+    end
+
+    def killed?
+      @killed
+    end
+
+    def kill
+      @fiber.kill
+      @killed = true
+      @value = EMPTY
+    end
+
+    def id
+      @id ||= @fiber.object_id
+    end
+
+    def resume
+      if @cancellation_error
+        @fiber.kill
+        return @cancellation_error
+      end
+
+      fiber_result = @fiber.resume
+
+      case fiber_result
+      when Ori::Channel, Ori::Promise, Ori::Semaphore, Ori::ReentrantSemaphore
+        fiber_result
+      else
+        return self if @fiber.alive?
+
+        @value = fiber_result
+      end
+    rescue => error
+      @fiber.kill
+      raise error
+    end
+
+    def await
+      Fiber.yield while @fiber.alive?
+      @value
+    end
+
+    def deconstruct
+      [await]
+    end
+
+    def cancel(error)
+      @cancellation_error = error
+      resume
+    end
+  end
+end

data/lib/ori/timeout.rb

@@ -0,0 +1,16 @@
+# typed: true
+
+module Ori
+  class Timeout
+    include(Ori::Selectable)
+
+    def initialize(duration)
+      @duration = duration
+    end
+
+    def await
+      sleep(@duration)
+      true
+    end
+  end
+end

data/lib/ori/tracer.rb

@@ -0,0 +1,335 @@
+# typed: true
+
+require "json"
+
+module Ori
+  class Tracer
+    TIMELINE_WIDTH = 80
+
+    Event = Struct.new(:fiber_id, :type, :timestamp, :data, :scope_id)
+    ScopeEvent = Struct.new(:scope_id, :type, :timestamp, :data)
+
+    def initialize
+      @events = []
+      @scope_events = []
+      @start_time = nil
+      @fiber_names = {}
+      @fiber_ids = Set.new
+      @scope_hierarchy = {}
+      @fiber_scopes = {}
+    end
+
+    def register_scope(scope_id, parent_scope_id = nil, creating_fiber_id = nil, name: nil)
+      if parent_scope_id
+        @scope_hierarchy[parent_scope_id] ||= []
+        @scope_hierarchy[parent_scope_id] << scope_id
+      end
+
+      # Store scope names and use them as group IDs
+      @scope_names ||= {}
+      if name
+        @scope_names[scope_id] = "Scope #{name}"
+      end
+
+      # Track which fiber created this scope (if any)
+      @scope_creators ||= {}
+      @scope_creators[scope_id] = creating_fiber_id if creating_fiber_id
+    end
+
+    def register_fiber(fiber_id, scope_id)
+      @fiber_scopes[fiber_id] = scope_id
+    end
+
+    def record(fiber_id, type, data = nil)
+      return unless fiber_id
+
+      @start_time ||= current_time
+      @fiber_ids << fiber_id
+
+      @events << Event.new(
+        fiber_id,
+        type,
+        (current_time - @start_time).round(8),
+        data,
+        @fiber_scopes[fiber_id],
+      )
+    end
+
+    def record_scope(scope_id, type, data = nil)
+      return unless scope_id
+
+      @start_time ||= current_time
+
+      @scope_events << ScopeEvent.new(
+        scope_id,
+        type,
+        (current_time - @start_time).round(8),
+        data,
+      )
+    end
+
+    def visualize
+      return "No events recorded." if @events.empty?
+
+      name_width = 42
+      min_spacing = 1
+      duration = [@events.last.timestamp, 0.00000001].max
+
+      output = []
+      output << "Fiber Execution Timeline (#{duration.round(3)}s)"
+
+      # First pass: calculate all positions with minimum spacing
+      positions_by_fiber = {}
+      max_position = T.let(0, T.untyped)
+
+      @fiber_ids.sort.each do |fiber_id|
+        fiber_events = @events.select { |e| e.fiber_id == fiber_id }
+        next if fiber_events.empty?
+
+        # Calculate raw positions based on timestamps
+        positions = []
+        fiber_events.each_with_index do |evt, idx|
+          raw_pos = (evt.timestamp / duration * TIMELINE_WIDTH).floor # Use larger scale initially
+
+          if idx > 0
+            # Ensure minimum spacing from previous event
+            prev_pos = T.unsafe(positions.last) || -1
+            positions << [raw_pos, prev_pos + min_spacing].max
+          else
+            positions << raw_pos
+          end
+        end
+
+        positions_by_fiber[fiber_id] = positions
+        max_position = [max_position, T.unsafe(positions.last) || 0].max
+      end
+
+      # Calculate final timeline width based on max position
+      timeline_width = max_position + 1 # Add some padding
+      separator = "=" * (timeline_width + name_width + 3)
+      output << separator
+
+      # Second pass: render the timeline
+      @fiber_ids.sort.each do |fiber_id|
+        fiber_events = @events.select { |e| e.fiber_id == fiber_id }
+        next if fiber_events.empty?
+
+        fiber_name = @fiber_names[fiber_id] || "Fiber #{fiber_id}"
+        line = "#{fiber_name.ljust(name_width)} |"
+        timeline = " " * timeline_width
+        positions = positions_by_fiber[fiber_id]
+
+        # Render events using calculated positions
+        fiber_events.each_with_index do |evt, idx|
+          pos = positions[idx]
+          next_pos = positions[idx + 1]
+
+          # Choose character based on event type
+          char = case evt.type
+          when :opened, :created then "█"
+          when :resuming then "▶"
+          when :waiting_io then "~"
+          when :sleeping then "."
+          when :yielded then "╎"
+          when :closed, :completed then "▒"
+          when :cancelling then "⏹"
+          when :error, :cancelled then "✗"
+          when :awaiting then "↻"
+          else " "
+          end
+
+          timeline[pos] = char
+
+          # Fill the space until the next event if there is one
+          next unless next_pos
+
+          length = next_pos - pos - 1
+          next if length <= 0
+
+          fill_char = case evt.type
+          when :resuming then "═"
+          when :waiting_io then "~"
+          when :sleeping then "."
+          when :yielded then "-"
+          else " "
+          end
+
+          timeline[pos + 1, length] = fill_char * length
+        end
+
+        line << timeline << "|"
+        output << line
+      end
+
+      output << separator
+      output << "Legend: (█ Start) (▒ Finish) (═ Running) (~ IO-Wait) (. Sleeping) (╎ Yield) (✗ Error)"
+
+      output.join("\n")
+    end
+
+    def generate_timeline_data
+      # Get unique scope IDs
+      scope_ids = @fiber_scopes.values.uniq.sort
+
+      # Track nested groups for each parent
+      nested_groups = Hash.new { |h, k| h[k] = [] }
+
+      # First, handle scope hierarchy relationships
+      scope_ids.each do |scope_id|
+        next unless scope_id
+
+        # If scope was created by a fiber, nest it under that fiber
+        if @scope_creators&.[](scope_id)
+          creating_fiber = @scope_creators[scope_id]
+          group_id = "scope_#{scope_id}"
+          nested_groups["fiber_#{creating_fiber}"] << group_id
+        else
+          # Otherwise use normal scope hierarchy
+          parent_id = @scope_hierarchy.find { |_, children| children.include?(scope_id) }&.first
+          group_id = "scope_#{scope_id}"
+          parent_group = if parent_id
+            "scope_#{parent_id}"
+          else
+            "main"
+          end
+          nested_groups[parent_group] << group_id
+        end
+      end
+
+      # Then map remaining fibers to their parent scopes
+      @fiber_ids.sort.each do |fiber_id|
+        next if nested_groups.values.any? { |groups| groups.include?("fiber_#{fiber_id}") }
+
+        scope_id = @fiber_scopes[fiber_id]
+        parent_group = if scope_id
+          "scope_#{scope_id}"
+        else
+          "main"
+        end
+        nested_groups[parent_group] << "fiber_#{fiber_id}"
+      end
+
+      # Generate groups data
+      groups = []
+
+      # Add root scope group
+      groups << {
+        id: "main",
+        content: "Root Scope",
+        value: 1,
+        className: "main-scope",
+        nestedGroups: nested_groups["main"],
+        showNested: true,
+      }
+
+      # Add scope groups
+      scope_ids.each do |scope_id|
+        next unless scope_id
+
+        group_id = "scope_#{scope_id}"
+        title = @scope_names[scope_id] || "Scope #{scope_id}"
+
+        data = {
+          id: group_id,
+          order: scope_id,
+          content: title,
+          value: 2,
+          className: "scope",
+          showNested: false,
+        }
+
+        if nested_groups[group_id].any?
+          data[:nestedGroups] = nested_groups[group_id]
+        end
+
+        groups << data
+      end
+
+      # Add fiber groups (including those that create scopes)
+      @fiber_ids.sort.each do |fiber_id|
+        data = {
+          id: "fiber_#{fiber_id}",
+          content: "Fiber #{fiber_id}",
+          value: 3,
+          className: "fiber",
+          showNested: false,
+        }
+
+        if nested_groups["fiber_#{fiber_id}"].any?
+          data[:nestedGroups] = nested_groups["fiber_#{fiber_id}"]
+        end
+
+        groups << data
+      end
+
+      # Generate dataset from both scope and fiber events
+      dataset = []
+
+      # Add scope lifecycle events
+      @scope_events.each do |event|
+        group_id = if event.scope_id == "main"
+          "main"
+        else
+          "scope_#{event.scope_id}"
+        end
+
+        item = {
+          group: group_id,
+          content: event.type.to_s,
+          start: (event.timestamp * 1_000_000).to_i.to_s,
+          className: event.type.to_s,
+          data: event.data,
+        }
+
+        if event.type == :tag
+          item[:content] = event.data
+          item.delete(:data)
+        end
+
+        dataset << item
+      end
+
+      # Add fiber events
+      @events.each do |event|
+        item = {
+          group: "fiber_#{event.fiber_id}",
+          content: event.type.to_s,
+          start: (event.timestamp * 1_000_000).to_i.to_s,
+          className: event.type.to_s,
+          data: event.data,
+        }
+
+        # Add end time if the event has duration
+        item[:end] = (event.end_timestamp * 1_000_000).to_i.to_s if event.respond_to?(:end_timestamp)
+
+        dataset << item
+      end
+
+      {
+        groups: groups,
+        dataset: dataset,
+      }
+    end
+
+    def write_timeline_data(output_path)
+      data = generate_timeline_data
+
+      # Create JavaScript file content
+      js_content = <<~JAVASCRIPT
+        export const groups = #{data[:groups].to_json};
+
+        export const dataset = #{data[:dataset].to_json};
+      JAVASCRIPT
+
+      # Write to file
+      File.write(File.join(output_path, "index.html"), File.read(File.join(__dir__, "out", "index.html")))
+      File.write(File.join(output_path, "script.js"), js_content)
+    end
+
+    private
+
+    def current_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/ori/version.rb

@@ -0,0 +1,5 @@
+# typed: strict
+
+module Ori
+  VERSION = "0.4"
+end

data/lib/ori.rb

@@ -0,0 +1,68 @@
+# typed: strict
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module Ori
+  class CancellationError < StandardError
+
+    #: Scope
+    attr_reader :scope
+
+    #: (Scope scope, ?String? message) -> void
+    def initialize(scope, message = "Scope cancelled")
+      @scope = scope
+      super(message)
+    end
+  end
+
+  class << self
+    #: (?name: String?, ?cancel_after: Numeric?, ?raise_after: Numeric?, ?trace: bool) { (Scope) -> void } -> Scope
+    def sync(name: nil, cancel_after: nil, raise_after: nil, trace: false, &block)
+      deadline = cancel_after || raise_after
+      prev_scheduler = Fiber.current_scheduler
+
+      scope = Scope.new(
+        prev_scheduler.is_a?(Scope) ? prev_scheduler : nil,
+        name,
+        deadline,
+        trace,
+      )
+
+      Fiber.set_scheduler(scope)
+
+      begin
+        if Fiber.current.blocking?
+          scope.fork { block.call(scope) }
+        else
+          yield(scope)
+        end
+
+        scope.await
+        scope
+      rescue CancellationError => error
+        # Re-raise if:
+        # 1. The error is from a different scope, or
+        # 2. This is our error but it's from raise_after
+        raise if error.scope != scope || !raise_after.nil?
+
+        scope # Return the scope even when cancelled
+      ensure
+        Fiber.set_scheduler(prev_scheduler)
+      end
+    end
+
+    # sig do
+    #   type_parameters(:U)
+    #     .params(resources: T::Array[T.all(T.type_parameter(:U), Ori::Selectable)])
+    #     .returns(T.type_parameter(:U))
+    # end
+    #: [U] (Array[U & Selectable] resources) -> U
+    def select(resources)
+      Ori::Select.await(resources)
+    end
+  end
+
+  private_constant(:Scope)
+end

data/mise-tasks/test

@@ -0,0 +1,15 @@
+#!/usr/bin/env -S usage bash
+
+#MISE description="Run tests"
+#MISE alias="t"
+#MISE depends=["typecheck"]
+#USAGE arg "<file>" help="Run specific test file" default=""
+#USAGE flag "-n --name <name>" help="Run tests with specific name" default=""
+
+if [ -z "$usage_file" ]; then
+  bin/rake test
+elif [ -z "$usage_name" ]; then
+  ruby -Itest "$usage_file"
+else
+  ruby -Itest "$usage_file" --name "$usage_name"
+fi

data/mise.toml

@@ -0,0 +1,40 @@
+[tools]
+ruby = "3.4.7"
+usage = "latest"
+watchexec = "latest"
+
+[tasks.console]
+description = "Start a REPL using IRB"
+alias = "c"
+run = "bin/console"
+
+[tasks."bundle:install"]
+description = "Install gem dependencies"
+run = "bundle install"
+
+[tasks.style]
+description = "Run lint using Rubocop"
+alias = "l"
+run = "bin/rubocop"
+
+[tasks.typecheck]
+description = "Run typecheck using Sorbet"
+alias = "tc"
+run = "srb tc --enable-experimental-rbs-comments"
+
+[tasks."rbi:update"]
+description = "Update RBI files using Tapioca"
+run = """
+#!/usr/bin/env bash
+bin/tapioca gem &&
+bin/spoom srb bump --from false --to true &&
+bin/spoom srb bump --from true --to strict
+"""
+
+[tasks.'gem:build']
+description = "Build the gem"
+run = "gem build && mkdir -p pkg && mv ori-rb-* pkg/"
+
+[tasks.'gem:publish']
+description = "Publish the gem"
+run = "gem push pkg/*.gem"

data/sorbet/config

@@ -0,0 +1,8 @@
+.
+--ignore=.dev/
+--ignore=.git/
+--allowed-extension=.rb
+--allowed-extension=.rbi
+--allowed-extension=.rake
+--allowed-extension=.ru
+--enable-experimental-rbs-comments

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true