muack 1.2.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2536a6bd8291b8510a652b7e8102c44e4d204586
-  data.tar.gz: b4ad06b8093fa3f241145a5586c07feb37487bc2
+SHA256:
+  metadata.gz: e65f1260993f94d96899086e3975500583ec077bfae332a8fd4cefc5a2c7da49
+  data.tar.gz: 736468eb986e1925f8f83973fec00c2142df16ca80aee9ce051bbdc255cbbfc8
 SHA512:
-  metadata.gz: e6c120cfe1b64fe2aa6a842de612c49eb7ec04166a1ac083fdc69f44deb6093fdc5e21a651faed82f76de70b8b25f25a94071311e61ef3a7d8a09700b91019ee
-  data.tar.gz: 692d50e023c30fa16a1906b18233d9c25a32839617c6a5ef951a7056ffced8ed5ed6173b6913e8824605e34aa8e4c26fa6e6832539e1183053f849b5b15b4273
+  metadata.gz: d3bb1281eab20185484890205696cbed1d3996ed6392b76e08297af8e742bd76a80f2e3a26fffec265848d18a5373dffd517db6d2127b4e511dfdc5a2b475937
+  data.tar.gz: 2c148e33b0dce444708d09a58f6364e160a926f73e5432120fa8668c7ee0dd65c83128e69723673fd6c95bb62db879b8ff3636af29c93e783954f8409a882ebd

data/.travis.yml

@@ -1,11 +1,21 @@
-
+sudo: false
 language: ruby
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - rbx-2
-  - jruby
 
-install: 'bundle install --retry=3'
-script: 'ruby -r bundler/setup -S rake test'
+install: 'gem update --system; gem install bundler; bundle install --retry=3'
+before_script: unset CI
+script: 'ruby -vwr bundler/setup -S rake test'
+
+matrix:
+  include:
+    - rvm: 2.4
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.5
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.6
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: 2.7
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: ruby-head
+      env: RUBYOPT=--enable-frozen-string-literal
+    - rvm: jruby
+      env: RUBYOPT=--enable-frozen-string-literal

data/CHANGES.md

@@ -1,5 +1,52 @@
 # CHANGES
 
+## Muack 1.5.0 -- 2020-11-28
+
+### Bugs fixed
+
+* Properly handle prepended objects
+* Properly restore method visibilities for singleton methods
+
+### Enhancement
+
+* Eliminated any potential keyword arguments warnings to be future proof
+* Some major internal restructure
+
+## Muack 1.4.0 -- 2015-11-21
+
+### Incompatible changes / Enhancement
+
+* Spies would now do pattern matching like stubs for matching
+  method arguments. This could be an incompatible change if you're
+  relying on spies checking the order for the same method calls.
+  This change would make spies and stubs more similar. If you are
+  really into a specific order, use mocks instead.
+
+## Muack 1.3.2 -- 2015-06-11
+
+* Fixed a bug for `where`, `having`, and `allowing` which should distinguish
+  between `nil` and `undefined` (which does not have a key in a hash)
+
+## Muack 1.3.1 -- 2015-05-27
+
+* Fixed a bug for `where`, `having`, and `allowing` which would raise an
+  exception whenever the actual value is not a hash or array.
+
+## 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/Gemfile

@@ -8,7 +8,3 @@ gem 'pork'
 
 gem 'simplecov', :require => false if ENV['COV']
 gem 'coveralls', :require => false if ENV['CI']
-
-platform :rbx do
-  gem 'rubysl-singleton' # used in rake
-end

data/README.md

