horseman 0.0.2 → 0.0.3

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/spec/rspec/matchers/throw_symbol_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    describe ThrowSymbol do
+      describe "with no args" do
+        before(:each) { @matcher = throw_symbol }
+      
+        it "matches if any Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "matches if any Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "does not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "provides a failure message" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
+        end
+        it "provides a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym})
+          @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
+        end
+      end
+          
+      describe "with a symbol" do
+        before(:each) { @matcher = throw_symbol(:sym) }
+      
+        it "matches if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "matches if correct Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "does not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "does not match if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym }).should be_false
+        end
+        it "provides a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
+        end
+        it "provides a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
+        end
+        it "provides a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
+        end
+        it "only matches NameErrors raised by uncaught throws" do
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
+        end
+      end
+
+      describe "with a symbol and an arg" do
+        before(:each) { @matcher = throw_symbol(:sym, "a") }
+    
+        it "matches if correct Symbol and args are thrown" do
+          @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        end
+        it "does not match if nothing is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "does not match if other Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+        end
+        it "does not match if no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_false
+        end
+        it "does not match if wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+        end
+        it "provides a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
+        end
+        it "provides a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
+        end
+        it "provides a failure message when wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
+        end
+        it "provides a failure message when no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
+        end
+        it "provides a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
+        end
+        it "only matches NameErrors raised by uncaught throws" do
+          expect {
+            @matcher.matches?(lambda{ sym }).should be_false
+          }.to raise_error(NameError)
+        end
+        it "raises other errors" do
+          expect {
+            @matcher.matches?(lambda { raise "Boom" })
+          }.to raise_error(/Boom/)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/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/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/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/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/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/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/spec/support/ruby_version.rb

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

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/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/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/README.md

@@ -0,0 +1,257 @@
+# 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 do this with any
+object in a system because rspec-mocks adds the `stub` and `should_receive`
+methods to every object. 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, ducktype(: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 Reponses
+
+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.
+
+## 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)

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/features/README.markdown

@@ -0,0 +1,67 @@
+rspec-mocks helps to control the context in a code example by letting you set
+known return values, fake implementations of methods, and even expectations
+that specific messages are received by an object.
+
+You can do these three things on test doubles that rspec-mocks creates for you
+on the fly, or you can do them on objects that are part of your system.
+
+## Messages and Methods
+
+_Message_ and _method_ are metaphors that we use somewhat interchangeably, but
+they are subtly different.  In Object Oriented Programming, objects communicate
+by sending _messages_ to one another. When an object receives a message, it
+invokes a _method_ with the same name as the message.
+
+## Test Doubles
+
+A test double is an object that stands in for another object in your system
+during a code example. Use the `double` method to create one:
+
+    double_account = double("Account")
+
+You can also use the `mock` and `stub` methods to create test doubles, however
+these methods are there for backward compatibility only and will likely be
+deprecated and then removed from future versions.
+
+## Method Stubs
+
+A method stub is an instruction to an object (real or test double) to return a
+known value in response to a message:
+
+    die.stub(:roll) { 3 }
+
+This tells the `die` object to return the value `3` when it receives the `roll`
+message.
+
+## Message Expectations
+
+A message expectation is an expectation that an object should receive a
+specific message during the course of a code example:
+
+    describe Account do
+      context "when closed" do
+        it "logs an 'account closed' message" do
+          logger = double()
+          account = Account.new
+          account.logger = logger
+
+          logger.should_receive(:account_closed).with(account)
+
+          account.close
+        end
+      end
+    end
+
+This example specifies that the `account` object sends the `logger` the
+`account_closed` message (with itself as an argument) when it receives the
+`close` message.
+
+## Issues
+
+The documentation for rspec-mocks is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-mocks/issues) or a [pull
+request](http://github.com/rspec/rspec-mocks).

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/features/Scope.md

@@ -0,0 +1,17 @@
+Doubles, stubs, and message expectations are all cleaned out after each
+example. This ensures that each example can be run in isolation, and in any
+order.
+
+### `before(:each)`
+
+It is perfectly fine to set up doubles, stubs, and message expectations in
+a `before(:each)` hook, as that hook is executed in the scope of the example:
+
+    before(:each) do
+      @account = double('account')
+    end
+
+### Do not create doubles, stubs, or message expectations in `before(:all)`
+
+If you do, they'll get cleaned out after the first example, and you will be
+very confused as to what's going on in the second example.

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/features/Upgrade.md

@@ -0,0 +1,22 @@
+## rspec-mocks-2.6
+
+### `any_instance`
+
+Set method stubs and message expectations on any instance of a class:
+
+    class Foo; end
+    Foo.any_instance.stub(:bar) { 'bar' }
+    Foo.new.bar # => 'bar'
+
+## rspec-mocks-2.2
+
+### `require "rspec/mocks/standalone"`
+
+Sets up top-level environment to explore rspec-mocks. Mostly useful in irb:
+
+    $ irb
+    > require 'rspec/mocks/standalone'
+    > foo = double()
+    > foo.stub(:bar) { :baz }
+    > foo.bar
+      => :baz

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.8.0/features/argument_matchers/README.md

@@ -0,0 +1,27 @@
+### Introduction
+
+Argument matchers can be used:
+
+* In stubs to constrain the scope of the stubbed method
+
+      obj.stub(:foo).with(:bar) do |arg|
+        #do something for :bar
+      end
+      obj.stub(:foo).with(:baz) do |arg|
+        #do something for :baz
+      end
+
+* In expectations to validate the arguments that should be received in a method call
+
+      #create a double
+      obj = double()
+      
+      #expect a message with given args
+      obj.should_receive(:message).with('an argument')
+
+If more control is needed, one can use a block
+
+    obj.should_receive(:message) do |arg1,  arg2|
+      # set expectations about the args in this block
+      # and optionally set a return value
+    end