fail-fast 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+== 1.0.0 2008-11-29
+
+* 1 major enhancement:
+  * Initial release
+
+

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+config/website.yml
+lib/fail_fast.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+spec/fail_fast_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb
+

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on fail-fast, see http://fail-fast.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,87 @@
+= fail-fast
+
+* http://fail-fast.rubyforge.org
+
+== DESCRIPTION:
+
+FailFast is a collection of assertion methods intended for lightweight contract checking.
+
+== FEATURES/PROBLEMS:
+
+* TODO More documentation
+
+== SYNOPSIS:
+
+  def try
+    yield
+  rescue FailFast::AssertionFailureError
+    "<Assertion Failure>"
+  end
+
+  include FailFast::Assertions
+
+  try { assert(true) }            # => true
+  try { assert(false) }           # => "<Assertion Failure>"
+  try { assert(nil) }             # => "<Assertion Failure>"
+
+  # We can check multiple values at once
+  try { assert("foo", :bar, 42) } # => 42
+  try { assert(1, 2, nil) }       # => "<Assertion Failure>"
+
+  # assert_exists only checks for nil-ness - false is OK.
+  try { assert_exists(true) }     # => true
+  try { assert_exists(false) }    # => false
+  try { assert_exists(nil) }      # => "<Assertion Failure>"
+
+  # check further constraints after verifying the object is non-nil
+  try { assert_exists(99) {|n| n > 100 } } # => "<Assertion Failure>"
+
+  # Assert that a collection is non-empty
+  try { assert_one_or_more([1]) }         # => [1]
+  try { assert_one_or_more(:foo => :bar) } # => {:foo=>:bar}
+  try { assert_one_or_more([]) }           # => "<Assertion Failure>"
+
+  # #deny is the opposite of #assert
+  try {  deny(true) }             # => "<Assertion Failure>"
+  try { deny(false) }             # => false
+  try { deny(nil) }               # => nil
+
+  # Assert that an object is hash-like and contains non-nil values for given keys
+  h = {:foo => 1, :bar => 2, :baz => nil}
+  try { assert_keys(h, :foo, :bar) } # => {:foo=>1, :bar=>2, :baz=>nil}
+  try { assert_keys(h, :baz) }       # => "<Assertion Failure>"
+  try { assert_keys(h, :buz) }       # => "<Assertion Failure>"
+  
+
+== REQUIREMENTS:
+
+* None!
+
+== INSTALL:
+
+* sudo gem install fail-fast
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Avdi Grimm
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/fail_fast'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('fail-fast', FailFast::VERSION) do |p|
+  p.developer('Avdi Grimm', 'avdi@avdi.org')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/config/website.yml

@@ -0,0 +1,2 @@
+host: avdi@rubyforge.org
+remote_dir: /var/www/gforge-projects/fail-fast

data/lib/fail_fast.rb

@@ -0,0 +1,81 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module FailFast
+  VERSION = '1.0.0'
+
+  class AssertionFailureError < Exception
+  end
+
+  module Assertions
+
+    # Assert that no +values+ are nil or false.  Returns the last value.
+    def assert(*values, &block)
+      iterate_and_return_last(values, block) do |v|
+        raise_assertion_error unless v
+      end
+    end
+
+    # The opposite of #assert.
+    def deny(*values)
+      assert(*values.map{ |v| !v})
+      assert(yield(*values)) if block_given?
+      values.last
+    end
+
+    # Assert that no +values+ are nil.  Returns the last value.
+    def assert_exists(*values, &block)
+      iterate_and_return_last(values, block) {  |value| deny(value.nil?) }
+    end
+
+    # Assert that +values+ are collections that contain at least one element.
+    # Returns the last value.
+    def assert_one_or_more(*values, &block)
+      iterate_and_return_last(values, block) do |value|
+        assert_exists(value)
+        deny(value.kind_of?(String))
+        deny(value.empty?)
+      end
+    end
+
+    # Assert that +hash+ exists, responds to #[], and contains a non-nil value
+    # for all +keys+.  Returns +hash+.
+    def assert_keys(hash, *keys)
+      assert_exists(hash)
+      assert(hash.respond_to?(:[]))
+      values = keys.inject([]) { |vals, k| vals << assert_exists(hash[k]) }
+      assert(yield(*values)) if block_given?
+      hash
+    end
+
+    # Assert that +object+ responds to +messages+.  Returns +object+.
+    def assert_respond_to(object, *messages)
+      messages.each do |message|
+        assert(object.respond_to?(message))
+      end
+      assert(yield(object)) if block_given?
+      object
+    end
+
+    private
+
+    def iterate_and_return_last(values, block = nil)
+      values.each { |v| yield(v) }
+      if block
+        raise_assertion_error unless block.call(*values)
+      end
+      values.last
+    end
+
+    def raise_assertion_error
+      error = FailFast::AssertionFailureError.new
+      backtrace = caller
+      trimmed_backtrace = []
+      trimmed_backtrace.unshift(backtrace.pop) until
+        backtrace.last.include?(__FILE__)
+      error.set_backtrace(trimmed_backtrace)
+      raise error
+    end
+
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/fail-fast.rb'}"
+puts "Loading fail-fast gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + "/../Rakefile"
+require 'rubyforge'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
+version  = $hoe.version
+
+def rubyforge_project_id
+  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/spec/fail_fast_spec.rb

