muack 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2536a6bd8291b8510a652b7e8102c44e4d204586
-  data.tar.gz: b4ad06b8093fa3f241145a5586c07feb37487bc2
+  metadata.gz: 3bdc0fed7c77d1ef5a925dc20e54857bc2bf279b
+  data.tar.gz: f5be7c8560523fe958c91683d6401e0cfc52f9de
 SHA512:
-  metadata.gz: e6c120cfe1b64fe2aa6a842de612c49eb7ec04166a1ac083fdc69f44deb6093fdc5e21a651faed82f76de70b8b25f25a94071311e61ef3a7d8a09700b91019ee
-  data.tar.gz: 692d50e023c30fa16a1906b18233d9c25a32839617c6a5ef951a7056ffced8ed5ed6173b6913e8824605e34aa8e4c26fa6e6832539e1183053f849b5b15b4273
+  metadata.gz: d32c303896f89c12a83a84602e1190062c53d89cb12e10aaff8fb05dc5382d98f82b9e2c8a9a5ae53fee6a284ecdf4bb7b96e10034b33347bce227a071eabbb1
+  data.tar.gz: 3d028e15246b9c8bdd79ab39accfcfb55ec68d5997c502744510a3093a75e8d4e4fa05da936c091fb32cd43dc0429e88cd2841157285fb08dbd3fe2da6d6b1fa

data/CHANGES.md

@@ -1,5 +1,20 @@
 # CHANGES
 
+## Muack 1.3.0 -- 2015-05-24
+
+### Incompatible changes
+
+* `Muack::API.match` is renamed to `Muack::API.matching`
+* `Muack::API.respond_to` is renamed to `Muack::API.responding_to`
+* `Muack::API.hash_including` is renamed to `Muack::API.having`
+* `Muack::API.satisfy` is renamed to `Muack::API.satisfying`
+* `Muack::Satisy` is renamed to `Muack::Satisying`
+
+### Enhancement
+
+* `Muack::API.where` is added
+* `Muack::API.allowing` is added
+
 ## Muack 1.2.0 -- 2015-03-10
 
 * Now stubs could be overwritten. Input from @mz026

data/README.md

@@ -59,9 +59,9 @@ end
 
 There are 3 parts in Muack, which are:
 
