mocktail 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e719e2144c3da8a2569e2ef5e7cf2c78d054625011fcf0bdf8f98f300bdcd805
-  data.tar.gz: 3635b7210ac6d5a7c05c4000f100ac1e07f4c8d5de7de81586e41f3b81e11ce5
+  metadata.gz: 426f5dbb08f6db2542f0a323d186df7126aaae652e848b0a0c378a602231d777
+  data.tar.gz: 898501920257accc975d441a12d9e54a034c40aef8c950be2f0fa80aeb0288c6
 SHA512:
-  metadata.gz: d84b7964c5fbe14e3ef2a8a881c1c328f0f4c37cbde2d1423965016fe26f153c6801032c5aa4a7018db6d98924aecbb031e3e473992178bb9d5fe46e53ac2ea5
-  data.tar.gz: 384e42b818b92ace165e975dafd1482e00a46fc3be4c4abf0bb54e2ff648f29da1b338a8845be5c64e1878abf738e4061345083c0e952206380119ecb82729cf
+  metadata.gz: 6eea3625f3851c035e00c1593e91ae7d97c76b499510a71bd8b68fb0cfb27c4cac9116f9224f30853a97cfb6826385338506e33bf2ea6d43160f12093e8a591c
+  data.tar.gz: 1e6041f4ea59a42c40b6ef42bf99f106f43eb18d3ec452580784072046f099af26753e61e79704679fba7973bc19b59b3b9cdf0b537fd95e20caceeb18a719ef

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# unreleased
+
+* Introduce Mocktail.explain(), which will return a message & reference object
+  for any of:
+  * A class that has been passed to Mocktail.replace()
+  * An instance created by Mocktail.of() or of_next()
+  * A nil value returned by an unsatisfied stubbing invocation
+* Fix some minor printing issue with the improved NoMethodError released in
+  0.0.3
+
+
 # 0.0.3
 
 * Implement method_missing on all mocked instance methods to print out useful

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mocktail (0.0.3)
+    mocktail (0.0.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -50,26 +50,37 @@ assert_equal "🎉", result
 verify { glass.pour!(:a_drink) }
 ```
 
-## Why order?
-
-Besides a lack of hangover, Mocktail offers several advantages over other
-mocking libraries:
-
-* **Fewer hoops to jump through**: [`Mocktail.of_next(type)`] avoids the need
-  for dependency injection by returning a Mocktail of the type the next time
-  `Type.new` is called. You can inject a fake into production code in one
-  line.
-* **Fewer false test passes**: Arity of arguments and keyword arguments of faked
-  methods is enforced—no more tests that keep passing after an API changes
-* **Super-duper detailed error messages when verifications fail**
-* **Fake class methods**: Singleton methods on classes and modules can be
-  replaced with [`Mocktail.replace(type)`](#mocktailreplace) while still
-  preserving thread safety
-* **Less test setup**: Dynamic stubbings based on the arguments passed to the actual call
+## Why Mocktail?
+
+Besides helping you avoid a hangover, Mocktail offers several advantages over
+Ruby's other mocking libraries:
+
+* **Simpler test recipes**: [Mocktail.of_next(type)](#mocktailof_next) both
+  creates your mock and supplies to your subject under test in a single
+  one-liner. No more forcing dependency injection for the sake of your tests
+* **WYSIWYG API**: Want to know how to stub a call to `phone.dial(911)`? You
+  just demonstrate the call with `stubs { phone.dial(911) }.with { :operator }`.
+  Because stubbing & verifying looks just like the actual call, your tests
+  becomes a sounding board for your APIs as you invent them
+* **Argument validation**: Ever see a test pass after a change to a mocked
+  method should have broken it? Not with Mocktail, you haven't
+* **Mocked class methods**: Singleton methods on modules and classes can be
+  faked out using [`Mocktail.replace(type)`](#mocktailreplace) without
+  sacrificing thread safety
+* **Super-duper detailed error messages** A good mocking library should make
+  coding feel like
+  [paint-by-number](https://en.wikipedia.org/wiki/Paint_by_number), thoughtfully
+  guiding you from one step to the next. Calling a method that doesn't exist
+  will print a sample definition you can copy-paste. Verification failures will
+  print every call that _did_ occur. And [Mocktail.explain()](#mocktailexplain)
+  provides even more introspection
 * **Expressive**: Built-in [argument matchers](#mocktailmatchers) and a simple
-  API for adding [custom matchers](#custom-matchers)
+  API for adding [custom matchers](#custom-matchers) allow you to tune your
+  stubbing configuration and call verification to match _exactly_ what your test
+  intends
 * **Powerful**: [Argument captors](#mocktailcaptor) for assertions of very
-  complex arguments
+  complex arguments, as well as advanced configuration options for stubbing &
+  verification
 
 ## Ready to order?
 
@@ -539,6 +550,154 @@ down bugs. (If this concerns you, then the fact that class methods are
 effectively global state may be a great reason not to rely too heavily on
 them!)]
 
+### Mocktail.explain
+
+Test debugging is hard enough when there _aren't_ fake objects flying every
+which way, so Mocktail tries to make it a little easier by way of better
+messages throughout the library.
+
+#### Undefined methods
+
+One message you'll see automatically if you try to call a method
+that doesn't exist is this one, which gives a sample definition of the method
+you had attempted to call:
+
+```ruby
+class IceTray
+end
+
+ice_tray = Mocktail.of(IceTray)
+
+ice_tray.fill(:water_type, 30)
+# => No method `IceTray#fill' exists for call: (NoMethodError)
+#
+#      fill(:water_type, 30)
+#
+#    Need to define the method? Here's a sample definition:
+#
+#      def fill(water_type, arg)
+#      end
+```
+
+From there, you can just copy-paste the provided method stub as a starting point
+for your new method.
+
+#### `nil` values returned by faked methods
+
+Suppose you go ahead and implement the `fill` method above and configure a
+stubbing:
+
+```ruby
+ice_tray = Mocktail.of(IceTray)
+
+stubs { ice_tray.fill(:tap_water, 30) }.with { :normal_ice }
+```
+
+But then you find that your subject under test is just getting `nil` back and
+you don't understand why:
+
+```ruby
+def prep
+  ice = ice_tray.fill(:tap_water, 50) # => nil
+  glass.add(ice)
+end
+```
+
+You can pass that `nil` value to `Mocktail.explain` and get an
+`UnsatisfiedStubExplanation` that will include both a `reference` object to explore
+ as well a summary message:
+
+```ruby
+def prep
+  ice = ice_tray.fill(:tap_water, 50).tap do |wat|
+    puts Mocktail.explain(wat).message
+  end
+  glass.add(ice)
+end
+```
+
+Which will print:
+
+```
+This `nil' was returned by a mocked `IceTray#fill' method
+because none of its configured stubbings were satisfied.
+
+The actual call:
+
+  fill(:tap_water, 50)
+
+Stubbings configured prior to this call but not satisfied by it:
+
+  fill(:tap_water, 30)
+```
+
+#### Fake instances created by Mocktail
+
+Any instances created by `Mocktail.of` or `Mocktail.of_next` can also be passed
+to `Mocktail.explain`, and they will list out all the calls and stubbings made
+for each of their fake methods.
+
+Calling `Mocktail.explain(ice_tray).message` following the example above will
+yield:
+
+```
+This is a fake `IceTray' instance.
+
+It has these mocked methods:
+  - fill
+
+`IceTray#fill' stubbings:
+
+  fill(:tap_water, 30)
+
+`IceTray#fill' calls:
+
+  fill(:tap_water, 50)
+```
+
+#### Modules and classes with singleton methods replaced
+
+If you've called `Mocktail.replace()` on a class or module, it can also be
+passed to `Mocktail.explain()` for a summary of all the stubbing configurations
+and calls made against its faked singleton methods for the currently running
+thread.
+
+```ruby
+Mocktail.replace(Shop)
+
+stubs { |m| Shop.open!(m.numeric) }.with { :a_bar }
+
+Shop.open!(42)
+
+Shop.close!(42)
+
+puts Mocktail.explain(Shop).message
+```
+
+Will print:
+
+```ruby
+`Shop' is a class that has had its singleton methods faked.
+
+It has these mocked methods:
+  - close!
+  - open!
+
+`Shop.close!' has no stubbings.
+
+`Shop.close!' calls:
+
+  close!(42)
+
+`Shop.open!' stubbings:
+
+  open!(numeric)
+
+`Shop.open!' calls:
+
+  open!(42)
+```
+
 ### Mocktail.reset
 
 This one's simple: you probably want to call `Mocktail.reset` after each test,

data/bin/console

@@ -56,6 +56,26 @@ class Bartender
   end
 end
 
-# (If you use this, don't forget to add pry to your Gemfile!)
+class IceTray
+  def fill(water_type, amount)
+  end
+end
+
+class Shop
+  def self.open!(bar_id)
+  end
+
+  def self.close!(bar_id)
+  end
+end
+
+Mocktail.replace(Shop)
+
+stubs { |m| Shop.open!(m.numeric) }.with { :a_bar }
+
+Shop.open!(42)
+
+Shop.close!(42)
+
 require "pry"
 Pry.start

data/lib/mocktail/explains_thing.rb

@@ -0,0 +1,132 @@
+require_relative "share/stringifies_method_name"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class ExplainsThing
+    def initialize
+      @stringifies_method_name = StringifiesMethodName.new
+      @stringifies_call = StringifiesCall.new
+    end
+
+    def explain(thing)
+      if is_stub_returned_nil?(thing)
+        unsatisfied_stub_explanation(thing)
+      elsif (double = Mocktail.cabinet.double_for_instance(thing))
+        double_explanation(double)
+      elsif (type_replacement = TopShelf.instance.type_replacement_if_exists_for(thing))
+        replaced_type_explanation(type_replacement)
+      else
+        no_explanation(thing)
+      end
+    end
+
+    private
+
+    # Our fake nil doesn't even implement respond_to?, instead quacking like nil
+    def is_stub_returned_nil?(thing)
+      thing.was_returned_by_unsatisfied_stub?
+    rescue NoMethodError
+    end
+
+    def unsatisfied_stub_explanation(stub_returned_nil)
+      unsatisfied_stubbing = stub_returned_nil.unsatisfied_stubbing
+      dry_call = unsatisfied_stubbing.call
+      other_stubbings = unsatisfied_stubbing.other_stubbings
+
+      UnsatisfiedStubExplanation.new(unsatisfied_stubbing, <<~MSG)
+        This `nil' was returned by a mocked `#{@stringifies_method_name.stringify(dry_call)}' method
+        because none of its configured stubbings were satisfied.
+
+        The actual call:
+
+          #{@stringifies_call.stringify(dry_call, always_parens: true)}
+
+        #{describe_multiple_calls(other_stubbings.map(&:recording),
+          "Stubbings configured prior to this call but not satisfied by it",
+          "No stubbings were configured on this method")}
+      MSG
+    end
+
+    def double_explanation(double)
+      double_data = DoubleData.new(
+        type: double.original_type,
+        double: double.dry_instance,
+        calls: Mocktail.cabinet.calls_for_double(double),
+        stubbings: Mocktail.cabinet.stubbings_for_double(double)
+      )
+
+      DoubleExplanation.new(double_data, <<~MSG)
+        This is a fake `#{double.original_type.name}' instance.
+
+        It has these mocked methods:
+        #{double.dry_methods.map { |method| "  - #{method}" }.join("\n")}
+
+        #{double.dry_methods.map { |method| describe_dry_method(double_data, method) }.join("\n")}
+      MSG
+    end
+
+    def replaced_type_explanation(type_replacement)
+      type_replacement_data = TypeReplacementData.new(
+        type: type_replacement.type,
+        replaced_method_names: type_replacement.replacement_methods.map(&:name).sort,
+        calls: Mocktail.cabinet.calls.select { |call|
+          call.double == type_replacement.type
+        },
+        stubbings: Mocktail.cabinet.stubbings.select { |stubbing|
+          stubbing.recording.double == type_replacement.type
+        }
+      )
+
+      ReplacedTypeExplanation.new(type_replacement_data, <<~MSG)
+        `#{type_replacement.type}' is a #{type_replacement.type.class.to_s.downcase} that has had its singleton methods faked.
+
+        It has these mocked methods:
+        #{type_replacement_data.replaced_method_names.map { |method| "  - #{method}" }.join("\n")}
+
+        #{type_replacement_data.replaced_method_names.map { |method| describe_dry_method(type_replacement_data, method) }.join("\n")}
+      MSG
+    end
+
+    def describe_dry_method(double_data, method)
+      method_name = @stringifies_method_name.stringify(Call.new(
+        original_type: double_data.type,
+        singleton: double_data.type == double_data.double,
+        method: method
+      ))
+
+      [
+        describe_multiple_calls(
+          double_data.stubbings.map(&:recording).select { |call|
+            call.method == method
+          },
+          "`#{method_name}' stubbings",
+          "`#{method_name}' has no stubbings"
+        ),
+        describe_multiple_calls(
+          double_data.calls.select { |call|
+            call.method == method
+          },
+          "`#{method_name}' calls",
+          "`#{method_name}' has no calls"
+        )
+      ].join("\n")
+    end
+
+    def describe_multiple_calls(calls, nonzero_message, zero_message)
+      if calls.empty?
+        "#{zero_message}.\n"
+      else
+        <<~MSG
+          #{nonzero_message}:
+
+          #{calls.map { |call| "  " + @stringifies_call.stringify(call) }.join("\n\n")}
+        MSG
+      end
+    end
+
+    def no_explanation(thing)
+      NoExplanation.new(thing,
+        "Unfortunately, Mocktail doesn't know what this thing is: #{thing.inspect}")
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/fulfills_stubbing/describes_unsatisfied_stubbing.rb

