RubyGems - rspec - Versions diffs - 0.5.11 → 0.5.12 - Mend

rspec 0.5.11 → 0.5.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

data/CHANGES +12 -0
data/README +4 -2
data/Rakefile +14 -4
data/bin/spec +7 -7
data/bin/test2spec +13 -8
data/lib/spec/api/helper/diff.rb +53 -0
data/lib/spec/api/helper/instance_helper.rb +11 -11
data/lib/spec/api/helper/instance_negator.rb +11 -11
data/lib/spec/api/helper/kind_helper.rb +11 -11
data/lib/spec/api/helper/kind_negator.rb +11 -11
data/lib/spec/api/helper/respond_helper.rb +11 -11
data/lib/spec/api/helper/respond_negator.rb +11 -11
data/lib/spec/api/helper/should_base.rb +6 -6
data/lib/spec/api/helper/should_helper.rb +35 -35
data/lib/spec/api/helper/should_negator.rb +20 -20
data/lib/spec/rake/spectask.rb +15 -6
data/lib/spec/runner.rb +1 -0
data/lib/spec/runner/backtrace_tweaker.rb +2 -0
data/lib/spec/runner/base_text_formatter.rb +3 -1
data/lib/spec/runner/html_formatter.rb +153 -0
data/lib/spec/runner/option_parser.rb +9 -2
data/lib/spec/runner/progress_bar_formatter.rb +4 -0
data/lib/spec/runner/rdoc_formatter.rb +3 -0
data/lib/spec/runner/reporter.rb +5 -5
data/lib/spec/runner/specdoc_formatter.rb +3 -0
data/lib/spec/test_to_spec/sexp_transformer.rb +1 -0
data/lib/spec/test_to_spec/translation_test_runner.rb +10 -2
data/lib/spec/version.rb +1 -1
data/test/spec/api/helper/arbitrary_predicate_test.rb +49 -73
data/test/spec/api/helper/diff_test.rb +60 -0
data/test/spec/api/helper/equality_test.rb +14 -0
data/test/spec/api/helper/should_have_test.rb +0 -29
data/test/spec/api/helper/typing_test.rb +87 -87
data/test/spec/api/sugar_test.rb +0 -6
data/test/spec/runner/backtrace_tweaker_test.rb +8 -2
data/test/spec/runner/html_formatter_test.rb +47 -0
data/test/spec/runner/option_parser_test.rb +0 -5
data/test/test_classes.rb +73 -0
data/test/test_helper.rb +3 -0
metadata +8 -49
data/doc/README +0 -3
data/doc/config.yaml +0 -2
data/doc/plugin/syntax.rb +0 -60
data/doc/plugin/version.rb +0 -19
data/doc/src/core_team.page +0 -31
data/doc/src/default.css +0 -199
data/doc/src/default.template +0 -31
data/doc/src/documentation/index.page +0 -188
data/doc/src/documentation/meta.info +0 -22
data/doc/src/documentation/mocks.page +0 -287
data/doc/src/documentation/underscores.page +0 -21
data/doc/src/examples.page +0 -9
data/doc/src/images/David_and_Aslak.jpg +0 -0
data/doc/src/images/Whats_That_Dude.jpg +0 -0
data/doc/src/images/ducks1.png +0 -0
data/doc/src/images/ul.gif +0 -0
data/doc/src/index.page +0 -74
data/doc/src/meta.info +0 -33
data/doc/src/tools/index.page +0 -49
data/doc/src/tools/meta.info +0 -18
data/doc/src/tools/rails.page +0 -132
data/doc/src/tools/rake.page +0 -21
data/doc/src/tools/rcov.page +0 -28
data/doc/src/tools/spec.page +0 -129
data/doc/src/tools/test2spec.page +0 -103
data/doc/src/tutorials/index.page +0 -52
data/doc/src/tutorials/meta.info +0 -36
data/doc/src/tutorials/notes.txt +0 -263
data/doc/src/tutorials/stack.rb +0 -11
data/doc/src/tutorials/stack_01.page +0 -226
data/doc/src/tutorials/stack_02.page +0 -182
data/doc/src/tutorials/stack_03.page +0 -283
data/doc/src/tutorials/stack_04.page +0 -164
data/doc/src/tutorials/stack_04.page.orig +0 -123
data/doc/src/tutorials/stack_05.page +0 -90
data/doc/src/tutorials/stack_05.page.orig +0 -124
data/doc/src/tutorials/stack_06.page +0 -359
data/doc/src/tutorials/stack_06.page.orig +0 -359
data/doc/src/tutorials/stack_spec.rb +0 -25
data/doc/src/ul.gif +0 -0

