rspec 0.5.6 → 0.5.7

data/CHANGES

@@ -1,5 +1,13 @@
 = RSpec Changelog
 
+== Version 0.5.7
+This release changes examples and documentation to recommend underscores rather than dots,
+and addresses some bugfixes and changes to the spec commandline.
+
+* spec DIR now works correctly, recursing down and slurping all *.rb files
+* All documentation and examples are now using '_' instead of '.'
+* Custom external formatters can now be specified via --require and --format.
+
 == Version 0.5.6
 This release fixes a bug in the Rails controller generator
 

data/Rakefile

@@ -25,7 +25,7 @@ PKG_FILES = FileList[
   'test/**/*.rb', 
   'examples/**/*.rb', 
   'doc/**/*'
-]
+].exclude('EXAMPLES.rd')
 
 task :default => [:test]
 
@@ -132,7 +132,9 @@ end
 
 desc "Creates a tag in svn"
 task :tag do
-  `svn cp svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/rspec/trunk svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/rspec/trunk/tags/#{Spec::VERSION::TAG}`
+  puts "Creating tag in SVN"
+  `svn cp svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/rspec/trunk svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/rspec/tags/#{Spec::VERSION::TAG} -m "Tag release #{Spec::VERSION::STRING}"`
+  puts "Done!"
 end
 
 desc "Build the website with rdoc and rcov, but do not publish it"
@@ -148,15 +150,13 @@ end
 
 desc "Upload Website to RubyForge"
 task :publish_website => [:verify_user, :website] do
-  unless ENV('SKIP_PUBLISH_WEBSITE') # Because of permission problems on Rubyforge.
-    publisher = Rake::SshDirPublisher.new(
-      "rspec-website@rubyforge.org",
-      "/var/www/gforge-projects/#{PKG_NAME}",
-      "doc/output"
-    )
-
-    publisher.upload
-  end
+  publisher = Rake::SshDirPublisher.new(
+    "rspec-website@rubyforge.org",
+    "/var/www/gforge-projects/#{PKG_NAME}",
+    "doc/output"
+  )
+
+  publisher.upload
 end
 
 task :package_rails do

data/bin/spec

@@ -3,9 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + "/../lib/spec") # better stack
 
 $context_runner = ::Spec::Runner::OptionParser.create_context_runner(ARGV, false, STDERR, STDOUT)
 
+# If ARGV is a glob, it will actually each over each one of the matching files.
 ARGV.each do |file_or_dir|
 	if File.lstat(file_or_dir).directory? then
-		(Dir.open(file_or_dir).select {|f| f =~ /.*\.rb/}).each {|file| require "#{file_or_dir}/#{file}"}
+		Dir["#{file_or_dir}/**/*.rb"].each do |file| 
+		  require "#{file}"
+		end
 	else
 		require file_or_dir
 	end

data/doc/src/documentation/index.page

@@ -14,21 +14,21 @@ h3. General
 h4. Arbitrary Block
 
 <ruby>
-target.should.satisfy {|arg| ...}
-target.should.not.satisfy {|arg| ...}
+target.should_satisfysatisfy {|arg| ...}
+target.should_satisfynot.satisfy {|arg| ...}
 </ruby>
 
 The supplied block is evaluated, passing <code>target</code> as the sole argument. If the block evaluates to <code>false</code>, <code>ExpectationNotMetError</code> is raised.
 
 <ruby>
-target.should.satisfy {|arg| arg > 0}
+target.should_satisfysatisfy {|arg| arg > 0}
 </ruby>
 
 h4. Equality
 
 <ruby>
-target.should.equal <value>
-target.should.not.equal <value>
+target.should_satisfyequal <value>
+target.should_satisfynot.equal <value>
 </ruby>
 
 The target object is compared to <code>value</code> using ==. If the result is <code>false</code>, <code>ExpectationNotMetError</code> is raised.
@@ -36,21 +36,21 @@ The target object is compared to <code>value</code> using ==. If the result is <
 h4. Floating Point Comparison
 
 <ruby>
