both_is_good 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0a0f01162c428c642c314b4abfcef3d918315c7816fc2b3ee1d31cdf276eb18
+  data.tar.gz: b8a4aa017737830cfe38dd8b47be2bca99d0b42258df9312c5f91dd410457ecd
+SHA512:
+  metadata.gz: 04f815942d66db366b44ec374ffabeba0094b1b64c41483b7a328ca4732191eae62075b2402fb4313bb7504468b5f0aac95e04f3e8029b906f4aedad618da5bd
+  data.tar.gz: a7a640ba54f642e98a0f67c06b3745cfe47a9b75b9bc5399691001e88139a6ef4282b96d9cb6b82cdbcf52cb1811a3b708b9b21eb8a84cc2edd680a90b59f4c5

data/.gitignore

@@ -0,0 +1,4 @@
+.ruby-version
+.ruby-gemset
+*.gem
+coverage/

data/.mdl_rules.rb

@@ -0,0 +1,2 @@
+all
+rule "MD013", ignore_code_blocks: true

data/.mdlrc

@@ -0,0 +1,2 @@
+style File.expand_path("../.mdl_rules.rb", __FILE__)
+git_recurse true

data/.quiet_quality.yml

@@ -0,0 +1,7 @@
+---
+default_tools: ["standardrb", "rubocop", "markdown_lint", "rspec"]
+executor: concurrent
+comparison_branch: origin/main
+logging: light
+changed_files: false
+filter_messages: false

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,22 @@
+---
+AllCops:
+  SuggestExtensions: false
+  DisabledByDefault: true
+  TargetRubyVersion: 3.1
+
+Metrics/AbcSize:
+  Max: 15
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/PerceivedComplexity:
+  Max: 7
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true

data/.standard.yml

