async-graph 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e191c8f8d75367ded4fb71dc739d1c337bc41b158e40577aaf06a054a0321f4
-  data.tar.gz: b82e743e0b5119862364200eb8ff558312cb7d0963dd7257e87b38f8895e5924
+  metadata.gz: 5fb46c9d6fc4ea1d3954655810b8605acdb74a84e3299f4910a2e8af30e19618
+  data.tar.gz: 8384644bec8efa74c592fd2bef726ccee2c41fe7596b802ea1f26fedde3ee25f
 SHA512:
-  metadata.gz: a351f8bdbb37c7b7da3d09ce4c63d965d9981d6ebeb97bd7473837909085d186c31e2d1efe2a28e46c9d3bd417b20f1cd851a7a4d44ef817360b026d249f7729
-  data.tar.gz: 1ad91c064b0dcd6bafd8bc8f62e987d6b909fb77f713eedadbe2581b6025e47a03d2ee1b36f2f04752718df9efb2fbbd743743ee837012053957634214ed2d7e
+  metadata.gz: aa56a0e83197515c7e66f869a8edfc8dd4db46a9fb08f030d38d05af93bc2e6b44168c689706b8061f5b6f63b57dcf8fd1d9d963260911805aaf1882ef7007fc
+  data.tar.gz: '083844bd7e389b9ccf3b68ed642cce69730c64f324efe416f3496e0531a9ea42f23c237ddcfb6cf1f20da73f3289c4ecdad31b3a7ef0ed8dd2785be340538bb0'

data/.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: "3.4.4"
-          bundler-cache: true
+      - run: bundle install
       - run: bundle exec rake
       - name: Run RuboCop
         run: |

data/README.erb

@@ -51,7 +51,7 @@ snapshot while your application still owns persistence and external jobs.
 
 ## Demo
 
-The repository includes two runnable examples in `examples/`:
+The repository includes three runnable examples in `examples/`:
 
 - persisted multi-pass flow with external job persistence:
 
@@ -59,10 +59,16 @@ The repository includes two runnable examples in `examples/`:
 bash examples/run.sh
 ```
 
-- self-contained runner loop with inline `:add` / `:subtract` request handling:
+- self-contained runner loop with inline `:add` / `:subtract` request handling through `resolve_request:`:
 
 ```bash
-ruby examples/all_in_one_runner.rb
+ruby examples/all_in_one_inline_runner.rb
+```
+
+- self-contained runner loop that still suspends, binds requests to in-memory job IDs, and resumes in the same process:
+
+```bash
+ruby examples/all_in_one_jobs_runner.rb
 ```
 
 ## Documentation

data/README.md

@@ -51,7 +51,7 @@ snapshot while your application still owns persistence and external jobs.
 
 ## Demo
 
-The repository includes two runnable examples in `examples/`:
+The repository includes three runnable examples in `examples/`:
 
 - persisted multi-pass flow with external job persistence:
 
@@ -59,10 +59,16 @@ The repository includes two runnable examples in `examples/`:
 bash examples/run.sh
 ```
 
-- self-contained runner loop with inline `:add` / `:subtract` request handling:
+- self-contained runner loop with inline `:add` / `:subtract` request handling through `resolve_request:`:
 
 ```bash
-ruby examples/all_in_one_runner.rb
+ruby examples/all_in_one_inline_runner.rb
+```
+
+- self-contained runner loop that still suspends, binds requests to in-memory job IDs, and resumes in the same process:
+
+```bash
+ruby examples/all_in_one_jobs_runner.rb
 ```
 
 ## Documentation

data/examples/all_in_one_inline_runner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../lib/async-graph"
+
+runner = AsyncGraph::Runner.new(
+  AsyncGraph::Graph.new do
+    node :calculate do |state, await|
+      results = await.all(
+        added: [:add, {left: state[:left], right: state[:right]}],
+        subtracted: [:subtract, {left: state[:total], right: state[:discount]}]
+      )
+
+      {
+        added: results[:added],
+        subtracted: results[:subtracted],
+        answer: results[:added] - results[:subtracted]
+      }
+    end
+
+    set_entry_point :calculate
+    set_finish_point :calculate
+  end
+)
+
+run = runner.start_run state: {left: 7, right: 5, total: 20, discount: 3}
+
+until run.finished?
+  run = runner.advance_run(
+    run: run,
+    resolve_request: lambda do |kind, payload|
+      case kind
+      when :add then payload[:left] + payload[:right]
+      when :subtract then payload[:left] - payload[:right]
+      else AsyncGraph::DEFER
+      end
+    end
+  )
+end
+
+puts JSON.pretty_generate(run.result)

