rspec 0.5.3 → 0.5.4

data/doc/src/community.page

@@ -1,7 +0,0 @@
----
-title: Community
-inMenu: true
----
-h2. Community
-
-Mailing lists, Issue tracker, How to send patches etc.

data/doc/src/documentation/api.page

@@ -1,185 +0,0 @@
----
-title: Core API
-inMenu: true
-ordering: 5
----
-h2. Core API
-
-When RSpec executes specifications, it defines a method <code>should</code> on every object in the system. This <code>should</code> method is your entry to the magic of RSpec.
-
-Almost all expectation forms have a corresponding negated form. It is listed when it is supported and, in general, is met when ever the non-negated form would be violated.
-
-h3. General
-
-h4. Arbitrary Block
-
-<pre>
-target.should.satisfy {|arg| ...}
-target.should.not.satisfy {|arg| ...}
-</pre>
-
-The supplied block is evaluated, passing <code>target</code> as the sole argument. If the block evaluates to <code>false</code> in the case of <code>should.satisfy</code>, or <code>true</code> in the case of <code>should.not.satisfy</code>, <code>ExpectationNotMetError</code> is raised.
-
-<pre>
-target.should.satisfy {|arg| arg > 0}
-</pre>
-
-h4. Equality
-
-<pre>
-target.should.equal <value>
-target.should.not.equal <value>
-</pre>
-
-The target object is compared to <code>value</code> using ==. If the result is <code>false</code> (or <code>true</code> for the negated form) <code>ExpectationNotMetError</code> is raised.
-
-h4. Floating Point Comparison
-
-<pre>
-target.should.be.close <value>, <tolerance>
-target.should.not.be.close <value>, <tolerance>
-</pre>
-
-The target object is compared to <code>value</code>. In the former case, if they differ by more that <code>tolerance</code> <code>ExpectationNotMetError</code> is raised. In the latter case, it is raised if they differ by less than <code>tolerance</code>.
-
-<pre>
-target.should.be.close 27.35, 0.05
-</pre>
-
-h4. Identity
-
-<pre>
-target.should.be <value>
-target.should.not.be <value>
-</pre>
-
-The target object is compared to <code>value</code> using <code>equal?</code>. If the result is <code>false</code> (or <code>true</code> for the negated form) <code>ExpectationNotMetError</code> is raised.
-
-h4. Arbitrary Predicate
-
-
-<pre>
-target.should.predicate [optional args]
-target.should.be.predicate [optional args]
-target.should.not.predicate [optional args]
-target.should.not.be.predicate [optional args]
-</pre>
-
-The message <code>predicate?</code> is sent to <code>target</code> with any supplied arguments. If the result is <code>false</code> (or <code>true</code> for the negated form) <code>ExpectationNotMetError</code> is raised.
-
-<pre>
-container.should.include 'a' => container.include? 'a'
-container.should.be.empty => container.empty?
-</pre>
-
-h4. Pattern Matching
-
-<pre>
-target.should.match <regex>
-target.should.not.match <regex>
-</pre>
-
-The <code>target</code> is matched against <code>regex</code>. An <code>ExpectationNotMetError</code> is raised if the match fails or succeeds, respectively.
-
-h3. Class/Type
-
-h4. Direct Instance
-
-<pre>
-target.should.be.an.instance.of <class>
-target.should.not.be.an.instance.of <class>
-</pre>
-
-An <code>ExpectationNotMetError</code> is raised if <code>target</code> is not or is, respectively, an direct instance of <code>class</code>. As expected this correlates to <code>target.instance_of?  class</code>.
-
-h4. Ancestor Class
-
-<pre>
-target.should.be.a.kind.of <class>
-target.should.not.be.a.kind.of <class>
-</pre>
-
-As above, but uses <code>target.kind_of? class</code>: checking whether <code>class</code> is the direct class of <code>target</code>, or an ancestor of <code>target</code>'s class.
-
-h4. Type
-
-<pre>
-target.should.respond.to <symbol>
-target.should.not.respond.to <symbol>
-</pre>
-
-Uses <code>target.respond_to? symbol?</code> to check whether <code>symbol</code> is the name of a message that <code>target</code> understands.
-
-h3. Procs
-
-h4. Raising
-
-<pre>
-proc.should.raise <exception>
-proc.should.not.raise <exception>
-</pre>
-
-Checks that <code>proc</code> does or doesn't cause the named exception to be raised. Typically the <code>proc</code> is created in place using <code>lambda</code>. For example:
-
-<pre>
-lambda { 3 / 0 }.should.raise ZeroDivisionError
-</pre>
-
-There is a more general form as well.
-
-<pre>
-proc.should.raise
-proc.should.not.raise
-</pre>
-
-These forms don't worry about what exception is raised (or not). All they are concern with is that some except was raised, or that no exception was raised.
-
-h4. Throwing
-
-<pre>
-proc.should.throw <symbol>
-proc.should.not.throw <symbol>
-</pre>
-
-Similar to the above, but checks that <code>symbol</code> is thrown from within <code>proc</code>, or that it is not. The latter is actually one of two cases: some other symbol is
-thrown, or no symbol is thrown.
-
-<pre>
-proc.should.not.throw
-</pre>
-
-This form is more specific.  It checks that no symbol is thrown from within <code>proc</code>.
-
-h3. Collections
-
-h4. Containment
-
-<pre>
-target.should.include <object>
-</pre>
-
-This is simply a specific case of the arbitrary predicate form. It uses <code>target.include? object</code> and raises an <code>ExpectationNotMetError</code> if that returns false. The remaining collection forms are a little more involved. They rely on two things: <code>target</code> responds to the message <code>things</code> by returning an object that responds to either <code>length</code> or <code>size</code>, which return a number that is a measure of size. Currently <code>length</code> is used if is appropriate, otherwise <code>size</code> is attempted.
-
-h4. Exact Size
-
-<pre>
-target.should.have(<number>).<things>
-</pre>
-
-The <code>things</code> of <code>target</code> has a length/size of exactly <code>number</code>. 
-
-h4. Lower Bound
-
-<pre>
-target.should.have.at.least(<number>).<things>
-</pre>
-
-The <code>things</code> of <code>target</code> has a length/size of no less than <code>number</code>.
-
-h4. Upper Bound
-
-<pre>
-target.should.have.at.most(<number>).<things>
-</pre>
-
-The <code>things</code> of <code>target</code> has a length/size of no more than <code>number</code>.