-* Mocks
-* Mocks Modifiers
-* Arguments Verifiers (Satisfy)
+* [Mocks](#mocks)
+* [Mocks Modifiers](#mocks-modifiers)
+* [Arguments Verifiers (Satisfying)](#arguments-verifiers-satisfying)
 
 Mocks are objects with injected methods which we could observe, and mocks
 modifiers are telling how we want to observe the mocks, and finally argument
@@ -290,6 +290,44 @@ You might also want to use `peek_args` and `peek_return` modifier along with
 proxies in order to slightly tweak the original implementation. Jump to
 _Muack as a mocky patching library_ section for more detail.
 
+#### Partial mode
+
+Occasionally we would want to fake some of the values inside a hash, but
+we don't want to interfere with the other values in that hash, and we also
+don't want to modify it directly, or we'll need to make sure to restore it
+after the tests.
+
+Partial mode is not really a mode, but a combination of using proxy mode and
+the [pattern matching mechanism specialized in stubs][pattern-matching].
+Suppose we want to stub `ENV` (which is not a hash but you get the idea),
+enabling some of the flags inside tests without really setting it, we'll do:
+
+``` ruby
+@user = ENV['USER']
+p ENV['NDEBUG'] # nil
+
+stub(ENV)[is_a(String)] #- NOTE: NEED TO DEFINE THIS PROXY FIRST
+stub(ENV)['NDEBUG'].returns{ '1' } #- `returns` workaround Ruby syntax
+
+p ENV['NDEBUG'] # '1'
+p ENV['USER']   # @user
+p Muack.verify  # true
+p ENV['NDEBUG'] # nil
+```
+
+Note that in order to make this work, proxy should be defined first. Because
+stubs are searched in Last In First Out (LIFO) order, it would first check
+if the key is matching `'NDEBUG'` in this case. If it's not matched, then
+search the next one. Eventually it would reach to the first stub, which
+we put `is_a(String)` there so it must match, and return the original value
+inside `ENV`.
+
+If the order is reversed, then it would always return the original value,
+because the proxy would always match, and Muack would stop searching the
+next stub.
+
+[pattern-matching]: #arguments-verifiers-satisfy
+
 #### any_instance_of mode
 
 We only talked about mocking a specific object, but never mentioned what if
@@ -635,7 +673,7 @@ p Muack.verify # true
 We could also omit `|_|` if we don't care about the original return value
 in the above example.
 
-### Arguments Verifiers (Satisfy)
+### Arguments Verifiers (Satisfying)
 
 If we're not passing any arguments to the injected method we define, then
 basically we're saying that there's no arguments should be passed to the
@@ -688,25 +726,13 @@ raise a `Muack::Unexpected` and list the candidates for us.
 
 However, What if we don't want to be so exact? Then we should use verifiers.
 We'll introduce each of them in next section. Note that verifiers
-are not recursive though. If you need complex argument verification,
+are not recursive though. If you need complex arguments verification,
 you'll need to use `satisfy` verifier which you could give an arbitrary
 block to verify anything.
 
-#### is_a
-
-`is_a` would check if the argument is a kind of the given class.
-Actually, it's calling `kind_of?` underneath.
-
-``` ruby
-obj = Object.new
-mock(obj).say(is_a(String)){ |arg| arg }
-p obj.say('something') # 'something'
-p Muack.verify         # true
-```
-
 #### anything
 
-`anything` is a wildcard argument verifier. It matches anything.
+`anything` is a wildcard arguments verifier. It matches anything.
 Although this actually verifies nothing, we could still think of
 this as an arity verifier. Since one anything is not two anythings.
 
@@ -718,15 +744,27 @@ p obj.say(true) # true
 p Muack.verify  # true
 ```
 
-#### match
+#### is_a
 
-`match` would check the argument with `match` method. Usually this is
+`is_a` would check if the argument is a kind of the given class.
+Actually, it's calling `kind_of?` underneath.
+
+``` ruby
+obj = Object.new
+mock(obj).say(is_a(String)){ |arg| arg }
+p obj.say('something') # 'something'
+p Muack.verify         # true
+```
+
+#### matching
+
+`matching` would check the argument with `match` method. Usually this is
 used with regular expression, but anything which responds to `match`
 should work.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(match(/\w+/)){ |arg| arg }
+mock(obj).say(matching(/\w+/)){ |arg| arg }
 p obj.say('Hi') # 'Hi'
 p Muack.verify  # true
 ```
@@ -735,18 +773,6 @@ Note that please don't pass the regular expression directly without
 wrapping it with a match verifier, or how do we distinguish if we
 really want to make sure the argument is exactly the regular expression?
 
-#### hash_including
-
-`hash_including` would check if the given hash is the actual
-argument's subset.
-
-``` ruby
-obj = Object.new
-mock(obj).say(hash_including(:a => 0)){ |arg| arg }
-p obj.say(:a => 0, :b => 1) # {:a => 0, :b => 1}
-p Muack.verify # true
-```
-
 #### including
 
 `including` would check if the actual argument includes the given value
@@ -771,36 +797,98 @@ p obj.say(0)   # 0
 p Muack.verify # true
 ```
 
-#### respond_to
+#### responding_to
 
-`respond_to` would check if the actual argument would be responding to
+`responding_to` would check if the actual argument would be responding to
 the given message, checked via `respond_to?`, also known as duck typing.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(respond_to(:size)){ |arg| arg }
+mock(obj).say(responding_to(:size)){ |arg| arg }
 p obj.say([])  # []
 p Muack.verify # true
 ```
 
-Note that you could give multiple messages to `respond_to`.
+Note that you could give multiple messages to `responding_to`.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(respond_to(:size, :reverse)){ |arg| arg }
+mock(obj).say(responding_to(:size, :reverse)){ |arg| arg }
 p obj.say([])  # []
 p Muack.verify # true
 ```
 
-#### satisfy
+#### where
+
+`where` would check if the actual argument matches given specification.
+
+``` ruby
+obj = Object.new
+mock(obj).say(where(:a => is_a(Fixnum))){ |arg| arg }
+p obj.say(:a => 0) # {:a => 0}
+p Muack.verify # true
+```
+
+Note that this could be recursive.
+
+``` ruby
+obj = Object.new
+mock(obj).say(where(:a => {:b => [is_a(Fixnum)]})){ |arg| arg[:a] }
+p obj.say(:a => {:b => [0]}) # {:b => [0]}
+p Muack.verify # true
+```
+
+#### having
+
+`having` would check if the actual argument is a superset of given
+specification.
+
+``` ruby
+obj = Object.new
+mock(obj).say(having(:a => 0)){ |arg| arg }
+p obj.say(:a => 0, :b => 1) # {:a => 0, :b => 1}
+p Muack.verify # true
+```
+
+Note that this could be recursive.
+
+``` ruby
+obj = Object.new
+mock(obj).say(having(:a => {:b => [is_a(Fixnum)]})){ |arg| arg[:c] }
+p obj.say(:a => {:b => [1]}, :c => 2) # 2
+p Muack.verify # true
+```
+
+#### allowing
+
+`allowing` would check if the actual argument is a subset of given
+specification.
+
+``` ruby
+obj = Object.new
+mock(obj).say(allowing(:a => 0, :b => [1])){ |arg| arg }
+p obj.say(:a => 0) # {:a => 0}
+p Muack.verify # true
+```
+
+Note that this could be recursive.
+
+``` ruby
+obj = Object.new
+mock(obj).say(allowing(:a => {:b => is_a(Fixnum), :c => 1})){ |arg| arg[:a] }
+p obj.say(:a => {:b => 2}) # {:b => 2}
+p Muack.verify # true
+```
+
+#### satisfying
 
-`satisfy` accepts a block to let you do arbitrary verification.
+`satisfying` accepts a block to let you do arbitrary verification.
 nil and false are considered false, otherwise true, just like in
 regular if expression.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(satisfy{ |arg| arg % 2 == 0 }){ |arg| arg }
+mock(obj).say(satisfying{ |arg| arg % 2 == 0 }){ |arg| arg }
 p obj.say(0)   # 0
 p Muack.verify # true
 ```
@@ -837,7 +925,7 @@ class implements each method. We could use conjunction for this.
 
 ``` ruby
 obj = Object.new
-mock(obj).say(is_a(Enumerable) & respond_to(:each)){}.times(3)
+mock(obj).say(is_a(Enumerable) & responding_to(:each)){}.times(3)
 p obj.say( [] ) # nil
 p obj.say( {} ) # nil
 p obj.say(0..1) # nil
@@ -1055,9 +1143,9 @@ verifiers. For example, we could do this to check if the food is frozen:
 Food = Class.new
 User = Class.new{ attr_accessor :food }
 
-FoodFrozen = Class.new(Muack::Satisfy) do
-  def initialize
-    super lambda{ |actual_arg| actual_arg.frozen? }
+FoodFrozen = Class.new(Muack::Satisfying) do
+  def match actual_arg
+    actual_arg.frozen?
   end
 end
 
@@ -1072,7 +1160,7 @@ p u.food = Food.new.freeze # ok
 p u.food = Food.new        # raise Muack::Unexpected
 ```
 
-Please check _Arguments Verifiers (Satisfy)_ section for more argument
+Please check _Arguments Verifiers (Satisfying)_ section for more argument
 verifiers details.
 
 [dm-core]: https://github.com/datamapper/dm-core

data/lib/muack.rb

@@ -1,6 +1,6 @@
 
 require 'muack/session'
-require 'muack/satisfy'
+require 'muack/satisfying'
 
 module Muack
   def self.verify obj=nil
@@ -46,20 +46,16 @@ module Muack
       if block_given? then yield(ret) else ret end
     end
 
-    def is_a klass
-      Muack::IsA.new(klass)
-    end
-
     def anything
       Muack::Anything.new
     end
 
-    def match regexp
-      Muack::Match.new(regexp)
+    def is_a klass
+      Muack::IsA.new(klass)
     end
 
-    def hash_including hash
-      Muack::HashIncluding.new(hash)
+    def matching regexp
+      Muack::Matching.new(regexp)
     end
 
     def including element
@@ -70,12 +66,48 @@ module Muack
       Muack::Within.new(range_or_array)
     end
 
+    def responding_to *msg
+      Muack::RespondingTo.new(*msg)
+    end
+
+    def where spec
+      Muack::Where.new(spec)
+    end
+
+    def having spec
+      Muack::Having.new(spec)
+    end
+
+    def allowing spec
+      Muack::Allowing.new(spec)
+    end
+
+    def satisfying &block
+      Muack::Satisfying.new(&block)
+    end
+
+    def match regexp
+      $stderr.puts("Muack::API.match is deprecated." \
+                   " Use Muack::API.matching instead.")
+      matching(regexp)
+    end
+
     def respond_to *msg
-      Muack::RespondTo.new(*msg)
+      $stderr.puts("Muack::API.respond_to is deprecated." \
+                   " Use Muack::API.responding_to instead.")
+      responding_to(*msg)
+    end
+
+    def hash_including spec
+      $stderr.puts("Muack::API.hash_including is deprecated." \
+                   " Use Muack::API.having instead.")
+      having(spec)
     end
 
     def satisfy &block
-      Muack::Satisfy.new(block)
+      $stderr.puts("Muack::API.satisfy is deprecated." \
+                   " Use Muack::API.satisfying instead.")
+      satisfying(&block)
     end
   end
 end

data/lib/muack/error.rb

@@ -15,4 +15,10 @@ module Muack
             ".times(#{times})"
     end
   end
+
+  class UnknownSpec < Error
+    def initialize spec
+      super "\nUnknown spec: #{spec.inspect}"
+    end
+  end
 end

data/lib/muack/mock.rb

@@ -194,12 +194,12 @@ module Muack
     def __mock_check_args expected_args, actual_args
       if expected_args == [WithAnyArgs]
         true
-      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfy) }
+      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfying) }
         expected_args == actual_args
 
       elsif expected_args.size == actual_args.size
         expected_args.zip(actual_args).all?{ |(e, a)|
-          if e.kind_of?(Satisfy) then e.match(a) else e == a end
+          if e.kind_of?(Satisfying) then e.match(a) else e == a end
         }
       else
         false