@@ -0,0 +1,13 @@
+module Mocktail
+  class DescribesUnsatisfiedStubbing
+    def describe(dry_call)
+      UnsatisfiedStubbing.new(
+        call: dry_call,
+        other_stubbings: Mocktail.cabinet.stubbings.select { |stubbing|
+                           dry_call.double == stubbing.recording.double &&
+                             dry_call.method == stubbing.recording.method
+                         }
+      )
+    end
+  end
+end

data/lib/mocktail/handles_dry_call/fulfills_stubbing.rb

@@ -1,15 +1,19 @@
 require_relative "fulfills_stubbing/finds_satisfaction"
+require_relative "fulfills_stubbing/describes_unsatisfied_stubbing"
 
 module Mocktail
   class FulfillsStubbing
     def initialize
       @finds_satisfaction = FindsSatisfaction.new
+      @describes_unsatisfied_stubbing = DescribesUnsatisfiedStubbing.new
     end
 
     def fulfill(dry_call)
       if (stubbing = satisfaction(dry_call))
         stubbing.satisfied!
         stubbing.effect&.call(dry_call)
+      else
+        StubReturnedNil.new(@describes_unsatisfied_stubbing.describe(dry_call))
       end
     end
 

data/lib/mocktail/imitates_type/makes_double/declares_dry_class.rb

