mocktail 0.0.2 → 0.0.6

data/lib/mocktail/raises_neato_no_method_error.rb

@@ -0,0 +1,81 @@
+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 `#{@stringifies_method_name.stringify(call)}' exists for call:
+
+          #{@stringifies_call.stringify(call, anonymous_blocks: true, always_parens: true)}
+
+        Need to define the method? Here's a sample definition:
+
+          def #{call.method}#{params(call)}
+          end
+        #{corrections(call)}
+      MSG
+    end
+
+    private
+
+    def params(call)
+      return if (params_lists = [
+        params_list(call.args),
+        kwparams_list(call.kwargs),
+        block_param(call.block)
+      ].compact).empty?
+
+      "(#{params_lists.join(", ")})"
+    end
+
+    def params_list(args)
+      return if args.empty?
+
+      count_repeats(args.map { |arg|
+        @creates_identifier.create(arg, default: "arg")
+      }).join(", ")
+    end
+
+    def kwparams_list(kwargs)
+      return if kwargs.empty?
+
+      kwargs.keys.map { |key| "#{key}:" }.join(", ")
+    end
+
+    def block_param(block)
+      return if block.nil?
+
+      "&blk"
+    end
+
+    def count_repeats(identifiers)
+      identifiers.map.with_index { |id, i|
+        if (preceding_matches = identifiers[0...i].count { |other_id| id == other_id }) > 0
+          "#{id}#{preceding_matches + 1}"
+        else
+          id
+        end
+      }
+    end
+
+    def corrections(call)
+      return if (corrections = DidYouMean::SpellChecker.new(dictionary: call.original_type.instance_methods).correct(call.method)).empty?
+
+      <<~MSG
+
+        There #{corrections.size == 1 ? "is" : "are"} also #{corrections.size} similar method#{"s" if corrections.size != 1} on #{call.original_type.name}.
+
+        Did you mean?
+        #{corrections.map { |c| "  #{c}" }.join("\n")}
+      MSG
+    end
+  end
+end

data/lib/mocktail/share/creates_identifier.rb

@@ -0,0 +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(/: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
+        unreserved(id, default)
+      end
+    end
+
+    private
+
+    def unreserved(id, default)
+      return id unless KEYWORDS.include?(id)
+
+      "#{id}_#{default}"
+    end
+  end
+end

data/lib/mocktail/{verifies_call/raises_verification_error → share}/stringifies_call.rb

@@ -1,18 +1,22 @@
 module Mocktail
   class StringifiesCall
-    def stringify(call)
-      "#{call.method}#{args_to_s(call)}#{blockify(call.block)}"
+    def stringify(call, anonymous_blocks: false, always_parens: false)
+      "#{call.method}#{args_to_s(call, parens: always_parens)}#{blockify(call.block, anonymous: anonymous_blocks)}"
     end
 
     private
 
-    def args_to_s(call)
-      unless (args_lists = [
+    def args_to_s(call, parens: true)
+      args_lists = [
         argify(call.args),
         kwargify(call.kwargs),
         lambdafy(call.block)
-      ].compact).empty?
+      ].compact
+
+      if !args_lists.empty?
         "(#{args_lists.join(", ")})"
+      elsif parens
+        "()"
       end
     end
 
@@ -31,9 +35,14 @@ module Mocktail
       "&lambda[#{source_locationify(block)}]"
     end
 
-    def blockify(block)
+    def blockify(block, anonymous:)
       return unless block && !block.lambda?
-      " { Proc at #{source_locationify(block)} }"
+
+      if anonymous
+        " {…}"
+      else
+        " { Proc at #{source_locationify(block)} }"
+      end
     end
 
     def source_locationify(block)

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/simulates_argument_error/cleans_backtrace.rb

@@ -0,0 +1,17 @@
+require "pathname"
+
+module Mocktail
+  class CleansBacktrace
+    BASE_PATH = (Pathname.new(__FILE__) + "../../..").to_s
+
+    def clean(error)
+      raise error
+    rescue => e
+      e.tap do |e|
+        e.set_backtrace(e.backtrace.drop_while { |frame|
+          frame.start_with?(BASE_PATH)
+        })
+      end
+    end
+  end
+end

data/lib/mocktail/simulates_argument_error/reconciles_args_with_params.rb

@@ -0,0 +1,20 @@
+module Mocktail
+  class ReconcilesArgsWithParams
+    def reconcile(signature)
+      args_match?(signature.positional_params, signature.positional_args) &&
+        kwargs_match?(signature.keyword_params, signature.keyword_args)
+    end
+
+    private
+
+    def args_match?(arg_params, args)
+      args.size >= arg_params.required.size &&
+        (arg_params.rest? || args.size <= arg_params.allowed.size)
+    end
+
+    def kwargs_match?(kwarg_params, kwargs)
+      kwarg_params.required.all? { |name| kwargs.key?(name) } &&
+        (kwarg_params.rest? || kwargs.keys.all? { |name| kwarg_params.allowed.include?(name) })
+    end
+  end
+end

data/lib/mocktail/simulates_argument_error/recreates_message.rb

@@ -0,0 +1,29 @@
+module Mocktail
+  class RecreatesMessage
+    def recreate(signature)
+      req_args = signature.positional_params.required.size
+      allowed_args = signature.positional_params.allowed.size
+      rest_args = signature.positional_params.rest?
+      req_kwargs = signature.keyword_params.required
+
+      if signature.positional_args.size < req_args || (!rest_args && signature.positional_args.size > allowed_args)
+        expected_desc = if rest_args
+          "#{req_args}+"
+        elsif allowed_args != req_args
+          "#{req_args}..#{allowed_args}"
+        else
+          req_args.to_s
+        end
+
+        "wrong number of arguments (given #{signature.positional_args.size}, expected #{expected_desc}#{"; required keyword#{"s" if req_kwargs.size > 1}: #{req_kwargs.join(", ")}" unless req_kwargs.empty?})"
+
+      elsif !(missing_kwargs = req_kwargs.reject { |name| signature.keyword_args.key?(name) }).empty?
+        "missing keyword#{"s" if missing_kwargs.size > 1}: #{missing_kwargs.map { |name| name.inspect }.join(", ")}"
+      elsif !(unknown_kwargs = signature.keyword_args.keys.reject { |name| signature.keyword_params.all.include?(name) }).empty?
+        "unknown keyword#{"s" if unknown_kwargs.size > 1}: #{unknown_kwargs.map { |name| name.inspect }.join(", ")}"
+      else
+        "unknown cause (this is probably a bug in Mocktail)"
+      end
+    end
+  end
+end

data/lib/mocktail/simulates_argument_error/transforms_params.rb

@@ -0,0 +1,32 @@
+module Mocktail
+  class TransformsParams
+    def transform(dry_call)
+      params = dry_call.original_method.parameters
+
+      Signature.new(
+        positional_params: Params.new(
+          all: params.select { |type, _|
+            [:req, :opt, :rest].include?(type)
+          }.map { |_, name| name },
+          required: params.select { |t, _| t == :req }.map { |_, n| n },
+          optional: params.select { |t, _| t == :opt }.map { |_, n| n },
+          rest: params.find { |type, _| type == :rest } & [1]
+        ),
+        positional_args: dry_call.args,
+
+        keyword_params: Params.new(
+          all: params.select { |type, _|
+            [:keyreq, :key, :keyrest].include?(type)
+          }.map { |_, name| name },
+          required: params.select { |t, _| t == :keyreq }.map { |_, n| n },
+          optional: params.select { |t, _| t == :key }.map { |_, n| n },
+          rest: params.find { |type, _| type == :keyrest } & [1]
+        ),
+        keyword_args: dry_call.kwargs,
+
+        block_param: params.find { |type, _| type == :block } & [1],
+        block_arg: dry_call.block
+      )
+    end
+  end
+end

data/lib/mocktail/simulates_argument_error.rb

@@ -0,0 +1,30 @@
+require_relative "simulates_argument_error/transforms_params"
+require_relative "simulates_argument_error/reconciles_args_with_params"
+require_relative "simulates_argument_error/recreates_message"
+require_relative "simulates_argument_error/cleans_backtrace"
+require_relative "share/stringifies_call"
+
+module Mocktail
+  class SimulatesArgumentError
+    def initialize
+      @transforms_params = TransformsParams.new
+      @reconciles_args_with_params = ReconcilesArgsWithParams.new
+      @recreates_message = RecreatesMessage.new
+      @cleans_backtrace = CleansBacktrace.new
+      @stringifies_call = StringifiesCall.new
+    end
+
+    def simulate(dry_call)
+      signature = @transforms_params.transform(dry_call)
+
+      unless @reconciles_args_with_params.reconcile(signature)
+        @cleans_backtrace.clean(
+          ArgumentError.new([
+            @recreates_message.recreate(signature),
+            "[Mocktail call: `#{@stringifies_call.stringify(dry_call)}']"
+          ].join(" "))
+        )
+      end
+    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/signature.rb

