both_is_good 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51b74df537030d143e21234302934cf0893cf9cb5e476c1eaf11d7451454b986
-  data.tar.gz: bda32fe8c40fe83abcbb8e416f1f3e2ce4f465ec6f125b9f5a28264305df20c8
+  metadata.gz: 2d102cfa072abe3f151cdb8ab22d34735fe6652c44742f3cb97042f0f09e9696
+  data.tar.gz: cf94ded67dab441497ec2b6bd3d95c06b79a4adbecbe3b20f9e904c563d5df2a
 SHA512:
-  metadata.gz: a368aa4dccf34706bbb6d0ca5b563cedd9af13920580775cf44cb7c5c135439e67b0b0fb306f6c9f0e467d21c19779ebb0c2ba69be15de89aec1a050c7e10fd7
-  data.tar.gz: 5d682bcfd654cae15d627aa53a51c0819a73874b70c6336df0177177e75ad1478e5ecb06f17724ce8537b71f7bec15f35452ea2180fe23115b34e170093e5949
+  metadata.gz: 6eb5a6c598cd9fe76a7596a5c2012d61f04b3c9c7bf289624c8ee52f5f928329f2502e4710fa8023f917c215b44e76e9f94752f76ed6e3a0129e9f215c741ab0
+  data.tar.gz: 989cfb3caa9f459b869829388e5256da660c7d729604f0024cb295a9f634aa623822b89438e9a25fa78bc35e6bf5a9a7d46bfbf5bf71e6ecb93454666e4d879e

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
-## 0.4.0 (unreleased)
+## 0.5.0
+
+### Breaking changes
+
+* All of the callables (except `on_hook_error`) are now passed a single
+  "context" object exposing the available data, instead of being yielded
+  complex lists of values depending on their arity. This also exposes
+  some additional data to those hooks for use.
+
+## 0.4.0
 
 ### Breaking changes
 

data/README.md

