ask-graph 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 965f606d4e8a059634acd10ed0e2fbf96c159ba487d30f5f2edcec9bb1b75b89
-  data.tar.gz: b419551a611da8cd81eb7ab0d31bdf0c8213d8ed829e6a30981fe0d561938e84
+  metadata.gz: c3062914e848e9fea15dd9b02bd001946b7a3fd0ab015a1805b4e21a371b68bf
+  data.tar.gz: 17866f6bfaf40d6e195c71655ac134430747e3690ce32c355036a8e30a62bbf1
 SHA512:
-  metadata.gz: fee1727d038a4a74c11571ad040b86cb1d1b18bbeda4e9e3e59c46ae1a9d2eeab34d9660fbc9674e94601a14704d014e71bf782f61848c4e681bf3efd5e8f896
-  data.tar.gz: 9f943406f882e4e4344870b05b3cc945bf03555095f0f581456b22a9f1b8596acc5091c72d6191c4e41ed0651e6c5a09a895c49b4ae3fc4a8550dc6f0fdd3c84
+  metadata.gz: ac9dad679a58246c1bd04d67de6812e9126f8f341edad4a72e842b80b759bcf2e020a2ad0c5bedd625eff861f22f0cbb224d4d2dc058a136d4c13087c4420248
+  data.tar.gz: b0f7285fd1e447c3f48e06d061aa441f64bb37de1952022e22e44835c3b549c639bceec13d9a690d0d14becb5eb724e1d2f31c05ea47a514ba2be57d9680de3b

data/CHANGELOG.md

@@ -1,3 +1,74 @@
+## [0.4.0] — 2026-07-27
+
+### Changed
+
+- **`checkpoint_store:` renamed to `storage:`** — shorter, more general name
+  for the backend that persists checkpoint data for crash recovery.
+
+  ```ruby
+  # Before
+  MyGraph.call(input, checkpoint_store: RedisPool.new)
+  g.new(input, checkpoint_store: RedisPool.new)
+
+  # After
+  MyGraph.call(input, storage: RedisPool.new)
+  g.new(input, storage: RedisPool.new)
+  ```
+
+### Added
+
+- **Class-level `storage`** — set once at the class level instead of passing
+  per-call. Works the same as `timeout`: per-call → graph class → global.
+
+  ```ruby
+  # Global default for all graphs
+  Ask::Graph.storage RedisPool.new
+
+  # Per-graph override
+  class MyGraph < Ask::Graph
+    storage PostgresStore.new
+  end
+
+  # Per-call override (overrides everything)
+  MyGraph.call(input, storage: InMemory.new)
+  ```
+
+  Falls back to `Ask::State::Memory.new` when nothing is configured.
+
+### Tested
+
+- 70 tests, 92 assertions, 0 failures
+
+## [0.3.0] — 2026-07-27
+
+### Added
+
+- **Class-level `timeout`** — set a default timeout for all steps in a graph.
+  Steps without an explicit `timeout:` option inherit the class default.
+
+  ```ruby
+  class MyGraph < Ask::Graph
+    timeout 30
+    step FastOp   # uses 30s
+    step SlowOp, timeout: 120  # overrides
+  end
+  ```
+
+- **Global default timeout** — `Ask::Graph.timeout 30` applies to all graphs
+  that don't set their own `timeout`. Resolution order: step option → graph
+  class → `Ask::Graph`.
+
+  ```ruby
+  Ask::Graph.timeout 30
+  ```
+
+- **Child override and clearing** — child graphs can override or clear
+  (`timeout nil`) the parent's default.
+
+### Tested
+
+- 62 tests, 83 assertions, 0 failures
+
 ## [0.2.0] — 2026-07-29
 
 ### Added

data/lib/ask/graph/runner.rb

@@ -21,16 +21,19 @@ module Ask
       attr_reader :declarations, :store
 
       # @param declarations [Array<Hash>] step declarations
-      # @param checkpoint_store [#set, #get, #delete] key-value store
+      # @param storage [#set, #get, #delete] key-value store for checkpoint data
       # @param hooks [Hash] lifecycle hook method names
       # @param graph_instance [Object] the graph instance (for hooks)