@@ -0,0 +1,36 @@
+module Mocktail
+  class Signature < Struct.new(
+    :positional_params,
+    :positional_args,
+    :keyword_params,
+    :keyword_args,
+    :block_param,
+    :block_arg,
+    keyword_init: true
+  )
+  end
+
+  class Params < Struct.new(
+    :all,
+    :required,
+    :optional,
+    :rest,
+    keyword_init: true
+  )
+
+    def initialize(**params)
+      super
+      self.all ||= []
+      self.required ||= []
+      self.optional ||= []
+    end
+
+    def allowed
+      required + optional
+    end
+
+    def rest?
+      !!rest
+    end
+  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

@@ -1,61 +1,60 @@
-# The top shelf stores all cross-thread & thread-aware state, so anything that
-# goes here is on its own when it comes to ensuring thread safety.
 module Mocktail
   class TopShelf
     def self.instance
-      @self ||= new
+      Thread.current[:mocktail_top_shelf] ||= new
     end
 
+    @@type_replacements = {}
+    @@type_replacements_mutex = Mutex.new
+
     def initialize
-      @type_replacements = {}
-      @new_registrations = {}
-      @of_next_registrations = {}
-      @singleton_method_registrations = {}
+      @new_registrations = []
+      @of_next_registrations = []
+      @singleton_method_registrations = []
     end
 
     def type_replacement_for(type)