data/doc/src/why_rspec.page

@@ -1,7 +0,0 @@
----
-title: Why RSpec
-inMenu: true
----
-h2. Why RSpec
-
-Bla bla bla

data/examples/empty_stack_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/spec'
-require File.dirname(__FILE__) + "/stack"
-
-context "An empty stack" do
-  
-  setup do
-    @stack = Stack.new
-  end
-  
-  specify "should accept an item when sent push" do
-    lambda { @stack.push Object.new }.should.not.raise
-  end
-  
-  specify "should complain when sent top" do
-    lambda { @stack.top }.should.raise StackUnderflowError
-  end
-  
-  specify "should complain when sent pop" do
-    lambda { @stack.pop }.should.raise StackUnderflowError
-  end
-  
-end

data/examples/team_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/spec'
-
-class Team
-  attr_reader :players
-  def initialize
-    @players = Players.new
-  end
-end
-
-class Players
-  def size
-    0
-  end
-end
-
-context "A new team" do
-  
-  setup do
-    @team = Team.new
-  end
-  
-  specify "should have 3 players (failing example)" do
-    @team.should.have(3).players
-  end
-  
-  specify "should have 1 player (failing example)" do
-    @team.players.size.should.be 1
-  end
-  
-end

data/lib/spec/api/duck_type.rb

@@ -1,16 +0,0 @@
-module Spec
-  module Api
-
-    class DuckType
-      def initialize(*methods_to_respond_do)
-        @methods_to_respond_do = methods_to_respond_do
-      end
-  
-      def walks_like?(obj)
-        @methods_to_respond_do.each { |sym| return false unless obj.respond_to? sym }
-        return true
-      end
-    end
-  
-  end
-end