@@ -33,12 +33,12 @@ implemented_twice(
   original: :foo_one,
   replacement: :foo_two,
   rate: 0.01,
-  switch: ->(klass, name) { FeatureFlags.enabled?(:"enable_#{name}") },
+  switch: ->(ctx) { FeatureFlags.enabled?(:"enable_#{ctx.tag}") },
   comparator: ->(val_one, val_two) { Math.abs(val_one - val_two) < 0.01 },
-  on_mismatch: ->(val_one, val_two) { LOGGER.warn("mismatch: #{val_one} | #{val_two}") },
-  on_compare: ->(val_one, val_two) { LOGGER.warn("comparing #{val_one} to #{val_two}") },
-  on_primary_error: ->(err, args) { LOGGER.warn("primary error #{err.class.name}") },
-  on_secondary_error: ->(err, args) { LOGGER.warn("secondary error #{err.class.name}") },
+  on_mismatch: ->(ctx) { LOGGER.warn("mismatch: #{ctx.primary_result} | #{ctx.secondary_result}") },
+  on_compare: ->(ctx) { LOGGER.warn("comparing #{ctx.primary_result} to #{ctx.secondary_result}") },
+  on_primary_error: ->(ctx) { LOGGER.warn("primary error #{ctx.error.class.name}") },
+  on_secondary_error: ->(ctx) { LOGGER.warn("secondary error #{ctx.error.class.name}") },
   on_hook_error: ->(err) { LOGGER.warn("OH NO! #{err.class.name}: #{err.message}") }
 )
 ```
@@ -60,39 +60,35 @@ The method takes these parameters:
   should bother evaluating the shadow implementation for comparison. If the
   implementation is costly (makes significant database calls, for example)
   and/or invoked frequently, you probably want a lower rate in production.
-* The `switch:` parameter takes a callable with arity 0 or 2. When it returns
+* The `switch:` parameter takes a callable with arity 0 or 1. When it returns
   a truthy value, the roles swap: replacement becomes the return value and
-  original becomes the shadow (called at `rate` for comparison). Arity 2
-  receives the target's actual class and the method name as a symbol, making
-  it straightforward to drive from a feature-flag system:
-
-  ```ruby
-  switch: ->(klass, name) { FeatureFlags.enabled?(:"enable_#{klass}_#{name}") }
-  ```
-
-  `switch` can be set on a shared `Configuration` object so you only have to
-  define it once.
+  original becomes the shadow (called at `rate` for comparison). Arity 1
+  receives a `BothIsGood::Context::Switching` object, making it straightforward
+  to drive from a feature-flag system. The context exposes `target_class`,
+  `method_name`, `target_class_name`, `target_class_string` (underscored,
+  like `"my_module/my_class"`), and `tag` (like `"my_mod/my_class--my_method"`)
 * The `comparator:` parameter takes a callable, and yields two arguments to
   it (the results of the two implementations); its result is truthy or falsey.
   By default, comparison is done using `==`.
-* The `on_mismatch:` parameter takes a callable (lambda or Proc generally).
-  It supports arities 2, 3, and 4. The first two arguments are always the
-  _primary_ result (the one being returned) and the _secondary_ result (the
-  shadow). **When `switch` is active, these are `(replacement, original)`,
-  not `(original, replacement)`.** Arity 3 also receives a names hash like
-  `{primary: :foo_one, secondary: :foo_two}` reflecting the current role
-  assignment. Arity 4 additionally receives the call args array before the
-  names hash. It fires any time the results _differ_.
-* The `on_compare:` parameter takes the same shaped argument, but fires any
+* The `on_mismatch:` parameter takes a callable that receives a
+  `BothIsGood::Context::Result`. It fires any time the results _differ_.
+* The `on_compare:` parameter takes the same shaped callable, but fires any
   time both implementations are evaluated (every time unless `rate` is set).
-* The `on_primary_error:` parameter takes a callable and yields 1, 2, or 3
-  arguments: the StandardError rescued, the args supplied (as an array,
-  potentially with a Hash at the end for kwargs), and the name of the primary
-  method. The exception will be re-raised after handling. With `switch`
-  active, "primary" is the replacement method.
-* The `on_secondary_error:` parameter behaves identically (yielding the
-  secondary method name), but secondary exceptions are _not_ re-raised.
-  With `switch` active, "secondary" is the original method.
+
+  The result context exposes `primary_result`, `secondary_result`,
+  `primary_name`, `secondary_name`, `args`, `target_class`, `method_name`,
+  `target_class_name`, `target_class_string`, and `tag`. **When `switch` is
+  active, "primary" is the replacement and "secondary" is the original.**
+* The `on_primary_error:` parameter takes a callable that receives a
+  `BothIsGood::Context::Error`. The exception will be re-raised after
+  handling. With `switch` active, "primary" is the replacement method.
+* The `on_secondary_error:` parameter takes the same shaped callable, but
+  secondary exceptions are _not_ re-raised. With `switch` active, "secondary"
+  is the original method.
+
+  The error context exposes `error`, `args`, `dispatched_name` (the actual
+  method called - primary or secondary), `target_class`, `method_name`,
+  `target_class_name`, `target_class_string`, and `tag`.
 * The `on_hook_error:` parameter is a callable that will be yielded _one_
   parameter (the StandardError instance), and is invoked if an error is
   _raised_ during one of the other hooks. Those errors will be swallowed if
@@ -138,7 +134,7 @@ avoid having to supply them constantly.
 # Global configuration
 BothIsGood.configure do |config|
   config.rate = 0.5
-  config.switch = ->(klass, name) { FeatureFlags.enabled?(:"enable_#{name}") }
+  config.switch = ->(ctx) { FeatureFlags.enabled?(:"enable_#{ctx.tag}") }
   config.on_compare = ->(a, b) { LOGGER.puts "compared!" }
   config.on_hook_error = ->(e) { LOGGER.puts "bad -.-" }
 end

data/lib/both_is_good/configuration.rb

@@ -34,27 +34,27 @@ module BothIsGood
     end
 
     def switch=(value)
-      validate_hook!(:switch, value, [0, 2])
+      validate_hook!(:switch, value, [0, 1])
       @switch = value
     end
 
     def on_mismatch=(value)
-      validate_hook!(:on_mismatch, value, [2, 3, 4])
+      validate_hook!(:on_mismatch, value, [1])
       @on_mismatch = value
     end
 
     def on_compare=(value)
-      validate_hook!(:on_compare, value, [2, 3, 4])
+      validate_hook!(:on_compare, value, [1])
       @on_compare = value
     end
 
     def on_primary_error=(value)
-      validate_hook!(:on_primary_error, value, [1, 2, 3])
+      validate_hook!(:on_primary_error, value, [1])
       @on_primary_error = value
     end
 
     def on_secondary_error=(value)
-      validate_hook!(:on_secondary_error, value, [1, 2, 3])
+      validate_hook!(:on_secondary_error, value, [1])
       @on_secondary_error = value
     end
 

data/lib/both_is_good/context/error.rb

@@ -0,0 +1,25 @@
+module BothIsGood
+  module Context
+    class Error
+      include BothIsGood::Memoization
+      include BothIsGood::Context::Names
+
+      attr_reader :error, :args, :dispatched_name
+
+      def initialize(target:, args:, error:, dispatched_name:)
+        @target = target
+        @args = args
+        @error = error
+        @dispatched_name = dispatched_name
+      end
+
+      def target_class = @target.target_class
+
+      def method_name = @target.method_name
+
+      memoize def target_class_name = target_class.name
+      memoize def target_class_string = class_to_tag(target_class)
+      memoize def tag = method_to_tag(target_class, method_name)
+    end
+  end
+end

data/lib/both_is_good/context/names.rb

@@ -0,0 +1,17 @@
+module BothIsGood
+  module Context
+    module Names
+      def underscore(supplied_name)
+        supplied_name
+          .gsub("::", "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+      end
+
+      def class_to_tag(klass) = underscore(klass.name)
+
+      def method_to_tag(klass, method_name) = "#{class_to_tag(klass)}--#{method_name}"
+    end
+  end
+end

data/lib/both_is_good/context/result.rb

@@ -0,0 +1,32 @@
+module BothIsGood
+  module Context
+    class Result
+      include BothIsGood::Memoization
+      include BothIsGood::Context::Names
+
+      attr_reader :args, :primary_result, :secondary_result
+
+      def initialize(target:, args:, primary_result:, secondary_result:, names:)
+        @target = target
+        @args = args
+        @primary_result = primary_result
+        @secondary_result = secondary_result
+        @names = names
+      end
+
+      memoize def target_class = @target.target_class
+
+      memoize def method_name = @target.method_name
+
+      memoize def primary_name = @names[:primary]
+
+      memoize def secondary_name = @names[:secondary]
+
+      memoize def target_class_name = target_class.name
+
+      memoize def target_class_string = class_to_tag(target_class)
+
+      memoize def tag = method_to_tag(target_class, method_name)
+    end
+  end
+end

data/lib/both_is_good/context/switching.rb

@@ -0,0 +1,21 @@
+module BothIsGood
+  module Context
+    class Switching
+      include BothIsGood::Memoization
+      include BothIsGood::Context::Names
+
+      def initialize(target_class, method_name)
+        @target_class = target_class
+        @method_name = method_name
+      end
+
+      attr_reader :target_class, :method_name
+
+      memoize def target_class_name = target_class.name
+
+      memoize def target_class_string = class_to_tag(target_class)
+
+      memoize def tag = method_to_tag(target_class, method_name)
+    end
+  end
+end

data/lib/both_is_good/context.rb

@@ -0,0 +1,4 @@
+require_relative "context/names"
+require_relative "context/switching"
+require_relative "context/result"
+require_relative "context/error"

data/lib/both_is_good/invocation.rb

@@ -24,7 +24,7 @@ module BothIsGood
       elsif @config.switch.arity == 0
         @config.switch.call
       else
-        @config.switch.call(@target.target_class, @target.method_name)
+        @config.switch.call(BothIsGood::Context::Switching.new(@target.target_class, @target.method_name))
       end
     end
 
@@ -53,14 +53,14 @@ module BothIsGood
 
     def on_primary_error(error)
       hook = @config.on_primary_error
-      with_hook_error_handling { invoke_error_hook(hook, error, primary) } if hook
+      with_hook_error_handling { hook.call(error_context(error, primary)) } if hook
     end
 
     def on_secondary_error(error)
       return unless @config.on_secondary_error
 
       with_hook_error_handling do
-        invoke_error_hook(@config.on_secondary_error, error, secondary)
+        @config.on_secondary_error.call(error_context(error, secondary))
       end
     end
 
@@ -74,7 +74,7 @@ module BothIsGood
       return unless @config.on_compare
 
       with_hook_error_handling do
-        invoke_result_hook(@config.on_compare, primary_result, secondary_result)
+        @config.on_compare.call(result_context)
       end
     end
 
@@ -82,7 +82,7 @@ module BothIsGood
       return unless @config.on_mismatch
 
       with_hook_error_handling do
-        invoke_result_hook(@config.on_mismatch, primary_result, secondary_result)
+        @config.on_mismatch.call(result_context)
       end
     end
 
@@ -104,20 +104,23 @@ module BothIsGood
     memoize def names = {primary:, secondary:}
     memoize def call_args = @kwargs.empty? ? @args : [*@args, @kwargs]
 
-    def invoke_result_hook(hook, primary_result, secondary_result)
-      case hook.arity
-      when 2 then hook.call(primary_result, secondary_result)
-      when 3 then hook.call(primary_result, secondary_result, names)
-      else hook.call(primary_result, secondary_result, call_args, names)
-      end
+    memoize def result_context
+      BothIsGood::Context::Result.new(
+        target: @target,
+        args: call_args,
+        primary_result:,
+        secondary_result:,
+        names:
+      )
     end
 
-    def invoke_error_hook(hook, error, method_name)
-      case hook.arity
-      when 1 then hook.call(error)
-      when 2 then hook.call(error, call_args)
-      else hook.call(error, call_args, method_name)
-      end
+    def error_context(error, dispatched_name)
+      BothIsGood::Context::Error.new(
+        target: @target,
+        args: call_args,
+        error:,
+        dispatched_name:
+      )
     end
   end
 end

data/lib/both_is_good/version.rb

@@ -1,3 +1,3 @@
 module BothIsGood
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/both_is_good.rb

@@ -105,6 +105,7 @@ module BothIsGood
   end
 end
 
+require_relative "both_is_good/context"
 require_relative "both_is_good/version"
 require_relative "both_is_good/configuration"
 require_relative "both_is_good/local_configuration"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: both_is_good
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -132,6 +132,11 @@ files:
 - both_is_good.gemspec
 - lib/both_is_good.rb
 - lib/both_is_good/configuration.rb
+- lib/both_is_good/context.rb
+- lib/both_is_good/context/error.rb
+- lib/both_is_good/context/names.rb
+- lib/both_is_good/context/result.rb
+- lib/both_is_good/context/switching.rb
 - lib/both_is_good/implemented_twice.rb
 - lib/both_is_good/invocation.rb
 - lib/both_is_good/local_configuration.rb