data/doc/src/default.template DELETED

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="{lang:}">
-  <head>
-    <title>{title: }</title>
-    <link href="{relocatable: default.css}" rel="stylesheet" type="text/css" media="screen"/>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  </head>
-<body>
-<div id="container">
-	<div id="header">
-        <h2>Behaviour Driven Development for <strong>Ruby</strong></h2>
-		<h1>RSpec {version: }</h1>
-	</div>
-	<div id="navigation">
-	    {menu: {menuStyle: horizontal}}
-	</div>
-	<div id="content">
-		{content: }
-		<div id="footer">
-			Webdesign by <a href="http://www.oswd.org/user/profile/id/9462">JM</a>
-		</div>
-	</div>
-</div>
-</body>
-</html>

data/doc/src/documentation/index.page DELETED

@@ -1,188 +0,0 @@
----
-title: Core API
-inMenu: true
-ordering: 5
----
-h2. Core API
-When RSpec executes specifications, it defines a method <code>should</code> on every object in the system. This <code>should</code> method is your entry to the magic of RSpec.
-Almost all expectation forms have a corresponding negated form. It is listed when it is supported and, unless otherwise stated, is met when ever the non-negated form would be violated.
-h3. General
-h4. Arbitrary Block
-<ruby>
-target.should_satisfy {|arg| ...}
-target.should_not_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}
-</ruby>
-h4. Equality
-<ruby>
-target.should_equal <value>
-target.should_not_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.
-h4. Floating Point Comparison
-<ruby>
-target.should_be_close <value>, <tolerance>
-target.should_not_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
-</ruby>
-h4. Identity
-<ruby>
-target.should_be <value>
-target.should_not_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.
-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]
-</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.
-For example:
-<ruby>
-container.should_include('a') => container.include?('a')
-container.should_be_empty => container.empty?
-</ruby>
-h4. Pattern Matching
-<ruby>
-target.should_match <regex>
-target.should_not_match <regex>
-</ruby>
-The <code>target</code> is matched against <code>regex</code>. An <code>ExpectationNotMetError</code> is raised if the match fails.
-h3. Class/Type
-h4. Direct Instance
-<ruby>
-target.should_be_an_instance_of <class>
-target.should_not_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>.
-h4. Ancestor Class
-<ruby>
-target.should_be_a_kind_of <class>
-target.should_not_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.
-h4. Type
-<ruby>
-target.should_respond_to <symbol>
-target.should_not_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.
-h3. Procs
-h4. Raising
-<ruby>
-proc.should_raise <exception>
-proc.should_not_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
-</ruby>
-There is a more general form as well.
-<ruby>
-proc.should_raise
-proc.should_not_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.
-h4. Throwing
-<ruby>
-proc.should_throw <symbol>
-proc.should_not_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
-</ruby>
-This form is more specific.  It checks that no symbol is thrown from within <code>proc</code>.
-h3. Collections
-h4. Containment
-<ruby>
-target.should_include <object>
-target.should_not_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.
-The remaining collection forms are a little more involved. They rely on two things: 1) <code>target</code> responds to the message <code>things</code> by returning an object that 2) responds to either <code>length</code> or <code>size</code>, which return a number that is a measure of size. Currently <code>length</code> is used if is appropriate, otherwise <code>size</code> is attempted.
-h4. Exact Size
-<ruby>
-target.should_have(<number>).things
-</ruby>
-The <code>things</code> of <code>target</code> has a length/size of exactly <code>number</code>.
-h4. Lower Bound
-<ruby>
-target.should_have_at_least(<number>).things
-</ruby>
-The <code>things</code> of <code>target</code> has a length/size of no less than <code>number</code>.
-h4. Upper Bound
-<ruby>
-target.should_have_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/meta.info DELETED

@@ -1,22 +0,0 @@
-index.page:
-  inMenu: 11
-underscores.page:
-  orderInfo: 13
-mocks.page:
-  orderInfo: 14
-rdoc.html:
-  title: RDoc
-  dest: ../rdoc/index.html
-  inMenu: true
-  orderInfo: 15
-rcov.html:
-  title: RCov
-  dest: ../coverage/index.html
-  inMenu: true
-  orderInfo: 16

data/doc/src/documentation/mocks.page DELETED

