mocktail 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5a4729eb601d9f3ed3ece213a460dd0881105a505a812c4d035c14cec252223
-  data.tar.gz: f4b3a3352f63de7de812ce8db616b570de740f1ce7550f8677eb47ecb99305fb
+  metadata.gz: e719e2144c3da8a2569e2ef5e7cf2c78d054625011fcf0bdf8f98f300bdcd805
+  data.tar.gz: 3635b7210ac6d5a7c05c4000f100ac1e07f4c8d5de7de81586e41f3b81e11ce5
 SHA512:
-  metadata.gz: 469b39914d0d887b7cd8d25006f5dc6f3ca8a1a3b5594f39bfae5e3c21f36f2983a30ec2849c916129e216dd9fb731f476abbdc5a41ad0f80c740d7106793a7d
-  data.tar.gz: d7c24487a15c7ddc9b540d6c9d5c2b3f07da3599eba61eee128a79f5faa3fd5f6c4e54b7ea4318119a86737ead855f30d814a7f39e30c1e20a6f3880f0c21ce2
+  metadata.gz: d84b7964c5fbe14e3ef2a8a881c1c328f0f4c37cbde2d1423965016fe26f153c6801032c5aa4a7018db6d98924aecbb031e3e473992178bb9d5fe46e53ac2ea5
+  data.tar.gz: 384e42b818b92ace165e975dafd1482e00a46fc3be4c4abf0bb54e2ff648f29da1b338a8845be5c64e1878abf738e4061345083c0e952206380119ecb82729cf

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.0.3
+
+* Implement method_missing on all mocked instance methods to print out useful
+  information, like the target type, the attempted call, an example method
+  definition that would match the call (for paint-by-numbers-like TDD), and
+  did_you_mean gem integration of similar method names in case it was just a
+  miss
+* Cleans artificially-generated argument errors of gem-internal backtraces
+
 # 0.0.2
 
 * Drop Ruby 2.7 support. Unbeknownst to me (since I developed mocktail using

data/Gemfile.lock

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

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,13 @@ 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)
       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 +18,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 +47,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 +58,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,20 +78,41 @@ module Mocktail
       end
     end
 
-    def type_of(type)
-      if type.is_a?(Class)
-        :class
-      elsif type.is_a?(Module)
-        :module
-      end
+    def define_method_missing_errors!(dry_class, type, instance_methods)
+      return if instance_methods.include?(:method_missing)
+
+      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 instance_methods_on(type)
-      type.instance_methods.reject { |m|
-        ignored_ancestors.include?(type.instance_method(m).owner)
+      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

data/lib/mocktail/raises_neato_no_method_error.rb

@@ -0,0 +1,79 @@
+require_relative "share/stringifies_call"
+require_relative "share/creates_identifier"
+
+module Mocktail
+  class RaisesNeatoNoMethodError
+    def initialize
+      @stringifies_call = StringifiesCall.new
+      @creates_identifier = CreatesIdentifier.new
+    end
+
+    def call(call)
+      raise NoMethodError.new <<~MSG
+        No method `#{call.original_type.name}##{call.method}' 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,13 @@
+module Mocktail
+  class CreatesIdentifier
+    def create(s, default: "identifier", max_length: 24)
+      id = s.to_s.downcase.gsub(/[^\w\s]/, "").gsub(/^\d+/, "")[0...max_length].strip.gsub(/\s+/, "_")
+
+      if id.empty?
+        default
+      else
+        id
+      end
+    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/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/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.rb

@@ -3,6 +3,7 @@ require_relative "value/call"
 require_relative "value/demo_config"
 require_relative "value/double"
 require_relative "value/matcher_registry"
+require_relative "value/signature"
 require_relative "value/stubbing"
 require_relative "value/top_shelf"
 require_relative "value/type_replacement"

data/lib/mocktail/verifies_call/raises_verification_error.rb

@@ -1,5 +1,5 @@
 require_relative "raises_verification_error/gathers_calls_of_method"
-require_relative "raises_verification_error/stringifies_call"
+require_relative "../share/stringifies_call"
 
 module Mocktail
   class RaisesVerificationError

data/lib/mocktail/version.rb

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

data/lib/mocktail.rb

@@ -6,11 +6,13 @@ 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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mocktail
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-10-04 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -53,6 +53,7 @@ files:
 - lib/mocktail/matchers/not.rb
 - lib/mocktail/matchers/numeric.rb
 - lib/mocktail/matchers/that.rb
+- lib/mocktail/raises_neato_no_method_error.rb
 - lib/mocktail/records_demonstration.rb
 - lib/mocktail/registers_matcher.rb
 - lib/mocktail/registers_stubbing.rb
@@ -61,14 +62,21 @@ files:
 - lib/mocktail/replaces_type/redefines_new.rb
 - lib/mocktail/replaces_type/redefines_singleton_methods.rb
 - lib/mocktail/resets_state.rb
+- lib/mocktail/share/creates_identifier.rb
 - lib/mocktail/share/determines_matching_calls.rb
-- lib/mocktail/share/simulates_argument_error.rb
+- lib/mocktail/share/stringifies_call.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
+- lib/mocktail/simulates_argument_error/recreates_message.rb
+- lib/mocktail/simulates_argument_error/transforms_params.rb
 - lib/mocktail/value.rb
 - lib/mocktail/value/cabinet.rb
 - lib/mocktail/value/call.rb
 - lib/mocktail/value/demo_config.rb
 - lib/mocktail/value/double.rb
 - lib/mocktail/value/matcher_registry.rb
+- lib/mocktail/value/signature.rb
 - lib/mocktail/value/stubbing.rb
 - lib/mocktail/value/top_shelf.rb
 - lib/mocktail/value/type_replacement.rb
@@ -76,7 +84,6 @@ files:
 - lib/mocktail/verifies_call/finds_verifiable_calls.rb
 - lib/mocktail/verifies_call/raises_verification_error.rb
 - lib/mocktail/verifies_call/raises_verification_error/gathers_calls_of_method.rb
-- lib/mocktail/verifies_call/raises_verification_error/stringifies_call.rb
 - lib/mocktail/version.rb
 - mocktail.gemspec
 homepage: https://github.com/testdouble/mocktail

data/lib/mocktail/share/simulates_argument_error.rb

@@ -1,28 +0,0 @@
-module Mocktail
-  class SimulatesArgumentError
-    def simulate(arg_params, args, kwarg_params, kwargs)
-      req_args = arg_params.count { |type, _| type == :req }
-      opt_args = arg_params.count { |type, _| type == :opt }
-      rest_args = arg_params.any? { |type, _| type == :rest }
-      req_kwargs = kwarg_params.select { |type, _| type == :keyreq }
-
-      allowed_args = req_args + opt_args
-      msg = if args.size < req_args || (!rest_args && 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 #{args.size}, expected #{expected_desc}#{"; required keyword#{"s" if req_kwargs.size > 1}: #{req_kwargs.map { |_, name| name }.join(", ")}" unless req_kwargs.empty?})"
-
-      elsif !(missing_kwargs = req_kwargs.reject { |_, name| kwargs.key?(name) }).empty?
-        "missing keyword#{"s" if missing_kwargs.size > 1}: #{missing_kwargs.map { |_, name| name.inspect }.join(", ")}"
-      end
-
-      ArgumentError.new(msg)
-    end
-  end
-end