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

rspec 0.5.11 → 0.5.12

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

@@ -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.