@@ -0,0 +1 @@
+ruby_version: 3.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Eric Mueller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# BothIsGood
+
+This gem adds a module to include into classes, supplying a convenient, concise way
+to implement multiple versions of the same method, and _run them both_. Then you
+can still _use_ the old implementation, but get an alert or log message if the new
+version ever produces a different result.
+
+This is not a new concept; `scientist` pioneered the approach in 2016. But scientist
+is moderately _heavy_, and takes significant effort to use, so I've ended up implementing
+lightweight dual-implementation libraries multiple times; this time I'm publishing
+it so I won't have to do so again later!
+
+## Inline Invocation
+
+The "simplest" way to use BothIsGood is 'inline' - no configuration object, you just
+supply all of the needed options on the `implemented_twice` call in place.
+
+```ruby
+include BothIsGood
+
+def foo_one = implementation(details)
+def foo_two = more_implementation(details)
+
+# A minimal call. Note that with no global configuration this is not very valuable,
+# since if the implementations disagree, there's no hook implemented to _tell you_ that.
+implemented_twice(:foo, primary: :foo_one, secondary: :foo_two)
+
+# A complex call using all of the available options:
+implemented_twice(
+  :foo,
+  primary: :foo_one,
+  secondary: :foo_two,
+  rate: 0.01,
+  comparator: ->(val_one, val_two) { Math.abs(val_one - val_two) < 0.01 },
+  on_mismatch: ->(val_one, val_two) { LOGGER.warn("result mismatch on Foo#foo_one vs Foo#foo_two: #{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("calling foo_one with #{args.to_json} produced error #{err.class.name}") },
+  on_secondary_error: ->(err, args) { LOGGER.warn("calling foo_two with #{args.to_json} produced error #{err.class.name}") },
+  on_hook_error: ->(err) { LOGGER.warn("OH NO! #{err.class.name}: #{err.message}") }
+)
+```
+
+The method takes these parameters:
+
+* The (only) positional parameter is the name of the method it will implement.
+  This _can_ match the 'primary' or 'secondary' name (but not both, obviously),
+  and if it does, `implemented_twice` will alias the existing method out of the
+  way (to `_bothisgood_primary_#{name}` or `_bothisgood_secondary_#{name}`).
+* The `primary:` parameter specifies a method name that will be called _and have
+  its result used as the result of the final method_ regardless of the comparison
+  outcome. Errors from the primary method are bubbled up as usual.
+* The `secondary:` parameter specifies a method name that will be called for
+  comparison's sake (though not necessarily every time). Errors raised from the
+  secondary method are swallowed.
+* The `rate:` parameter (default 1.0) specifies what fraction of the calls should
+  bother evaluating the secondary implementation for comparison. If the
+  implementation is costly (makes significant database calls, for example) and/or
+  invoked frequently, you probably want a lower rate, at least in production.
+* The `comparator:` parameter takes a callable, and yields two arguments to it
+  (the results of the two implementations); its result is either truthy or falsey.
+  By default, comparison is done using `==`.
+* The `on_mismatch:` parameter takes a callable (lamba or Proc generally). It will
+  yield the two values being compared, but can yield additional details depending
+  on the arity of the callable; arities 2, 3, and 4 are all supported, and will be
+  yielded the arguments supplied, and then a Hash of the implementation method
+  names like `{primary: :foo_one, secondary: :foo_two}`. It will be invoked any
+  time the results of the two implementations _differ_.
+* The `on_compare:` parameter takes the same shaped argument, but will be fired
+  any time both implementations are evaluated (so every time, unless `rate` is set)
+* The `on_primary_error:` parameter takes a callable and yields 1, 2, or 3
+  arguments to it, depending on its arity - those arguments are the StandardError
+  instance rescued, the args supplied to the implementation (as an array,
+  potentially with a Hash arg at the end for any kwargs), and the name of the
+  primary method. The exception will be re-raised after handling.
+* The `on_secondary_error:` parameter behaves identically (yielding the secondary
+  method name), but secondary exceptions are _not_ re-raised.
+* 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. None of us write bug-free code, and the callbacks
+  supplied to `implemented_twice` are no exception. Those errors will be swallowed
+  if `on_hook_error` is supplied (unless your hook raises the error!), but will be
+  bubbled otherwise.
+
+`implemented_twice` can additionally be called with three positional parameters;
+the second parameter is used as the `primary` method name, and the third parameter
+is used as the `secondary` method name. That means that, if you use a configuration
+object, you can just:
+
+```ruby
+include BothIsGood
+
+def foo_one = implementation(details)
+def foo_two = more_implementation(details)
+
+# defines `foo`, using `foo_one` as the primary implementation and `foo_two` as secondary.
+implemented_twice :foo, :foo_one, :foo_two
+```
+
+If it is called with _two_ positional parameters, it will use the first argument
+as both the final method name _and_ the primary implementation.
+
+```ruby
+include BothIsGood
+
+def foo = implementation(details)
+def foo_two = more_implementation(details)
+
+# Defines `foo`, using `foo` as the primary implementation and `foo_two` as secondary.
+# In the process, the original `foo` method is redefined as `_bothisgood_primary_foo`.
+implemented_twice :foo, :foo_two
+```
+
+## Configuration
+
+All of those parameters aside from the positional, `primary`, and `secondary` ones
+can be configured globally, or onto a BothIsGood::Configuration object, to avoid
+having to supply them constantly.
+
+```ruby
+# Global configuration
+BothIsGood.configure do |config|
+  config.rate = 0.5
+  config.on_compare = ->(a, b) { LOGGER.puts "compared!" }
+  config.on_hook_error = ->(e) { LOGGER.puts "bad -.-" }
+end
+
+# Local configuration - starting values are taken from the global config
+MY_BIG_CONFIG = BothIsGood::Configuration.new
+MY_BIG_CONFIG.rate = 0.7
+MY_BIG_CONFIG.on_secondary_error = ->(a, b) { LOGGER.puts "No" }
+
+module MyFoo
+  include BothIsGood
+  self.both_is_good_configure(MY_BIG_CONFIG)
+end
+
+
+# In-class configuration - starting values are taken from the global config, or the
+# supplied config object if one is given.
+module MyBar
+  include BothIsGood
+  self.both_is_good_configure(rate: 0.02)
+end
+```

data/both_is_good.gemspec

