gem_repackager 0.1.0

data/support/gems/rspec-expectations-2.11.2/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+def add_to_load_path(path, prepend=false)
+  path = File.expand_path("../../#{path}/lib", __FILE__)
+  if prepend
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  else
+    $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+  end
+end
+
+require 'test/unit'
+
+add_to_load_path("rspec-expectations", :prepend)
+add_to_load_path("rspec-core")
+add_to_load_path("rspec-mocks")
+
+require 'rspec/expectations'
+require 'rspec/core'
+require 'rspec/mocks'
+
+Dir['./spec/support/**/*'].each {|f| require f}
+
+RSpec::configure do |config|
+  config.color_enabled = true
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+  config.order = :random
+end

data/support/gems/rspec-expectations-2.11.2/spec/support/classes.rb

@@ -0,0 +1,56 @@
+# various classes used by the specs
+module RSpec
+  module Expectations
+    module Helper
+      class CollectionWithSizeMethod
+        def initialize; @list = []; end
+        def size; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithLengthMethod
+        def initialize; @list = []; end
+        def length; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithCountMethod
+        def initialize; @list = []; end
+        def count; @list.count; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionOwner
+        attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method, :items_in_collection_with_count_method
+
+        def initialize
+          @items_in_collection_with_size_method = CollectionWithSizeMethod.new
+          @items_in_collection_with_length_method = CollectionWithLengthMethod.new
+          @items_in_collection_with_count_method = CollectionWithCountMethod.new
+        end
+
+        def add_to_collection_with_size_method(item)
+          @items_in_collection_with_size_method.push(item)
+        end
+
+      def add_to_collection_with_length_method(item)
+        @items_in_collection_with_length_method.push(item)
+      end
+
+      def add_to_collection_with_count_method(item)
+        @items_in_collection_with_count_method.push(item)
+      end
+
+        def items_for(arg)
+          return [1, 2, 3] if arg == 'a'
+          [1]
+        end
+
+        def items
+          @items_in_collection_with_size_method
+        end
+      end
+
+    end
+  end
+end

data/support/gems/rspec-expectations-2.11.2/spec/support/in_sub_process.rb

@@ -0,0 +1,31 @@
+module InSubProcess
+  # Useful as a way to isolate a global change to a subprocess.
+  def in_sub_process
+    readme, writeme = IO.pipe
+
+    pid = Process.fork do
+      value = nil
+      begin
+        yield
+      rescue => e
+        value = e
+      end
+
+      writeme.write Marshal.dump(value)
+
+      readme.close
+      writeme.close
+      exit! # prevent at_exit hooks from running (e.g. minitest)
+    end
+
+    writeme.close
+    Process.waitpid(pid)
+
+    if exception = Marshal.load(readme.read)
+      raise exception
+    end
+
+    readme.close
+  end
+end
+

