bitfab 0.38.1 → 0.38.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2816ce4e3bcd11bb1335ba7dac6b36376277d17075cf853d26c9befa231a758b
-  data.tar.gz: 7e923c2efb8dfd38edbdd592972a8f236a3fa81cdfabcbd46b8303ba4160b01e
+  metadata.gz: 29901e7611834921e9378870830af40c08e5af02d1ca0708585a02b169b12e6e
+  data.tar.gz: b42984a3710e9399159fd44af3aaac7b76e3155bd3121eaa5482aa27570fbb2e
 SHA512:
-  metadata.gz: 15a2df82260f61733b90da3c110b195c92373c187c3eddce5faa041f44499bb008ec5a14cd27dab22b63e2973540010cc2e2f10fcc2dcd75481405d018a107f6
-  data.tar.gz: 13968f6a9f8d3c88ea2845d0d59e0cc1d31ffadc1054311addeedc1e4ba92d94aea504f0f5d11e9891fd0a233e92d285e635e5d8e85e46ebfdf553cdedc45005
+  metadata.gz: 576a44cbe7e2fdf7270f14af3d8a98541bb2e15cd2b02289c18d58f033688d6797b2b3a0cfc8153f1ba8adbf0d72f9b9b9241e1bfd5fbd3ffcc687a4cb9adb44
+  data.tar.gz: ce3586fbdc541ffad387d87ca4299ee34df5e0c61a5c01a6b5112ee11084cb7900d6616f9e3db45ec0386fc019bc1712f267ea3c5799809880ae3611d3d30cb9

data/lib/bitfab/client.rb

@@ -122,14 +122,15 @@ module Bitfab
     #   traces were captured. Receives (args, kwargs, ctx) where ctx is
     #   { original_trace_id:, original_span_id: } (with deprecated
     #   source_trace_id/source_span_id aliases), and returns [new_args, new_kwargs].
-    # @param mock_override [Hash, Array<Hash>, nil] optional selective mock
-    #   override(s), each a { match:, value: } hash. match is a callable:
+    # @param mock_override [Hash, Proc, Array<Hash, Proc>, nil] optional selective
+    #   mock override(s), as { match:, value: } hashes or global resolvers. match is a callable:
     #   match.call(node) selects spans to substitute (node is
     #   { trace_function_key:, span_name:, type:, original_span_id: }). value is
     #   EITHER a flat value injected directly OR a callable invoked with
     #   { node:, inputs:, kwargs:, get_original_output: }; its result becomes
     #   the span's output (full replacement), so downstream real code runs against it. The
-    #   first matching override wins. Per-call overrides take precedence over
+    #   first matching override that does not return NO_MOCK_OVERRIDE wins.
+    #   Per-call overrides take precedence over
     #   those registered via register_mock_override, and both take precedence
     #   over the base mock strategy. The root span is never overridden.
     # @param db_branch [Boolean, Hash, nil] +true+ or a Hash enables database
@@ -169,10 +170,9 @@ module Bitfab
     # clear_mock_overrides to reset. Per-call replay(mock_override:) overrides
     # take precedence, and both take precedence over the base mock strategy.
     #
-    # Accepts either the (match, value) positional form or the keyword form
-    # (a { match:, value: } hash is also accepted). `match` must be callable;
-    # `value` is either a flat value injected directly or a callable invoked
-    # with the ctx hash.
+    # Accepts the (match, value) positional form, the keyword/hash form, one
+    # global resolver callable, or (trace_function_key, override_or_resolver).
+    # A resolver can return Bitfab::NO_MOCK_OVERRIDE to decline the span.
     #
     # @example keyword form (primary), flat value
     #   client.register_mock_override(
@@ -186,19 +186,43 @@ module Bitfab
     #     ->(ctx) { {label: "refund", inputs: ctx[:inputs]} }
     #   )
     #
-    # @param positional [Array] either (match, value) or a single
-    #   { match:, value: } hash
+    # @param positional [Array] a (match, value) pair, one { match:, value: }
+    #   hash, one global resolver, or a trace function key followed by a
+    #   resolver or override hash
     # @param match [#call, nil] keyword form matcher
     # @param value [Object, #call, nil] keyword form injected value or producer
     # @return [void]
     def register_mock_override(*positional, match: nil, value: VALUE_UNSET)
       if match.nil? && value.equal?(VALUE_UNSET)