-target.should.be.close <value>, <tolerance>
-target.should.not.be.close <value>, <tolerance>
+target.should_satisfybe.close <value>, <tolerance>
+target.should_satisfynot.be.close <value>, <tolerance>
 </ruby>
 
 The target object is compared to <code>value</code>. If they differ by more that <code>tolerance</code>, <code>ExpectationNotMetError</code> is raised. In the negated case, <code>ExpectationNotMetError</code> is raised if they differ by less than <code>tolerance</code>.
 
 <ruby>
-target.should.be.close 27.35, 0.05
+target.should_satisfybe.close 27.35, 0.05
 </ruby>
 
 h4. Identity
 
 <ruby>
-target.should.be <value>
-target.should.not.be <value>
+target.should_satisfybe <value>
+target.should_satisfynot.be <value>
 </ruby>
 
 The target object is compared to <code>value</code> using <code>equal?</code>. If the result is <code>false</code>, <code>ExpectationNotMetError</code> is raised.
@@ -58,10 +58,10 @@ The target object is compared to <code>value</code> using <code>equal?</code>. I
 h4. Arbitrary Predicate
 
 <ruby>
-target.should.predicate [optional args]
-target.should.be.predicate [optional args]
-target.should.not.predicate [optional args]
-target.should.not.be.predicate [optional args]
+target.should_satisfypredicate [optional args]
+target.should_satisfybe.predicate [optional args]
+target.should_satisfynot.predicate [optional args]
+target.should_satisfynot.be.predicate [optional args]
 </ruby>
 
 The message <code>predicate?</code> is sent to <code>target</code> with any supplied arguments. If the result is <code>false</code>, <code>ExpectationNotMetError</code> is raised.
@@ -69,15 +69,15 @@ The message <code>predicate?</code> is sent to <code>target</code> with any supp
 For example:
 
 <ruby>
-container.should.include('a') => container.include?('a')
-container.should.be.empty => container.empty?
+container.should_satisfyinclude('a') => container.include?('a')
+container.should_satisfybe.empty => container.empty?
 </ruby>
 
 h4. Pattern Matching
 
 <ruby>
-target.should.match <regex>
-target.should.not.match <regex>
+target.should_satisfymatch <regex>
+target.should_satisfynot.match <regex>
 </ruby>
 
 The <code>target</code> is matched against <code>regex</code>. An <code>ExpectationNotMetError</code> is raised if the match fails.
@@ -87,8 +87,8 @@ h3. Class/Type
 h4. Direct Instance
 
 <ruby>
-target.should.be.an.instance.of <class>
-target.should.not.be.an.instance.of <class>
+target.should_satisfybe.an.instance.of <class>
+target.should_satisfynot.be.an.instance.of <class>
 </ruby>
 
 An <code>ExpectationNotMetError</code> is raised if <code>target</code> is not or is, respectively, an direct instance of <code>class</code>. As expected this correlates to <code>target.instance_of?  class</code>.
@@ -96,8 +96,8 @@ An <code>ExpectationNotMetError</code> is raised if <code>target</code> is not o
 h4. Ancestor Class
 
 <ruby>
-target.should.be.a.kind.of <class>
-target.should.not.be.a.kind.of <class>
+target.should_satisfybe.a.kind.of <class>
+target.should_satisfynot.be.a.kind.of <class>
 </ruby>
 
 As above, but uses <code>target.kind_of? class</code>: checking whether <code>class</code> is the direct class of <code>target</code>, or an ancestor of <code>target</code>'s direct class.
@@ -105,8 +105,8 @@ As above, but uses <code>target.kind_of? class</code>: checking whether <code>cl
 h4. Type
 
 <ruby>
-target.should.respond.to <symbol>
-target.should.not.respond.to <symbol>
+target.should_satisfyrespond.to <symbol>
+target.should_satisfynot.respond.to <symbol>
 </ruby>
 
 Uses <code>target.respond_to?(symbol)</code> to check whether <code>symbol</code> is the name of a message that <code>target</code> understands.
@@ -116,21 +116,21 @@ h3. Procs
 h4. Raising
 
 <ruby>