data/support/gems/rspec-expectations-2.11.2/spec/support/matchers.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+module RSpec
+  module Matchers
+    def fail
+      raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+
+    def fail_matching(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, /#{Regexp.escape(message)}/)
+    end
+  end
+end
+

data/support/gems/rspec-expectations-2.11.2/spec/support/ruby_version.rb

@@ -0,0 +1,10 @@
+module RSpec
+  module Ruby
+    class << self
+      def version
+        RUBY_VERSION
+      end
+    end
+  end
+end
+

data/support/gems/rspec-mocks-2.11.1/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+-
+README.md
+License.txt
+Changelog.md

data/support/gems/rspec-mocks-2.11.1/.yardopts

@@ -0,0 +1,6 @@
+--exclude features
+--no-private
+--markup markdown
+-
+Changelog.md
+License.txt

data/support/gems/rspec-mocks-2.11.1/Changelog.md

@@ -0,0 +1,199 @@
+### 2.11.1 / 2012-07-09
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.11.0...v2.11.1)
+
+Bug fixes
+
+* Fix `should_receive` so that when it is called on an `as_null_object`
+  double with no implementation, and there is a previous explicit stub
+  for the same method, the explicit stub remains (rather than being
+  overriden with the null object implementation--`return self`). (Myron Marston)
+
+### 2.11.0 / 2012-07-07
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.10.1...v2.11.0)
+
+Enhancements
+
+* expose ArgumentListMatcher as a formal API
+    * supports use by 3rd party mock frameworks like Surrogate
+* Add `stub_const` API to stub constants for the duration of an
+  example (Myron Marston).
+
+Bug fixes
+
+* Fix regression of edge case behavior. `double.should_receive(:foo) { a }`
+  was causing a NoMethodError when `double.stub(:foo).and_return(a, b)`
+  had been setup before (Myron Marston).
+* Infinite loop generated by using `any_instance` and `dup`. (Sidu Ponnappa @kaiwren)
+* `double.should_receive(:foo).at_least(:once).and_return(a)` always returns a
+  even if `:foo` is already stubbed.
+* Prevent infinite loop when interpolating a null double into a string
+  as an integer (`"%i" % double.as_null_object`). (Myron Marston)
+* Fix `should_receive` so that null object behavior (e.g. returning
+  self) is preserved if no implementation is given (Myron Marston).
+* Fix `and_raise` so that it raises `RuntimeError` rather than
+  `Exception` by default, just like ruby does. (Andrew Marshall)
+
+### 2.10.1 / 2012-05-05
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.10.0...v2.10.1)
+
+Bug fixes
+
+* fix regression of edge case behavior
+  (https://github.com/rspec/rspec-mocks/issues/132)
+    * fixed failure of `object.should_receive(:message).at_least(0).times.and_return value`
+    * fixed failure of `object.should_not_receive(:message).and_return value`
+
+### 2.10.0 / 2012-05-03
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.9.0...v2.10.0)
+
+Bug fixes
+
+* fail fast when an `exactly` or `at_most` expectation is exceeded
+
+### 2.9.0 / 2012-03-17
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.8.0...v2.9.0)
+
+Enhancements
+
+* Support order constraints across objects (preethiramdev)
+
+Bug fixes
+
+* Allow a `as_null_object` to be passed to `with`
+* Pass proc to block passed to stub (Aubrey Rhodes)
+* Initialize child message expectation args to match any args (#109 -
+  preethiramdev)
+
+### 2.8.0 / 2012-01-04
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.8.0.rc2...v2.8.0)
+
+No changes for this release. Just releasing with the other rspec gems.
+
+### 2.8.0.rc2 / 2011-12-19
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.8.0.rc1...v2.8.0.rc2)
+
+No changes for this release. Just releasing with the other rspec gems.
+
+### 2.8.0.rc1 / 2011-11-06
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.7.0...v2.8.0.rc1)
+
+Enhancements
+
+* Eliminate Ruby warnings (Matijs van Zuijlen)
+
+### 2.7.0 / 2011-10-16
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.6.0...v2.7.0)
+
+Enhancements
+
+* Use `__send__` rather than `send` (alextk)
+* Add support for `any_instance.stub_chain` (Sidu Ponnappa)
+* Add support for `any_instance` argument matching based on `with` (Sidu
+  Ponnappa and Andy Lindeman)
+
+Changes
+
+* Check for `failure_message_for_should` or `failure_message` instead of
+  `description` to detect a matcher (Tibor Claassen)
+
+Bug fixes
+
+* pass a hash to `any_instance.stub`. (Justin Ko)
+* allow `to_ary` to be called without raising `NoMethodError` (Mikhail
+  Dieterle)
+* `any_instance` properly restores private methods (Sidu Ponnappa)
+
+### 2.6.0 / 2011-05-12
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.5.0...v2.6.0)
+
+Enhancements
+
+* Add support for `any_instance.stub` and `any_instance.should_receive` (Sidu
+  Ponnappa and Andy Lindeman)
+
+Bug fixes
+
+* fix bug in which multiple chains with shared messages ending in hashes failed
+  to return the correct value
+
+### 2.5.0 / 2011-02-05
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.4.0...v2.5.0)
+
+Bug fixes
+
+* message expectation counts now work in combination with a stub (Damian
+  Nurzynski)
+* fix failure message when message received with incorrect args (Josep M.
+  Bach)
+
+### 2.4.0 / 2011-01-02
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.3.0...v2.4.0)
+
+No functional changes in this release, which was made to align with the
+rspec-core-2.4.0 release.
+
+### 2.3.0 / 2010-12-12
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.2.0...v2.3.0)
+
+Bug fixes
+
+* Fix our Marshal extension so that it does not interfere with objects that
+  have their own `@mock_proxy` instance variable. (Myron Marston)
+
+### 2.2.0 / 2010-11-28
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.1.0...v2.2.0)
+
+Enhancements
+
+* Added "rspec/mocks/standalone" for exploring the rspec-mocks in irb.
+
+Bug fix
+
+* Eliminate warning on splat args without parens (Gioele Barabucci)
+* Fix bug where `obj.should_receive(:foo).with(stub.as_null_object)` would pass
+  with a false positive.
+
+### 2.1.0 / 2010-11-07
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.0.1...v2.1.0)
+
+Bug fixes
+
+* Fix serialization of stubbed object (Josep M Bach)
+
+### 2.0.0 / 2010-10-10
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.0.0.beta.22...v2.0.0)
+
+### 2.0.0.rc / 2010-10-05
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.0.0.beta.22...v2.0.0.rc)
+
+Enhancements
+
+* support passing a block to an expectation block (Nicolas Braem)
+    * `obj.should_receive(:msg) {|&block| ... }`
+
+Bug fixes
+
+* Fix YAML serialization of stub (Myron Marston)
+* Fix rdoc rake task (Hans de Graaff)
+
+### 2.0.0.beta.22 / 2010-09-12
+
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.0.0.beta.20...v2.0.0.beta.22)
+
+Bug fixes
+
+* fixed regression that broke `obj.stub_chain(:a, :b => :c)`
+* fixed regression that broke `obj.stub_chain(:a, :b) { :c }`
+* `respond_to?` always returns true when using `as_null_object`