data/lib/muack/satisfying.rb

@@ -0,0 +1,186 @@
+
+require 'muack/error'
+
+module Muack
+  class Satisfying < Struct.new(:api_args, :block)
+    def initialize args=nil, &block
+      super(args, block)
+    end
+
+    def match actual_arg
+      !!block.call(actual_arg)
+    end
+
+    def | rhs; Satisfying::Disj.new(self, rhs); end
+    def & rhs; Satisfying::Conj.new(self, rhs); end
+
+    class Disj < Satisfying
+      def initialize lhs, rhs
+        @lhs, @rhs = lhs, rhs
+      end
+
+      def match actual_arg
+        @lhs.match(actual_arg) || @rhs.match(actual_arg)
+      end
+
+      def to_s; "#{@lhs} | #{@rhs}"; end
+      alias_method :inspect, :to_s
+    end
+
+    class Conj < Satisfying
+      def initialize lhs, rhs
+        @lhs, @rhs = lhs, rhs
+      end
+
+      def match actual_arg
+        @lhs.match(actual_arg) && @rhs.match(actual_arg)
+      end
+
+      def to_s; "#{@lhs} & #{@rhs}"; end
+      alias_method :inspect, :to_s
+    end
+
+    def to_s
+      "Muack::API.#{api_name}(#{api_args.map(&:inspect).join(', ')})"
+    end
+    alias_method :inspect, :to_s
+
+    def api_name
+      (self.class.name || 'Unknown')[/(::)*(\w+)$/, 2].
+        gsub(/([A-Z][a-z]*)+?(?=[A-Z][a-z]*)/, '\\1_').downcase
+    end
+
+    def api_args
+      super || [block || method(:match)]
+    end
+  end
+
+  class Anything < Satisfying
+    def initialize
+      super([])
+    end
+
+    def match _
+      true
+    end
+  end
+
+  class IsA < Satisfying
+    def initialize klass
+      super([klass])
+    end
+
+    def match actual_arg
+      actual_arg.kind_of?(api_args.first)
+    end
+  end
+
+  class Matching < Satisfying
+    def initialize regexp
+      super([regexp])
+    end
+
+    def match actual_arg
+      api_args.first.match(actual_arg)
+    end
+  end
+
+  class Including < Satisfying
+    def initialize element
+      super([element])
+    end
+
+    def match actual_arg
+      actual_arg.include?(api_args.first)
+    end
+  end
+
+  class Within < Satisfying
+    def initialize range_or_array
+      super([range_or_array])
+    end
+
+    def match actual_arg
+      api_args.first.include?(actual_arg)
+    end
+  end
+
+  class RespondingTo < Satisfying
+    def initialize *messages
+      super(messages)
+    end
+
+    def match actual_arg
+      api_args.all?{ |msg| actual_arg.respond_to?(msg) }
+    end
+  end
+
+  class Where < Satisfying
+    def initialize spec
+      super([spec])
+    end
+
+    def match actual_arg, spec=api_args.first
+      case spec
+      when Hash
+        match_hash(actual_arg, spec)
+      when Array
+        match_array(actual_arg, spec)
+      else
+        raise UnknownSpec.new(spec)
+      end
+    end
+
+    private
+    def match_hash actual_arg, spec
+      (spec.keys | actual_arg.keys).all? do |key|
+        match_value(actual_arg[key], spec[key])
+      end
+    end
+
+    def match_array actual_arg, spec
+      spec.zip(actual_arg).all? do |(ev, av)|
+        match_value(av, ev)
+      end
+    end
+
+    def match_value av, ev
+      case ev
+      when Satisfying
+        ev.match(av)
+      when Hash
+        match_hash(av, ev)
+      when Array
+        match_array(av, ev)
+      else
+        ev == av
+      end
+    end
+  end
+
+  class Having < Where
+    def initialize subset
+      super(subset)
+    end
+
+    private
+    def match_hash actual_arg, subset
+      subset.each_key.all? do |key|
+        match_value(actual_arg[key], subset[key])
+      end
+    end
+  end
+
+  class Allowing < Where
+    def initialize superset
+      super(superset)
+    end
+
+    private
+    def match_hash actual_arg, superset
+      actual_arg.each_key.all? do |key|
+        match_value(actual_arg[key], superset[key])
+      end
+    end
+  end
+end