@@ -5,8 +5,7 @@ module Mocktail
       @raises_neato_no_method_error = RaisesNeatoNoMethodError.new
     end
 
-    def declare(type)
-      instance_methods = instance_methods_on(type)
+    def declare(type, instance_methods)
       dry_class = Class.new(Object) {
         include type if type.instance_of?(Module)
 
@@ -98,23 +97,5 @@ module Mocktail
         )
       }
     end
-
-    def instance_methods_on(type)
-      methods = type.instance_methods + [
-        (:respond_to_missing? if type.private_method_defined?(:respond_to_missing?))
-      ].compact
-
-      methods.reject { |m|
-        ignore?(type, m)
-      }
-    end
-
-    def ignore?(type, method_name)
-      ignored_ancestors.include?(type.instance_method(method_name).owner)
-    end
-
-    def ignored_ancestors
-      Object.ancestors
-    end
   end
 end

data/lib/mocktail/imitates_type/makes_double/gathers_fakeable_instance_methods.rb

@@ -0,0 +1,21 @@
+module Mocktail
+  class GathersFakeableInstanceMethods
+    def gather(type)
+      methods = type.instance_methods + [
+        (:respond_to_missing? if type.private_method_defined?(:respond_to_missing?))
+      ].compact
+
+      methods.reject { |m|
+        ignore?(type, m)
+      }
+    end
+
+    def ignore?(type, method_name)
+      ignored_ancestors.include?(type.instance_method(method_name).owner)
+    end
+
+    def ignored_ancestors
+      Object.ancestors
+    end
+  end
+end

