ruby-contract 0.1.1

data/COPYING

@@ -0,0 +1,56 @@
+ruby-contract is copyrighted free software by Florian Gross <flgr@ccan.de>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see the file GPL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/Manifest

@@ -0,0 +1,85 @@
+lib
+test
+doc
+TODO
+COPYING
+README
+setup.rb
+Manifest
+lib/contract.rb
+lib/contract
+lib/contract/integration.rb
+lib/contract/assertions.rb
+lib/contract/overrides.rb
+lib/contract/exception.rb
+test/tc_contract.rb
+test/tc_integration.rb
+test/coverage
+test/tc_exception.rb
+test/tc_all.rb
+test/coverage/_-lib-contract-integration_rb.html
+test/coverage/_-lib-contract-assertions_rb.html
+test/coverage/_-lib-contract-overrides_rb.html
+test/coverage/_-lib-contract-exception_rb.html
+test/coverage/_-lib-contract_rb.html
+test/coverage/__-lib-contract-assertions_rb.html
+test/coverage/__-lib-contract-exception_rb.html
+test/coverage/__-lib-contract_rb.html
+test/coverage/__-lib-contract-overrides_rb.html
+test/coverage/__-lib-contract-integration_rb.html
+test/coverage/index.html
+doc/index.html
+doc/fr_method_index.html
+doc/fr_class_index.html
+doc/fr_file_index.html
+doc/classes
+doc/files
+doc/rdoc-style.css
+doc/dot
+doc/created.rid
+doc/classes/Kernel.html
+doc/classes/MethodSignatureMixin.html
+doc/classes/Module.html
+doc/classes/Method.html
+doc/classes/Contract
+doc/classes/Contract.html
+doc/classes/Contract/ContractMismatch.html
+doc/classes/Contract/ContractError.html
+doc/classes/Contract/Check
+doc/classes/Contract/Check.html
+doc/classes/Contract/ContractException.html
+doc/classes/Contract/Check/Quack.html
+doc/classes/Contract/Check/Block.html
+doc/classes/Contract/Check/None.html
+doc/classes/Contract/Check/All.html
+doc/classes/Contract/Check/Any.html
+doc/files/lib
+doc/files/README.html
+doc/files/COPYING.html
+doc/files/TODO.html
+doc/files/lib/contract_rb.html
+doc/files/lib/contract
+doc/files/lib/contract/integration_rb.html
+doc/files/lib/contract/assertions_rb.html
+doc/files/lib/contract/overrides_rb.html
+doc/files/lib/contract/exception_rb.html
+doc/dot/f_7.png
+doc/dot/f_7.dot
+doc/dot/f_6_1.png
+doc/dot/f_6_1.dot
+doc/dot/f_6_0.png
+doc/dot/f_6_0.dot
+doc/dot/f_6.png
+doc/dot/f_6.dot
+doc/dot/f_5.png
+doc/dot/f_5.dot
+doc/dot/f_4.png
+doc/dot/f_4.dot
+doc/dot/f_3.png
+doc/dot/f_3.dot
+doc/dot/f_2.png
+doc/dot/f_2.dot
+doc/dot/f_1.png
+doc/dot/f_1.dot
+doc/dot/f_0.png
+doc/dot/f_0.dot

data/README