data/lib/spec/runner/simple_text_reporter.rb

@@ -1,88 +0,0 @@
-module Spec
-  module Runner
-    class SimpleTextReporter
-      def initialize(output=STDOUT,verbose=false,backtrace_tweaker=BacktraceTweaker.new)
-        @output = output
-        @context_names = []
-        @errors = []
-        @spec_names = []
-        @verbose = verbose
-        @backtrace_tweaker = backtrace_tweaker
-      end
-  
-      def add_context(name)
-        @output << "\n" if @context_names.empty? unless @verbose
-        @output << "\n#{name}\n" if @verbose
-        @context_names << name
-      end
-      
-      def add_spec(name, errors=[])
-        if errors.empty?
-          spec_passed(name)
-        else
-          errors.each { |error| @backtrace_tweaker.tweak_backtrace(error, name) }
-          # only show the first one (there might be more)
-          spec_failed(name, errors[0])
-        end
-      end
-      
-      def start
-        @start_time = Time.new
-      end
-  
-      def end
-        @end_time = Time.new
-      end
-  
-      def dump
-        @output << "\n"
-        dump_errors
-        @output << "\n\n" unless @errors.empty?
-        @output << "\n" if @errors.empty?
-        @output << "Finished in " << (duration).to_s << " seconds\n\n"
-        @output << "#{@context_names.length} context#{'s' unless @context_names.length == 1 }, "
-        @output << "#{@spec_names.length} specification#{'s' unless @spec_names.length == 1 }, "
-        @output << "#{@errors.length} failure#{'s' unless @errors.length == 1 }"
-        @output << "\n"
-      end
-
-      def dump_errors
-        return if @errors.empty?
-        @output << "\n"
-        @errors.inject(1) do |index, error|
-          @output << "\n\n" if index > 1
-          @output << index.to_s << ")\n"
-          @output << "#{error.message} (#{error.class.name})\n"
-          dump_backtrace(error.backtrace)
-          index + 1
-        end
-      end
-
-      def dump_backtrace(trace)
-        @output << trace.join("\n") unless trace.nil?
-      end
-
-      private
-  
-        def duration
-          return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
-          return "0.0"
-        end
-
-        def spec_passed(name)
-          @spec_names << name
-          @output << "- #{name}\n" if @verbose
-          @output << '.' unless @verbose
-        end
-
-        def spec_failed(name, error)
-          @spec_names << name
-          @errors << error
-          @output << "- #{name} (FAILED - #{@errors.length})\n" if @verbose
-          @output << 'F' unless @verbose
-        end
-
-    end
-    
-  end
-end

data/test/rcov/rcov_verify.rb

@@ -1,28 +0,0 @@
-module RCov
-  class VerifyTask < Rake::TaskLib
-    attr_accessor :name
-    attr_accessor :index_html
-    attr_accessor :threshold
-    
-    def initialize(name=:rcov_verify)
-      @name = name
-      yield self if block_given?
-      raise "Threshold must be set" if @threshold.nil?
-      define
-    end
-    
-    def define
-      desc "Verify that rcov coverage is at least #{threshold}"
-      task @name do
-        total_coverage = nil
-        File.open(index_html).each_line do |line|
-          if line =~ /<tt>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/
-            total_coverage = eval($1)
-            break
-          end
-        end
-        raise "Coverage must be at least #{threshold}% but was #{total_coverage}%" if total_coverage < threshold
-      end
-    end
-  end
-end

data/test/spec/runner/simple_text_reporter_test.rb