data/lib/muack/version.rb

@@ -1,4 +1,4 @@
 
 module Muack
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/muack.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: muack 1.2.0 ruby lib
+# stub: muack 1.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "muack"
-  s.version = "1.2.0"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2015-03-10"
+  s.date = "2015-05-24"
   s.description = "Muack -- A fast, small, yet powerful mocking library.\n\nInspired by [RR][], and it's 32x times faster (750s vs 23s) than RR\nfor running [Rib][] tests.\n\n[RR]: https://github.com/rr/rr\n[Rib]: https://github.com/godfat/rib"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   "lib/muack/failure.rb",
   "lib/muack/mock.rb",
   "lib/muack/modifier.rb",
-  "lib/muack/satisfy.rb",
+  "lib/muack/satisfying.rb",
   "lib/muack/session.rb",
   "lib/muack/spy.rb",
   "lib/muack/stub.rb",
@@ -44,11 +44,11 @@ Gem::Specification.new do |s|
   "test/test_mock.rb",
   "test/test_modifier.rb",
   "test/test_proxy.rb",
-  "test/test_satisfy.rb",
+  "test/test_satisfying.rb",
   "test/test_stub.rb"]
   s.homepage = "https://github.com/godfat/muack"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.6"
+  s.rubygems_version = "2.4.7"
   s.summary = "Muack -- A fast, small, yet powerful mocking library."
   s.test_files = [
   "test/test_any_instance_of.rb",
@@ -57,6 +57,6 @@ Gem::Specification.new do |s|
   "test/test_mock.rb",
   "test/test_modifier.rb",
   "test/test_proxy.rb",
-  "test/test_satisfy.rb",
+  "test/test_satisfying.rb",
   "test/test_stub.rb"]
 end

