fact_checker 0.0.1 → 0.0.2

data/.rvmrc

@@ -1 +1 @@
-rvm use 1.9.2@fact_checker 2>/dev/null
+rvm use 1.9.3 2>/dev/null

data/README.md

@@ -0,0 +1,31 @@
+# Fact Checker
+
+  Simple ruby gem to check hierarchically dependent "facts" about objects.
+
+## Installation
+
+    gem install fact_checker
+
+## Synopsys
+
+``` ruby
+class Person
+  include FactChecker
+
+  def_fact :good_job,    if: ->(p) { p.job.good? }
+  def_fact :good_family, if: ->(p) { p.family.good? }
+  def_fact :is_healthy,  if: ->(p) { p.health.good? }
+  def_fact :is_happy => [:is_healthy, :good_family, :good_job],  if: ->(p) { ! p.too_clever? }
+
+  ...
+end
+
+p = Person.new(:job => good_job, :family => good_family, :health => :good, :intellect => :too_clever)
+p.good_job?                 # => true
+p.good_family?              # => true
+p.is_healthy?               # => true
+p.fact_possible?(:is_happy) # => true (dependency satisfied)
+p.is_happy?                 # => false
+
+p.possible_facts - p.accomplished_facts # => [:happy]
+```

data/fact_checker.gemspec

@@ -23,7 +23,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.8.7"
   s.required_rubygems_version = ">= 1.3.5"
 
-  s.add_development_dependency 'rspec', '~> 2.6'
+  s.add_development_dependency 'rspec', '~> 2.8.0'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'bundler'
+  s.add_development_dependency 'simplecov', '~> 0.6.1'
 end

data/lib/fact_checker/base.rb

@@ -20,6 +20,7 @@ module FactChecker
     def accomplished_facts(context)
       facts.select{ |fact| fact_accomplished?(context, fact) }
     end
+
     def possible_facts(context)
       facts.select{ |fact| fact_possible?(context, fact) }
     end

data/lib/fact_checker/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module FactChecker
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/fact_checker/base_spec.rb

@@ -3,178 +3,270 @@
 require 'spec_helper'
 
 describe FactChecker::Base do
-  describe "constructor" do
-    it "should accept facts, dependencies and requirements as arguments" do
-      fc = FactChecker::Base.new([:a, :b], {:a => :b}, {:b => :nil?})
-      fc.facts.should         == [:a, :b]
-      fc.dependencies.should  == {:a => :b}
-      fc.requirements.should  == {:b => :nil?}
-    end
-    it "should use empty hash as a default for requirements" do
-      fc = FactChecker::Base.new([:a, :b], {:a => :b})
-      fc.requirements.should == {}
-    end
-    it "should use empty hash as a default for dependencies" do
-      fc = FactChecker::Base.new([:a, :b])
-      fc.dependencies.should == {}
-    end
-    it "should use empty array as a default for facts" do
-      fc = FactChecker::Base.new()
-      fc.facts.should == []
-    end
-  end
 
-  describe "#facts" do
-    it "should return all facts" do
-      fc = FactChecker::Base.new([:f1, :f2])
-      fc.facts.should == [:f1, :f2]
+  describe "#initialize" do
+    context "called with all arguments (fact_list, dependencies_hash, requirements_hash), its " do
+      subject { FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f1 => :nil?}) }
+      specify("facts == fact_list") { subject.facts.should == [:f1, :f2] }
+      specify("dependencies == dependencies_hash") { subject.dependencies.should == {:f1 => :f2} }
+      specify("requirements == requirements_hash") { subject.requirements.should == {:f1 => :nil?} }
     end
-  end
 
-  describe "#accomplished_facts" do
-    it "should return accomplished facts" do
-      fc = FactChecker::Base.new([:f1, :f2], nil, {:f2 => lambda{ false }})
-      fc.accomplished_facts("context").should == [:f1]
+    context "called" do
+      specify("without fact_list, its facts == [] by default") { subject.facts.should == [] }
+      specify("without dependencies_hash, its dependencies == {} by default") { subject.dependencies.should == {} }
+      specify("without requirements_hash, its requirements == {} by default") { subject.requirements.should == {} }
     end
   end
 
-  describe "#possible_facts" do
-    it "should return possible facts" do
-      fc = FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f2 => lambda{ false }})
-      fc.possible_facts("context").should == [:f2]
+  describe "#requirement_satisfied_for?(context, fact)" do
+    context "when no requirement defined for the fact" do
+      subject { FactChecker::Base.new([:f1]) }
+      it "returns true for any object" do
+        subject.requirement_satisfied_for?(1, :f1).should be_true
+        subject.requirement_satisfied_for?(nil, :f1).should be_true
+      end
     end