data/support/gems/rspec-mocks-2.11.1/License.txt

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+Copyright (c) 2005 Steven Baker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/support/gems/rspec-mocks-2.11.1/README.md

@@ -0,0 +1,276 @@
+# RSpec Mocks [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/rspec/rspec-mocks)
+
+rspec-mocks is a test-double framework for rspec with support for method stubs,
+fakes, and message expectations on generated test-doubles and real objects
+alike.
+
+## Install
+
+    gem install rspec       # for rspec-core, rspec-expectations, rspec-mocks
+    gem install rspec-mocks # for rspec-mocks only
+
+## Test Doubles
+
+A Test Double is an object that stands in for a real object in a test.
+RSpec creates test doubles that support method stubs and message
+expectations.
+
+```ruby
+book = double("book")
+```
+
+## Method Stubs
+
+A method stub is an implementation that returns a pre-determined value.  Method
+stubs can be declared on test doubles or real objects using the same syntax.
+rspec-mocks supports 3 forms for declaring method stubs:
+
+```ruby
+book.stub(:title) { "The RSpec Book" }
+book.stub(:title => "The RSpec Book")
+book.stub(:title).and_return("The RSpec Book")
+```
+
+You can also use this shortcut, which creates a test double and declares a
+method stub in one statement:
+
+```ruby
+book = double("book", :title => "The RSpec Book")
+```
+
+The first argment is a name, which is used for documentation and appears in
+failure messages. If you don't care about the name, you can leave it out,
+making the combined instantiation/stub declaration very terse:
+
+```ruby
+double(:foo => 'bar')
+```
+
+This is particularly nice when providing a list of test doubles to a method
+that iterates through them:
+
+```ruby
+order.calculate_total_price(stub(:price => 1.99),stub(:price => 2.99))
+```
+
+## Consecutive return values
+
+When a stub might be invoked more than once, you can provide additional
+arguments to `and_return`.  The invocations cycle through the list. The last
+value is returned for any subsequent invocations:
+
+```ruby
+die.stub(:roll).and_return(1,2,3)
+die.roll # => 1
+die.roll # => 2
+die.roll # => 3
+die.roll # => 3
+die.roll # => 3
+```
+
+To return an array in a single invocation, declare an array:
+
+```ruby
+team.stub(:players).and_return([stub(:name => "David")])
+```
+
+## Message Expectations
+
+A message expectation is an expectation that the test double will receive a
+message some time before the example ends. If the message is received, the
+expectation is satisfied. If not, the example fails.
+
+```ruby
+validator = double("validator")
+validator.should_receive(:validate).with("02134")
+zipcode = Zipcode.new("02134", validator)
+zipcode.valid?
+```
+
+## Nomenclature
+
+### Mock Objects and Test Stubs
+
+The names Mock Object and Test Stub suggest specialized Test Doubles.  i.e.
+a Test Stub is a Test Double that only supports method stubs, and a Mock
+Object is a Test Double that supports message expectations and method
+stubs.
+
+There is a lot of overlapping nomenclature here, and there are many
+variations of these patterns (fakes, spies, etc). Keep in mind that most of
+the time we're talking about method-level concepts that are variations of
+method stubs and message expectations, and we're applying to them to _one_
+generic kind of object: a Test Double.
+
+### Test-Specific Extension
+
+a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a
+real object in a system that is instrumented with test-double like
+behaviour in the context of a test. This technique is very common in Ruby
+because we often see class objects acting as global namespaces for methods.
+For example, in Rails:
+
+```ruby
+person = double("person")
+Person.stub(:find) { person }
+```
+
+In this case we're instrumenting Person to return the person object we've
+defined whenever it receives the `find` message. We can also set a message
+expectation so that the example fails if `find` is not called:
+
+```ruby
+person = double("person")
+Person.should_receive(:find) { person }
+```
+
+We can do this with any object in a system because rspec-mocks adds the `stub`
+and `should_receive` methods to every object, including class objects. When we
+use either, RSpec replaces the method we're stubbing or mocking with its own
+test-double-like method. At the end of the example, RSpec verifies any message
+expectations, and then restores the original methods.
+
+## Expecting Arguments
+
+```ruby
+double.should_receive(:msg).with(*args)
+double.should_not_receive(:msg).with(*args)
+```
+
+## Argument Matchers
+
+Arguments that are passed to `with` are compared with actual arguments
+received using ==. In cases in which you want to specify things about the
+arguments rather than the arguments themselves, you can use any of the
+matchers that ship with rspec-expectations. They don't all make syntactic
+sense (they were primarily designed for use with RSpec::Expectations), but
+you are free to create your own custom RSpec::Matchers.
+
+rspec-mocks also adds some keyword Symbols that you can use to
+specify certain kinds of arguments:
+
+```ruby
+double.should_receive(:msg).with(no_args())
+double.should_receive(:msg).with(any_args())
+double.should_receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
+double.should_receive(:msg).with(1, boolean(), "b") #2nd argument can true or false
+double.should_receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
+double.should_receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
+double.should_receive(:msg).with(1, duck_type(:abs, :div), "b")
+                    #2nd argument can be object that responds to #abs and #div
+```
+
+## Receive Counts
+
+```ruby
+double.should_receive(:msg).once
+double.should_receive(:msg).twice
+double.should_receive(:msg).exactly(n).times
+double.should_receive(:msg).at_least(:once)
+double.should_receive(:msg).at_least(:twice)
+double.should_receive(:msg).at_least(n).times
+double.should_receive(:msg).at_most(:once)
+double.should_receive(:msg).at_most(:twice)
+double.should_receive(:msg).at_most(n).times
+double.should_receive(:msg).any_number_of_times
+```
+
+## Ordering
+
+```ruby
+double.should_receive(:msg).ordered
+double.should_receive(:other_msg).ordered
+  #This will fail if the messages are received out of order
+```
+
+## Setting Responses
+
+Whether you are setting a message expectation or a method stub, you can
+tell the object precisely how to respond. The most generic way is to pass
+a block to `stub` or `should_receive`:
+
+```ruby
+double.should_receive(:msg) { value }
+```
+
+When the double receives the `msg` message, it evaluates the block and returns
+the result.
+
+```ruby
+double.should_receive(:msg).and_return(value)
+double.should_receive(:msg).exactly(3).times.and_return(value1, value2, value3)
+  # returns value1 the first time, value2 the second, etc
+double.should_receive(:msg).and_raise(error)
+  #error can be an instantiated object or a class
+  #if it is a class, it must be instantiable with no args
+double.should_receive(:msg).and_throw(:msg)
+double.should_receive(:msg).and_yield(values,to,yield)
+double.should_receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  # for methods that yield to a block multiple times
+```
+
+Any of these responses can be applied to a stub as well
+
+```ruby
+double.stub(:msg).and_return(value)
+double.stub(:msg).and_return(value1, value2, value3)
+double.stub(:msg).and_raise(error)
+double.stub(:msg).and_throw(:msg)
+double.stub(:msg).and_yield(values,to,yield)
+double.stub(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+```
+
+## Arbitrary Handling
+
+Once in a while you'll find that the available expectations don't solve the
+particular problem you are trying to solve. Imagine that you expect the message
+to come with an Array argument that has a specific length, but you don't care
+what is in it. You could do this:
+
+```ruby
+double.should_receive(:msg) do |arg|
+  arg.size.should eq(7)
+end
+```
+
+## Combining Expectation Details
+
+Combining the message name with specific arguments, receive counts and responses
+you can get quite a bit of detail in your expectations:
+
+```ruby
+double.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
+```
+
+While this is a good thing when you really need it, you probably don't really
+need it! Take care to specify only the things that matter to the behavior of
+your code.
+
+## Stubbing Constants
+
+See the [stubbing constants
+README](https://github.com/rspec/rspec-mocks/blob/master/features/stubbing_constants/README.md)
+for info on this feature.
+
+## Use `before(:each)`, not `before(:all)`
+
+Stubs in `before(:all)` are not supported. The reason is that all stubs and mocks get cleared out after each example, so any stub that is set in `before(:all)` would work in the first example that happens to run in that group, but not for any others.
+
+Instead of `before(:all)`, use `before(:each)`.
+
+## Further Reading
+
+There are many different viewpoints about the meaning of mocks and stubs. If
+you are interested in learning more, here is some recommended reading:
+
+* Mock Objects: http://www.mockobjects.com/
+* Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf
+* Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf
+* Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
+* Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
+
+## Also see
+
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-expectations](http://github.com/rspec/rspec-expectations)