fact_checker 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage
+.DS_Store

data/.rvmrc

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fact_checker.gemspec
+gemspec

data/README

@@ -0,0 +1,23 @@
+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

data/Rakefile

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'rake'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+Dir['lib/tasks/**/*.rake'].
+  concat(Dir['tasks/**/*.rake']).
+  concat(Dir['{test,spec}/*.rake']).each { |rake| load(rake) }
+
+task :default => :spec
+task :test => :spec # for http://test.rubygems.org/

data/examples/README.md

@@ -0,0 +1,72 @@
+# FactChecker / Examples
+
+## How to run
+
+``` ruby
+bundle exec ruby -rubygems examples/basic.rb
+```
+
+## BasicExample
+
+``` ruby
+# encoding: utf-8
+
+require 'fact_checker'
+
+class BasicExample
+  include FactChecker
+
+  def_fact :be
+  def_fact :be_or => :be
+  def_fact :be_or_not => :be, :if => :my_requirement?
+  def_fact :be_or_not_to => [:be, :be_or_not], :if => :my_requirement?
+  def_fact :be_or_not_to_be => :be, :if => lambda { |context| !context.my_requirement? }
+end
+
+target = BasicExample.new
+
+def target.my_requirement?; false end
+
+p target.fact_possible?     :be
+# => true
+p target.fact_accomplished? :be
+# => true
+p target.be?
+# => true
+
+puts
+
+p target.fact_possible?     :be_or
+# => true
+p target.fact_accomplished? :be_or
+# => true
+p target.be_or?
+# => true
+
+puts
+
+p target.fact_possible?     :be_or_not
+# => true
+p target.fact_accomplished? :be_or_not
+# => false
+p target.be_or_not?
+# => false
+
+puts
+
+p target.fact_possible?     :be_or_not_to
+# => false
+p target.fact_accomplished? :be_or_not_to
+# => false
+p target.be_or_not_to?
+# => false
+
+puts
+
+p target.fact_possible?     :be_or_not_to_be
+# => true
+p target.fact_accomplished? :be_or_not_to_be
+# => true
+p target.be_or_not_to_be?
+# => true
+```

data/examples/basic.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'fact_checker'
+
+class BasicExample
+  include FactChecker
+
+  def_fact :be
+  def_fact :be_or => :be
+  def_fact :be_or_not => :be, :if => :my_requirement?
+  def_fact :be_or_not_to => [:be, :be_or_not], :if => :my_requirement?
+  def_fact :be_or_not_to_be => :be, :if => lambda { |context| !context.my_requirement? }
+end
+
+target = BasicExample.new
+
+def target.my_requirement?; false end
+
+p target.fact_possible?     :be
+# => true
+p target.fact_accomplished? :be
+# => true
+p target.be?
+# => true
+
+puts
+
+p target.fact_possible?     :be_or
+# => true
+p target.fact_accomplished? :be_or
+# => true
+p target.be_or?
+# => true
+
+puts
+
+p target.fact_possible?     :be_or_not
+# => true
+p target.fact_accomplished? :be_or_not
+# => false
+p target.be_or_not?
+# => false
+
+puts
+
+p target.fact_possible?     :be_or_not_to
+# => false
+p target.fact_accomplished? :be_or_not_to
+# => false
+p target.be_or_not_to?
+# => false
+
+puts
+
+p target.fact_possible?     :be_or_not_to_be
+# => true
+p target.fact_accomplished? :be_or_not_to_be
+# => true
+p target.be_or_not_to_be?
+# => true

data/fact_checker.gemspec

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+$:.push File.expand_path("../lib", __FILE__)
+require "fact_checker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fact_checker"
+  s.version     = FactChecker::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alexey Smolianinov", "Ivan Povalyukhin"]
+  s.email       = ["alexisowl+fact_checker@gmail.com"]
+  s.homepage    = "https://github.com/alexis/fact_checker"
+  s.summary     = %q{Checks facts which may depend on other facts}
+  s.description = %q{Simple gem to check hierarchically dependent "facts" about objects}
+
+  s.rubyforge_project = "fact_checker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  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 'rake'
+  s.add_development_dependency 'bundler'
+end