data/lib/mocktail/imitates_type/makes_double.rb

@@ -1,17 +1,21 @@
 require_relative "makes_double/declares_dry_class"
+require_relative "makes_double/gathers_fakeable_instance_methods"
 
 module Mocktail
   class MakesDouble
     def initialize
       @declares_dry_class = DeclaresDryClass.new
+      @gathers_fakeable_instance_methods = GathersFakeableInstanceMethods.new
     end
 
-    def make(klass)
-      dry_type = @declares_dry_class.declare(klass)
+    def make(type)
+      dry_methods = @gathers_fakeable_instance_methods.gather(type)
+      dry_type = @declares_dry_class.declare(type, dry_methods)
       Double.new(
-        original_type: klass,
+        original_type: type,
         dry_type: dry_type,
-        dry_instance: dry_type.new
+        dry_instance: dry_type.new,
+        dry_methods: dry_methods
       )
     end
   end

data/lib/mocktail/raises_neato_no_method_error.rb

@@ -1,16 +1,18 @@
 require_relative "share/stringifies_call"
+require_relative "share/stringifies_method_name"
 require_relative "share/creates_identifier"
 
 module Mocktail
   class RaisesNeatoNoMethodError
     def initialize
       @stringifies_call = StringifiesCall.new
+      @stringifies_method_name = StringifiesMethodName.new
       @creates_identifier = CreatesIdentifier.new
     end
 
     def call(call)
       raise NoMethodError.new <<~MSG