@@ -0,0 +1,42 @@
+require_relative "lib/both_is_good/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "both_is_good"
+  spec.version = BothIsGood::VERSION
+  spec.authors = ["Eric Mueller"]
+  spec.email = ["nevinera@gmail.com"]
+
+  spec.summary = "A convenient way to give a method multiple implementations"
+  spec.description = <<~DESC
+    BothIsGood adds a clean way to run multiple implementations of a method,
+    switching between them using a feature-flagging system or other static or
+    runtime method, and potentially run multiple implementations to confirm
+    accuracy.
+  DESC
+
+  spec.homepage = "https://github.com/nevinera/both_is_good"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.start_with?("spec") }
+      .reject { |f| f.start_with?("Gemfile") }
+  end
+
+  spec.bindir = "bin"
+  spec.executables = []
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+  spec.add_development_dependency "pry", "~> 0.15"
+  spec.add_development_dependency "standard", "= 1.37.0"
+  spec.add_development_dependency "rubocop", "~> 1.63"
+  spec.add_development_dependency "quiet_quality", "~> 1.5"
+  spec.add_development_dependency "mdl", "~> 0.13"
+end

data/lib/both_is_good/configuration.rb

@@ -0,0 +1,94 @@
+module BothIsGood
+  class Configuration
+    DEFAULTS = {
+      rate: 1.0,
+      on_mismatch: nil,
+      on_compare: nil,
+      on_primary_error: nil,
+      on_secondary_error: nil,
+      on_hook_error: nil
+    }.freeze
+
+    ATTRIBUTES = DEFAULTS.keys.freeze
+    UNSUPPLIED = Object.new.freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    def self.global
+      @global ||= new(nil, **DEFAULTS)
+    end
+
+    def initialize(supplied_base = UNSUPPLIED, **overrides)
+      base = base_config(supplied_base)
+      apply_initial_values(base, **overrides)
+    end
+
+    def dup = self.class.new(self)
+
+    def rate=(value)
+      unless value.is_a?(Numeric) && (0.0..1.0).cover?(value)
+        raise ArgumentError, "rate must be a number between 0.0 and 1.0, got #{value.inspect}"
+      end
+      @rate = value
+    end
+
+    def on_mismatch=(value)
+      validate_hook!(:on_mismatch, value, [2, 3, 4])
+      @on_mismatch = value
+    end
+
+    def on_compare=(value)
+      validate_hook!(:on_compare, value, [2, 3, 4])
+      @on_compare = value
+    end
+
+    def on_primary_error=(value)
+      validate_hook!(:on_primary_error, value, [1, 2, 3])
+      @on_primary_error = value
+    end
+
+    def on_secondary_error=(value)
+      validate_hook!(:on_secondary_error, value, [1, 2, 3])
+      @on_secondary_error = value
+    end
+
+    def on_hook_error=(value)
+      validate_hook!(:on_hook_error, value, [1])
+      @on_hook_error = value
+    end
+
+    private
+
+    def validate_hook!(name, value, valid_arities)
+      return if value.nil?
+
+      unless value.respond_to?(:call) && valid_arities.include?(value.arity)
+        raise ArgumentError, "#{name} must be nil or callable with arity in #{valid_arities.inspect}"
+      end
+    end
+
+    def base_config(supplied_base)
+      if supplied_base == UNSUPPLIED
+        Configuration.global
+      else
+        supplied_base
+      end
+    end
+
+    def initial_value_for(base, attr:, default:, overrides:)
+      if overrides.key?(attr)
+        overrides[attr]
+      elsif base
+        base.public_send(attr)
+      else
+        default
+      end
+    end
+
+    def apply_initial_values(base, **overrides)
+      DEFAULTS.each_pair do |attr, default|
+        public_send(:"#{attr}=", initial_value_for(base, attr:, default:, overrides:))
+      end
+    end
+  end
+end

data/lib/both_is_good/implemented_twice.rb

@@ -0,0 +1,12 @@
+module BothIsGood
+  class ImplementedTwice
+    def initialize(owner, primary:, secondary:, **opts)
+      base = owner.both_is_good_configuration
+      @local_config = LocalConfiguration.new(base, owner:, primary:, secondary:, **opts)
+    end
+
+    def call(target, *args, **kwargs)
+      Invocation.new(@local_config, target, args, kwargs).run
+    end
+  end
+end

data/lib/both_is_good/invocation.rb