data/test/test_from_readme.rb

@@ -13,7 +13,7 @@ describe 'from README.md' do
 
     def describe desc, &block
       @executor.describe(desc, &block)
-      @executor.execute(@stat)
+      @executor.execute(Pork.execute_mode, @stat)
     end
 
     def results; @results ||= []; end
@@ -26,7 +26,7 @@ describe 'from README.md' do
         if exp.start_with?('raise')
           res.should.kind_of? eval(exp.sub('raise', ''))
         else
-          res.should.eq eval(exp)
+          res.should.eq instance_eval(exp)
         end
       end
     end

data/test/{test_satisfy.rb → test_satisfying.rb}

@@ -1,35 +1,12 @@
 
 require 'muack/test'
 
-describe Muack::Satisfy do
+describe Muack::Satisfying do
   after do
     Muack.reset
     Muack::EnsureReset.call
   end
 
-  describe Muack::IsA do
-    would 'have human readable to_s and inspect' do
-      matcher = is_a(String)
-      expected = 'Muack::API.is_a(String)'
-      matcher.to_s   .should.eq expected
-      matcher.inspect.should.eq expected
-    end
-
-    would 'satisfy' do
-      mock(Str).say(is_a(String)){ |arg| arg.reverse }
-      Str.say('Foo').should.eq 'ooF'
-      Muack.verify.should.eq true
-    end
-
-    would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(is_a(Array)){ 'boo' }
-      e = should.raise(Muack::Unexpected){ Obj.say(false) }
-      e.expected.should.eq 'obj.say(Muack::API.is_a(Array))'
-      e.was     .should.eq 'obj.say(false)'
-      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
-    end
-  end
-
   describe Muack::Anything do
     would 'have human readable to_s and inspect' do
       matcher = anything
@@ -58,63 +35,48 @@ describe Muack::Satisfy do
     end
   end
 
-  describe Muack::Match do
+  describe Muack::IsA do
     would 'have human readable to_s and inspect' do
-      matcher = match(/\w/)
-      expected = 'Muack::API.match(/\w/)'
+      matcher = is_a(String)
+      expected = 'Muack::API.is_a(String)'
       matcher.to_s   .should.eq expected
       matcher.inspect.should.eq expected
     end
 
     would 'satisfy' do
-      mock(Str).say(match(/\w/)){ |arg| arg }
-      Str.say('aa').should.eq 'aa'
+      mock(Str).say(is_a(String)){ |arg| arg.reverse }
+      Str.say('Foo').should.eq 'ooF'
       Muack.verify.should.eq true
     end
 
     would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(match(/\w/)){ 'boo' }
-      e = should.raise(Muack::Unexpected){ Obj.say('!') }
-      e.expected.should.eq 'obj.say(Muack::API.match(/\w/))'
-      e.was     .should.eq 'obj.say("!")'
+      mock(Obj).say(is_a(Array)){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(false) }
+      e.expected.should.eq 'obj.say(Muack::API.is_a(Array))'
+      e.was     .should.eq 'obj.say(false)'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
   end
 
-  describe Muack::HashIncluding do
+  describe Muack::Matching do
     would 'have human readable to_s and inspect' do
-      matcher = hash_including(:b => 2)
-      expected = 'Muack::API.hash_including({:b=>2})'
+      matcher = matching(/\w/)
+      expected = 'Muack::API.matching(/\w/)'
       matcher.to_s   .should.eq expected
       matcher.inspect.should.eq expected
     end
 
     would 'satisfy' do
-      mock(Str).say(hash_including(:b => 2)){ |arg| arg[:a] }
-      Str.say(:a => 1, :b => 2).should.eq 1
-      Muack.verify.should.eq true
-    end
-
-    would 'satisfy with satisfy' do
-      mock(Str).say(hash_including(:b => is_a(Fixnum))){ |arg| arg[:b] }
-      Str.say(:a => 1, :b => 2).should.eq 2
+      mock(Str).say(matching(/\w/)){ |arg| arg }
+      Str.say('aa').should.eq 'aa'
       Muack.verify.should.eq true
     end
 
     would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(hash_including(:b => 2)){ 'boo' }
-      e = should.raise(Muack::Unexpected){ Obj.say(:a => 1) }
-      e.expected.should.eq 'obj.say(Muack::API.hash_including({:b=>2}))'
-      e.was     .should.eq 'obj.say({:a=>1})'
-      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
-    end
-
-    would 'raise Unexpected error if passing unsatisfied argument' do
-      mock(Obj).say(hash_including(:b => is_a(String))){ 'boo' }
-      e = should.raise(Muack::Unexpected){ Obj.say(:b => 1) }
-      e.expected.should.eq \
-        'obj.say(Muack::API.hash_including({:b=>Muack::API.is_a(String)}))'
-      e.was     .should.eq 'obj.say({:b=>1})'
+      mock(Obj).say(matching(/\w/)){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say('!') }
+      e.expected.should.eq 'obj.say(Muack::API.matching(/\w/))'
+      e.was     .should.eq 'obj.say("!")'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
   end