data/lib/fact_checker/base.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+module FactChecker
+  class Base
+    attr_accessor :facts, :dependencies, :requirements
+
+    def initialize(facts = nil, deps = nil, reqs = nil)
+      @facts        = facts || []
+      @dependencies = deps  || {}
+      @requirements = reqs  || {}
+    end
+
+    def initialize_copy(orig)
+      super
+      @facts = orig.facts.dup
+      @dependencies = orig.dependencies.dup
+      @requirements = orig.requirements.dup
+    end
+
+    def accomplished_facts(context)
+      facts.select{ |fact| fact_accomplished?(context, fact) }
+    end
+    def possible_facts(context)
+      facts.select{ |fact| fact_possible?(context, fact) }
+    end
+
+    # Checks if requirement and dependency for the fact are satisfied
+    def fact_accomplished?(context, fact)
+      fact_possible?(context, fact) && requirement_satisfied_for?(context, fact)
+    end
+
+    # Checks if dependency for the fact is satisfied
+    def fact_possible?(context, fact)
+      [* @dependencies[fact] || []].all?{ |dep| fact_accomplished?(context, dep) }
+    end
+
+    # Checks if requirement for the fact is satisfied (no dependency checks here)
+    def requirement_satisfied_for?(context, fact)
+      return false unless @facts.include?(fact)
+
+      case req = @requirements[fact]
+      when Symbol   then context.send(req)
+      when Proc     then req.arity < 1 ? req.call : req.call(context)
+      when NilClass then true
+      else raise RuntimeError, "can't check this fact - wrong requirement"
+      end
+    end
+
+    # Syntactic sugar, adds fact with its requirement and dependency. Examples:
+    # - def_fact(:fact)
+    # - def_fact(:fact, :if => :requirement)
+    # - def_fact(:fact => :dependency)
+    # - def_fact(:fact => :dependency, :if => :requirement)
+    def def_fact(*opt)
+      raise ArgumentError, "wrong number of arguments (#{opt.size} for 2)" if opt.size > 2
+      raise ArgumentError, "wrong number of arguments (0 for 1)"           if opt.size == 0
+
+      if opt[0].is_a?(Hash)
+        raise ArgumentError, "wrong arguments (hash argument can only be the last one)" if opt.size > 1
+        hash = opt[0]
+      else
+        raise ArgumentError, "wrong arguments (second argument must be a hash)" if opt[1] && ! opt[1].is_a?(Hash)
+        hash = (opt[1] || {}).merge(opt[0] => nil)
+      end
+
+      req  = hash.delete(:if)
+      fact = hash.keys.first
+      dep  = hash.delete(fact)
+
+      raise ArgumentError, "wrong arguments: #{hash.keys.join(', ')}" if hash.size > 0
+
+      @requirements[fact] = req
+      @dependencies[fact] = dep
+      @facts |= [fact]
+      fact
+    end
+  end
+end

data/lib/fact_checker/version.rb

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

data/lib/fact_checker.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "fact_checker/base"
+require "fact_checker/version"
+
+module FactChecker
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    def inherited(child)
+      child.instance_variable_set('@fact_checker', fact_checker.dup)
+    end
+
+    def def_fact(*opts)
+      fact_name = fact_checker.def_fact(*opts)
+      define_method(fact_name.to_s << '?') { fact_accomplished?(fact_name) }
+    end
+
+    def fact_checker
+      @fact_checker ||= FactChecker::Base.new
+    end
+  end
+
+  # Delegate methods to self.class.fact_checker
+  [:fact_accomplished?, :fact_possible?, :accomplished_facts, :possible_facts].each do |name|
+    define_method(name) { |*opts| self.class.fact_checker.send(name, self, *opts) }
+  end
+  def facts; self.class.fact_checker.facts; end
+end

data/spec/fact_checker/base_spec.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+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]
+    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]
+    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]
+    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
+    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
+    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
+    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)
+    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
+    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
+    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
+    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
+    end
+  end
+
+  describe "#def_fact" do
+    let(:fc) { FactChecker::Base.new }
+
+    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]
+    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?
+    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
+    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?
+    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
+    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
+    end
+  end
+end

data/spec/fact_checker/version_spec.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FactChecker::VERSION do
+  it { should =~ /\A\d+\.\d+\.\d+\z/ }
+end

data/spec/fact_checker_inheritance_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'FactCheckerInheritance' do
+  describe ChildOfClassWithFacts do
+    subject { ChildOfClassWithFacts }
+
+    it { should respond_to :def_fact }
+    its(:fact_checker) { should be_kind_of FactChecker::Base }
+
+    describe 'context for inherited facts' do
+      let(:target) { ChildOfClassWithFacts.new }
+
+      context 'inherited bare fact', :fact => :bare_fact do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'inherited true fact with no dependencies', :fact => :true_fact_with_no_dependencies  do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'inherited true fact with true dependencies', :fact => :true_fact_with_true_dependencies do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'inherited true fact with false dependencies', :fact => :true_fact_with_false_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      false
+      end
+
+      context 'inherited false fact with no dependencies', :fact => :false_fact_with_no_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'inherited false fact with true dependencies', :fact => :false_fact_with_true_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'inherited false fact with false dependencies', :fact => :false_fact_with_false_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      false
+      end
+
+      specify '#facts' do
+        target.facts.size.should == 7
+      end
+
+      specify '#accomplished_facts' do
+        target.accomplished_facts.should == [ :bare_fact, :true_fact_with_no_dependencies, :true_fact_with_true_dependencies ]
+      end
+
+      specify '#possible_facts' do
+        target.possible_facts.should == target.facts - [ :true_fact_with_false_dependencies, :false_fact_with_false_dependencies ]
+      end
+    end
+  end
+end