@@ -0,0 +1,113 @@
+module BothIsGood
+  class Invocation
+    include BothIsGood::Memoization
+
+    def initialize(local_config, target, args, kwargs)
+      @config = local_config
+      @target = target
+      @args = args
+      @kwargs = kwargs
+      @memo = {}
+    end
+
+    def run
+      invoke_primary!
+      invoke_secondary! if trigger?
+      primary_result
+    end
+
+    private
+
+    memoize def primary = @config.primary
+    memoize def secondary = @config.secondary
+
+    memoize def trigger? = rand < @config.rate
+
+    def invoke_primary!
+      primary_result
+    rescue => e
+      on_primary_error(e)
+      raise
+    end
+
+    def invoke_secondary!
+      secondary_result
+    rescue => e
+      on_secondary_error(e)
+    else
+      on_secondary_success
+    end
+
+    memoize def primary_result = @target.send(@config.primary, *@args, **@kwargs)
+    memoize def secondary_result = @target.send(@config.secondary, *@args, **@kwargs)
+
+    def on_primary_error(error)
+      hook = @config.on_primary_error
+      with_hook_error_handling { invoke_error_hook(hook, 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)
+      end
+    end
+
+    def on_secondary_success
+      matched = compare(primary_result, secondary_result)
+      on_compare
+      on_mismatch unless matched
+    end
+
+    def on_compare
+      return unless @config.on_compare
+
+      with_hook_error_handling do
+        invoke_result_hook(@config.on_compare, primary_result, secondary_result)
+      end
+    end
+
+    def on_mismatch
+      return unless @config.on_mismatch
+
+      with_hook_error_handling do
+        invoke_result_hook(@config.on_mismatch, primary_result, secondary_result)
+      end
+    end
+
+    def with_hook_error_handling
+      yield
+    rescue => e
+      if @config.on_hook_error
+        @config.on_hook_error.call(e)
+      else
+        raise
+      end
+    end
+
+    def compare(primary_result, secondary_result)
+      comparator = @config.comparator
+      comparator ? comparator.call(primary_result, secondary_result) : primary_result == secondary_result
+    end
+
+    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
+    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
+    end
+  end
+end

data/lib/both_is_good/local_configuration.rb

@@ -0,0 +1,33 @@
+module BothIsGood
+  class LocalConfiguration < Configuration
+    LOCAL_ATTRIBUTES = %i[primary secondary comparator].freeze
+
+    attr_reader(*LOCAL_ATTRIBUTES)
+
+    def initialize(base_config, owner:, primary:, secondary:, **opts)
+      comparator = opts.delete(:comparator)
+      super(base_config, **opts)
+      @primary = validated_method(owner, :primary, primary)
+      @secondary = validated_method(owner, :secondary, secondary)
+      @comparator = validated_comparator(comparator)
+    end
+
+    private
+
+    def validated_method(owner, role, name)
+      raise ArgumentError, "#{role} must not be nil" if name.nil?
+      unless owner.method_defined?(name)
+        raise ArgumentError, "#{role} method #{name.inspect} is not defined on #{owner}"
+      end
+      name
+    end
+
+    def validated_comparator(value)
+      return nil if value.nil?
+      unless value.respond_to?(:call) && value.arity == 2
+        raise ArgumentError, "comparator must be nil or callable with arity 2"
+      end
+      value
+    end
+  end
+end

data/lib/both_is_good/memoization.rb

@@ -0,0 +1,23 @@
+module BothIsGood
+  module Memoization
+    def self.included(base) = base.extend(ClassMethods)
+
+    module ClassMethods
+      def memoize(method_name)
+        original_method = instance_method(method_name)
+
+        define_method(method_name) do |*args|
+          raise ArgumentError, "Cannot memoize methods that take arguments" if args.any?
+
+          @memo ||= {}
+
+          if @memo.key?(method_name)
+            @memo[method_name]
+          else
+            @memo[method_name] = original_method.bind_call(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/both_is_good/version.rb

@@ -0,0 +1,3 @@
+module BothIsGood
+  VERSION = "0.3.0"
+end

data/lib/both_is_good.rb

@@ -0,0 +1,111 @@
+require_relative "both_is_good/memoization"
+
+module BothIsGood
+  def self.configuration = Configuration.global
+
+  def self.configure = yield(configuration)
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def both_is_good_configure(base = nil, **overrides)
+      @both_is_good_configuration =
+        if base
+          Configuration.new(base, **overrides)
+        else
+          Configuration.new(**overrides)
+        end
+    end
+
+    def both_is_good_configuration
+      @both_is_good_configuration || BothIsGood.configuration
+    end
+
+    def implemented_twice(*positional, primary: nil, secondary: nil, **opts)
+      implementer = DualImplementer.new(*positional, target: self, primary:, secondary:, **opts)
+      implementer.apply_aliases!
+      runner = implementer.implementation
+
+      define_method(implementer.name) do |*args, **kwargs|
+        runner.call(self, *args, **kwargs)
+      end
+    end
+  end
+
+  class DualImplementer
+    include Memoization
+
+    def initialize(*positional, target:, primary:, secondary:, **opts)
+      @target = target
+      @positional = positional
+      @kw_primary = primary
+      @kw_secondary = secondary
+      @opts = opts
+
+      validate!
+    end
+
+    attr_reader :positional, :target, :opts
+
+    memoize def name = positional.first
+    memoize def primary = aliased_primary? ? :"_bothisgood_primary_#{name}" : original_primary
+    memoize def secondary = aliased_secondary? ? :"_bothisgood_secondary_#{name}" : original_secondary
+
+    def apply_aliases!
+      target.alias_method(primary, name) if aliased_primary?
+      target.alias_method(secondary, name) if aliased_secondary?
+    end
+
+    memoize def implementation = ImplementedTwice.new(target, primary:, secondary:, **opts)
+
+    private
+
+    memoize def original_primary = @kw_primary || positional[-2]
+    memoize def original_secondary = @kw_secondary || positional.last
+
+    memoize def aliased_primary? = original_primary == name
+    memoize def aliased_secondary? = original_secondary == name
+
+    def validate!
+      validate_name_supplied!
+      validate_secondary_supplied!
+      validate_no_primary_secondary_match!
+      validate_no_mixing!
+      validate_no_extra_positional!
+    end
+
+    def validate_name_supplied!
+      return unless positional.empty?
+      raise(ArgumentError, "the 'name' positional parameter is required")
+    end
+
+    def validate_secondary_supplied!
+      return if @kw_secondary || positional.length >= 2
+      raise ArgumentError, "secondary is required, either as a positional argument or as a keyword argument"
+    end
+
+    def validate_no_primary_secondary_match!
+      return if original_primary != original_secondary
+      raise ArgumentError, "primary and secondary cannot be the same method"
+    end
+
+    def validate_no_mixing!
+      return if positional.length <= 1
+      return if @kw_primary.nil? && @kw_secondary.nil?
+      raise ArgumentError, "cannot mix positional and keyword primary:/secondary:"
+    end
+
+    def validate_no_extra_positional!
+      return if positional.length <= 3
+      raise ArgumentError, "implemented_twice takes at most 3 positional arguments"
+    end
+  end
+end
+
+require_relative "both_is_good/version"
+require_relative "both_is_good/configuration"
+require_relative "both_is_good/local_configuration"
+require_relative "both_is_good/invocation"
+require_relative "both_is_good/implemented_twice"

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: both_is_good
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Eric Mueller
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.37.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.37.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.63'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.63'
+- !ruby/object:Gem::Dependency
+  name: quiet_quality
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: mdl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+description: |
+  BothIsGood adds a clean way to run multiple implementations of a method,
+  switching between them using a feature-flagging system or other static or
+  runtime method, and potentially run multiple implementations to confirm
+  accuracy.
+email:
+- nevinera@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".mdl_rules.rb"
+- ".mdlrc"
+- ".quiet_quality.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".standard.yml"
+- LICENSE
+- README.md
+- both_is_good.gemspec
+- lib/both_is_good.rb
+- lib/both_is_good/configuration.rb
+- lib/both_is_good/implemented_twice.rb
+- lib/both_is_good/invocation.rb
+- lib/both_is_good/local_configuration.rb
+- lib/both_is_good/memoization.rb
+- lib/both_is_good/version.rb
+homepage: https://github.com/nevinera/both_is_good
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nevinera/both_is_good
+  source_code_uri: https://github.com/nevinera/both_is_good
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A convenient way to give a method multiple implementations
+test_files: []