@@ -169,68 +131,212 @@ describe Muack::Satisfy do
     end
   end
 
-  describe Muack::RespondTo do
+  describe Muack::RespondingTo do
     would 'have human readable to_s and inspect' do
-      matcher = respond_to(:id)
-      expected = 'Muack::API.respond_to(:id)'
+      matcher = responding_to(:id)
+      expected = 'Muack::API.responding_to(:id)'
       matcher.to_s   .should.start_with? expected
       matcher.inspect.should.start_with? expected
 
-      matcher = respond_to(:id, :reload)
-      expected = 'Muack::API.respond_to(:id, :reload)'
+      matcher = responding_to(:id, :reload)
+      expected = 'Muack::API.responding_to(:id, :reload)'
       matcher.to_s   .should.start_with? expected
       matcher.inspect.should.start_with? expected
     end
 
     would 'satisfy' do
-      mock(Str).say(respond_to(:verify, :reset)){ |arg| arg.name }
+      mock(Str).say(responding_to(:verify, :reset)){ |arg| arg.name }
       Str.say(Muack).should.eq 'Muack'
       Muack.verify.should.eq true
 
-      mock(Str).say(respond_to(:verify        )){ |arg| arg.name }
+      mock(Str).say(responding_to(:verify        )){ |arg| arg.name }
       Str.say(Muack).should.eq 'Muack'
       Muack.verify.should.eq true
     end
 
     would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(respond_to(:nothing)){ 'boo' }
+      mock(Obj).say(responding_to(:nothing)){ 'boo' }
       e = should.raise(Muack::Unexpected){ Obj.say(0) }
-      e.expected.should.eq 'obj.say(Muack::API.respond_to(:nothing))'
+      e.expected.should.eq 'obj.say(Muack::API.responding_to(:nothing))'
       e.was     .should.eq 'obj.say(0)'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
   end
 
-  describe Muack::Satisfy do
+  describe Muack::Where do
+    would 'have human readable to_s and inspect' do
+      matcher = where(:b => 2)
+      expected = 'Muack::API.where({:b=>2})'
+      matcher.to_s   .should.eq expected
+      matcher.inspect.should.eq expected
+    end
+
+    would 'satisfy' do
+      mock(Str).say(where(:b => 2)){ |arg| arg[:b] }
+      Str.say(:b => 2).should.eq 2
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy' do
+      mock(Str).say(where(:b => is_a(Fixnum))){ |arg| arg[:b] }
+      Str.say(:b => 3).should.eq 3
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy recursive' do
+      spec = where(:a => {:b => is_a(Fixnum)})
+      mock(Str).say(spec){ |arg| arg[:a][:b] }
+      Str.say(:a => {:b => 1}).should.eq 1
+      Muack.verify.should.eq true
+    end
+
+    would 'raise Unexpected error if passing unexpected argument' do
+      mock(Obj).say(where(:b => 2)){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:b => 1) }
+      e.expected.should.eq 'obj.say(Muack::API.where({:b=>2}))'
+      e.was     .should.eq 'obj.say({:b=>1})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Unexpected error if passing unsatisfied argument' do
+      mock(Obj).say(where(:a => 0, :b => is_a(String))){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:a => 0) }
+      e.expected.should.eq \
+        'obj.say(Muack::API.where({:a=>0, :b=>Muack::API.is_a(String)}))'
+      e.was     .should.eq 'obj.say({:a=>0})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Unexpected error if passing unsatisfied argument' do
+      mock(Obj).say(where(:a => 0, :b => is_a(Fixnum))){ 'boo' }
+      e = should.raise(Muack::Unexpected){Obj.say(:a => 0, :b => 1, :c => 2)}
+      e.expected.should.eq \
+        'obj.say(Muack::API.where({:a=>0, :b=>Muack::API.is_a(Fixnum)}))'
+      e.was     .should.eq 'obj.say({:a=>0, :b=>1, :c=>2})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+  end
+
+  describe Muack::Having do
+    would 'have human readable to_s and inspect' do
+      matcher = having(:b => 2)
+      expected = 'Muack::API.having({:b=>2})'
+      matcher.to_s   .should.eq expected
+      matcher.inspect.should.eq expected
+    end
+
+    would 'satisfy' do
+      mock(Str).say(having(:b => 2)){ |arg| arg[:a] }
+      Str.say(:a => 1, :b => 2).should.eq 1
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy' do
+      mock(Str).say(having(:b => is_a(Fixnum))){ |arg| arg[:b] }
+      Str.say(:a => 1, :b => 2).should.eq 2
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy recursive' do
+      spec = having(:a => {:b => is_a(Fixnum)})
+      mock(Str).say(spec){ |arg| arg[:a][:c] }
+      Str.say(:a => {:b => 1, :c => 2}, :d => 3).should.eq 2
+      Muack.verify.should.eq true
+    end
+
+    would 'raise Unexpected error if passing unexpected argument' do
+      mock(Obj).say(having(:b => 2)){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:a => 1) }
+      e.expected.should.eq 'obj.say(Muack::API.having({:b=>2}))'
+      e.was     .should.eq 'obj.say({:a=>1})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Unexpected error if passing unsatisfied argument' do
+      mock(Obj).say(having(:a => 0, :b => is_a(Fixnum))){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:b => 1) }
+      e.expected.should.eq \
+        'obj.say(Muack::API.having({:a=>0, :b=>Muack::API.is_a(Fixnum)}))'
+      e.was     .should.eq 'obj.say({:b=>1})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+  end
+
+  describe Muack::Allowing do
+    would 'have human readable to_s and inspect' do
+      matcher = allowing(:b => 2)
+      expected = 'Muack::API.allowing({:b=>2})'
+      matcher.to_s   .should.eq expected
+      matcher.inspect.should.eq expected
+    end
+
+    would 'satisfy' do
+      mock(Str).say(allowing(:a => 0, :b => 1)){ |arg| arg[:a] }
+      Str.say(:a => 0).should.eq 0
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy' do
+      mock(Str).say(allowing(:a => is_a(Fixnum), :b => 1)){ |arg| arg[:a] }
+      Str.say(:a => 0).should.eq 0
+      Muack.verify.should.eq true
+    end
+
+    would 'satisfy with satisfy recursive' do
+      spec = allowing(:a => {:b => is_a(Fixnum), :c => 1}, :d => 2)
+      mock(Str).say(spec){ |arg| arg[:a][:b] }
+      Str.say(:a => {:b => 0}).should.eq 0
+      Muack.verify.should.eq true
+    end
+
+    would 'raise Unexpected error if passing unexpected argument' do
+      mock(Obj).say(allowing(:b => 2)){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:a => 1) }
+      e.expected.should.eq 'obj.say(Muack::API.allowing({:b=>2}))'
+      e.was     .should.eq 'obj.say({:a=>1})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+
+    would 'raise Unexpected error if passing unsatisfied argument' do
+      mock(Obj).say(allowing(:b => is_a(String))){ 'boo' }
+      e = should.raise(Muack::Unexpected){ Obj.say(:b => '1', :c => 2) }
+      e.expected.should.eq \
+        'obj.say(Muack::API.allowing({:b=>Muack::API.is_a(String)}))'
+      e.was     .should.eq 'obj.say({:b=>"1", :c=>2})'
+      e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
+    end
+  end
+
+  describe Muack::Satisfying do
     would 'have human readable to_s and inspect' do