-  end
 
-  describe "#requirement_satisfied_for?" do
-    it "should return true if no requerment defined for the step" do
-      fc = FactChecker::Base.new([:f1])
-      fc.requirement_satisfied_for?(1, :f1).should be_true
+    context "when requirement for the fact was defined as symbol" do
+      subject { FactChecker::Base.new([:f1], nil, {:f1 => :nil?}) }
+      it "returns false if fact is unknown" do
+        subject.requirement_satisfied_for?(1, :f2).should be_false
+      end
+      it "returns false if context.symbol() == false" do
+        subject.requirement_satisfied_for?(1, :f1).should be_false
+      end
+      it "returns true if context.symbol() == true" do
+        subject.requirement_satisfied_for?(nil, :f1).should be_true
+      end
     end
-    it "should return false if fact is unknown" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => :nil?})
-      fc.requirement_satisfied_for?(1, :f2).should be_false
-    end
-    it "should return false if requirement is :symbol and context.symbol() == false" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => :nil?})
-      fc.requirement_satisfied_for?(1, :f1).should be_false
-    end
-    it "should return true if requirement is :symbol and context.symbol() == true" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => :nil?})
-      fc.requirement_satisfied_for?(nil, :f1).should be_true
-    end
-    it "should return false if requirement is Proc and proc(context) == false" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => lambda{|t| t.nil?}})
-      fc.requirement_satisfied_for?(1, :f1).should be_false
-    end
-    it "should return true if requirement is Proc and proc(context) == true" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => lambda{|t| t.nil?}})
-      fc.requirement_satisfied_for?(nil, :f1).should be_true
-    end
-    it "should return false if requirement is Proc with arity < 1 and proc() == false" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => lambda{false}})
-      fc.requirement_satisfied_for?(nil, :f1).should be_false
+
+    context "when requirement was defined as Proc with arity == 1" do
+      subject { FactChecker::Base.new([:f1], nil, {:f1 => lambda{|t| t.nil?}}) }
+      it "returns false if proc(context) == false" do
+        subject.requirement_satisfied_for?(1, :f1).should be_false
+      end
+      it "returns true if proc(context) == true" do
+        subject.requirement_satisfied_for?(nil, :f1).should be_true
+      end
     end
-    it "should return true if requirement is Proc with arity < 1 and proc() == true" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => lambda{true}})
-      fc.requirement_satisfied_for?(nil, :f1).should be_true
+
+    context "when requirement was defined as Proc with arity == 0" do
+      it "returns false if proc() == false" do
+        subject = FactChecker::Base.new([:f1], nil, {:f1 => lambda{false}})
+        subject.requirement_satisfied_for?(nil, :f1).should be_false
+      end
+      it "returns true if proc() == true" do
+        subject = FactChecker::Base.new([:f1], nil, {:f1 => lambda{true}})
+        subject.requirement_satisfied_for?(nil, :f1).should be_true
+      end
     end
-    it "should raise RuntimeError if requirement has wrong type" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => "wrong"})
-      lambda{fc.requirement_satisfied_for?(nil, :f1)}.should raise_error(RuntimeError)
+
+    context "when requirement was defined as something else" do
+      subject { FactChecker::Base.new([:f1], nil, {:f1 => "wrong"}) }
+      it "raises RuntimeError" do
+        lambda{ subject.requirement_satisfied_for?(nil, :f1) }.should raise_error(RuntimeError)
+      end
     end
   end
 
   describe "#fact_accomplished?" do
-    it "should return false if fact is unknown" do
-      fc = FactChecker::Base.new([:f2], nil, {:f1 => :nil?})
-      fc.fact_accomplished?(nil, :f1).should be_false
-    end
-    it "should return true if requirement satisfied and fact has no dependencies" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => lambda{|o| o.size > 2}})
-      fc.fact_accomplished?("name", :f1).should be_true
-    end
-    it "should return false if requirement not satisfied (fact has no dependencies)" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => :nil?})
-      fc.fact_accomplished?("something", :f1).should be_false
-    end
-    it "should return false if fact has unsatisfied dependencies" do
-      fc = FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f2 => :nil?})
-      fc.fact_accomplished?("something", :f1).should be_false
-    end
-    it "should return false if fact has both satisfied and unsatisfied dependencies" do
-      fc = FactChecker::Base.new([:f1, :f2, :f3, :f4], {:f1 => [:f2, :f3], :f3 => :f4}, {:f2 => :size, :f3 => :size, :f4 => :nil?})
-      fc.fact_accomplished?("something", :f1).should be_false
-    end
-    it "should return true if all dependencies are satisfied and fact has no requirements" do
-      fc = FactChecker::Base.new([:f1, :f2, :f3, :f4], {:f1 => [:f2, :f3], :f3 => :f4}, {:f2 => :size, :f3 => :size, :f4 => :size})
-      fc.fact_accomplished?("something", :f1).should be_true
+    context "when fact is unknown" do
+      subject { FactChecker::Base.new([:f2], nil, {:f1 => :nil?}) }
+      it("always returns false") { subject.fact_accomplished?(nil, :f1).should be_false }
     end