@@ -0,0 +1,315 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+module AssertionsSpecHelper
+  def do_success(&block)
+    do_assertion(@success_values.first, &block)
+  end
+  def do_failure(&block)
+    do_assertion(@failure_values.first, &block)
+  end
+end
+
+describe "any assertion", :shared => true do
+  it "on failure, should raise an exception with trimmed backtrace" do
+    begin
+      do_failure
+    rescue FailFast::AssertionFailureError => e
+      e.backtrace.first.should include(__FILE__)
+    end
+  end
+end
+
+describe "a basic assertion", :shared => true do
+  it "should raise FailFast::AssertionFailureError when it fails" do
+    @failure_values.each do |value|
+      lambda do
+        do_assertion(value)
+      end.should raise_error(FailFast::AssertionFailureError)
+    end
+  end
+
+  it "should not raise an exception when it succeeds" do
+    @success_values.each do |value|
+      lambda do
+        do_assertion(value)
+      end.should_not raise_error
+    end
+  end
+
+  it "should return its argument on success" do
+    @success_values.each do |value|
+      do_assertion(value).should equal(value)
+    end
+  end
+
+end
+
+describe "an assertion taking a block", :shared => true do
+  it "should fail if the block result is not true" do
+    lambda do
+      do_success { false }
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+end
+
+describe "an assertion yielding passed values", :shared => true do
+
+  it_should_behave_like "an assertion taking a block"
+
+  it "should yield values that pass the test" do
+    @success_values.each do |value|
+      did_yield = false
+      do_assertion(value) do |yielded_value|
+        did_yield = true
+        yielded_value.should equal(value)
+        true
+      end
+      did_yield.should be_true
+    end
+  end
+
+  it "should not yield values that fail the test" do
+    @failure_values.each do |value|
+      did_yield = false
+      lambda do
+        do_assertion(value) do |yielded_value|
+          did_yield = true
+        end
+      end.should raise_error(FailFast::AssertionFailureError)
+      did_yield.should be_false
+    end
+  end
+
+end
+
+describe "an assertion taking multiple values", :shared => true do
+  def gather_arguments(values)
+    args = []
+    # gather 3 arguments
+    3.times do |i|
+      args[i] = values[i % values.size]
+    end
+    args
+  end
+
+  it "should not raise error if all values succeed test" do
+    values = gather_arguments(@success_values)
+    lambda { do_assertion(*values) }.should_not raise_error
+  end
+
+  it "should raise error if all values fail test" do
+    values = gather_arguments(@failure_values)
+    lambda { do_assertion(*values) }.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should raise error if one values fails test" do
+    values = gather_arguments(@success_values)
+    values[1] = @failure_values.first
+    lambda { do_assertion(*values) }.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should return the last argument on success" do
+    values = gather_arguments(@success_values)
+    do_assertion(*values).should equal(values.last)
+  end
+
+end
+
+describe FailFast::Assertions, "#assert" do
+
+  include FailFast::Assertions
+  include AssertionsSpecHelper
+
+  def do_assertion(*args, &block)
+    assert(*args, &block)
+  end
+
+  before :each do
+    @success_values      = [true, "", 0]
+    @failure_values      = [false, nil]
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "a basic assertion"
+  it_should_behave_like "an assertion taking multiple values"
+  it_should_behave_like "an assertion yielding passed values"
+end
+
+describe FailFast::Assertions, "#assert_exists" do
+
+  include FailFast::Assertions
+  include AssertionsSpecHelper
+
+  def do_assertion(*args, &block)
+    assert_exists(*args, &block)
+  end
+
+  before :each do
+    @success_values = ["foo", 123, false]
+    @failure_values = [nil]
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "a basic assertion"
+  it_should_behave_like "an assertion taking multiple values"
+  it_should_behave_like "an assertion yielding passed values"
+
+end
+
+describe FailFast::Assertions, "#assert_one_or_more" do
+
+  include FailFast::Assertions
+  include AssertionsSpecHelper
+
+  def do_assertion(*args, &block)
+    assert_one_or_more(*args, &block)
+  end
+
+  before :each do
+    @success_values = [[1], {:foo => :bar }]
+    @failure_values = [nil, [], "foo"]
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "a basic assertion"
+  it_should_behave_like "an assertion taking multiple values"
+  it_should_behave_like "an assertion yielding passed values"
+end
+
+describe FailFast::Assertions, "#deny" do
+
+  include FailFast::Assertions
+  include AssertionsSpecHelper
+
+  def do_assertion(*args, &block)
+    deny(*args, &block)
+  end
+
+  before :each do
+    @success_values = [false, nil]
+    @failure_values = [true, "", 0]
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "a basic assertion"
+  it_should_behave_like "an assertion taking multiple values"
+  it_should_behave_like "an assertion yielding passed values"
+end
+
+describe FailFast::Assertions, "#assert_keys" do
+
+  include FailFast::Assertions
+
+  def do_assertion(*args, &block)
+    assert_keys(*args, &block)
+  end
+
+  def do_success(&block)
+    assert_keys({}, &block)
+  end
+
+  def do_failure(&block)
+    assert_keys({}, :foo, &block)
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "an assertion taking a block"
+
+  it "should fail if a specified key does not exist" do
+    lambda { assert_keys({}, :foo) }.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should fail if a specified key is nil" do
+    lambda do
+      assert_keys({:foo => nil}, :foo)
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should fail if any of the specified keys are nil" do
+    lambda do
+      assert_keys({:foo => true, :bar => nil}, :foo, :bar)
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should fail if the given hash is nil" do
+    lambda do
+      assert_keys(nil)
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should fail if given something unlike a hash" do
+    lambda do
+      assert_keys(true)
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+
+  it "should succeed if no keys are given" do
+    lambda do
+      assert_keys({:foo => true, :bar => nil})
+    end.should_not raise_error
+  end
+
+  it "should yield key values if they all exist" do
+    did_yield = false
+    assert_keys({:foo => 23, :bar => 32}, :foo, :bar) do |x, y|
+      did_yield = true
+      x.should == 23
+      y.should == 32
+      true
+    end
+    did_yield.should be_true
+  end
+
+  it "should yield nothing if a key is missing" do
+    begin
+      did_yield = false
+      assert_keys({:foo => 23, :bar => 32}, :foo, :bar) do |x, y|
+        did_yield = true
+      end
+    rescue FailFast::AssertionFailureError
+      did_yield.should be_false
+    end
+  end
+
+  it "should return the hash" do
+    @hash = { :buz => 42 }
+    assert_keys(@hash, :buz).should equal(@hash)
+  end
+end
+
+describe FailFast::Assertions, "#assert_respond_to" do
+  include FailFast::Assertions
+
+  def do_assertion(object, &block)
+    assert_respond_to(object, :size, &block)
+  end
+
+  def do_success(&block)
+    assert_respond_to("foo", :size, &block)
+  end
+
+  def do_failure(&block)
+    assert_respond_to("foo", :bar, &block)
+  end
+
+  before :each do
+    @success_values = [[], ""]
+    @failure_values = [nil]
+  end
+
+  it_should_behave_like "any assertion"
+  it_should_behave_like "a basic assertion"
+  it_should_behave_like "an assertion taking a block"
+
+  it "should fail if ANY messages are not supported" do
+    lambda do
+      assert_respond_to("foo", :size, :bar)
+    end.should raise_error(FailFast::AssertionFailureError)
+  end
+end
+
+describe FailFast::AssertionFailureError do
+  it "should derive from Exception" do
+    FailFast::AssertionFailureError.superclass.should equal(Exception)
+  end
+end