-proc.should.raise <exception>
-proc.should.not.raise <exception>
+proc.should_satisfyraise <exception>
+proc.should_satisfynot.raise <exception>
 </ruby>
 
 Checks that <code>proc</code> causes the named exception to be raised or not. The latter is actually one of two cases: some other exception is raised, or no exception is raised. Typically the <code>proc</code> is created in place using <code>lambda</code>. For example:
 
 <ruby>
-lambda { 3 / 0 }.should.raise ZeroDivisionError
+lambda { 3 / 0 }.should_satisfyraise ZeroDivisionError
 </ruby>
 
 There is a more general form as well.
 
 <ruby>
-proc.should.raise
-proc.should.not.raise
+proc.should_satisfyraise
+proc.should_satisfynot.raise
 </ruby>
 
 These forms don't worry about what exception is raised (or not). All they are concerned with is that some except was raised, or that no exception was.
@@ -138,14 +138,14 @@ These forms don't worry about what exception is raised (or not). All they are co
 h4. Throwing
 
 <ruby>
-proc.should.throw <symbol>
-proc.should.not.throw <symbol>
+proc.should_satisfythrow <symbol>
+proc.should_satisfynot.throw <symbol>
 </ruby>
 
 Similar to the above, but checks that <code>symbol</code> is thrown from within <code>proc</code>, or not. The latter is actually one of two cases: some other symbol is thrown, or no symbol is thrown.
 
 <ruby>
-proc.should.not.throw
+proc.should_satisfynot.throw
 </ruby>
 
 This form is more specific.  It checks that no symbol is thrown from within <code>proc</code>.
@@ -155,8 +155,8 @@ h3. Collections
 h4. Containment
 
 <ruby>
-target.should.include <object>
-target.should.not.include <object>
+target.should_satisfyinclude <object>
+target.should_satisfynot.include <object>
 </ruby>
 
 This is simply a specific case of the arbitrary predicate form. It uses <code>target.include?(object)</code> and raises an <code>ExpectationNotMetError</code> if that returns false. 
@@ -166,7 +166,7 @@ The remaining collection forms are a little more involved. They rely on two thin
 h4. Exact Size
 
 <ruby>
-target.should.have(<number>).things
+target.should_satisfyhave(<number>).things
 </ruby>
 
 The <code>things</code> of <code>target</code> has a length/size of exactly <code>number</code>. 
@@ -174,7 +174,7 @@ The <code>things</code> of <code>target</code> has a length/size of exactly <cod
 h4. Lower Bound
 
 <ruby>
-target.should.have.at.least(<number>).things
+target.should_satisfyhave.at.least(<number>).things
 </ruby>
 
 The <code>things</code> of <code>target</code> has a length/size of no less than <code>number</code>.
@@ -182,7 +182,7 @@ The <code>things</code> of <code>target</code> has a length/size of no less than
 h4. Upper Bound
 
 <ruby>
-target.should.have.at.most(<number>).things
+target.should_satisfyhave.at.most(<number>).things
 </ruby>
 
 The <code>things</code> of <code>target</code> has a length/size of no more than <code>number</code>.

data/doc/src/documentation/mocks.page

@@ -27,7 +27,7 @@ my_mock = mock("blah", :null_object => true)
 h3. Expecting Messages
 
 <ruby>
-my_mock.should.receive(<message>)
+my_mock.should_receivereceive(<message>)
 </ruby>
 
 The <code>message</code> argument is a symbol that is the name of a message that you want the mock to expect.
@@ -39,7 +39,7 @@ by the mock, the block is evaluated, and passed any arguments. The result is
 the return value of the message. For example:
 
 <ruby>
-my_mock.should.receive(:random_call) {| a | a.should.be true}
+my_mock.should_receivereceive(:random_call) {| a | a.should_receivebe true}
 </ruby>
 
 This allows arbitrary argument validation and result computation.  It's handy and kind of cool to be able to do this, but I advise against it.  Mocks should not be functional.  they should be completely declarative.  That said, it's sometimes useful to give them some minimal behaviour.
@@ -47,25 +47,25 @@ This allows arbitrary argument validation and result computation.  It's handy an
 h3. Expecting Arguments
 
 <ruby>
-my_mock.should.receive(:msg).with(<args>)
+my_mock.should_receivereceive(:msg).with(<args>)
 </ruby>
 
 for example: 
 
 <ruby>