-      @type_replacements[type] ||= TypeReplacement.new(type: type)
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type] ||= TypeReplacement.new(type: type)
+      }
+    end
+
+    def type_replacement_if_exists_for(type)
+      @@type_replacements_mutex.synchronize {
+        @@type_replacements[type]
+      }
     end
 
     def reset_current_thread!
-      @new_registrations[Thread.current] = []
-      @of_next_registrations[Thread.current] = []
-      @singleton_method_registrations[Thread.current] = []
+      Thread.current[:mocktail_top_shelf] = self.class.new
     end
 
     def register_new_replacement!(type)
-      @new_registrations[Thread.current] ||= []
-      @new_registrations[Thread.current] |= [type]
+      @new_registrations |= [type]
     end
 
     def new_replaced?(type)
-      @new_registrations[Thread.current] ||= []
-      @new_registrations[Thread.current].include?(type)
+      @new_registrations.include?(type)
     end
 
     def register_of_next_replacement!(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current] |= [type]
+      @of_next_registrations |= [type]
     end
 
     def of_next_registered?(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current].include?(type)
+      @of_next_registrations.include?(type)
     end
 
     def unregister_of_next_replacement!(type)
-      @of_next_registrations[Thread.current] ||= []
-      @of_next_registrations[Thread.current] -= [type]
+      @of_next_registrations -= [type]
     end
 
     def register_singleton_method_replacement!(type)
-      @singleton_method_registrations[Thread.current] ||= []
-      @singleton_method_registrations[Thread.current] |= [type]
+      @singleton_method_registrations |= [type]
     end
 
     def singleton_methods_replaced?(type)
-      @singleton_method_registrations[Thread.current] ||= []
-      @singleton_method_registrations[Thread.current].include?(type)
+      @singleton_method_registrations.include?(type)
     end
   end
 end

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,7 +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 "raises_verification_error/stringifies_call"
+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.2"
+  VERSION = "0.0.6"
 end

data/lib/mocktail.rb

@@ -1,16 +1,19 @@
 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"
 require_relative "mocktail/initializes_mocktail"
 require_relative "mocktail/matcher_presentation"
 require_relative "mocktail/matchers"
+require_relative "mocktail/raises_neato_no_method_error"
 require_relative "mocktail/registers_matcher"
 require_relative "mocktail/registers_stubbing"
 require_relative "mocktail/replaces_next"
 require_relative "mocktail/replaces_type"
 require_relative "mocktail/resets_state"
+require_relative "mocktail/simulates_argument_error"
 require_relative "mocktail/value"
 require_relative "mocktail/verifies_call"
 require_relative "mocktail/version"
@@ -54,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

data/mocktail.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors = ["Justin Searls"]
   spec.email = ["searls@gmail.com"]
 
-  spec.summary = "your objects, less potency"
+  spec.summary = "Take your objects, and make them a double"
   spec.homepage = "https://github.com/testdouble/mocktail"
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")