-      def initialize(declarations, checkpoint_store: nil,
+      # @param default_timeout [Integer, nil] fallback timeout for steps with no explicit timeout
+      def initialize(declarations, storage: nil,
                      hooks: { before_step: [], after_step: [], on_failure: [] },
-                     graph_instance: nil)
+                     graph_instance: nil,
+                     default_timeout: nil)
         @declarations = declarations
-        @store = checkpoint_store
+        @store = storage
         @hooks = hooks
         @graph = graph_instance
+        @default_timeout = default_timeout
         @completed_steps = []
       end
 
@@ -90,6 +93,7 @@ module Ask
       end
 
       def run_with_timeout(decl, context, timeout_value)
+        timeout_value ||= @default_timeout
         if timeout_value
           ::Timeout.timeout(timeout_value) { execute_step(decl, context) }
         else

data/lib/ask/graph/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   class Graph
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/ask/graph.rb

@@ -46,6 +46,70 @@ module Ask
         subclass.instance_variable_set(:@lifecycle_hooks, lifecycle_hooks.dup)
       end
 
+      # --- Timeout ---
+
+      # Set or get the default timeout (in seconds) for steps in this graph.
+      # Steps without an explicit +timeout:+ option will inherit this value.
+      # Setting on {Ask::Graph} itself applies to all graphs that don't set
+      # their own default — a global default.
+      #
+      # @example Global default for all graphs
+      #   Ask::Graph.timeout 30
+      #
+      # @example Per-graph override
+      #   class MyGraph < Ask::Graph
+      #     timeout 15
+      #     step FastOp          # uses 15s
+      #     step SlowOp, timeout: 60  # overrides
+      #   end
+      #
+      # @param seconds [Integer, nil] timeout in seconds, or nil to clear
+      # @return [Integer, nil] the current default timeout for this graph
+      def timeout(seconds = :not_set)
+        if seconds == :not_set
+          if instance_variable_defined?(:@timeout)
+            @timeout
+          elsif superclass.respond_to?(:timeout)
+            superclass.timeout
+          end
+        else
+          @timeout = seconds
+        end
+      end
+
+      # --- Storage ---
+
+      # Set or get the default storage backend for checkpoint data.
+      # The storage object must respond to +#set(key, value)+ and +#get(key)+.
+      #
+      # Setting on {Ask::Graph} itself applies to all graphs that don't set
+      # their own storage — a global default.
+      #
+      # @example Global default for all graphs
+      #   Ask::Graph.storage RedisPool.new
+      #
+      # @example Per-graph override
+      #   class MyGraph < Ask::Graph
+      #     storage PostgresStore.new
+      #   end
+      #
+      # @example Per-call override
+      #   MyGraph.call(input, storage: InMemory.new)
+      #
+      # @param store [Object, nil] a backend that responds to +#set+ and +#get+
+      # @return [Object, nil] the current storage for this graph
+      def storage(store = :not_set)
+        if store == :not_set
+          if instance_variable_defined?(:@storage)
+            @storage
+          elsif superclass.respond_to?(:storage)
+            superclass.storage
+          end
+        else
+          @storage = store
+        end
+      end
+
       # --- Lifecycle hooks ---
 
       def lifecycle_hooks
@@ -111,8 +175,8 @@ module Ask
       end
 
       # Convenience: create instance and call.
-      def call(input = nil, checkpoint_store: nil)
-        new(input, checkpoint_store: checkpoint_store).call
+      def call(input = nil, storage: nil)
+        new(input, storage: storage).call
       end
       alias run call
 
@@ -132,14 +196,15 @@ module Ask
       end
     end
 
-    def initialize(input = nil, checkpoint_store: nil)
+    def initialize(input = nil, storage: nil)
       @input = input
-      store = checkpoint_store || Ask::State::Memory.new
+      store = storage || self.class.storage || Ask::State::Memory.new
       hooks = self.class.lifecycle_hooks
       @runner = Runner.new(self.class.declarations,
-                           checkpoint_store: store,
+                           storage: store,
                            hooks: hooks,
-                           graph_instance: self)
+                           graph_instance: self,
+                           default_timeout: self.class.timeout)
       @context = nil
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-graph
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kaka Ruto