cheat sheets.

--- assert_tag version 1	Sat May 31 07:31:26 +0000 2008
+++ assert_tag version 3	Tue Nov 25 10:26:52 +0000 2008
@@ -1,84 +1,84 @@
-assert_tag(*opts)
+assert_tag(*arg)
 
 Asserts that there is a tag/node/element in the body of the response that meets
 all of the given conditions. The conditions parameter must be a hash of any of
 the following keys (all are optional):
 
     * :tag: the node type must match the corresponding value
     * :attributes: a hash. The node‘s attributes must match the corresponding
     values in the hash.
     * :parent: a hash. The node‘s parent must match the corresponding hash.
     * :child: a hash. At least one of the node‘s immediate children must meet
     the criteria described by the hash.
     * :ancestor: a hash. At least one of the node‘s ancestors must meet the
     criteria described by the hash.
     * :descendant: a hash. At least one of the node‘s descendants must meet
     the criteria described by the hash.
     * :sibling: a hash. At least one of the node‘s siblings must meet the
     criteria described by the hash.
     * :after: a hash. The node must be after any sibling meeting the criteria
     described by the hash, and at least one sibling must match.
     * :before: a hash. The node must be before any sibling meeting the criteria
     described by the hash, and at least one sibling must match.
     * :children: a hash, for counting children of a node. Accepts the keys:
           o :count: either a number or a range which must equal (or include) the
           number of children that match.
           o :less_than: the number of matching children must be less than this
           number.
           o :greater_than: the number of matching children must be greater than
           this number.
           o :only: another hash consisting of the keys to use to match on the
           children, and only matching children will be counted.
     * :content: the textual content of the node must match the given value. This
     will not match HTML tags in the body of a tag—only text.
 
 Conditions are matched using the following algorithm:
 
     * if the condition is a string, it must be a substring of the value.
     * if the condition is a regexp, it must match the value.
     * if the condition is a number, the value must match number.to_s.
     * if the condition is true, the value must not be nil.
     * if the condition is false or nil, the value must be nil.
 
 Examples
 
   # Assert that there is a "span" tag
   assert_tag :tag => "span"
 
   # Assert that there is a "span" tag with id="x"
   assert_tag :tag => "span", :attributes => { :id => "x" }
 
   # Assert that there is a "span" tag using the short-hand
   assert_tag :span
 
   # Assert that there is a "span" tag with id="x" using the short-hand
   assert_tag :span, :attributes => { :id => "x" }
 
   # Assert that there is a "span" inside of a "div"
   assert_tag :tag => "span", :parent => { :tag => "div" }
 
   # Assert that there is a "span" somewhere inside a table
   assert_tag :tag => "span", :ancestor => { :tag => "table" }
 
   # Assert that there is a "span" with at least one "em" child
   assert_tag :tag => "span", :child => { :tag => "em" }
 
   # Assert that there is a "span" containing a (possibly nested)
   # "strong" tag.
   assert_tag :tag => "span", :descendant => { :tag => "strong" }
 
   # Assert that there is a "span" containing between 2 and 4 "em" tags
   # as immediate children
   assert_tag :tag => "span",
              :children => { :count => 2..4, :only => { :tag => "em" } }
 
   # Get funky: assert that there is a "div", with an "ul" ancestor
   # and an "li" parent (with "class" = "enum"), and containing a
   # "span" descendant that contains text matching /hello world/
   assert_tag :tag => "div",
              :ancestor => { :tag => "ul" },
              :parent => { :tag => "li",
                           :attributes => { :class => "enum" } },
              :descendant => { :tag => "span",
                               :child => /hello world/ }