-      matcher = satisfy{ |arg| arg % 2 == 0 }
-      expected = 'Muack::API.satisfy(#<Proc:'
+      matcher = satisfying{ |arg| arg % 2 == 0 }
+      expected = 'Muack::API.satisfying(#<Proc:'
       matcher.to_s   .should.start_with? expected
       matcher.inspect.should.start_with? expected
     end
 
     would 'not crash for top-level subclass' do
-      Class.new(Muack::Satisfy){ def self.name; 'TopLevel'; end }.new.
+      Class.new(Muack::Satisfying){ def self.name; 'TopLevel'; end }.new.
         api_name.should.eq 'top_level'
     end
 
     would 'satisfy' do
-      mock(Str).say(satisfy{ |arg| arg % 2 == 0 }){ |arg| arg + 1 }
+      mock(Str).say(satisfying{ |arg| arg % 2 == 0 }){ |arg| arg + 1 }
       Str.say(14).should.eq 15
       Muack.verify.should.eq true
       Muack::EnsureReset.call
     end
 
     would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(satisfy{ |arg| arg % 2 == 0 }){ 'boo' }
+      mock(Obj).say(satisfying{ |arg| arg % 2 == 0 }){ 'boo' }
       e = should.raise(Muack::Unexpected){ Obj.say(1) }
-      e.expected.should.start_with? 'obj.say(Muack::API.satisfy(#<Proc:'
+      e.expected.should.start_with? 'obj.say(Muack::API.satisfying(#<Proc:'
       e.was     .should.eq          'obj.say(1)'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
   end
 
-  describe Muack::Satisfy::Disj do
+  describe Muack::Satisfying::Disj do
     would 'have human readable to_s and inspect' do
       matcher = is_a(TrueClass) | is_a(FalseClass)
       expected = 'Muack::API.is_a(TrueClass) | Muack::API.is_a(FalseClass)'
@@ -246,26 +352,27 @@ describe Muack::Satisfy do
     end
 
     would 'raise Unexpected error if passing unexpected argument' do
-      mock(Obj).say(within('0'..'1') | match(/a/)){ 'boo' }
+      mock(Obj).say(within('0'..'1') | matching(/a/)){ 'boo' }
       e = should.raise(Muack::Unexpected){ Obj.say('2') }
       e.expected.should.eq \
-        'obj.say(Muack::API.within("0".."1") | Muack::API.match(/a/))'
+        'obj.say(Muack::API.within("0".."1") | Muack::API.matching(/a/))'
       e.was     .should.eq \
         'obj.say("2")'
       e.message .should.eq "\nExpected: #{e.expected}\n but was: #{e.was}"
     end
   end
 