@@ -1,4 +1,4 @@
-# Muack [![Build Status](https://secure.travis-ci.org/godfat/muack.png?branch=master)](http://travis-ci.org/godfat/muack) [![Coverage Status](https://coveralls.io/repos/godfat/muack/badge.png?branch=master)](https://coveralls.io/r/godfat/muack?branch=master)
+# Muack [![Build Status](https://secure.travis-ci.org/godfat/muack.png?branch=master)](http://travis-ci.org/godfat/muack) [![Coverage Status](https://coveralls.io/repos/github/godfat/muack/badge.png)](https://coveralls.io/github/godfat/muack) [![Join the chat at https://gitter.im/godfat/muack](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/muack)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -7,6 +7,7 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 * [github](https://github.com/godfat/muack)
 * [rubygems](https://rubygems.org/gems/muack)
 * [rdoc](http://rdoc.info/github/godfat/muack)
+* [issues](https://github.com/godfat/muack/issues) (feel free to ask for support)
 
 ## DESCRIPTION:
 
@@ -25,7 +26,7 @@ Muack is much simpler and thus much faster and much more consistent.
 
 ## REQUIREMENTS:
 
-* Tested with MRI (official CRuby), Rubinius and JRuby.
+* Tested with MRI (official CRuby) and JRuby.
 
 ## INSTALLATION:
 
@@ -39,14 +40,14 @@ Here's a quick example using [Pork][].
 require 'pork/auto'
 require 'muack'
 
-include Muack::API
-
 describe 'Hello' do
+  include Muack::API
+
   before{ Muack.reset  }
   after { Muack.verify }
 
   would 'say world!' do
-    str = 'Hello'
+    str = 'Hello'.dup
     mock(str).say('!'){ |arg| "World#{arg}" }
     str.say('!').should.eq 'World!'
   end
@@ -59,9 +60,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
@@ -98,7 +99,7 @@ p obj.name     # 'obj'
 p Muack.verify # true
 ```
 
-Which is roughly semantically equivalent to using a stub with a spy:
+Which is similar to using a stub with a spy:
 
 ``` ruby
 obj = Object.new
@@ -143,6 +144,11 @@ p Muack.verify # true
 However you should not mix mocks and stubs with the same method, or you
 might encounter some unexpected result. Jump to _Caveat_ for more detail.
 
+The other differences for stubs and spies, please check
+[Pattern Matching for stubs and spies][pattern-matching].
+In short, stubs and spies would do some kind of pattern matching,
+making the order of the same method irrelevant.
+
 On the other hand, stubs aren't limited to testing. If we want to monkey
 patching something, stubs could be useful as we don't care how many times
 the injected methods are called. Jump to _Muack as a mocky patching library_
@@ -167,7 +173,7 @@ affecting the others. This is helpful in the cases of mocking some very
 basic objects like Time, without causing too much side effect.
 
 ``` ruby
-name = 'str'
+name = 'str'.dup
 stub(name).to_s{ 'hi'       }
 stub(Time).new { Time.at(0) }
 mock(Time).now { Time.new   }
@@ -269,7 +275,7 @@ into proxy mode we simply do not provide any block to the injected method,
 but just name it. Here's an example:
 
 ``` ruby
-str = 'str'
+str = 'str'.dup
 mock(str).reverse
 p str.reverse  # 'rts'
 p Muack.verify # true
@@ -279,7 +285,7 @@ Note that if reverse was not called exactly once, the mock would complain.
 We could also use stub + spy to do the same thing as well:
 
 ``` ruby
-str = 'str'
+str = 'str'.dup
 stub(str).reverse
 p str.reverse  # 'rts'
 spy(str).reverse
@@ -290,6 +296,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]: #pattern-matching-for-stubs-and-spies
+
 #### any_instance_of mode
 
 We only talked about mocking a specific object, but never mentioned what if
@@ -408,7 +452,7 @@ p Muack.verify # true
 
 Note that it does not make sense to specify `times` for stubs, because
 stubs don't care about times. Spies do, though. So this is also
-semantically equivalent to below:
+similar to below:
 
 ``` ruby
 obj = Object.new
@@ -580,7 +624,7 @@ our own behaviour, then we already have full control of the arguments.
 There's no points to use both. This also applies to `peek_return`.
 
 ``` ruby
-str = 'ff'
+str = 'ff'.dup
 mock(str).to_i.with_any_args.peek_args{ |radix| radix * 2 }
 p str.to_i(8)  # 255
 p Muack.verify # true
@@ -611,7 +655,7 @@ might just want to take a look at the return? Here's an example using
 `peek_return` to modify the original return value.
 
 ``` ruby
-str = 'ff'
+str = 'ff'.dup
 mock(str).to_i.with_any_args.peek_return{ |int| int * 2 }
 p str.to_i(16) # 510
 p Muack.verify # true
@@ -635,7 +679,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
@@ -670,6 +714,8 @@ obj.say{ |msg| p msg } # 'Hi'
 p Muack.verify  # true
 ```
 
+#### Pattern Matching for stubs and spies
+
 Moreover, we could also have stubs on the same method for different
 arguments. We could think of this as a sort of pattern matching, and Muack
 would try to find the best matched stub for us.
@@ -684,29 +730,18 @@ p Muack.verify # true
 ```
 
 If `obj.find(2)` is called and Muack cannot find a matched stub, it would
-raise a `Muack::Unexpected` and list the candidates for us.
+raise a `Muack::Unexpected` and list the candidates for us. This also
+applies to spies.
 
 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 +753,27 @@ p obj.say(true) # true
 p Muack.verify  # true
 ```
 
-#### match
+#### 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
+```
+
+#### matching
 
-`match` would check the argument with `match` method. Usually this is
+`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 +782,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 +806,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(Integer))){ |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(Integer)]})){ |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(Integer)]})){ |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(Integer), :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 +934,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
@@ -1026,7 +1123,7 @@ Consider we have two classes:
 
 ```  ruby
 Food = Class.new
-User = Class.new{ attr_accessor :food }
+User = Class.new(Struct.new(:food))
 ```
 
 And we could make sure User#food is always a kind of `Food` by putting this
@@ -1053,11 +1150,11 @@ verifiers. For example, we could do this to check if the food is frozen:
 
 ``` ruby
 Food = Class.new
-User = Class.new{ attr_accessor :food }
+User = Class.new(Struct.new(: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 +1169,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
@@ -1113,8 +1210,8 @@ Or, I am happy to break legacy.
 ## USERS:
 
 * [Rib][]
-* [rest-core](https://github.com/cardinalblue/rest-core)
-* [rest-more](https://github.com/cardinalblue/rest-more)
+* [rest-core](https://github.com/godfat/rest-core)
+* [rest-more](https://github.com/godfat/rest-more)
 
 ## CONTRIBUTORS:
 
@@ -1122,9 +1219,9 @@ Or, I am happy to break legacy.
 
 ## LICENSE:
 
-Apache License 2.0
+Apache License 2.0 (Apache-2.0)
 
-Copyright (c) 2013-2015, Lin Jen-Shin (godfat)
+Copyright (c) 2013-2020, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.