@@ -1,123 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Runner
-    class SimpleTextReporterTest < Test::Unit::TestCase
-      
-      def setup
-        @io = StringIO.new
-        @backtrace_tweaker = Spec::Api::Mock.new("backtrace tweaker")
-        @reporter = SimpleTextReporter.new(@io, false, @backtrace_tweaker)
-      end
-
-      def test_should_include_time
-        @reporter.start
-        @reporter.end
-        @reporter.dump
-        assert_match(/Finished in [0-9].[0-9|e|-]+ seconds/, @io.string)
-      end
-      
-      def test_should_output_stats_even_with_no_data
-        @reporter.dump
-        assert_match(/Finished in 0.0 seconds/, @io.string)
-        assert_match(/0 contexts, 0 specifications, 0 failures/, @io.string)
-      end
-  
-      def test_should_account_for_context_in_stats_for_pass
-        @reporter.add_context "context"
-        @reporter.dump
-        assert_match(/1 context, 0 specifications, 0 failures/, @io.string)
-      end
-  
-      def test_should_account_for_spec_in_stats_for_pass
-        @reporter.add_spec Specification.new("spec"), {}
-        @reporter.dump
-        assert_match(/0 contexts, 1 specification, 0 failures/, @io.string)
-      end
-  
-      def test_should_account_for_spec_and_error_in_stats_for_pass
-        @backtrace_tweaker.should.receive(:tweak_backtrace)
-        @reporter.add_context "context"
-        @reporter.add_spec Specification.new("spec"), [RuntimeError.new]
-        @reporter.dump
-        assert_match(/1 context, 1 specification, 1 failure/, @io.string)
-      end
-      
-      def test_should_handle_multiple_contexts_same_name
-        @reporter.add_context Context.new("context") {}
-        @reporter.add_context Context.new("context") {}
-        @reporter.add_context Context.new("context") {}
-        @reporter.dump
-        assert_match(/3 contexts, 0 specifications, 0 failures/, @io.string)
-      end
-  
-      def test_should_handle_multiple_specs_same_name
-        @backtrace_tweaker.should.receive(:tweak_backtrace)
-        @reporter.add_context "context"
-        @reporter.add_spec "spec"
-        @reporter.add_spec "spec", [RuntimeError.new]
-        @reporter.add_context "context"
-        @reporter.add_spec "spec"
-        @reporter.add_spec "spec", [RuntimeError.new]
-        @reporter.dump
-        assert_match(/2 contexts, 4 specifications, 2 failures/, @io.string)
-      end
-      
-      def test_should_delegate_to_backtrace_tweaker
-        @backtrace_tweaker.should.receive(:tweak_backtrace)
-        @reporter.add_context "context"
-        @reporter.add_spec "spec", [RuntimeError.new]
-        @backtrace_tweaker.__verify
-      end
-
-    end
-
-    class SimpleTextReporterQuietOutputTest < Test::Unit::TestCase
-
-      def setup
-        @io = StringIO.new
-        @reporter = SimpleTextReporter.new(@io)
-        @reporter.add_context "context"
-      end
-      
-      def test_should_remain_silent_when_context_name_provided
-        assert_equal("\n", @io.string)
-      end
-      
-      def test_should_output_dot_when_spec_passed
-        @reporter.add_spec "spec"
-        assert_equal("\n.", @io.string)
-      end
-
-      def test_should_output_F_when_spec_failed
-        @reporter.add_spec "spec", [RuntimeError.new]
-        assert_equal("\nF", @io.string)
-      end
-      
-    end
-
-    class SimpleTextReporterVerboseOutputTest < Test::Unit::TestCase
-
-      def setup
-        @io = StringIO.new
-        @reporter = SimpleTextReporter.new(@io, true)
-        @reporter.add_context "context"
-      end
-      
-      def test_should_output_when_context_name_provided
-        assert_match(/\ncontext\n/, @io.string)
-      end
-      
-      def test_should_output_spec_name_when_spec_passed
-        @reporter.add_spec "spec"
-        assert_match(/- spec\n/, @io.string)
-      end
-
-      def test_should_output_failure_when_spec_failed
-        @reporter.add_spec "spec", [RuntimeError.new]
-        assert_match(/spec \(FAILED - 1\)/, @io.string)
-      end
-
-    end
-  end
-end