-    it "should return false if requirements not satisfied (all dependencies are satisfied)" do
-      fc = FactChecker::Base.new([:f1, :f2, :f3, :f4], {:f1 => [:f2, :f3], :f3 => :f4}, {:f1 => :nil?, :f2 => :size, :f3 => :size, :f4 => :size})
-      fc.fact_accomplished?("something", :f1).should be_false
+
+    context "when fact is known and" do
+      context "has no dependencies" do
+        subject { FactChecker::Base.new([:f1], nil, {:f1 => lambda{|o| o.size > 3}}) }
+        it("returns true if requirement satisfied") do
+          subject.fact_accomplished?("String", :f1).should be_true
+        end
+        it "returns false if requirement not satisfied" do
+          subject.fact_accomplished?("Str", :f1).should be_false
+        end
+      end
+
+      context "has only unsatisfied dependencies" do
+        subject { FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f1 => lambda{true}, :f2 => :nil?}) }
+        it "returns false" do
+          subject.fact_accomplished?("something", :f1).should be_false
+        end
+      end
+
+      context "has both satisfied and unsatisfied dependencies" do
+        subject { FactChecker::Base.new([:f1, :f2, :f3, :f4], {:f1 => [:f2, :f3], :f3 => :f4}, {:f2 => :size, :f3 => :size, :f4 => :nil?}) }
+        it "returns false" do
+          subject.fact_accomplished?("something", :f1).should be_false
+        end
+      end
+
+      context "has only satisfied dependencies" do
+        subject {
+          FactChecker::Base.new(
+            [:f1, :f2, :f3, :f4],
+            {:f1 => [:f2, :f3], :f3 => :f4},
+            {:f1 => lambda{|o| o.size == 4}, :f2 => lambda{|o| o.size < 5}, :f3 => lambda{|o| o.size > 2} }
+          )
+        }
+
+        it "returns true if fact has no requirements" do
+          subject.fact_accomplished?("something", :f4).should be_true
+        end
+
+        it "returns false if requirements not satisfied" do
+          subject.fact_accomplished?("somet", :f1).should be_false
+        end
+
+        it "returns true if all requirements are satisfied" do
+          subject.fact_accomplished?("some", :f1).should be_true
+        end
+      end
     end
   end
 
   describe "#fact_possible?" do
-    it "should return true if fact is unknown" do
-      fc = FactChecker::Base.new([:f2], nil, {:f1 => :nil?})
-      fc.fact_possible?(nil, :f1).should be_true
-    end
-    it "should return true if dependencies satisfied (even if requirement is not satisfied)" do
-      fc = FactChecker::Base.new([:f1], nil, {:f1 => :nil?})
-      fc.fact_possible?(1, :f1).should be_true
+    context "when fact is unknown" do
+      it "returns true" do
+        subject.fact_possible?(nil, :x).should be_true
+      end
     end
-    it "should return false if dependencies unsatisfied (even if requirement is satisfied)" do
-      fc = FactChecker::Base.new([:f1], {:f1 => :f2}, {:f2 => :nil?})
-      fc.fact_possible?(1, :f1).should be_false
+
+    context "when fact is known" do
+      it "returns true if dependencies satisfied (even if requirement is not satisfied)" do
+        subject = FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f1 => :nil?, :f2 => :to_i})
+        subject.fact_possible?(1, :f1).should be_true
+      end
+
+      it "returns false if dependencies unsatisfied (even if requirement is satisfied)" do
+        subject = FactChecker::Base.new([:f1, :f2], {:f1 => :f2}, {:f1 => :to_i, :f2 => :nil?})
+        subject.fact_possible?(1, :f1).should be_false
+      end
     end
   end
 
   describe "#def_fact" do