-        No method `#{call.original_type.name}##{call.method}' exists for call:
+        No method `#{@stringifies_method_name.stringify(call)}' exists for call:
 
           #{@stringifies_call.stringify(call, anonymous_blocks: true, always_parens: true)}
 

data/lib/mocktail/share/creates_identifier.rb

@@ -1,13 +1,28 @@
 module Mocktail
   class CreatesIdentifier
+    KEYWORDS = %w[__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield]
+
     def create(s, default: "identifier", max_length: 24)
-      id = s.to_s.downcase.gsub(/[^\w\s]/, "").gsub(/^\d+/, "")[0...max_length].strip.gsub(/\s+/, "_")
+      id = s.to_s.downcase
+        .gsub(/:0x[0-9a-f]+/, "") # Lazy attempt to wipe any Object:0x802beef identifiers
+        .gsub(/[^\w\s]/, "")
+        .gsub(/^\d+/, "")[0...max_length]
+        .strip
+        .gsub(/\s+/, "_") # snake_case
 
       if id.empty?
         default
       else
-        id
+        unreserved(id, default)
       end
     end
+
+    private
+
+    def unreserved(id, default)
+      return id unless KEYWORDS.include?(id)
+
+      "#{id}_#{default}"
+    end
   end
 end

data/lib/mocktail/share/stringifies_method_name.rb

@@ -0,0 +1,11 @@
+module Mocktail
+  class StringifiesMethodName
+    def stringify(call)
+      [
+        call.original_type.name,
+        call.singleton ? "." : "#",
+        call.method
+      ].join
+    end
+  end
+end

data/lib/mocktail/value/cabinet.rb

@@ -37,5 +37,17 @@ module Mocktail
     def demonstration_in_progress?
       @demonstration_in_progress
     end
+
+    def double_for_instance(thing)
+      @doubles.find { |double| double.dry_instance == thing }
+    end
+
+    def stubbings_for_double(double)
+      @stubbings.select { |stubbing| stubbing.recording.double == double.dry_instance }
+    end
+
+    def calls_for_double(double)
+      @calls.select { |call| call.double == double.dry_instance }
+    end
   end
 end