data/examples/{all_in_one_runner.rb → all_in_one_jobs_runner.rb}

@@ -29,7 +29,7 @@ run = runner.start_run state: {left: 7, right: 5, total: 20, discount: 3}
 until run.finished?
   run = runner.advance_run(
     run: run,
-    resolved_for: lambda do |token|
+    resolved: lambda do |token|
       token[:awaits].each_with_object({}) do |(key, request_id), memo|
         memo[key.to_s] = results[request_id] if results.key?(request_id)
       end

data/examples/graph_run.rb

@@ -7,7 +7,7 @@ def advance_graph_state!(graph_state, job_list, jobs_by_uid)
   graph_uid = graph_state.fetch(:graph_uid)
   next_run = RUNNER.advance_run(
     run: graph_state.fetch(:run),
-    resolved_for: lambda do |token|
+    resolved: lambda do |token|
       token.fetch(:awaits, {}).each_with_object({}) do |(key, job_uid), memo|
         job = jobs_by_uid[job_uid]
         memo[key.to_s] = job[:result] if job&.[](:status) == "done"

data/examples/run.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd "$(dirname "$0")"
 
-for file in app_graph.rb reset.rb graph_run.rb execute_jobs.rb all_in_one_runner.rb; do
+for file in app_graph.rb reset.rb graph_run.rb execute_jobs.rb all_in_one_inline_runner.rb all_in_one_jobs_runner.rb; do
   ruby -c "$file"
 done
 
@@ -41,5 +41,8 @@ ruby graph_run.rb
 cat graph_states.json
 cat jobs.json
 
-printf '\n== all-in-one runner ==\n'
-ruby all_in_one_runner.rb
+printf '\n== all-in-one inline runner ==\n'
+ruby all_in_one_inline_runner.rb
+
+printf '\n== all-in-one jobs runner ==\n'
+ruby all_in_one_jobs_runner.rb

data/lib/async-graph/graph.rb

@@ -4,6 +4,7 @@ require_relative "graph_validation"
 
 module AsyncGraph
   FINISH = :__finish__
+  DEFER = Object.new.freeze
 
   Request = Struct.new(:key, :kind, :payload, keyword_init: true)
   Edge = Struct.new(:to, :branch, keyword_init: true)
@@ -48,15 +49,20 @@ module AsyncGraph
   # 2. Use await.all(...) inside one node to queue a batch and suspend once.
   # 3. Use a two-phase API such as await.defer + await.resolve_all.
   class Await
-    def initialize(resolved)
+    def initialize(resolved, resolve_request = nil)
       @resolved = resolved
+      @resolve_request = resolve_request
     end
 
     def call(key, kind, payload = {})
       key = key.to_s
       return @resolved[key] if @resolved.key?(key)
 
-      throw :await, AwaitSignal.new(requests: [Request.new(key:, kind:, payload:)])
+      request = Request.new(key:, kind:, payload:)
+      resolved = resolve(request)
+      throw :await, AwaitSignal.new(requests: [request]) if resolved.equal?(DEFER)
+
+      resolved
     end
 
     def all(definitions)
@@ -64,18 +70,37 @@ module AsyncGraph
         [key.to_s, [kind, payload || {}]]
       end
 
+      resolved = {}
       missing = normalized.filter_map do |key, (kind, payload)|
-        next if @resolved.key?(key)
+        if @resolved.key?(key)
+          resolved[key] = @resolved[key]
+          next
+        end
 
-        Request.new(key:, kind:, payload:)
+        request = Request.new(key:, kind:, payload:)
+        value = resolve(request)
+        if value.equal?(DEFER)
+          request
+        else
+          resolved[key] = value
+          nil
+        end
       end
 
       throw :await, AwaitSignal.new(requests: missing) unless missing.empty?
 
-      normalized.keys.to_h { |key| [key.to_sym, @resolved[key]] }
+      normalized.keys.to_h { |key| [key.to_sym, resolved[key]] }
     end
 
     def to_proc = method(:call).to_proc
+
+    private
+
+    def resolve(request)
+      return DEFER unless @resolve_request
+
+      @resolve_request.call(request.kind, request.payload)
+    end
   end
 
   class Graph
@@ -124,14 +149,14 @@ module AsyncGraph
 
     def set_finish_point(name) = edge(name, FINISH)
 
-    def step(state:, node:, resolved: {})
+    def step(state:, node:, resolved: {}, resolve_request: nil)
       validate!
 
       current = node.to_sym
       return Finished.new(state:) if current == FINISH
 
       validate_known_node!(current, context: "Step node")
-      await = Await.new(resolved)
+      await = Await.new(resolved, resolve_request)
       result = catch(:await) { [:ok, call_node(@nodes[current], state, await)] }
       return Suspended.new(state:, node: current, requests: result.requests) if result.is_a?(AwaitSignal)
 

data/lib/async-graph/runner.rb

@@ -52,13 +52,14 @@ module AsyncGraph
       )
     end
 
-    def step(token:, joins:, resolved: {}, &)
+    def step(token:, joins:, resolved: {}, resolve_request: nil, &)
       return build_join_result(@graph.process_join(token:, joins:)) if join_token?(token)
 
       graph_step = @graph.step(
         state: token.fetch(:state),
         node: token.fetch(:node),
-        resolved: resolved
+        resolved: resolved,
+        resolve_request: resolve_request
       )
 
       case graph_step
@@ -73,13 +74,18 @@ module AsyncGraph
       end
     end
 
-    def advance_run(run:, resolved_for: nil, &)
+    def advance_run(run:, resolved: nil, resolved_for: nil, resolve_request: nil, &)
+      if resolved && resolved_for
+        raise ArgumentError, "Runner#advance_run accepts either resolved: or resolved_for:, not both"
+      end
+
       current_run = normalize_run(run)
       return current_run if current_run.finished?
 
       next_tokens, joins, final_state = advance_tokens(
         current_run,
-        resolved_for: resolved_for,
+        resolved_source: resolved || resolved_for,
+        resolve_request: resolve_request,
         &
       )
       Run.new(
@@ -226,7 +232,7 @@ module AsyncGraph
       raise ArgumentError, "Runner#step requires a block to bind external IDs for new requests"
     end
 
-    def advance_tokens(run, resolved_for:, &)
+    def advance_tokens(run, resolved_source:, resolve_request:, &)
       next_tokens = []
       joins = run.joins
       final_state = run.result
@@ -235,7 +241,8 @@ module AsyncGraph
         outcome = step(
           token: token,
           joins: joins,
-          resolved: resolved_for&.call(token) || {},
+          resolved: resolved_source&.call(token) || {},
+          resolve_request: resolve_request,
           &
         )
         joins = outcome.joins

data/lib/async-graph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AsyncGraph
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/async_graph_spec.rb

@@ -47,6 +47,96 @@ RSpec.describe AsyncGraph::Graph do
     end
   end
 
+  it "resolves await.call inline through resolve_request" do
+    graph = described_class.new do
+      node :calculate do |state, await|
+        sum = await.call(:sum, :add, left: state[:left], right: state[:right])
+        {sum: sum}
+      end
+
+      set_entry_point :calculate
+      set_finish_point :calculate
+    end
+
+    step = graph.step(
+      state: {left: 7, right: 5},
+      node: graph.entry,
+      resolve_request: lambda do |kind, payload|
+        case kind
+        when :add then payload[:left] + payload[:right]
+        else AsyncGraph::DEFER
+        end
+      end
+    )
+
+    aggregate_failures do
+      expect(step).to be_a(AsyncGraph::Advanced)
+      expect(step.state).to eq(left: 7, right: 5, sum: 12)
+      expect(step.destinations.map(&:to)).to eq([AsyncGraph::FINISH])
+    end
+  end
+
+  it "suspends await.all only for deferred requests" do
+    graph = described_class.new do
+      node :calculate do |state, await|
+        results = await.all(
+          added: [:add, {left: state[:left], right: state[:right]}],
+          discounted: [:discount, {total: state[:total], amount: state[:discount]}]
+        )
+
+        {
+          added: results[:added],
+          discounted: results[:discounted]
+        }
+      end
+
+      set_entry_point :calculate
+      set_finish_point :calculate
+    end
+
+    step = graph.step(
+      state: {left: 7, right: 5, total: 20, discount: 3},
+      node: graph.entry,
+      resolve_request: lambda do |kind, payload|
+        case kind
+        when :add then payload[:left] + payload[:right]
+        else AsyncGraph::DEFER
+        end
+      end
+    )
+
+    aggregate_failures do
+      expect(step).to be_a(AsyncGraph::Suspended)
+      expect(step.requests.map(&:key)).to eq(["discounted"])
+      expect(step.requests.map(&:kind)).to eq([:discount])
+    end
+
+    resumed = graph.step(
+      state: step.state,
+      node: step.node,
+      resolved: {"discounted" => 17},
+      resolve_request: lambda do |kind, payload|
+        case kind
+        when :add then payload[:left] + payload[:right]
+        else AsyncGraph::DEFER
+        end
+      end
+    )
+
+    aggregate_failures do
+      expect(resumed).to be_a(AsyncGraph::Advanced)
+      expect(resumed.state).to eq(
+        left: 7,
+        right: 5,
+        total: 20,
+        discount: 3,
+        added: 12,
+        discounted: 17
+      )
+      expect(resumed.destinations.map(&:to)).to eq([AsyncGraph::FINISH])
+    end
+  end
+
   it "builds a barrier edge from multiple sources" do
     graph = described_class.new do
       node :left do

data/spec/runner_spec.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+RSpec.describe AsyncGraph::Runner do
+  it "creates a start token from the graph entry point" do
+    graph = AsyncGraph::Graph.new do
+      node :start do
+      end
+
+      set_entry_point :start
+    end
+
+    token = described_class.new(graph).start(state: {user_id: 7})
+
+    expect(token).to eq(
+      token_uid: "t1",
+      node: :start,
+      state: {user_id: 7},
+      fork_uid: nil,
+      branch: nil,
+      source_node: nil,
+      awaits: {}
+    )
+  end
+
+  it "builds an opaque persisted run from the entry point" do
+    graph = AsyncGraph::Graph.new do
+      node :start do
+      end
+
+      set_entry_point :start
+    end
+
+    run = described_class.new(graph).start_run(state: {user_id: 7})
+
+    aggregate_failures do
+      expect(run).to be_running
+      expect(run.result).to be_nil
+      expect(run.to_h).to eq(
+        status: "running",
+        tokens: [
+          {
+            token_uid: "t1",
+            node: :start,
+            state: {user_id: 7},
+            fork_uid: nil,
+            branch: nil,
+            source_node: nil,
+            awaits: {}
+          }
+        ],
+        joins: {},
+        result: nil
+      )
+    end
+  end
+
+  it "spawns branch tokens for fan-out and finishes on finish edges" do
+    graph = AsyncGraph::Graph.new do
+      node :split do
+      end
+
+      node :left do
+        {left_ready: true}
+      end
+
+      node :right do
+        {right_ready: true}
+      end
+
+      set_entry_point :split
+      edge :split, :left, branch: :left
+      edge :split, :right, branch: :right
+      set_finish_point :left
+      set_finish_point :right
+    end
+
+    runner = described_class.new(graph)
+    split = runner.step(
+      token: runner.start(state: {user_id: 7}),
+      joins: {}
+    )
+
+    aggregate_failures do
+      expect(split).to be_advanced
+      expect(split.tokens).to eq(
+        [
+          {
+            token_uid: "t1.left",
+            node: :left,
+            state: {user_id: 7},
+            fork_uid: "fork-t1",
+            branch: :left,
+            source_node: :split,
+            awaits: {}
+          },
+          {
+            token_uid: "t1.right",
+            node: :right,
+            state: {user_id: 7},
+            fork_uid: "fork-t1",
+            branch: :right,
+            source_node: :split,
+            awaits: {}
+          }
+        ]
+      )
+    end
+
+    left = runner.step(token: split.tokens.first, joins: split.joins)
+    right = runner.step(token: split.tokens.last, joins: split.joins)
+
+    aggregate_failures do
+      expect(left).to be_finished
+      expect(left.state).to eq(user_id: 7, left_ready: true)
+      expect(right).to be_finished
+      expect(right.state).to eq(user_id: 7, right_ready: true)
+    end
+  end
+
+  it "advances a persisted run without exposing joins to the caller" do
+    graph = AsyncGraph::Graph.new do
+      node :split do
+      end
+
+      node :left do
+        {left_ready: true}
+      end
+
+      node :right do
+        {right_ready: true}
+      end
+
+      node :merge do |state, await|
+        profile = await.call(:profile, :fetch_profile, user_id: state[:user_id])
+        {profile: profile}
+      end
+
+      set_entry_point :split
+      edge :split, :left, branch: :left
+      edge :split, :right, branch: :right
+      edge %i[left right], :merge
+      set_finish_point :merge
+    end
+
+    runner = described_class.new(graph)
+    run = runner.start_run(state: {user_id: 7})
+    run1 = runner.advance_run(run: run)
+    run2 = runner.advance_run(run: run1)
+    run3 = runner.advance_run(run: run2)
+    run4 = runner.advance_run(run: run3) { |_| "job-1" }
+    run5 = runner.advance_run(
+      run: run4,
+      resolved_for: ->(token) { token[:awaits][:profile] == "job-1" ? {"profile" => {id: 7, name: "Ada"}} : {} }
+    )
+
+    aggregate_failures do
+      expect(run1.tokens.map { |token| token[:token_uid] }).to eq(%w[t1.left t1.right])
+      expect(run2.tokens.map { |token| token[:node] }).to eq(%i[merge merge])
+      expect(run3.tokens.map { |token| token[:token_uid] }).to eq(["fork-t1.join"])
+      expect(run4.tokens.first.fetch(:awaits)).to eq(profile: "job-1")
+      expect(run5).to be_finished
+      expect(run5.result).to eq(
+        user_id: 7,
+        left_ready: true,
+        right_ready: true,
+        profile: {id: 7, name: "Ada"}
+      )
+    end
+  end
+
+  it "finishes a run inline when resolve_request handles all awaits" do
+    graph = AsyncGraph::Graph.new do
+      node :calculate do |state, await|
+        results = await.all(
+          added: [:add, {left: state[:left], right: state[:right]}],
+          subtracted: [:subtract, {left: state[:total], right: state[:discount]}]
+        )
+
+        {
+          added: results[:added],
+          subtracted: results[:subtracted],
+          answer: results[:added] - results[:subtracted]
+        }
+      end
+
+      set_entry_point :calculate
+      set_finish_point :calculate
+    end
+
+    runner = described_class.new(graph)
+    run = runner.advance_run(
+      run: runner.start_run(state: {left: 7, right: 5, total: 20, discount: 3}),
+      resolve_request: lambda do |kind, payload|
+        case kind
+        when :add then payload[:left] + payload[:right]
+        when :subtract then payload[:left] - payload[:right]
+        else AsyncGraph::DEFER
+        end
+      end
+    )
+
+    aggregate_failures do
+      expect(run).to be_finished
+      expect(run.result).to eq(
+        left: 7,
+        right: 5,
+        total: 20,
+        discount: 3,
+        added: 12,
+        subtracted: 17,
+        answer: -5
+      )
+    end
+  end
+
+  it "binds only deferred requests when resolve_request handles part of await.all inline" do
+    graph = AsyncGraph::Graph.new do
+      node :calculate do |state, await|
+        results = await.all(
+          added: [:add, {left: state[:left], right: state[:right]}],
+          discounted: [:discount, {total: state[:total], amount: state[:discount]}]
+        )
+
+        {
+          added: results[:added],
+          discounted: results[:discounted]
+        }
+      end
+
+      set_entry_point :calculate
+      set_finish_point :calculate
+    end
+
+    resolve_request = lambda do |kind, payload|
+      case kind
+      when :add then payload[:left] + payload[:right]
+      else AsyncGraph::DEFER
+      end
+    end
+
+    runner = described_class.new(graph)
+    first = runner.advance_run(
+      run: runner.start_run(state: {left: 7, right: 5, total: 20, discount: 3}),
+      resolved: ->(_token) { nil },
+      resolve_request: resolve_request
+    ) { |request| "job-#{request.key}" }
+
+    finished = runner.advance_run(
+      run: first,
+      resolved: lambda do |token|
+        token[:awaits][:discounted] == "job-discounted" ? {"discounted" => 17} : {}
+      end,
+      resolve_request: resolve_request
+    )
+
+    aggregate_failures do
+      expect(first).to be_running
+      expect(first.tokens.first.fetch(:awaits)).to eq(discounted: "job-discounted")
+      expect(finished).to be_finished
+      expect(finished.result).to eq(
+        left: 7,
+        right: 5,
+        total: 20,
+        discount: 3,
+        added: 12,
+        discounted: 17
+      )
+    end
+  end
+
+  it "reuses existing request bindings when a suspended token is retried" do
+    graph = AsyncGraph::Graph.new do
+      node :fetch do |state, await|
+        user = await.call(:user, :fetch_user, user_id: state[:user_id])
+        {user: user}
+      end
+
+      set_entry_point :fetch
+      set_finish_point :fetch
+    end
+
+    runner = described_class.new(graph)
+    first = runner.step(token: runner.start(state: {user_id: 7}), joins: {}) { |_| "job-1" }
+    second = runner.step(token: first.token, joins: first.joins)
+    finished = runner.step(
+      token: first.token,
+      joins: first.joins,
+      resolved: {"user" => {id: 7, name: "Ada"}}
+    )
+
+    aggregate_failures do
+      expect(first).to be_suspended
+      expect(first.token.fetch(:awaits)).to eq(user: "job-1")
+      expect(second).to be_suspended
+      expect(second.token.fetch(:awaits)).to eq(user: "job-1")
+      expect(second.request_refs).to eq(user: "job-1")
+      expect(finished).to be_finished
+      expect(finished.state).to eq(
+        user_id: 7,
+        user: {id: 7, name: "Ada"}
+      )
+    end
+  end
+
+  it "parks and releases join tokens through the runner" do
+    graph = AsyncGraph::Graph.new do
+      node :split do
+      end
+
+      node :left do
+        {left_ready: true}
+      end
+
+      node :right do
+        {right_ready: true}
+      end
+
+      node :merge do
+      end
+
+      set_entry_point :split
+      edge :split, :left, branch: :left
+      edge :split, :right, branch: :right
+      edge %i[left right], :merge
+    end
+
+    runner = described_class.new(graph)
+    split = runner.step(
+      token: runner.start(state: {user_id: 7}),
+      joins: {}
+    )
+    left = runner.step(token: split.tokens.first, joins: split.joins)
+    right = runner.step(token: split.tokens.last, joins: split.joins)
+    parked = runner.step(token: left.token, joins: left.joins)
+    released = runner.step(token: right.token, joins: parked.joins)
+
+    aggregate_failures do
+      expect(parked).to be_parked
+      expect(parked.joins.keys).to eq([:'fork-t1:merge'])
+      expect(released).to be_released
+      expect(released.tokens).to eq(
+        [
+          {
+            token_uid: "fork-t1.join",
+            node: :merge,
+            state: {user_id: 7, left_ready: true, right_ready: true},
+            fork_uid: nil,
+            branch: nil,
+            source_node: nil,
+            awaits: {}
+          }
+        ]
+      )
+      expect(released.joins).to eq({})
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-graph
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Artem Borodkin
@@ -114,7 +114,8 @@ files:
 - Rakefile
 - async-graph.gemspec
 - bin/console
-- examples/all_in_one_runner.rb
+- examples/all_in_one_inline_runner.rb
+- examples/all_in_one_jobs_runner.rb
 - examples/app_graph.rb
 - examples/execute_jobs.rb
 - examples/graph_run.rb
@@ -126,6 +127,7 @@ files:
 - lib/async-graph/runner.rb
 - lib/async-graph/version.rb
 - spec/async_graph_spec.rb
+- spec/runner_spec.rb
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/async-graph
 licenses: