duckpond 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed77b024ca7fdcad68dff17391aeb0de607e7da9
-  data.tar.gz: e00d0cc54ecc3dea1b83eb7a75bcea3382b784bc
+  metadata.gz: 49a48ab6dd27f5acfb06ff204a3679299aabab0d
+  data.tar.gz: adeae633ba2f56c289cff8b0f3ae902e2f63e2d2
 SHA512:
-  metadata.gz: f79bd621cd72f4e2ca362633e25c4433ea9ba3f1242dd69ae2410061035768bef3f2c8b38cf91fe924394f01ac6c4801e71fba1fb121bc6eff1504ddc972d75b
-  data.tar.gz: d214ef206b663b6d7b84b7cf05239d4f4105ff68d460934200e53f36e709952c70ba3cb4a1c2bbe2d8ab3f9de4e011665bfb2ed82bf407a27c20a29a531e46d6
+  metadata.gz: 21d67910df3b44f7aac195706ab565b3e20b23549d73251f8ba7dba36f31d033c2e293333d3c17b33b83555b23a345b6b73e97be7ba3cf49b9c19338d64b6c3a
+  data.tar.gz: 2cbf35d78a704430210fff5e7fe78aea5da7c04aba15d484e420501a8b5e4ec26948f6682e019687fed20fd32ed04964d9ea5d7615dcfd5b091b8f5a32184c36

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 
 rvm:
-  - "1.9.2"
-  - "1.9.3"
-  - "2.0.0"
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - jruby-19mode 
 
 script: bundle exec rspec spec

data/Gemfile

@@ -4,6 +4,6 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'rake'
   gem 'rspec'
+  gem 'coveralls', require: false
 end

data/Gemfile.lock

@@ -6,8 +6,19 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    coveralls (0.7.0)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
     diff-lcs (1.2.5)
-    rake (10.3.2)
+    docile (1.1.5)
+    mime-types (2.3)
+    multi_json (1.10.1)
+    rake (0.9.6)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
     rspec (3.0.0)
       rspec-core (~> 3.0.0)
       rspec-expectations (~> 3.0.0)
@@ -20,12 +31,22 @@ GEM
     rspec-mocks (3.0.1)
       rspec-support (~> 3.0.0)
     rspec-support (3.0.0)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.3.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.3)
+  coveralls
   duckpond!
-  rake
+  rake (~> 0)
   rspec

data/README.md

@@ -1,5 +1,6 @@
 [![Gem Version](https://badge.fury.io/rb/duckpond.svg)](http://badge.fury.io/rb/duckpond)
 [![Build Status](https://travis-ci.org/mikeyhogarth/duckpond.svg?branch=master)](https://travis-ci.org/mikeyhogarth/duckpond)
+[![Coverage Status](https://img.shields.io/coveralls/mikeyhogarth/duckpond.svg)](https://coveralls.io/r/mikeyhogarth/duckpond)
 
 # Duckpond
 
@@ -12,13 +13,9 @@ Duck Typing can make code confusing and unreadable, particularly
 when multiple developers are working on the same project or when 
 projects are inherited by new developers. 
 
-The spec folder has two files that go through the purpose of this gem
-in spec form. This would be a good place to start, although there is a crash 
-course below.
+* [the_problem](docs/the_problem.txt) - This outlines the problems with duck typing.
 
-* [the_problem_spec](spec/the_problem_spec.rb) - This outlines the problems with duck typing.
-
-* [the_solution_spec](spec/the_solution_spec.rb) - This outlines how duckpond gets around these problems.
+* [the_solution](docs/the_solution.txt) - This outlines how duckpond gets around these problems.
 
 
 ## Installation
@@ -38,35 +35,34 @@ Or install it yourself as:
 
 ## Usage
 
-Usage is demonstrated in '[the_solution_spec](spec/the_solution_spec.rb)', but in a nutshell you can create 
-"contract" classes by inheriting from DuckPond::Contract. This file should be commented
-extensively as it describes the contract the duck represents. The "has_method" method
-can be used to specify methods as symbols. 
+Usage is demonstrated in '[the_solution](docs/the_solution.txt)', but in a nutshell you 
+create "contract" classes by inheriting from DuckPond::Contract. These classes should 
+be commented extensively. 
+
+The "has_method" method is used to specify which methods the contract expects to see. The
+following contract describes classes which respond to #length and #to_s
 
     class MyContract < DuckPond::Contract
-      has_method :length  
+      has_method :length
       has_method :to_s
     end
 
-Once you've declared a contract, you can use "binoculars" to see if objects quack like
-that duck:
-
-    obj = "Hello World"
-    sighting = DuckPond::Binoculars.identify(obj)
-    sighting.quacks_like? MyContract
-    => true
-
-There are other syntaxes:
+Once you've declared a contract, you can compare objects to it to see if the contract is 
+fulfilled by the object:
 
-    #This syntax gets all the comparison done in one line
-    DuckPond::Binoculars.confirm(obj, MyContract)
-    => true
+  MyContract.fulfilled_by? "Hello"
+  => true
+  MyContract.fulfilled_by? 12
+  => false
 
-    #This syntax does the same thing, but raises an excaption instead of returning false 
-    DuckPond::Binoculars.confirm!(obj, MyContract)
+There is also a "bang" version of the fulfilled_by method, that raises an error instead 
+of returning false.
 
+  MyContract.fulfilled_by! 12
+  => RAISES ERROR!!
 
-Ducks can be combined into composite "super contracts" - contracts which are made up of various other contracts. This ties in with the reccomendation of preferring composition over inheritance:
+Contracts can be combined into composite "super contracts" - contracts which are made up of 
+various other contracts. This ties in with the reccomendation of preferring composition over inheritance:
 
     class MyCompositeConrtact < DuckPond::Contract
       include_methods_from MyContract
@@ -74,7 +70,7 @@ Ducks can be combined into composite "super contracts" - contracts which are mad
     end
 
 
-A *serious duck* might look like this:
+In the real world, a contract might look like this:
 
     class IEmailable < DuckPond::Contract
       #send: should send the results of :message via email to :to
@@ -91,12 +87,22 @@ And then be implemented in a method like this:
 
     class Emailer
       def send(email)
-        DuckPond::Binoculars.confirm!(email, IEmailable)
+        IEmailable.fulfilled_by! email
         email.send
       end
     end
 
 
+## Compatibility
+
+CI tests exist for the following rubies, so they definately work and there's no reason all 1.9.x rubies wouldnt' work either:
+
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - jruby-19mode 
+
+
 ## Contributing
 
 1. Fork it

data/docs/the_problem.txt

@@ -0,0 +1,98 @@
+# 
+# Take this class for instance...
+#
+# It has a single method which;
+#
+# * Calls an instance method on its parameter.
+# * Sends its parameter off to some other object.
+# * Creates an instance variable with the result.
+#
+
+class Foo
+  def self.bar(obj)
+    obj.foo!
+    fooinator = Test::Fooinator.new
+    @fooified_obj = fooinator.foo(obj)
+  end
+end
+
+# 
+# From an architectural perspective, there is really nothing
+# wrong with this class/method. Even from a design perspective
+# the only thing that you can really criticize is that the 
+# method is a little vague in terms of what it does, and that's just 
+# because we don't know what "fooing" is.
+# 
+# But there are a few other problems.
+#
+# You will often hear rubyists talking about the wonder of
+# "duck typing". Developers can pass anything they want to the "bar" 
+# method above and it'll still work so long as the parameter responds 
+# to certain methods etc.
+#
+# You will almost as often hear programmers freaking out about how 
+# chaotic and crazy this approach is! Arguments about such matters usually
+# eventually gravitate towards the problem being that ruby is not 
+# strongly typed. The knowledge about what "ducks" can be sent to the
+# :bar method is not stored anywhere: it's implicit in obj's usage. Great if
+# you were the developer of the method and you understand it completely, 
+# but what if it's someone else?
+#
+# In the above example, in order to see which type of object they can 
+# pass to the "bar" method, a developer would at the very least need
+# to:
+#
+# * Grep for "foo!" to see what the hell it does
+# * See what the hell a "Fooinator" does
+# * Look at the fooinator#foo method to see what the hell THAT does
+# * Look for all instances of @fooified_obj and see what the hell THOSE DO
+#
+# And even if they do all that, there's a chance they might miss something.
+# If they do miss something, this will likely manifest itself in an error
+# further up the stack, such as method missing exceptions etc., in places
+# OTHER than where the actual mistake was made. 
+#
+# Nightmare!
+#
+# Wouldn't it be nice if the "bar" method did a check or two, or even  raised 
+# an exception when it was passed an object that wasn't compatible with its 
+# functionality? You could do this yourself manually:
+#
+
+class Foo
+  def self.bar(obj)
+    raise TypeError unless obj.respond_to?(:foo!) && obj.respond_to?(:chunky_bacon)
+
+    obj.foo!
+    fooinator = Test::Fooinator.new
+    @fooified_obj = fooinator.foo(obj)
+  end
+end
+
+# 
+# But now you've got more problems!
+#
+# * The method is now becoming longer and messier.
+# * The "knowledge" about what :bar can receive is stored within the
+# :bar method itself, but that knowledge may be needed elsewhere. 
+#
+# Wouldn't it be nice if there was a neat way to store knowledge about all 
+# our ducks in one place, and to be able to reference them whenever we need to.
+#
+# Although duck typing is seen as a ruby technique, it is actually 
+# used in other languages too but the contract in strongly typed languages
+# is made explicit through the use of interfaces. In c#, for example:
+#
+# public string foo(IMyInterface interface)
+# {
+#   //your implementation here. A confused developer
+#   //could go off and look in IMyInterface to see what
+#   //this "duck" is meant to do. 
+# }
+#
+# As ruby is not strongly typed, you don't have this reference and the code
+# becomes impossible for other developers to use!
+#
+# This is the problem duckpond hopes to solve.
+#
+

data/docs/the_solution.txt

@@ -0,0 +1,56 @@
+#
+# First, declare a contract.
+#
+
+class ObjContract < DuckPond::Contract
+  has_method :to_s
+  has_method :length
+end
+
+#
+# Then use it to check stuff!
+#
+
+ObjContract.fulfilled_by? "Hello"
+=> true (or false if not fulfilled)
+
+#
+# The "bang" version will raise an error if the object isn't the duck.
+#
+
+ObjContract.fulfilled_by! "Hello"
+=> true (or error if not fulfilled)
+
+#
+# So, going back to that example from the problem doc...
+#
+
+class Foo
+  def self.bar(obj)
+    ObjContract.fulfilled_by! obj
+
+    obj.foo!
+    fooinator = Test::Fooinator.new
+    @fooified_obj = fooinator.foo(obj)
+  end
+end
+
+
+#
+# Viola!
+#
+# Final Tips: 
+#
+# * Contracts should be commented liberally. They form the descripiton
+# of a contract just as interfaces would in strongly typed languages.
+# Developers will be prompted to consult the duck when they see a pair
+# of binoculars in your code, so make sure they find what they're looking
+# for.
+#
+# * Rather than writing the duckpond functionality directly within the methods
+# themselves, you could easily put them in hooks or method aliases. If you do this
+# though, remember that the point of this app is to make things *more* visible, not
+# less, so don't go tucking these duck checks too far away from where they are needed
+# or leave an obvious trail if you do!
+#
+

data/duckpond.gemspec

@@ -5,7 +5,7 @@ require 'duckpond/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "duckpond"
-  spec.version       = Duckpond::VERSION
+  spec.version       = DuckPond::VERSION
   spec.authors       = ["Mikey Hogarth"]
   spec.email         = ["mikehogarth20@hotmail.com"]
   spec.description   = %q{Explicit duck-typing for ruby}

data/lib/duckpond/contract.rb

@@ -7,6 +7,8 @@
 #
 module DuckPond
   class Contract
+    class ContractInfringementError < TypeError;end
+
     class << self
 
       def clauses
@@ -22,7 +24,6 @@ module DuckPond
         clauses << method_name
       end
 
-
       #
       # include_clauses_from
       #
@@ -34,16 +35,21 @@ module DuckPond
         end
       end
 
-      
-      #
-      # quacks_like?
       #
-      # The main quack checking method for a duck
+      # fulfilled_by?
       #
-      def quacks_like?(method)
-        clauses.include?(method)
+      def fulfilled_by?(obj)
+        inspection = DuckPond::Inspection.new(obj)
+        return false unless inspection.fulfilled_by? self
+        true
       end
 
+      #
+      # fulfilled_by!
+      #
+      def fulfilled_by!(obj)
+        raise ContractInfringementError unless fulfilled_by?(obj)
+      end
     end
   end
 end

data/lib/duckpond/inspection.rb

@@ -0,0 +1,36 @@
+#
+# DuckPond::Inspection
+#
+# The duckpond analysis class is essentially just a wrapper for the inspected
+# object, used here to avoid un-nessecary monkey patching.
+#
+module DuckPond
+  class Inspection
+
+    # the wrapped object
+    attr_reader :subject
+
+    #
+    # initialize
+    #
+    # Construct with any ruby object. 
+    #
+    def initialize(subject)
+      @subject = subject
+    end
+
+    # 
+    # fulfilled_by? 
+    #
+    # receives exactly one contract, and returns true/false if
+    # the inspected object responds to the same methods indicated
+    # by the contract's clauses.
+    #
+    def fulfilled_by?(contract)
+      contract.clauses.each do |clause|
+        return false unless @subject.respond_to? clause
+      end
+      true
+    end
+  end
+end

data/lib/duckpond/version.rb

@@ -1,3 +1,3 @@
-module Duckpond
-  VERSION = "1.0.2"
+module DuckPond
+  VERSION = "1.1.0"
 end

data/lib/duckpond.rb

@@ -1,7 +1,6 @@
 require 'duckpond/version'
 require 'duckpond/contract'
-require 'duckpond/binoculars'
-require 'duckpond/sighting'
+require 'duckpond/inspection'
 
-module Duckpond
+module DuckPond
 end

data/spec/contract_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module DuckPond
+  describe Contract do
+    describe 'attributes' do
+      context '.clauses' do
+        it 'responds to and memoizes the result' do
+          expect(Contract).to respond_to :clauses
+          expect(Contract.clauses).to be_an Array
+          expect(Contract.clauses).to be_empty
+        end
+      end
+    end
+
+    class LengthContract < DuckPond::Contract
+      has_method :length
+    end
+ 
+    describe 'fulfilled_by?' do
+      context 'when the object is fulfilled by the contract' do
+        it 'returns true' do
+          expect(LengthContract.fulfilled_by?("Hello")).to eq true
+        end
+      end
+      context 'when the object is not fulfilled by the contract' do
+        it 'returns false' do
+          expect(LengthContract.fulfilled_by?(2)).to eq false
+        end
+      end
+    end
+
+    describe 'fulfilled_by!' do
+      context 'when the object is fulfilled by the contract' do
+        it 'returns true' do
+          expect{LengthContract.fulfilled_by!("Hello")}.to_not raise_error
+        end
+      end
+      context 'when the object is not fulfilled by the contract' do
+        it 'returns false' do
+          expect{LengthContract.fulfilled_by!(2)}.to raise_error
+        end
+      end
+    end
+  end
+
+  class MyContract < Contract
+    has_method :foo
+    has_method :bar
+  end
+
+  describe MyContract do
+    context '.clauses' do
+      it 'quacks like foo and bar' do
+        clauses = MyContract.clauses
+        expect(clauses.length).to eq 2
+        expect(clauses).to include :foo
+        expect(clauses).to include :bar
+      end
+    end
+  end
+
+  class MySimilarContract < Contract
+    include_clauses_from MyContract
+    has_method :chunky_bacon
+  end
+
+  describe MySimilarContract do
+    it 'retains its parents quackings' do
+      clauses = MySimilarContract.clauses
+      expect(clauses.length).to eq 3 
+      expect(clauses).to include :foo
+      expect(clauses).to include :bar
+      expect(clauses).to include :chunky_bacon
+    end
+  end
+end

data/spec/{sighting_spec.rb → inspection_spec.rb}

@@ -1,17 +1,16 @@
 require 'ostruct'
 
 module DuckPond
-  describe Sighting do
-
+  describe Inspection do
     describe '#initialize' do
       it 'is constructed using any ruby object' do
         obj = Object.new
-        sighting = Sighting.new(obj)
-        expect(sighting.sighted_object).to be obj
+        analysis = Inspection.new(obj)
+        expect(analysis.subject).to be obj
       end
     end
 
-    describe '#quacks_like?' do
+    describe '#fulfilled_by?' do
 
       class MyChunkyBaconContract < Contract
         has_method :chunky_bacon
@@ -20,16 +19,16 @@ module DuckPond
       context 'when the sighted object quacks like the duck' do
         it 'returns true' do
           obj = OpenStruct.new(:chunky_bacon => :mmm)
-          sighting = Sighting.new(obj)
-          expect(sighting.quacks_like? MyChunkyBaconContract).to be true
+          inspection = Inspection.new(obj)
+          expect(inspection.fulfilled_by? MyChunkyBaconContract).to be true
         end
       end
 
       context 'when the sighted object does not quack like the duck' do
         it 'returns false' do
           obj = OpenStruct.new(:vegan_fallafal => :yuck)
-          sighting = Sighting.new(obj)
-          expect(sighting.quacks_like? MyChunkyBaconContract).to be false
+          inspection = Inspection.new(obj)
+          expect(inspection.fulfilled_by? MyChunkyBaconContract).to be false
         end
       end
 

data/spec/spec_helper.rb

@@ -1,2 +1,5 @@
 require 'duckpond'
 require 'classes/fooinator'
+require 'coveralls'
+
+Coveralls.wear!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckpond
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Mikey Hogarth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,19 +53,18 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/.the_solution.txt.swp
+- docs/the_problem.txt
+- docs/the_solution.txt
 - duckpond.gemspec
 - lib/duckpond.rb
-- lib/duckpond/binoculars.rb
 - lib/duckpond/contract.rb
-- lib/duckpond/sighting.rb
+- lib/duckpond/inspection.rb
 - lib/duckpond/version.rb
-- spec/binoculars_spec.rb
 - spec/classes/fooinator.rb
-- spec/duck_spec.rb
-- spec/sighting_spec.rb
+- spec/contract_spec.rb
+- spec/inspection_spec.rb
 - spec/spec_helper.rb
-- spec/the_problem_spec.rb
-- spec/the_solution_spec.rb
 homepage: https://github.com/mikeyhogarth/duckpond
 licenses:
 - MIT
@@ -91,10 +90,7 @@ signing_key:
 specification_version: 4
 summary: Explicit duck-typing for ruby
 test_files:
-- spec/binoculars_spec.rb
 - spec/classes/fooinator.rb
-- spec/duck_spec.rb
-- spec/sighting_spec.rb
+- spec/contract_spec.rb
+- spec/inspection_spec.rb
 - spec/spec_helper.rb
-- spec/the_problem_spec.rb
-- spec/the_solution_spec.rb

data/lib/duckpond/binoculars.rb

@@ -1,57 +0,0 @@
-#
-# DuckPond::Binoculars
-#
-# Binoculars are the users interface to the ducks themselves and 
-# are responsible for building "sightings" out of objects. There
-# are also a couple of convinience methods on here to perform 
-# common duck-spotting tasks.
-#
-module DuckPond
-  class Binoculars
-    class ContractInfringementError < TypeError;end
-
-    # The sighted object
-    attr_reader :sighting
-
-    #
-    # identify (class and instance level version)
-    #
-    # receives any ruby object, returns a "sighting" of that object
-    #
-    def identify(obj)
-      @sighting = DuckPond::Sighting.new(obj)
-    end
-
-    def self.identify(obj)
-      DuckPond::Sighting.new(obj)
-    end
-
-    #
-    # confirm
-    #
-    # receives any ruby object and a duck class
-    # returns true if the object quacks like the duck, 
-    # otherwise false.
-    #
-    def self.confirm(obj, duck)
-      binoculars = DuckPond::Binoculars.new
-      sighting = binoculars.identify(obj)
-      return false unless sighting.quacks_like?(duck)
-      true
-    end
-
-    #
-    # confirm!
-    #
-    # does exactly the same as the standard confirm
-    # method, but raises an exception if the object
-    # does not quack like the duck.
-    #
-    def self.confirm!(obj, duck)
-      raise ContractInfringementError unless confirm(obj, duck)
-    end
-
-  end
-end
-
-

data/lib/duckpond/sighting.rb

@@ -1,37 +0,0 @@
-#
-# DuckPond::Sighting
-#
-# The duckpond sighting class is essentially just a wrapper for the sighted
-# object, used here to avoid un-nessecary monkey patching.
-#
-module DuckPond
-  class Sighting
-
-    # the wrapped object
-    attr_reader :sighted_object
-
-    #
-    # initialize
-    #
-    # Construct with any ruby object. 
-    #
-    def initialize(sighted_object)
-      @sighted_object = sighted_object
-    end
-
-    # 
-    # quacks_like? 
-    #
-    # receives exactly one duck, and returns true/false if
-    # the sighted object responds to the same methods indicated
-    # by the duck's quacks.
-    #
-    def quacks_like?(duck)
-      duck.clauses.each do |clause|
-        return false unless @sighted_object.respond_to? clause
-      end
-      true
-    end
-    alias :looks_like? :quacks_like?
-  end
-end

data/spec/binoculars_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module DuckPond
-  describe Binoculars do
-  
-    let(:obj) { Object.new }
-
-    describe '#identify' do
-      it 'returns any ruby object, in "sighting" form' do
-        bins = Binoculars.new
-        sighting = bins.identify(obj)
-        expect(sighting).to be_a Sighting
-        expect(sighting.sighted_object). to be obj
-      end
-    end
-
-    describe ".identify" do
-      it 'returns any ruby object, in "sighting" form' do
-        sighting = Binoculars.identify(obj)
-        expect(sighting).to be_a Sighting
-        expect(sighting.sighted_object). to be obj
-      end
-    end
-
-    describe '.confirm' do
-
-      class StringContract < Contract
-        has_method :to_s
-        has_method :length
-      end
-
-      context 'when given a ruby object and a duck class that it quacks like' do
-        it 'returns true' do
-          expect(DuckPond::Binoculars.confirm("Hello World", StringContract)).to be true
-        end
-      end
-
-      context 'when given a ruby object and a duck class that it doesnt quacks like' do
-        it 'returns false' do
-          expect(DuckPond::Binoculars.confirm(Object.new, StringContract)).to be false
-        end
-      end
-    end
-
-    describe '.confirm!' do
-      it 'behaves like the un-banged version, but raises an error if it doesnt quack right' do
-        expect {DuckPond::Binoculars.confirm!(Object.new, StringContract)}.to raise_error
-      end
-    end
-
-  end
-end

data/spec/duck_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module DuckPond
-
-  describe Contract do
-    describe 'attributes' do
-      context '.clauses' do
-        it 'responds to and memoizes the result' do
-          expect(Contract).to respond_to :clauses
-          expect(Contract.clauses).to be_an Array
-          expect(Contract.clauses).to be_empty
-        end
-      end
-    end
-  end
-
-  class MyContract < Contract
-    has_method :foo
-    has_method :bar
-  end
-
-  describe MyContract do
-    context '.clauses' do
-      it 'quacks like foo and bar' do
-        clauses = MyContract.clauses
-        expect(clauses.length).to eq 2
-        expect(clauses).to include :foo
-        expect(clauses).to include :bar
-      end
-    end
-
-    describe '.quacks_like?' do
-      it 'returns true if the argument is in the quackings' do
-        expect(MyContract.quacks_like? :foo).to be true
-        expect(MyContract.quacks_like? :chunky_bacon).to be false
-      end
-    end
-  end
-
-  class MySimilarContract < Contract
-    include_clauses_from MyContract
-    has_method :chunky_bacon
-  end
-
-  describe MySimilarContract do
-    it 'retains its parents quackings' do
-      expect(MySimilarContract.quacks_like? :chunky_bacon).to be true
-      expect(MySimilarContract.quacks_like? :foo).to be true
-      expect(MySimilarContract.quacks_like? :bar).to be true
-    end
-  end
-
-end

data/spec/the_problem_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-module Duckpond
-  describe 'The Problem' do
-    context 'when a method is called' do
-      it 'is often difficult to see what parameters are allowed' do
-
-        # 
-        # Take this class for instance...
-        #
-        # It has a single method which;
-        #
-        # * Calls an instance method on its parameter.
-        # * Sends its parameter off to some other object.
-        # * Creates an instance variable with the result.
-        #
-
-        class Foo
-          def self.bar(obj)
-            obj.foo!
-            fooinator = Test::Fooinator.new
-            @fooified_obj = fooinator.foo(obj)
-          end
-        end
-
-        # 
-        # From an architectural perspective, there is really nothing
-        # wrong with this class/method. Even from a design perspective
-        # the only thing that you can really criticize is that the 
-        # method is a little vague in terms of what it does, and that's just 
-        # because we don't know what "fooing" is.
-        # 
-        # But there are a few other problems.
-        #
-        # You will often hear rubyists talking about the wonder of
-        # "duck typing". Developers can pass anything they want to the "bar" 
-        # method above and it'll still work so long as the parameter responds 
-        # to certain methods etc.
-        #
-        # You will almost as often hear programmers freaking out about how 
-        # chaotic and crazy this approach is! Arguments about such matters usually
-        # eventually gravitate towards the problem being that ruby is not 
-        # strongly typed. The knowledge about what "ducks" can be sent to the
-        # :bar method is not stored anywhere: it's implicit in obj's usage. Great if
-        # you were the developer of the method and you understand it completely, 
-        # but what if it's someone else?
-        #
-        # In the above example, in order to see which type of object they can 
-        # pass to the "bar" method, a developer would at the very least need
-        # to:
-        #
-        # * Grep for "foo!" to see what the hell it does
-        # * See what the hell a "Fooinator" does
-        # * Look at the fooinator#foo method to see what the hell THAT does
-        # * Look for all instances of @fooified_obj and see what the hell THOSE DO
-        #
-        # And even if they do all that, there's a chance they might miss something.
-        # If they do miss something, this will likely manifest itself in an error
-        # further up the stack, such as method missing exceptions etc., in places
-        # OTHER than where the actual mistake was made. 
-        #
-        # Nightmare!
-        #
-        # Wouldn't it be nice if the "bar" method did a check or two, or even  raised 
-        # an exception when it was passed an object that wasn't compatible with its 
-        # functionality? You could do this yourself manually:
-        #
-        
-        class Foo
-          def self.bar(obj)
-            raise TypeError unless obj.respond_to?(:foo!) && obj.respond_to?(:chunky_bacon)
-
-            obj.foo!
-            fooinator = Test::Fooinator.new
-            @fooified_obj = fooinator.foo(obj)
-          end
-        end
-
-        # 
-        # But now you've got more problems!
-        #
-        # * The method is now becoming longer and messier.
-        # * The "knowledge" about what :bar can receive is stored within the
-        # :bar method itself, but that knowledge may be needed elsewhere. 
-        #
-        # Wouldn't it be nice if there was a neat way to store knowledge about all 
-        # our ducks in one place, and to be able to reference them whenever we need to.
-        #
-        # Although duck typing is seen as a ruby technique, it is actually 
-        # used in other languages too but the contract in strongly typed languages
-        # is made explicit through the use of interfaces. In c#, for example:
-        #
-        # public string foo(IMyInterface interface)
-        # {
-        #   //your implementation here. A confused developer
-        #   //could go off and look in IMyInterface to see what
-        #   //this "duck" is meant to do. 
-        # }
-        #
-        # As ruby is not strongly typed, you don't have this reference and the code
-        # becomes impossible for other developers to use!
-        #
-        # This is the problem duckpond hopes to solve.
-        #
-
-        class Reader
-          def intrigued?
-            true
-          end
-        end
-
-        the_reader = Reader.new
-        expect(the_reader).to be_intrigued
-
-      end
-    end
-  end
-end
-
-

data/spec/the_solution_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-module DuckPond
-  describe "The Solution" do
-    context 'when a method is called' do
-      it 'pays to use duckpond' do
-
-        #
-        # First, declare a duck.
-        #
-
-        class ObjContract < DuckPond::Contract
-          has_method :to_s
-          has_method :length
-        end
-
-        #
-        # Grab a pair of binoculars...
-        #
-        
-        binoculars = DuckPond::Binoculars.new
-
-        # 
-        # Now, lets say you have an object...
-        #
-
-        obj = "Hello World"
-
-        #
-        # You can "spot" it with your binoculars...
-        #
-
-        sighting = binoculars.identify(obj)
-
-        #
-        # And now you can compare your sightings with your ducks!
-        #
-
-        result = sighting.quacks_like?(ObjContract)
-        expect(result).to be true
-
-        #
-        # You could check all of this within a method:
-        #
-
-        binoculars = DuckPond::Binoculars.new
-        sighting = binoculars.identify(obj)
-        raise TypeError unless sighting.quacks_like?(ObjContract)
-       
-        #
-        # But because this trio of lines are so common, a
-        # convinience method exists to perform all three at
-        # once:
-        #
-
-        result = DuckPond::Binoculars.confirm(obj, ObjContract)
-        expect(result).to be true
-
-        #
-        # The "bang" version will raise an error if the object isn't the duck.
-        #
-        
-        expect { DuckPond::Binoculars.confirm!(Object.new, ObjContract) }.to raise_error TypeError
-
-
-        #
-        # So, going back to that example from the problem_spec
-        #
-        
-        class Foo
-          def self.bar(obj)
-            DuckPond::Binoculars.confirm!(obj,ObjConrtact) 
-
-            obj.foo!
-            fooinator = Test::Fooinator.new
-            @fooified_obj = fooinator.foo(obj)
-          end
-        end
-
-
-        #
-        # Viola!
-        #
-        # Final Tips: 
-        #
-        # * Contracts should be commented liberally. They form the descripiton
-        # of a contract just as interfaces would in strongly typed languages.
-        # Developers will be prompted to consult the duck when they see a pair
-        # of binoculars in your code, so make sure they find what they're looking
-        # for.
-        #
-        # * Rather than writing the duckpond functionality directly within the methods
-        # themselves, you could easily put them in hooks or method aliases. If you do this
-        # though, remember that the point of this app is to make things *more* visible, not
-        # less, so don't go tucking these duck checks too far away from where they are needed
-        # or leave an obvious trail if you do!
-        #
-
-      end
-    end
-  end
-end