data/lib/mocktail/value/double.rb

@@ -1,11 +1,10 @@
 module Mocktail
-  class Double
-    attr_reader :original_type, :dry_type, :dry_instance
-
-    def initialize(original_type:, dry_type:, dry_instance:)
-      @original_type = original_type
-      @dry_type = dry_type
-      @dry_instance = dry_instance
-    end
+  class Double < Struct.new(
+    :original_type,
+    :dry_type,
+    :dry_instance,
+    :dry_methods,
+    keyword_init: true
+  )
   end
 end

data/lib/mocktail/value/double_data.rb

@@ -0,0 +1,10 @@
+module Mocktail
+  class DoubleData < Struct.new(
+    :type,
+    :double,
+    :calls,
+    :stubbings,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value/explanation.rb

@@ -0,0 +1,26 @@
+module Mocktail
+  class Explanation
+    attr_reader :reference, :message
+
+    def initialize(reference, message)
+      @reference = reference
+      @message = message
+    end
+
+    def type
+      self.class
+    end
+  end
+
+  class NoExplanation < Explanation
+  end
+
+  class UnsatisfiedStubExplanation < Explanation
+  end
+
+  class DoubleExplanation < Explanation
+  end
+
+  class ReplacedTypeExplanation < Explanation
+  end
+end

data/lib/mocktail/value/stub_returned_nil.rb

@@ -0,0 +1,26 @@
+module Mocktail
+  class StubReturnedNil < BasicObject
+    attr_reader :unsatisfied_stubbing
+
+    def initialize(unsatisfied_stubbing)
+      @unsatisfied_stubbing = unsatisfied_stubbing
+    end
+
+    def was_returned_by_unsatisfied_stub?
+      true
+    end
+
+    def tap
+      yield self
+      self
+    end
+
+    def method_missing(name, *args, **kwargs, &blk)
+      nil.send(name, *args, **kwargs, &blk)
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      nil.respond_to?(name, include_all)
+    end
+  end
+end

data/lib/mocktail/value/top_shelf.rb

@@ -17,6 +17,10 @@ module Mocktail
       @type_replacements[type] ||= TypeReplacement.new(type: type)
     end
 
+    def type_replacement_if_exists_for(type)
+      @type_replacements[type]
+    end
+
     def reset_current_thread!
       @new_registrations[Thread.current] = []
       @of_next_registrations[Thread.current] = []

data/lib/mocktail/value/type_replacement_data.rb

@@ -0,0 +1,13 @@
+module Mocktail
+  class TypeReplacementData < Struct.new(
+    :type,
+    :replaced_method_names,
+    :calls,
+    :stubbings,
+    keyword_init: true
+  )
+    def double
+      type
+    end
+  end
+end

data/lib/mocktail/value/unsatisfied_stubbing.rb

@@ -0,0 +1,8 @@
+module Mocktail
+  class UnsatisfiedStubbing < Struct.new(
+    :call,
+    :other_stubbings,
+    keyword_init: true
+  )
+  end
+end

data/lib/mocktail/value.rb

@@ -2,8 +2,13 @@ require_relative "value/cabinet"
 require_relative "value/call"
 require_relative "value/demo_config"
 require_relative "value/double"
+require_relative "value/double_data"
+require_relative "value/explanation"
 require_relative "value/matcher_registry"
 require_relative "value/signature"
 require_relative "value/stubbing"
+require_relative "value/stub_returned_nil"
 require_relative "value/top_shelf"
 require_relative "value/type_replacement"
+require_relative "value/type_replacement_data"
+require_relative "value/unsatisfied_stubbing"

data/lib/mocktail/verifies_call/raises_verification_error.rb

@@ -1,16 +1,18 @@
 require_relative "raises_verification_error/gathers_calls_of_method"
+require_relative "../share/stringifies_method_name"
 require_relative "../share/stringifies_call"
 
 module Mocktail
   class RaisesVerificationError
     def initialize
       @gathers_calls_of_method = GathersCallsOfMethod.new
+      @stringifies_method_name = StringifiesMethodName.new
       @stringifies_call = StringifiesCall.new
     end
 
     def raise(recording, verifiable_calls, demo_config)
       Kernel.raise VerificationError.new <<~MSG
-        Expected mocktail of #{recording.original_type.name}##{recording.method} to be called like:
+        Expected mocktail of `#{@stringifies_method_name.stringify(recording)}' to be called like:
 
           #{@stringifies_call.stringify(recording)}#{[
             (" [#{demo_config.times} #{pl("time", demo_config.times)}]" unless demo_config.times.nil?),

data/lib/mocktail/version.rb

@@ -1,3 +1,3 @@
 module Mocktail
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/mocktail.rb

@@ -1,5 +1,6 @@
 require_relative "mocktail/dsl"
 require_relative "mocktail/errors"
+require_relative "mocktail/explains_thing"
 require_relative "mocktail/handles_dry_call"
 require_relative "mocktail/handles_dry_new_call"
 require_relative "mocktail/imitates_type"
@@ -56,7 +57,13 @@ module Mocktail
     ResetsState.new.reset
   end
 
+  def self.explain(thing)
+    ExplainsThing.new.explain(thing)
+  end
+
   # Stores most transactional state about calls & stubbing configurations
+  # Anything returned by this is undocumented and could change at any time, so
+  # don't commit code that relies on it!
   def self.cabinet
     Thread.current[:mocktail_store] ||= Cabinet.new
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mocktail
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 2021-10-07 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -31,8 +31,10 @@ files:
 - lib/mocktail.rb
 - lib/mocktail/dsl.rb
 - lib/mocktail/errors.rb
+- lib/mocktail/explains_thing.rb
 - lib/mocktail/handles_dry_call.rb
 - lib/mocktail/handles_dry_call/fulfills_stubbing.rb
+- lib/mocktail/handles_dry_call/fulfills_stubbing/describes_unsatisfied_stubbing.rb
 - lib/mocktail/handles_dry_call/fulfills_stubbing/finds_satisfaction.rb
 - lib/mocktail/handles_dry_call/logs_call.rb
 - lib/mocktail/handles_dry_call/validates_arguments.rb
@@ -41,6 +43,7 @@ files:
 - lib/mocktail/imitates_type/ensures_imitation_support.rb
 - lib/mocktail/imitates_type/makes_double.rb
 - lib/mocktail/imitates_type/makes_double/declares_dry_class.rb
+- lib/mocktail/imitates_type/makes_double/gathers_fakeable_instance_methods.rb
 - lib/mocktail/initializes_mocktail.rb
 - lib/mocktail/matcher_presentation.rb
 - lib/mocktail/matchers.rb
@@ -65,6 +68,7 @@ files:
 - lib/mocktail/share/creates_identifier.rb
 - lib/mocktail/share/determines_matching_calls.rb
 - lib/mocktail/share/stringifies_call.rb
+- lib/mocktail/share/stringifies_method_name.rb
 - lib/mocktail/simulates_argument_error.rb
 - lib/mocktail/simulates_argument_error/cleans_backtrace.rb
 - lib/mocktail/simulates_argument_error/reconciles_args_with_params.rb
@@ -75,11 +79,16 @@ files:
 - lib/mocktail/value/call.rb
 - lib/mocktail/value/demo_config.rb
 - lib/mocktail/value/double.rb
+- lib/mocktail/value/double_data.rb
+- lib/mocktail/value/explanation.rb
 - lib/mocktail/value/matcher_registry.rb
 - lib/mocktail/value/signature.rb
+- lib/mocktail/value/stub_returned_nil.rb
 - lib/mocktail/value/stubbing.rb
 - lib/mocktail/value/top_shelf.rb
 - lib/mocktail/value/type_replacement.rb
+- lib/mocktail/value/type_replacement_data.rb
+- lib/mocktail/value/unsatisfied_stubbing.rb
 - lib/mocktail/verifies_call.rb
 - lib/mocktail/verifies_call/finds_verifiable_calls.rb
 - lib/mocktail/verifies_call/raises_verification_error.rb