-        if positional.length == 1 && positional[0].is_a?(Hash)
+        if positional.length == 2 && positional[0].is_a?(String)
+          trace_function_key, keyed_override = positional
+          if keyed_override.is_a?(Hash) && keyed_override[:match].respond_to?(:call) && keyed_override.key?(:value)
+            keyed_match = keyed_override[:match]
+            @mock_overrides << {
+              match: ->(node) { node[:trace_function_key] == trace_function_key && keyed_match.call(node) },
+              value: keyed_override[:value]
+            }
+            return nil
+          end
+          if keyed_override.respond_to?(:call)
+            @mock_overrides << {
+              match: ->(node) { node[:trace_function_key] == trace_function_key },
+              value: keyed_override
+            }
+            return nil
+          end
+          raise ArgumentError,
+            "register_mock_override(trace_function_key, override) requires " \
+            "a { match:, value: } hash or callable resolver."
+        elsif positional.length == 1 && positional[0].is_a?(Hash)
           override = positional[0]
           match = override[:match]
           # Distinguish an omitted :value from an explicit `value: nil`: the
           # key's presence, not a nil read, is what marks it provided.
           value = override.key?(:value) ? override[:value] : VALUE_UNSET
+        elsif positional.length == 1 && positional[0].respond_to?(:call)
+          @mock_overrides << {match: ->(_) { true }, value: positional[0]}
+          return nil
         elsif positional.length == 2
           match, value = positional
         end
@@ -782,8 +806,9 @@ module Bitfab
           type: span_type,
           original_span_id: mock_entry && mock_entry[:source_span_id]
         }
-        override = overrides.find { |o| o[:match].call(node) }
-        if override
+        overrides.each do |override|
+          next unless override[:match].call(node)
+
           value = override[:value]
           # value is EITHER a flat value (injected directly) OR a callable
           # invoked with the ctx hash. The result IS the span's output (full
@@ -791,7 +816,10 @@ module Bitfab
           # override always injects, execute_span short-circuits even when this
           # is nil (nil != MOCK_REPLAY_MISS). To inject a proc as the literal
           # output, wrap it in a callable value.
-          return [value, "override"] unless value.respond_to?(:call)
+          unless value.respond_to?(:call)
+            return [value, "override"] unless value.equal?(NO_MOCK_OVERRIDE)
+            next
+          end
 
           get_original_output = lambda do
             unless mock_entry
@@ -799,7 +827,8 @@ module Bitfab
             end
             resolve_recorded_output(mock_entry, replay_ctx)
           end
-          return [value.call({node:, inputs: args, kwargs:, get_original_output:}), "override"]
+          resolved = value.call({node:, inputs: args, kwargs:, get_original_output:})
+          return [resolved, "override"] unless resolved.equal?(NO_MOCK_OVERRIDE)
         end
       end
 

data/lib/bitfab/mock_override.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 module Bitfab
+  # Return from an override resolver to continue to the next override and then
+  # the replay's base mock strategy.
+  NO_MOCK_OVERRIDE = Object.new.freeze
+
   # Selective mock overrides for replay. Mirrors the TypeScript SDK's
   # mockOverride feature.
   #
@@ -10,8 +14,10 @@ module Bitfab
   # substituted output. This is a third mock mode alongside "run real code" and
   # "replay recorded output" (see MOCK_STRATEGIES in replay.rb).
   #
-  # An override is a (match, value) pair, represented as a symbol-keyed hash
-  # { match:, value: }:
+  # An override is a (match, value) pair represented as { match:, value: }, or
+  # one global resolver invoked for every child span. A resolver can route on
+  # ctx[:node][:trace_function_key] and return Bitfab::NO_MOCK_OVERRIDE to
+  # decline the current span.
   #
   # - match is a callable (proc/lambda): match.call(node) -> boolean. node is a
   #   structural-metadata hash { trace_function_key:, span_name:, type:,
@@ -38,9 +44,8 @@ module Bitfab
   module MockOverride
     module_function
 
-    # Normalize the per-call `mock_override` option (a single override hash, an
-    # array of them, or nil) into an array. First match wins downstream, so
-    # order is preserved.
+    # Normalize the per-call `mock_override` option (an override hash, a global
+    # resolver callable, an array, or nil) into an ordered override array.
     #
     # Each override is validated: it must be a hash with a callable `:match` and
     # must include a `:value` key. A forgotten `:value` raises rather than
@@ -49,12 +54,15 @@ module Bitfab
     # `register_mock_override`, and the Python/TypeScript SDKs, where the per-call
     # override object requires a value.
     #
-    # @param mock_override [Hash, Array<Hash>, nil]
+    # @param mock_override [Hash, Proc, Array<Hash, Proc>, nil]
     # @return [Array<Hash>]
     def normalize(mock_override)
       return [] if mock_override.nil?
 
       overrides = mock_override.is_a?(Array) ? mock_override : [mock_override]
+      overrides = overrides.map do |override|
+        override.respond_to?(:call) ? {match: ->(_) { true }, value: override} : override
+      end
       overrides.each do |override|
         unless override.is_a?(Hash) && override[:match].respond_to?(:call)
           raise ArgumentError,

data/lib/bitfab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bitfab
-  VERSION = "0.38.1"
+  VERSION = "0.38.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.38.1
+  version: 0.38.2
 platform: ruby
 authors:
 - Harvest Team