@@ -1,287 +0,0 @@
----
-title: Mock API
-inMenu: true
----
-h2. Mock API
-RSpec contains a tightly integrated, powerful Mock Object framework.
-h3. Creating a mock
-<ruby>
-my_mock = mock(<name>)
-</ruby>
-This creates a new mock with the given <code>name</code> (a string) and registers it.
-When the specification finishes, all registered mocks are verified.
-<ruby>
-my_mock = mock(<name>, <options>)
-</ruby>
-As above, but allows you to specific options to tweak the mock's behaviour. The
-<code>options</code> argument is a hash. Currently the only supported option is
-<code>:null_object</code>. Setting this to true instructs the mock to ignore
-(quietly consume) any messages it hasn't been told to expect - and return itself.  I.e.:
-<ruby>
-my_mock = mock("blah", :null_object => true)
-</ruby>
-h3. Expecting Messages
-<ruby>
-my_mock.should_receive(<message>)
-</ruby>
-The <code>message</code> argument is a symbol that is the name of a message
-that you want the mock to expect.
-h3. Expecting Arguments
-<ruby>
-my_mock.should_receive(:msg).with(<args>)
-</ruby>
-for example:
-<ruby>
-my_mock.should_receive(: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)
-</ruby>
-The message (<code>msg</code>) is expected to be passed no arguments.
-<ruby>
-my_mock.should_receive(: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.
-h3. Argument Constraints
-Constraints can be placed on individual arguments which are looser than value
-equivalence (as above).
-h4. :anything
-accepts any value for this argument, e.g.:
-<ruby>
-my_mock.should_receive(:msg).with(1, :anything, "A")
-</ruby>
-h4. :numeric
-accepts any numeric value for this argument, e.g.:
-<ruby>
-my_mock.should_receive(:msg).with(a, :numeric, "b")
-</ruby>
-h4. :boolean
-accepts a boolean value for this argument, e.g.:
-<ruby>
-my_mock.should_receive(:msg).with(a, :boolean, "b")
-</ruby>
-h4. :string
-accepts any string for this argument, e.g.:
-<ruby>
-my_mock.should_receive(:msg).with(a, :string, "b")
-</ruby>
-h4. duck_type(message(s))
-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")
-</ruby>
-h3. Receive Counts
-<ruby>
-my_mock.should_receive(:msg).never
-</ruby>
-An exception is raised if the message is ever received.
-This is equivalent to not specifying the reception of :msg,
-but it's more declarative and useful for humans.
-<ruby>
-my_mock.should_receive(:msg).any_number_of_times
-</ruby>
-The message can be received 0 or more times.
-<ruby>
-my_mock.should_receive(: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
-</ruby>
-An exception is raised if the message is received anything but two times.
-<ruby>
-my_mock.should_receive(: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)
-</ruby>
-An exception is raised if the message is never received.
-<ruby>
-my_mock.should_receive(: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
-</ruby>
-An exception is raised if the message is received fewer than <code>n</code> times.
-h3. Return Values
-h4. Single return value
-<ruby>
-my_mock.should_receive(:msg).once_and_return(<value>)
-</ruby>
-Each time the expected message is received, <code>value</code> will be returned as the result.
-h4. Consequtive return values
-<ruby>
-and_return([<value-1>, <value-2>, ..., <value-n>])
-</ruby>
-When the expected message is received, <code>value-i</code> will be returned as the result
-for the ith reception of the message. After the message has been received <code>i</code> times,
-<code>value-n</code> is returned for all
-subsequent receives.
-*Note:* if you wish to have a single return value that is an array, you must use this form, with
-one item that is the array to return.  Otherwise your array will be interpreted as a series of return values.
-For example:
-<ruby>
-and_return([[1, 2, 3]])
-</ruby>
-h4. Computed return value
-<ruby>
-my_mock.should_receive(:msg).once_and_return {...}
-</ruby>
-When the expected message is received, the result of evaluating the supplied
-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}
-</ruby>
-h3. Raising and Throwing
-<ruby>
-my_mock.should_receive(:msg).once_and_raise(<exception>)
-my_mock.should_receive(:msg).once_and_throw(<symbol>)
-</ruby>
-These instruct the mock to raise an exception or throw a symbol, respectively,
-instead of returning a value.
-h3. Yielding
-<ruby>
-my_mock.should_receive(: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.
-h3. Ordering
-There are times when you want to specify the order of messages sent to a mock.
-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
-</ruby>
-If the send of <code>flop</code> is seen before <code>flip</code> the specification will fail.
-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
-</ruby>
-The expected order is the order in which the expectations are declared.
-Order-independent 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-independent methods can be made in any order, even interspersed with
-calls to order-dependent 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)
-  # This will pass:
-  my_mock.one
-  my_mock.one_and_a_half
-  my_mock.zero
-  my_mock.two
-</ruby>
-h3. Arbitrary Handling of Received Messages
-You can supply a block to a message expectation. When the message is received
-by the mock, the block is passed any arguments and evaluated. The result is
-the return value of the block. For example:
-<ruby>
-my_mock.should_receive(:msg) { |a, b|
-  a.should_be true
-  b.should_not_contain('mice')
-  "Chunky bacon!"
-}
-</ruby>
-This allows arbitrary argument validation and result computation.  It's handy and kind of cool to be able to
-do this, but it is advised to not use this form in most situations.  Mocks should not be functional.
-They should be completely declarative.  That said, it's sometimes useful to give them some minimal behaviour.