-my_mock.should.receive(:msg).with(1, 2, 3)
+my_mock.should_receivereceive(:msg).with(1, 2, 3)
 </ruby>
 
 The <code>args</code> argument is a series of arguments (e.g. 1, 2, 3) that are expected to be passed as arguments to the associated message.
 
 <ruby>
-my_mock.should.receive(:msg).with(:no_args)
+my_mock.should_receivereceive(:msg).with(:no_args)
 </ruby>
 
 The message (<code>msg</code>) is expected to be passed no arguments.
 
 <ruby>
-my_mock.should.receive(:msg).with(:any_args)
+my_mock.should_receivereceive(:msg).with(:any_args)
 </ruby>
 
 Any arguments (and any number of arguments) are to be accepted. This includes cases where no arguments are provided. *This is the default when no <code>with()</code> clause is specified.*  Even so, sometimes you want to be explicit about it.
@@ -79,7 +79,7 @@ h4. :anything
 accepts any value for this argument, e.g.:
 
 <ruby>
-my_mock.should.receive(:msg).with(1, :anything, "A")
+my_mock.should_receivereceive(:msg).with(1, :anything, "A")
 </ruby>
 
 h4. :numeric
@@ -87,7 +87,7 @@ h4. :numeric
 accepts any numeric value for this argument, e.g.:
 
 <ruby>
-my_mock.should.receive(:msg).with(a, :numeric, "b")
+my_mock.should_receivereceive(:msg).with(a, :numeric, "b")
 </ruby>
 
 h4. :boolean
@@ -95,7 +95,7 @@ h4. :boolean
 accepts a boolean value for this argument, e.g.:
 
 <ruby>
-my_mock.should.receive(:msg).with(a, :boolean, "b")
+my_mock.should_receivereceive(:msg).with(a, :boolean, "b")
 </ruby>
 
 h4. :string
@@ -103,7 +103,7 @@ h4. :string
 accepts any string for this argument, e.g.:
 
 <ruby>
-my_mock.should.receive(:msg).with(a, :string, "b")
+my_mock.should_receivereceive(:msg).with(a, :string, "b")
 </ruby>
 	
 h4. duck_type(message(s))
@@ -112,55 +112,55 @@ accepts any object that responds to the prescribed message(s), e.g.:
 
 <ruby>
 #accepts a Fixnum for the second arg
-my_mock.should.receive(:msg).with(a, duck_type(:abs, :div), "b") 
+my_mock.should_receivereceive(:msg).with(a, duck_type(:abs, :div), "b") 
 </ruby>
 
 h3. Receive Counts
 
 <ruby>
-my_mock.should.receive(:msg).never
+my_mock.should_receivereceive(:msg).never
 </ruby>
 
 An exception is raised if the message is ever received.
 
 <ruby>
-my_mock.should.receive(:msg).any.number.of.times
+my_mock.should_receivereceive(:msg).any.number.of.times
 </ruby>
 
 The message can be received 0 or more times.
 
 <ruby>
-my_mock.should.receive(:msg).once
+my_mock.should_receivereceive(:msg).once
 </ruby>
 
 An exception is raised if the message is never received, or it is received more than once.
 
 <ruby>
-my_mock.should.receive(:msg).twice
+my_mock.should_receivereceive(:msg).twice
 </ruby>
 
 An exception is raised if the message is received anything but two times.
 
 <ruby>
-my_mock.should.receive(:msg).exactly(n).times
+my_mock.should_receivereceive(:msg).exactly(n).times
 </ruby>
 
 An exception is raised if the message is received anything but <code>n</code> times.
 
 <ruby>
-my_mock.should.receive(:msg).at.least(:once)
+my_mock.should_receivereceive(:msg).at.least(:once)
 </ruby>
 
 An exception is raised if the message is never received.
 
 <ruby>
-my_mock.should.receive(:msg).at.least(:twice)
+my_mock.should_receivereceive(:msg).at.least(:twice)
 </ruby>
 
 An exception is raised if the message is never received or is received only once.
 
 <ruby>