data/spec/fact_checker_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'FactChecker' do
+  describe ClassWithNoFacts do
+    its(:facts)              { should == [] }
+    its(:possible_facts)     { should == [] }
+    its(:accomplished_facts) { should == [] }
+
+    specify '#fact_possible? and #fact_accomplished?' do
+      subject.fact_possible?(:unknown_fact).should be_true
+      subject.fact_accomplished?(:unknown_fact).should be_false
+    end
+  end
+
+  describe ClassWithFacts do
+    subject { ClassWithFacts }
+
+    it { should respond_to :def_fact }
+    its(:fact_checker) { should be_kind_of FactChecker::Base }
+
+    describe 'context for facts' do
+      let(:target) { ClassWithFacts.new }
+
+      context 'given bare fact', :fact => :bare_fact do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'given true fact with no dependencies', :fact => :true_fact_with_no_dependencies  do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'given true fact with true dependencies', :fact => :true_fact_with_true_dependencies do
+        it_behaves_like 'an accomplished fact', true
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'given true fact with false dependencies', :fact => :true_fact_with_false_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      false
+      end
+
+      context 'given false fact with no dependencies', :fact => :false_fact_with_no_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'given false fact with true dependencies', :fact => :false_fact_with_true_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      true
+      end
+
+      context 'given false fact with false dependencies', :fact => :false_fact_with_false_dependencies do
+        it_behaves_like 'an accomplished fact', false
+        it_behaves_like 'a possible fact',      false
+      end
+
+      specify '#facts' do
+        target.facts.size.should == 7
+      end
+
+      specify '#accomplished_facts' do
+        target.accomplished_facts.should == [ :bare_fact, :true_fact_with_no_dependencies, :true_fact_with_true_dependencies ]
+      end
+
+      specify '#possible_facts' do
+        target.possible_facts.should == target.facts - [ :true_fact_with_false_dependencies, :false_fact_with_false_dependencies ]
+      end
+    end
+  end
+end

data/spec/spec.rake

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'rspec/core/rake_task'
+
+desc 'Run complete application spec suite'
+RSpec::Core::RakeTask.new(:spec)
+
+spec_tasks = Dir['spec/*/'].map { |d| File.basename(d) }
+
+spec_tasks.each do |folder|
+  RSpec::Core::RakeTask.new("spec:#{folder}") do |t|
+    t.pattern = "./spec/#{folder}/**/*_spec.rb"
+    t.rspec_opts = %w(--color)
+  end
+end
+
+# task 'spec' => spec_tasks.map { |f| "spec:#{f}" }

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'fact_checker'
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |conf|
+  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
+  conf.run_all_when_everything_filtered = true
+end

data/spec/support/classes_with_facts.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+class ClassWithNoFacts
+  include FactChecker
+end
+
+class ClassWithFacts
+  include FactChecker
+
+  def_fact :bare_fact
+  def_fact :true_fact_with_no_dependencies, :if => lambda { true }
+  def_fact :true_fact_with_true_dependencies => :bare_fact, :if => lambda { true }
+  def_fact :true_fact_with_false_dependencies => :false_fact_with_no_dependencies, :if => lambda { true }
+  def_fact :false_fact_with_no_dependencies, :if => lambda { false }
+  def_fact :false_fact_with_true_dependencies => :bare_fact , :if => lambda { false }
+  def_fact :false_fact_with_false_dependencies => :false_fact_with_no_dependencies , :if => lambda { false }
+end
+
+class ChildOfClassWithFacts < ClassWithFacts
+end
+
+# :another_fact should not creep back to parent classes
+class GrandChildOfClassWithFacts < ChildOfClassWithFacts
+  def_fact :another_fact
+end

data/spec/support/shared_facts_behaviour.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples 'an accomplished fact' do |true_or_false|
+  specify '#fact_accomplished?' do
+    target.fact_accomplished?(example.metadata[:fact]).should be true_or_false
+  end
+
+  specify '#(:fact)? predicate' do
+    target.send("#{example.metadata[:fact]}?").should be true_or_false
+  end
+end
+
+shared_examples 'a possible fact' do |true_or_false|
+  specify '#fact_possible?' do
+    target.fact_possible?(example.metadata[:fact]).should be true_or_false
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: fact_checker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexey Smolianinov
+- Ivan Povalyukhin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-31 00:00:00.000000000 +04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &84896850 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *84896850
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &84896660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *84896660
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &84896430 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *84896430
+description: Simple gem to check hierarchically dependent "facts" about objects
+email:
+- alexisowl+fact_checker@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- examples/README.md
+- examples/basic.rb
+- fact_checker.gemspec
+- lib/fact_checker.rb
+- lib/fact_checker/base.rb
+- lib/fact_checker/version.rb
+- 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
+has_rdoc: true
+homepage: https://github.com/alexis/fact_checker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: fact_checker
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Checks facts which may depend on other facts
+test_files: []