-    let(:fc) { FactChecker::Base.new }
+    context "called with (:fact_name)" do
+      it "adds :fact_name to facts" do
+        subject.def_fact(:f1)
+        subject.def_fact(:f2)
+        subject.facts.should == [:f1, :f2]
+      end
 
-    it "should add argument to facts when called with (:fact) and return (:fact)" do
-      fc.def_fact(:f1).should be :f1
-      fc.def_fact(:f2).should be :f2
-      fc.facts.should == [:f1, :f2]
+      it "returns :fact_name" do
+        subject.def_fact(:f1).should be :f1
+      end
     end
 
-    it "should define fact correctly when called with (:fact, :if => :requirement)" do
-      fc.def_fact(:f1)
-      fc.def_fact(:f2, :if => :nil?)
-      fc.facts.should == [:f1, :f2]
-      fc.requirements[:f2].should == :nil?
+    context "called with (:fact_name, :if => :requirement)" do
+      it "adds :fact_name to facts" do
+        subject.def_fact(:f1)
+        subject.def_fact(:f2, :if => :nil?)
+        subject.facts.should == [:f1, :f2]
+      end
+
+      it "adds :requirement to requirements" do
+        subject.def_fact(:f2, :if => :nil?)
+        subject.requirements[:f2].should == :nil?
+      end
     end
 
-    it "should define fact correctly when called with (:fact => :dependency)" do
-      fc.def_fact(:f1)
-      fc.def_fact(:f2 => :f1)
-      fc.facts.should == [:f1, :f2]
-      fc.dependencies[:f2].should == :f1
+    context "called with (:fact_name => :dependency)" do
+      it "adds :fact_name to facts" do
+        subject.def_fact(:f1)
+        subject.def_fact(:f2 => :f1)
+        subject.facts.should == [:f1, :f2]
+      end
+
+      it "adds :dependency to dependencies" do
+        subject.def_fact(:f2 => :f1)
+        subject.dependencies[:f2].should == :f1
+      end
     end
 
-    it "should define fact correctly when called with (:fact => :dependency, :if => :requirement)" do
-      fc.def_fact(:f1)
-      fc.def_fact(:f2 => :f1, :if => :nil?)
-      fc.facts.should == [:f1, :f2]
-      fc.dependencies[:f2].should == :f1
-      fc.requirements[:f2].should == :nil?
+    context "called with (:fact_name => :dependency, :if => :requirement)" do
+      subject do
+        FactChecker::Base.new.tap do |checker|
+          checker.def_fact(:f1)
+          checker.def_fact(:f2 => :f1, :if => :to_i)
+        end
+      end
+
+      it "adds :fact_name to facts" do
+        subject.facts.should == [:f1, :f2]
+      end
+
+      it "adds :requirement to requirements" do
+        subject.requirements[:f2].should == :to_i
+      end
+
+      it "adds :dependency to dependencies" do
+        subject.dependencies[:f2].should == :f1
+      end
     end
 
-    it "should redefine fact if a fact with a given name already exists" do
-      fc.def_fact(:f1 => :f2, :if => :nil?)
-      fc.def_fact(:f1)
-      fc.facts.should == [:f1]
-      fc.requirements[:f1].should be_nil
-      fc.dependencies[:f1].should be_nil
+    context "called again for the same fact_name" do
+      subject do
+        FactChecker::Base.new.tap do |checker|
+          checker.def_fact(:f1 => :f2, :if => :nil?)
+          checker.def_fact(:f1)
+        end
+      end
+
+      it "doesn't add 2nd fact_name to facts" do
+        subject.facts.should == [:f1]
+      end
+
+      it "overwrites fact_name's dependency" do
+        subject.dependencies[:f1].should be_nil
+      end
+
+      it "overwrites fact_name's requirement" do
+        subject.requirements[:f1].should be_nil
+      end
     end
 