-my_mock.should.receive(:msg).at.least(n).times
+my_mock.should_receivereceive(:msg).at.least(n).times
 </ruby>
 
 An exception is raised if the message is received fewer than <code>n</code> times.
@@ -170,7 +170,7 @@ h3. Return Values
 h4. Single return value
 
 <ruby>
-my_mock.should.receive(:msg).once.and.return(<value>)
+my_mock.should_receivereceive(:msg).once.and.return(<value>)
 </ruby>
 
 Each time the expected message is received, <code>value</code> will be returned as the result.
@@ -193,7 +193,7 @@ and.return([[1, 2, 3]])
 h4. Computed return value
 
 <ruby>
-my_mock.should.receive(:msg).once.and.return {...} 
+my_mock.should_receivereceive(:msg).once.and.return {...} 
 </ruby>
 
 When the expected message is received, the result of evaluating the supplied
@@ -201,14 +201,14 @@ block will be returned as the result. The block is passed any arguments passed
 as arguments of the message. This capability can be used to compute return values based on the arguments.  For example:
 
 <ruby>
-my_mock.should.receive(:msg).with(:numeric, :numeric) once.and.return {|a, b| a + b}
+my_mock.should_receivereceive(:msg).with(:numeric, :numeric) once.and.return {|a, b| a + b}
 </ruby>
 
 h3. Raising and Throwing
 
 <ruby>
-my_mock.should.receive(:msg).once.and.raise(<exception>)
-my_mock.should.receive(:msg).once.and.throw(<symbol>) 
+my_mock.should_receivereceive(:msg).once.and.raise(<exception>)
+my_mock.should_receivereceive(:msg).once.and.throw(<symbol>) 
 </ruby>
 
 These instruct the mock to raise an exception or throw a symbol, respectively, instead of returning a value.
@@ -216,7 +216,7 @@ These instruct the mock to raise an exception or throw a symbol, respectively, i
 h3. Yielding
 
 <ruby>
-my_mock.should.receive(:msg).once.and.yield([<value-1>, <value-2>, ..., <value-n>])
+my_mock.should_receivereceive(:msg).once.and.yield([<value-1>, <value-2>, ..., <value-n>])
 </ruby>
 
 When the expected message is received, the mock will yield the values to the passed block.
@@ -229,8 +229,8 @@ It shouldn't be the case very often, but it can be handy at times.
 Labeling expectations as being ordered is done by the <code>ordered</code> call:
 
 <ruby>
-my_mock.should.receive(:flip).once.ordered
-my_mock.should.receive(:flop).once.ordered
+my_mock.should_receivereceive(:flip).once.ordered
+my_mock.should_receivereceive(:flop).once.ordered
 </ruby>
 
 If the send of <code>flop</code> is seen before <code>flip</code> the specification will fail.
@@ -238,9 +238,9 @@ If the send of <code>flop</code> is seen before <code>flip</code> the specificat
 Of course, chains of ordered expectations can be set up:
 
 <ruby>
-my_mock.should.receive(:one).ordered
-my_mock.should.receive(:two).ordered
-my_mock.should.receive(:three).ordered
+my_mock.should_receivereceive(:one).ordered
+my_mock.should_receivereceive(:two).ordered
+my_mock.should_receivereceive(:three).ordered
 </ruby>
 
 The expected order is the order in which the expectations are declared.
@@ -248,10 +248,10 @@ The expected order is the order in which the expectations are declared.
 Order-independant expectations can be set anywhere in the expectation sequence, in any order.  Only the order of expectations tagged with the <code>ordered</code> call is significant.  Likewise, calls to order-independant methods can be made in any order, even interspersed with calls to order-dependant methods.  For example:
 
 <ruby>
-  my_mock.should.receive(:zero)
-  my_mock.should.receive(:one).ordered
-  my_mock.should.receive(:two).ordered
-  my_mock.should.receive(:one_and_a_half)
+  my_mock.should_receivereceive(:zero)
+  my_mock.should_receivereceive(:one).ordered
+  my_mock.should_receivereceive(:two).ordered
+  my_mock.should_receivereceive(:one_and_a_half)
   my_mock.one
   my_mock.one_and_a_half
   my_mock.zero