@@ -0,0 +1,32 @@
+= ruby-contract 0.1.1 README
+
+ruby-contract provides support for describing and using types via unit-tests.
+It offers support for specifying contracts (Contract), method signature checks
+(Module#signature), automatic adaption between types (Kernel#adaption) and
+integration with the classic message- and class-based typing.
+
+== Requirements
+
+* Ruby >= 1.8.1
+
+
+== Installation
+
+De-compress archive and enter its top directory. Then type:
+
+  ($ su)
+  # ruby setup.rb
+
+These simple step installs this program under the default location of Ruby
+libraries. You can also install files into your favorite directory by supplying
+setup.rb some options. Try "ruby setup.rb --help".
+
+
+== License
+
+Dual licensed under GPL and Ruby's custom license. See COPYING.
+
+
+== Author
+
+Florian Gross, flgr@ccan.de

data/TODO

@@ -0,0 +1,83 @@
+= TODO
+
+* Also think about how to extend the DBC abilities. Invariants would be nice, but
+  how to implement them?
+
+* Add multi method dispatch facilities similar to those from dispatch.rb. It would
+  be good if code could be shared between that and signatures.
+
+* Write introductionary explanation of what we do and don't and why we do so.
+  Probably belongs into the README but should also appear in the RDoc output.
+  http://split-s.blogspot.com/2005/02/quack-quack.html might be useful for
+  explaining why this is better than doing the usual is-a typing of static
+  languages.
+
+* Perhaps teach the Rakefile how to export the SVN tree to the RubyForge project
+  (see http://svn2cvs.tigris.org/)
+
+* If we add DBC we probably ought to have ways of getting the pre and post
+  checks as well as the in-variants as an Array of Procs or something like
+  that.
+
+* Make Method#signature return a meta object that allows you to do
+  method.signature.matches?(*args) or something similar?
+
+
+= Done
+
+* Add methods for querying signature meta information. (Unbound)Method#signature
+  would return the original Module#signature arguments.
+
+* Set up a RubyForge project and teach the Rakefile how to upload releases
+
+* Contact the pragprog guys about DBC in Ruby:
+  http://www.eng.cse.dmu.ac.uk/~hgs/projects/ruby_dbc.html
+  * Done, might base post/pre-conditions implementation on that project
+
+* Think about the kind of object adaption that matz discussed on his weblog:
+  http://redhanded.hobix.com/inspect/staticTyping.html
+  Also see http://www.python.org/peps/pep-0246.html and
+  http://peak.telecommunity.com/DevCenter/MonkeyTyping
+
+    adaption :from => Pathname, :to => String, :via => :to_str
+    adaption :from => String, :to => Pathname do |string|
+      Pathname.new(string)
+    end
+    adaption :from => String, :to => Pathname, :via => Pathname.method(:new)
+
+  Perhaps make both :from and :to default to self so short forms are possible
+  inside classes: (raise Exception when :to == :from)
+
+    class String
+      adaption :to => Pathname, :via => Pathname.method(:new)
+      adaption :from => Pathname, :via => :to_str
+
+      adaption :to => Symbol, :via => :to_sym
+    end
+
+  Might be nice to have conditional adaption routes:
+
+    class Object
+      adaption :to => String, :via => :to_str, :if => Contract::Check::Quack[:to_str]
+      # perhaps also introduce this short form
+      adaption :to => String, :via => :to_str, :if => :to_str
+    end
+
+  Perhaps :if should default to :via if :via is a Symbol which would allow the
+  above to become
+
+    class Object
+      adaption :to => String, :via => :to_str
+    end
+  * Implemented.
+
+* Think about implementing Contract#implies which would automatically trigger the
+  inclusion of a Module on other Modules/Classes that do fulfills(contract).
+  * Implemented.
+
+* Module#fulfills(contract) -- a way of stating that all instances of a Class
+  should be checked against the contract after initialisation. This would always
+  need to be called after defining a custom initialize().
+
+* Read http://www.smalltalk.org/articles/
+  * Has a few generic comments about static typing and dynamic typing.

data/doc/classes/Contract.html

@@ -0,0 +1,599 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Class: Contract</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <meta http-equiv="Content-Script-Type" content="text/javascript" />
+  <link rel="stylesheet" href=".././rdoc-style.css" type="text/css" media="screen" />
+  <script type="text/javascript">
+  // <![CDATA[
+
+  function popupCode( url ) {
+    window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
+  }
+
+  function toggleCode( id ) {
+    if ( document.getElementById )
+      elem = document.getElementById( id );
+    else if ( document.all )
+      elem = eval( "document.all." + id );
+    else
+      return false;
+
+    elemStyle = elem.style;
+    
+    if ( elemStyle.display != "block" ) {
+      elemStyle.display = "block"
+    } else {
+      elemStyle.display = "none"
+    }
+
+    return true;
+  }
+  
+  // Make codeblocks hidden by default
+  document.writeln( "<style type=\"text/css\">div.method-source-code { display: none }</style>" )
+  
+  // ]]>
+  </script>
+
+</head>
+<body>
+
+
+
+    <div id="classHeader">
+        <table class="header-table">
+        <tr class="top-aligned-row">
+          <td><strong>Class</strong></td>
+          <td class="class-name-in-header">Contract</td>
+        </tr>
+        <tr class="top-aligned-row">
+            <td><strong>In:</strong></td>
+            <td>
+                <a href="../files/lib/contract/exception_rb.html">
+                lib/contract/exception.rb
+                </a>
+        <br />
+                <a href="../files/lib/contract/overrides_rb.html">
+                lib/contract/overrides.rb
+                </a>
+        <br />
+                <a href="../files/lib/contract/assertions_rb.html">
+                lib/contract/assertions.rb
+                </a>
+        <br />
+                <a href="../files/lib/contract/integration_rb.html">
+                lib/contract/integration.rb
+                </a>
+        <br />
+                <a href="../files/lib/contract_rb.html">
+                lib/contract.rb
+                </a>
+        <br />
+            </td>
+        </tr>
+
+        <tr class="top-aligned-row">
+            <td><strong>Parent:</strong></td>
+            <td>
+                Test::Unit::TestCase
+            </td>
+        </tr>
+        </table>
+    </div>
+  <!-- banner header -->
+
+  <div id="bodyContent">
+
+
+
+  <div id="contextContent">
+    <div id="diagram">
+      <map id="map" name="map">
+  <area shape="RECT" coords="32,113,104,161"      href="Contract.html" alt="Contract" title="Contract">
+</map>
+<img src="../dot/f_7.png" usemap="#map" border=0 alt="lib/contract.rb">
+    </div>
+
+    <div id="description">
+      <p>
+Represents a contract between Objects as a collection of test cases.
+Objects are said to fulfill a contract if all test cases suceed. This is
+useful for ensuring that Objects your code is getting behave in a way that
+you expect them to behave so you can fail early or execute different logic
+for Objects with different interfaces.
+</p>
+<p>
+The tests of the test suite will be run on a copy of the tested Object so
+you can safely test its behavior without having to fear data loss. By
+default Contracts obtain deep copies of Objects by serializing and
+unserializing them with Ruby&#8217;s <tt>Marshal</tt> functionality. This
+will work in most cases but can fail for Objects containing unserializable
+parts like Procs, Files or Sockets. In those cases it is currently of your
+responsibility to provide a fitting implementation by overwriting the <a
+href="Contract.html#M000007">Contract.deep_copy</a> method. In the future
+the contract library might provide different implementations of it via
+Ruby&#8217;s mixin mechanism.
+</p>
+
+    </div>
+
+
+   </div>
+
+    <div id="method-list">
+      <h3 class="section-bar">Methods</h3>
+
+      <div class="name-list">
+      <a href="#M000002">adapt</a>&nbsp;&nbsp;
+      <a href="#M000007">deep_copy</a>&nbsp;&nbsp;
+      <a href="#M000004">enforce</a>&nbsp;&nbsp;
+      <a href="#M000003">fulfilled_by?</a>&nbsp;&nbsp;
+      <a href="#M000008">implies</a>&nbsp;&nbsp;
+      <a href="#M000001">provides</a>&nbsp;&nbsp;
+      <a href="#M000005">test</a>&nbsp;&nbsp;
+      <a href="#M000006">test_all</a>&nbsp;&nbsp;
+      </div>
+    </div>
+
+  </div>
+
+
+    <!-- if includes -->
+
+    <div id="section">
+
+    <div id="class-list">
+      <h3 class="section-bar">Classes and Modules</h3>
+
+      Module <a href="Contract/Check.html" class="link">Contract::Check</a><br />
+Module <a href="Contract/ContractException.html" class="link">Contract::ContractException</a><br />
+Class <a href="Contract/ContractError.html" class="link">Contract::ContractError</a><br />
+Class <a href="Contract/ContractMismatch.html" class="link">Contract::ContractMismatch</a><br />
+
+    </div>
+
+    <div id="constants-list">
+      <h3 class="section-bar">Constants</h3>
+
+      <div class="name-list">
+        <table summary="Constants">
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">Version</td>
+          <td>=</td>
+          <td class="context-item-value">current_version</td>
+          <td width="3em">&nbsp;</td>
+          <td class="context-item-desc">
+The Version of the contract library you are using as String of the 1.2.3
+form where the digits stand for release, major and minor version
+respectively.
+
+</td>
+        </tr>
+        </table>
+      </div>
+    </div>
+
+    <div id="aliases-list">
+      <h3 class="section-bar">External Aliases</h3>
+
+      <div class="name-list">
+                        <table summary="aliases">
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">check_signatures</td>
+          <td>-></td>
+          <td class="context-item-value">check_signatures?</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">check_fulfills</td>
+          <td>-></td>
+          <td class="context-item-value">check_fulfills?</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">fulfilled_by?</td>
+          <td>-></td>
+          <td class="context-item-value">===</td>
+        </tr>
+      <tr class="top-aligned-row context-row">
+        <td>&nbsp;</td>
+        <td colspan="2" class="context-item-desc">
+You can use contracts in <tt>case</tt> &#8230; <tt>when</tt> statements or
+in <a href="Module.html#M000015">Module#signature</a> checks. For example:
+
+<pre>
+  case obj
+    when Numeric then obj + 1
+    when ListContract then obj + [1]
+  end
+</pre>
+</td>
+      </tr>
+                        </table>
+      </div>
+    </div>
+
+
+    <div id="attribute-list">
+      <h3 class="section-bar">Attributes</h3>
+
+      <div class="name-list">
+        <table>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">check_fulfills</td>
+          <td class="context-item-value">&nbsp;[RW]&nbsp;</td>
+          <td class="context-item-desc">
+Whether fulfills should be checked. This is enabled by default.
+
+<p>
+Note: If you want to change this you need to do so before doing any <a
+href="Module.html#M000016">Module#fulfills</a> calls or it will not be
+applied. It&#8217;s probably best set right after requiring the contract
+library.
+</p>
+</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">check_signatures</td>
+          <td class="context-item-value">&nbsp;[RW]&nbsp;</td>
+          <td class="context-item-desc">
+Whether signatures should be checked. By default signatures are checked
+only when the application is run in $DEBUG mode. (By specifying the -d
+switch on the invocation of Ruby.)
+
+<p>
+Note: If you want to change this you need to do so before doing any <a
+href="Module.html#M000015">Module#signature</a> calls or it will not be
+applied. It&#8217;s probably best set right after requiring the contract
+library.
+</p>
+</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">implications</td>
+          <td class="context-item-value">&nbsp;[R]&nbsp;</td>
+          <td class="context-item-desc">
+Returns all implications of a given contract that were stated via calling
+<a href="Contract.html#M000008">Contract.implies</a>.
+
+</td>
+        </tr>
+        </table>
+      </div>
+    </div>
+      
+
+
+    <!-- if method_list -->
+    <div id="methods">
+      <h3 class="section-bar">Public Class methods</h3>
+
+      <div id="method-M000002" class="method-detail">
+        <a name="M000002"></a>
+
+        <div class="method-heading">
+          <a href="#M000002" class="method-signature">
+          <span class="method-name">adapt</span><span class="method-args">(object, type)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Tries to adapt the specified object to the specified type. Returns the old
+object if no suitable adaption route was found or if it already is of the
+specified type.
+</p>
+<p>
+This will only use adaptions where the :to part is equal to the specified
+type. No multi-step conversion will be performed.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000002-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000002-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/contract/integration.rb, line 124</span>
+124:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">adapt</span>(<span class="ruby-identifier">object</span>, <span class="ruby-identifier">type</span>)
+125:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">object</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">object</span>
+126: 
+127:     <span class="ruby-ivar">@adaptions</span>[<span class="ruby-identifier">type</span>].<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">adaption</span><span class="ruby-operator">|</span>
+128:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">adaption</span>[<span class="ruby-identifier">:from</span>] <span class="ruby-operator">===</span> <span class="ruby-identifier">object</span> <span class="ruby-keyword kw">and</span>
+129:         (<span class="ruby-identifier">adaption</span>[<span class="ruby-identifier">:if</span>].<span class="ruby-identifier">nil?</span> <span class="ruby-keyword kw">or</span> <span class="ruby-identifier">adaption</span>[<span class="ruby-identifier">:if</span>] <span class="ruby-operator">===</span> <span class="ruby-identifier">object</span>)
+130:       <span class="ruby-keyword kw">then</span>
+131:         <span class="ruby-identifier">result</span> = <span class="ruby-identifier">adaption</span>[<span class="ruby-identifier">:via</span>].<span class="ruby-identifier">call</span>(<span class="ruby-identifier">object</span>)
+132:         <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">result</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">result</span>
+133:       <span class="ruby-keyword kw">end</span>
+134:     <span class="ruby-keyword kw">end</span>
+135: 
+136:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">object</span>
+137:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000007" class="method-detail">
+        <a name="M000007"></a>
+
+        <div class="method-heading">
+          <a href="#M000007" class="method-signature">
+          <span class="method-name">deep_copy</span><span class="method-args">(object)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+This method is used internally for getting a copy of Objects that the
+contract is checked against. By default it uses Ruby&#8217;s
+<tt>Marshal</tt> functionality for obtaining a copy, but this can fail if
+the Object contains unserializable parts like Procs, Files or Sockets. It
+is currently your responsibility to provide a fitting implementation of
+this by overwriting the method in case the default implementation does not
+work for you. In the future the contract library might offer different
+implementations for this via Ruby&#8217;s mixin mechanism.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000007-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000007-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/contract.rb, line 104</span>
+104:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">deep_copy</span>(<span class="ruby-identifier">object</span>)
+105:     <span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">load</span>(<span class="ruby-constant">Marshal</span>.<span class="ruby-identifier">dump</span>(<span class="ruby-identifier">object</span>))
+106:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000004" class="method-detail">
+        <a name="M000004"></a>
+
+        <div class="method-heading">
+          <a href="#M000004" class="method-signature">
+          <span class="method-name">enforce</span><span class="method-args">(object)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Enforces that object implements this contract. If it does not an Exception
+will be raised. This is useful for example useful when you need to ensure
+that the arguments given to a method fulfill a given contract.
+</p>
+<p>
+Note that using Module#enforce is a higher-level way of checking arguments
+and return values for the conformance of a given type. You might however
+still want to use <a href="Contract.html#M000004">Contract.enforce</a>
+directly when you need more flexibility.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000004-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000004-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/contract.rb, line 65</span>
+65:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">enforce</span>(<span class="ruby-identifier">object</span>)
+66:     <span class="ruby-identifier">reason</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">test</span>(<span class="ruby-identifier">object</span>)
+67:     <span class="ruby-identifier">raise</span> <span class="ruby-identifier">reason</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">reason</span>
+68:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000003" class="method-detail">
+        <a name="M000003"></a>
+
+        <div class="method-heading">
+          <a href="#M000003" class="method-signature">
+          <span class="method-name">fulfilled_by?</span><span class="method-args">(object)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Returns true if the given object fulfills this contract. This is useful for
+implementing dispatching mechanisms where you want to hit different code
+branches based on whether an Object has one or another interface.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000003-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000003-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/contract.rb, line 42</span>
+42:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">fulfilled_by?</span>(<span class="ruby-identifier">object</span>)
+43:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">test</span>(<span class="ruby-identifier">object</span>).<span class="ruby-identifier">nil?</span>
+44:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000008" class="method-detail">
+        <a name="M000008"></a>
+
+        <div class="method-heading">
+          <a href="#M000008" class="method-signature">
+          <span class="method-name">implies</span><span class="method-args">(*mixins)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Fulfilling this <a href="Contract.html">Contract</a> (via <a
+href="Module.html#M000016">Module#fulfills</a>) implies that the Object is
+automatically compatible with the specified mixins which will then be
+included automatically. For example the Enumerable relationship could be
+expressed like this:
+</p>
+<pre>
+  class EnumerableContract &lt; Contract
+    provides :each
+    implies Enumerable
+  end
+</pre>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000008-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000008-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/contract.rb, line 117</span>
+117:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">implies</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">mixins</span>)
+118:     <span class="ruby-identifier">mixins</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">mixin</span><span class="ruby-operator">|</span>
+119:       <span class="ruby-keyword kw">if</span> <span class="ruby-keyword kw">not</span> <span class="ruby-identifier">mixin</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Module</span>) <span class="ruby-keyword kw">then</span>
+120:         <span class="ruby-identifier">raise</span>(<span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;wrong argument type #{mixin.class} for &quot;</span> <span class="ruby-operator">+</span>
+121:           <span class="ruby-node">&quot;#{mixin.inspect} (expected Module)&quot;</span>)
+122:       <span class="ruby-keyword kw">end</span>
+123:     <span class="ruby-keyword kw">end</span>
+124: 
+125:     <span class="ruby-ivar">@implications</span> <span class="ruby-operator">||=</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>
+126:     <span class="ruby-ivar">@implications</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">mixins</span>
+127:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000001" class="method-detail">
+        <a name="M000001"></a>
+
+        <div class="method-heading">
+          <a href="#M000001" class="method-signature">
+          <span class="method-name">provides</span><span class="method-args">(*symbols) {|| ...}</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Tests that the tested Object provides the specified methods with the
+specified behavior.
+</p>
+<p>
+If a block is supplied it will be evaluated in the context of the contract
+so <tt>@object</tt> will refer to the object being tested.
+</p>
+<p>
+This can be used like this:
+</p>
+<pre>
+  class ListContract &lt; Contract
+    provides :size do
+      assert(@object.size &gt;= 0, &quot;#size should never be negative.&quot;)
+    end
+
+    provides :include?
+
+    provides :each do
+      count = 0
+      @object.each do |item|
+        assert(@object.include?(item),
+          &quot;#each should only yield items that the list includes.&quot;)
+        count += 1
+      end
+      assert_equal(@object.size, count,
+        &quot;#each should yield #size items.&quot;)
+    end
+  end
+</pre>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000001-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000001-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/contract/assertions.rb, line 34</span>
+34:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">provides</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">symbols</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>) <span class="ruby-comment cmt"># :yields:</span>
+35:     <span class="ruby-identifier">symbols</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">symbol</span><span class="ruby-operator">|</span>
+36:       <span class="ruby-identifier">define_method</span>(<span class="ruby-node">&quot;test_provides_#{symbol}&quot;</span>.<span class="ruby-identifier">intern</span>) <span class="ruby-keyword kw">do</span>
+37:         <span class="ruby-identifier">assert_respond_to</span>(<span class="ruby-ivar">@object</span>, <span class="ruby-identifier">symbol</span>)
+38:         <span class="ruby-identifier">instance_eval</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>) <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block</span>
+39:       <span class="ruby-keyword kw">end</span>
+40:     <span class="ruby-keyword kw">end</span>
+41:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000005" class="method-detail">
+        <a name="M000005"></a>
+
+        <div class="method-heading">
+          <a href="#M000005" class="method-signature">
+          <span class="method-name">test</span><span class="method-args">(object, return_all = false)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Tests whether the given Object fulfils this contract.
+</p>
+<p>
+Note: This will return the first reason for the Object not fulfilling the
+contract or <tt>nil</tt> in case it fulfills it.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000005-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000005-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/contract.rb, line 74</span>
+74:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">test</span>(<span class="ruby-identifier">object</span>, <span class="ruby-identifier">return_all</span> = <span class="ruby-keyword kw">false</span>)
+75:     <span class="ruby-identifier">reasons</span> = []
+76: 
+77:     <span class="ruby-identifier">result</span> = <span class="ruby-constant">Test</span><span class="ruby-operator">::</span><span class="ruby-constant">Unit</span><span class="ruby-operator">::</span><span class="ruby-constant">TestResult</span>.<span class="ruby-identifier">new</span>
+78:     <span class="ruby-identifier">result</span>.<span class="ruby-identifier">add_listener</span>(<span class="ruby-constant">Test</span><span class="ruby-operator">::</span><span class="ruby-constant">Unit</span><span class="ruby-operator">::</span><span class="ruby-constant">TestResult</span><span class="ruby-operator">::</span><span class="ruby-constant">FAULT</span>) <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">fault</span><span class="ruby-operator">|</span>
+79:       <span class="ruby-identifier">reason</span> = <span class="ruby-constant">Contract</span>.<span class="ruby-identifier">fault_to_exception</span>(<span class="ruby-identifier">fault</span>, <span class="ruby-identifier">object</span>, <span class="ruby-keyword kw">self</span>)
+80:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">reason</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">return_all</span>
+81:       <span class="ruby-identifier">reasons</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">reason</span>
+82:     <span class="ruby-keyword kw">end</span>
+83: 
+84:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">suite</span>.<span class="ruby-identifier">run</span>(<span class="ruby-identifier">result</span>, <span class="ruby-identifier">deep_copy</span>(<span class="ruby-identifier">object</span>))
+85: 
+86:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">reasons</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">passed?</span>
+87:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000006" class="method-detail">
+        <a name="M000006"></a>
+
+        <div class="method-heading">
+          <a href="#M000006" class="method-signature">
+          <span class="method-name">test_all</span><span class="method-args">(object)</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <p>
+Same as <a href="Contract.html#M000005">Contract.test</a>, but will return
+all reasons for the Object not fulfilling the contract in an Array or nil
+in case of fulfillment. (as an Array of Exceptions) or <tt>nil</tt> in the
+case it does fulfill it.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000006-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000006-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/contract.rb, line 92</span>
+92:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">test_all</span>(<span class="ruby-identifier">object</span>)
+93:     <span class="ruby-identifier">test</span>(<span class="ruby-identifier">object</span>, <span class="ruby-keyword kw">true</span>)
+94:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+
+    </div>
+
+
+  </div>
+
+
+<div id="validator-badges">
+  <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
+</div>
+
+</body>
+</html>