mocktail 0.0.1 → 0.0.5

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/handles_dry_call/validates_arguments.rb

@@ -1,5 +1,3 @@
-require_relative "../share/simulates_argument_error"
-
 module Mocktail
   class ValidatesArguments
     def self.disable!
@@ -30,28 +28,9 @@ module Mocktail
     def validate(dry_call)
       return if self.class.disabled?
 
-      arg_params, kwarg_params = dry_call.original_method.parameters.reject { |type, _|
-        type == :block
-      }.partition { |type, _|
-        [:req, :opt, :rest].include?(type)
-      }
-
-      unless args_match?(arg_params, dry_call.args) &&
-          kwargs_match?(kwarg_params, dry_call.kwargs)
-        raise @simulates_argument_error.simulate(arg_params, dry_call.args, kwarg_params, dry_call.kwargs)
+      if (error = @simulates_argument_error.simulate(dry_call))
+        raise error
       end
     end
-
-    private
-
-    def args_match?(arg_params, args)
-      args.size >= arg_params.count { |type, _| type == :req } &&
-        (arg_params.any? { |type, _| type == :rest } || args.size <= arg_params.size)
-    end
-
-    def kwargs_match?(kwarg_params, kwargs)
-      kwarg_params.select { |type, _| type == :keyreq }.all? { |_, name| kwargs.key?(name) } &&
-        (kwarg_params.any? { |type, _| type == :keyrest } || kwargs.keys.all? { |name| kwarg_params.any? { |_, key| name == key } })
-    end
   end
 end

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

@@ -2,13 +2,12 @@ module Mocktail
   class DeclaresDryClass
     def initialize
       @handles_dry_call = HandlesDryCall.new
+      @raises_neato_no_method_error = RaisesNeatoNoMethodError.new
     end
 
-    def declare(type)
-      type_type = type_of(type)
-      instance_methods = instance_methods_on(type)
+    def declare(type, instance_methods)
       dry_class = Class.new(Object) {
-        include type if type_type == :module
+        include type if type.instance_of?(Module)
 
         def initialize(*args, **kwargs, &blk)
         end
@@ -18,15 +17,19 @@ module Mocktail
         }
         alias_method :kind_of?, :is_a?
 
-        if type_type == :class
+        if type.instance_of?(Class)
           define_method :instance_of?, ->(thing) {
             type == thing
           }
         end
       }
 
-      add_stringify_methods!(dry_class, :to_s, type, type_type, instance_methods)
-      add_stringify_methods!(dry_class, :inspect, type, type_type, instance_methods)
+      # These have special implementations, but if the user defines
+      # any of them on the object itself, then they'll be replaced with normal
+      # mocked methods. YMMV
+      add_stringify_methods!(dry_class, :to_s, type, instance_methods)
+      add_stringify_methods!(dry_class, :inspect, type, instance_methods)
+      define_method_missing_errors!(dry_class, type, instance_methods)
 
       define_double_methods!(dry_class, type, instance_methods)
 
@@ -43,7 +46,7 @@ module Mocktail
             singleton: false,
             double: self,
             original_type: type,
-            dry_type: self.class,
+            dry_type: dry_class,
             method: method,
             original_method: type.instance_method(method),
             args: args,
@@ -54,7 +57,7 @@ module Mocktail
       end
     end
 
-    def add_stringify_methods!(dry_class, method_name, type, type_type, instance_methods)
+    def add_stringify_methods!(dry_class, method_name, type, instance_methods)
       dry_class.define_singleton_method method_name, -> {
         if (id_matches = super().match(/:([0-9a-fx]+)>$/))
           "#<Class #{"including module " if type.instance_of?(Module)}for mocktail of #{type.name}:#{id_matches[1]}>"
@@ -74,22 +77,25 @@ module Mocktail
       end
     end
 
-    def type_of(type)
-      if type.is_a?(Class)
-        :class
-      elsif type.is_a?(Module)
-        :module
-      end
-    end
+    def define_method_missing_errors!(dry_class, type, instance_methods)
+      return if instance_methods.include?(:method_missing)
 
-    def instance_methods_on(type)
-      type.instance_methods.reject { |m|
-        ignored_ancestors.include?(type.instance_method(m).owner)
+      raises_neato_no_method_error = @raises_neato_no_method_error
+      dry_class.define_method :method_missing, ->(name, *args, **kwargs, &block) {
+        raises_neato_no_method_error.call(
+          Call.new(
+            singleton: false,
+            double: self,
+            original_type: type,
+            dry_type: self.class,
+            method: name,
+            original_method: nil,
+            args: args,
+            kwargs: kwargs,
+            block: block
+          )
+        )
       }
     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

@@ -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,15 @@
+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