-  describe Muack::Satisfy::Conj do
+  describe Muack::Satisfying::Conj do
     would 'have human readable to_s and inspect' do
-      matcher = respond_to(:ancestors) & is_a(Class)
-      expected = 'Muack::API.respond_to(:ancestors) & Muack::API.is_a(Class)'
+      matcher = responding_to(:ancestors) & is_a(Class)
+      expected =
+        'Muack::API.responding_to(:ancestors) & Muack::API.is_a(Class)'
       matcher.to_s   .should.eq expected
       matcher.inspect.should.eq expected
     end
 
     would 'satisfy' do
-      mock(Str).say(respond_to(:ancestors) & is_a(Class)){ |arg| arg.new }
+      mock(Str).say(responding_to(:ancestors) & is_a(Class)){ |arg| arg.new }
       Str.say(String).should.eq ''
       Muack.verify   .should.eq true
       Muack::EnsureReset.call

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: muack
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-10 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Muack -- A fast, small, yet powerful mocking library.
@@ -41,7 +41,7 @@ files:
 - lib/muack/failure.rb
 - lib/muack/mock.rb
 - lib/muack/modifier.rb
-- lib/muack/satisfy.rb
+- lib/muack/satisfying.rb
 - lib/muack/session.rb
 - lib/muack/spy.rb
 - lib/muack/stub.rb
@@ -56,7 +56,7 @@ files:
 - test/test_mock.rb
 - test/test_modifier.rb
 - test/test_proxy.rb
-- test/test_satisfy.rb
+- test/test_satisfying.rb
 - test/test_stub.rb
 homepage: https://github.com/godfat/muack
 licenses:
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Muack -- A fast, small, yet powerful mocking library.
@@ -89,5 +89,5 @@ test_files:
 - test/test_mock.rb
 - test/test_modifier.rb
 - test/test_proxy.rb
-- test/test_satisfy.rb
+- test/test_satisfying.rb
 - test/test_stub.rb

data/lib/muack/satisfy.rb

@@ -1,100 +0,0 @@
-
-module Muack
-  class Satisfy < Struct.new(:block, :api_args)
-    def match actual_arg
-      !!block.call(actual_arg)
-    end
-
-    def | rhs; Satisfy::Disj.new(self, rhs); end
-    def & rhs; Satisfy::Conj.new(self, rhs); end
-
-    class Disj < Satisfy
-      def initialize lhs, rhs
-        @lhs, @rhs = lhs, rhs
-        super(lambda{ |actual_arg| lhs.match(actual_arg) ||
-                                   rhs.match(actual_arg) })
-      end
-
-      def to_s; "#{@lhs} | #{@rhs}"; end
-      alias_method :inspect, :to_s
-    end
-
-    class Conj < Satisfy
-      def initialize lhs, rhs
-        @lhs, @rhs = lhs, rhs
-        super(lambda{ |actual_arg| lhs.match(actual_arg) &&
-                                   rhs.match(actual_arg) })
-      end
-
-      def to_s; "#{@lhs} & #{@rhs}"; end
-      alias_method :inspect, :to_s
-    end
-
-    def to_s
-      "Muack::API.#{api_name}(#{api_args.map(&:inspect).join(', ')})"
-    end
-    alias_method :inspect, :to_s
-
-    def api_name
-      (self.class.name || 'Unknown')[/(::)*(\w+)$/, 2].
-        gsub(/([A-Z][a-z]*)+?(?=[A-Z][a-z]*)/, '\\1_').downcase
-    end
-
-    def api_args
-      super || [block]
-    end
-  end
-
-  class IsA < Satisfy
-    def initialize klass
-      super lambda{ |actual_arg| actual_arg.kind_of?(klass) }, [klass]
-    end
-  end
-
-  class Anything < Satisfy
-    def initialize
-      super lambda{ |_| true }, []
-    end
-  end
-
-  class Match < Satisfy
-    def initialize regexp
-      super lambda{ |actual_arg| regexp.match(actual_arg) }, [regexp]
-    end
-  end
-
-  class HashIncluding < Satisfy
-    def initialize hash
-      super lambda{ |actual_arg|
-        actual_arg.values_at(*hash.keys).zip(hash.values).all? do |(av, ev)|
-          if ev.kind_of?(Satisfy)
-            ev.match(av)
-          else
-            ev == av
-          end
-        end
-      }, [hash]
-    end
-  end
-
-  class Including < Satisfy
-    def initialize element
-      super lambda{ |actual_arg|
-        actual_arg.include?(element) }, [element]
-    end
-  end
-
-  class Within < Satisfy
-    def initialize range_or_array
-      super lambda{ |actual_arg| range_or_array.include?(actual_arg) },
-            [range_or_array]
-    end
-  end
-
-  class RespondTo < Satisfy
-    def initialize *messages
-      super lambda{ |actual_arg|
-        messages.all?{ |msg| actual_arg.respond_to?(msg) } }, messages
-    end
-  end
-end