-    it "should raise ArgumentError exception when called with wrong arguments" do
-      expect { fc.def_fact() }.to                                                  raise_error ArgumentError
-      expect { fc.def_fact(:f1, {:if => :nil?}, true) }.to                         raise_error ArgumentError
-      expect { fc.def_fact(:f1, :f2) }.to                                          raise_error ArgumentError
-      expect { fc.def_fact({:if => :nil?}, :f1) }.to                               raise_error ArgumentError
-      expect { fc.def_fact(:f1 => :f2, :if => :nil?, :something_else => true) }.to raise_error ArgumentError
+    context "called with wrong arguments it RAISES ERROR, for example" do
+      specify "#def_fact() raises error" do
+        expect { subject.def_fact() }.to raise_error ArgumentError
+      end
+
+      specify "#def_fact(:fact_name, {:if => :requirement}, something_else) raises error" do
+        expect { subject.def_fact(:f1, {:if => :nil?}, 1) }.to raise_error ArgumentError
+      end
+
+      specify "#def_fact(:fact_name, some_scalar_value) raises error" do
+        expect { subject.def_fact(:f1, 1)}.to raise_error ArgumentError
+      end
+
+      specify "#def_fact({:if => :requirement}, something_else) raises error" do
+        expect { subject.def_fact({:if => :nil?}, :f1) }.to raise_error ArgumentError
+      end
+
+      specify "#def_fact(:fact_name => :dependency, :if => :requirement, :some_other_key => something_else) raises error" do
+        expect { subject.def_fact(:f1 => :f2, :if => :nil?, :something_else => true) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  context "has 3 *_facts methods, i.e." do
+    subject { FactChecker::Base.new([:f1, :f2, :f3], {:f1 => :f2}, {:f2 => :nil?, :f3 => lambda{false} }) }
+
+    describe "#accomplished_facts" do
+      it "returns accomplished facts - ones with both dependencies and requirements satisfied" do
+        subject.accomplished_facts(nil).should == [:f1, :f2]
+      end
+    end
+
+    describe "#possible_facts" do
+      it "returns possible facts - ones with dependencies but not requirements satisfied" do
+        subject.possible_facts("SomeString").should == [:f2, :f3]
+      end
+    end
+
+    describe "#facts" do
+      it("returns all defined facts") { subject.facts.should == [:f1, :f2, :f3] }
     end
   end
+
 end

data/spec/spec_helper.rb

@@ -1,16 +1,19 @@
 # encoding: utf-8
 
 $:.unshift File.expand_path('../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.start
+
 require 'fact_checker'
 Dir['./spec/support/**/*.rb'].each { |f| require f }
 
 RSpec.configure do |conf|
+  conf.formatter = :documentation
   conf.color_enabled = true
   conf.treat_symbols_as_metadata_keys_with_true_values = true
-
   conf.expect_with :rspec, :stdlib
   conf.mock_with :rspec
-
   conf.fail_fast = true
   conf.filter_run :focus  => true
   conf.filter_run_excluding :broken => true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fact_checker
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,23 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-31 00:00:00.000000000 +04:00
-default_executable: 
+date: 2012-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &84896850 !ruby/object:Gem::Requirement
+  requirement: &2156208200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *84896850
+  version_requirements: *2156208200
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &84896660 !ruby/object:Gem::Requirement
+  requirement: &2156206880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *84896660
+  version_requirements: *2156206880
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &84896430 !ruby/object:Gem::Requirement
+  requirement: &2156204720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,7 +44,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *84896430
+  version_requirements: *2156204720
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2156219360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *2156219360
 description: Simple gem to check hierarchically dependent "facts" about objects
 email:
 - alexisowl+fact_checker@gmail.com
@@ -56,7 +66,7 @@ files:
 - .gitignore
 - .rvmrc
 - Gemfile
-- README
+- README.md
 - Rakefile
 - examples/README.md
 - examples/basic.rb
@@ -72,7 +82,6 @@ files:
 - spec/spec_helper.rb
 - spec/support/classes_with_facts.rb
 - spec/support/shared_facts_behaviour.rb
-has_rdoc: true
 homepage: https://github.com/alexis/fact_checker
 licenses: []
 post_install_message: 
@@ -93,8 +102,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.5
 requirements: []
 rubyforge_project: fact_checker
-rubygems_version: 1.6.2
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Checks facts which may depend on other facts
-test_files: []
+test_files:
+- spec/fact_checker/base_spec.rb
+- spec/fact_checker/version_spec.rb
+- spec/fact_checker_inheritance_spec.rb
+- spec/fact_checker_spec.rb
+- spec/spec.rake
+- spec/spec_helper.rb
+- spec/support/classes_with_facts.rb
+- spec/support/shared_facts_behaviour.rb

data/README

@@ -1,23 +0,0 @@
-1. What is FactChecker
-
-  Simple ruby gem to check hierarchically dependent "facts" about objects.
-
-2. Getting started
-
-  2.1 Installation
-
-    gem install fact_checker
-
-  2.2 Usage
-
-    https://github.com/alexis/fact_checker/tree/master/examples
-
-3. Development / Contributing
-
-  3.1 Testing code with rspec
-
-    rake spec
-
-  3.2 Testing code coverage with rcov for ruby 1.8
-
-    rcov -Ilib:spec --exclude gem spec/fact_checker_spec.rb