pupu 0.0.1

data/vendor/rspec/examples/passing/simple_matcher_example.rb

@@ -0,0 +1,29 @@
+describe "arrays" do
+  def contain_same_elements_as(expected)
+    simple_matcher "array with same elements in any order as #{expected.inspect}" do |actual|
+      if actual.size == expected.size
+        a, e = actual.dup, expected.dup
+        until e.empty? do
+          if i = a.index(e.pop) then a.delete_at(i) end
+        end
+        a.empty?
+      else
+        false
+      end
+    end
+  end
+  
+  describe "can be matched by their contents disregarding order" do
+    subject { [1,2,2,3] }
+    it { should contain_same_elements_as([1,2,2,3]) }
+    it { should contain_same_elements_as([2,3,2,1]) }
+    it { should_not contain_same_elements_as([3,3,2,1]) }
+  end
+  
+  describe "fail the match with different contents" do
+    subject { [1,2,3] }
+    it { should_not contain_same_elements_as([2,3,4])}
+    it { should_not contain_same_elements_as([1,2,2,3])}
+    it { should_not contain_same_elements_as([1,2])}
+  end
+end

data/vendor/rspec/examples/passing/stack.rb

@@ -0,0 +1,36 @@
+class StackUnderflowError < RuntimeError
+end
+
+class StackOverflowError < RuntimeError
+end
+
+class Stack
+  
+  def initialize
+    @items = []
+  end
+  
+  def push object
+    raise StackOverflowError if @items.length == 10
+    @items.push object
+  end
+  
+  def pop
+    raise StackUnderflowError if @items.empty?
+    @items.delete @items.last
+  end
+  
+  def peek
+    raise StackUnderflowError if @items.empty?
+    @items.last
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def full?
+    @items.length == 10
+  end
+  
+end

data/vendor/rspec/examples/passing/stack_spec.rb

@@ -0,0 +1,63 @@
+require 'examples/passing/stack'
+require 'examples/passing/shared_stack_examples'
+
+describe Stack, " (empty)" do
+  before(:each) do
+    @stack = Stack.new
+  end
+  
+  # This uses @stack (because the described class is Stack) auto-generates the
+  # description "should be empty"
+  it { should be_empty }
+  
+  it_should_behave_like "non-full Stack"
+  
+  it "should complain when sent #peek" do
+    lambda { @stack.peek }.should raise_error(StackUnderflowError)
+  end
+  
+  it "should complain when sent #pop" do
+    lambda { @stack.pop }.should raise_error(StackUnderflowError)
+  end
+end
+
+describe Stack, " (with one item)" do
+  before(:each) do
+    @stack = Stack.new
+    @stack.push 3
+    @last_item_added = 3
+  end
+
+  it_should_behave_like "non-empty Stack"
+  it_should_behave_like "non-full Stack"
+
+end
+
+describe Stack, " (with one item less than capacity)" do
+  before(:each) do
+    @stack = Stack.new
+    (1..9).each { |i| @stack.push i }
+    @last_item_added = 9
+  end
+  
+  it_should_behave_like "non-empty Stack"
+  it_should_behave_like "non-full Stack"
+end
+
+describe Stack, " (full)" do
+  before(:each) do
+    @stack = Stack.new
+    (1..10).each { |i| @stack.push i }
+    @last_item_added = 10
+  end
+
+  # NOTE that this one auto-generates the description "should be full"
+  it { @stack.should be_full }  
+
+  it_should_behave_like "non-empty Stack"
+
+  it "should complain on #push" do
+    lambda { @stack.push Object.new }.should raise_error(StackOverflowError)
+  end
+  
+end

data/vendor/rspec/examples/passing/stack_spec_with_nested_example_groups.rb

@@ -0,0 +1,66 @@
+require 'examples/passing/stack'
+require 'examples/passing/shared_stack_examples'
+
+describe Stack do
+  
+  before(:each) do
+    @stack = Stack.new
+  end
+
+  describe "(empty)" do
+
+    it { @stack.should be_empty }
+  
+    it_should_behave_like "non-full Stack"
+  
+    it "should complain when sent #peek" do
+      lambda { @stack.peek }.should raise_error(StackUnderflowError)
+    end
+  
+    it "should complain when sent #pop" do
+      lambda { @stack.pop }.should raise_error(StackUnderflowError)
+    end
+
+  end
+
+  describe "(with one item)" do
+    
+    before(:each) do
+      @stack.push 3
+      @last_item_added = 3
+    end
+
+    it_should_behave_like "non-empty Stack"
+    it_should_behave_like "non-full Stack"
+
+  end
+
+  describe "(with one item less than capacity)" do
+    
+    before(:each) do
+      (1..9).each { |i| @stack.push i }
+      @last_item_added = 9
+    end
+  
+    it_should_behave_like "non-empty Stack"
+    it_should_behave_like "non-full Stack"
+  end
+
+  describe "(full)" do
+    
+    before(:each) do
+      (1..10).each { |i| @stack.push i }
+      @last_item_added = 10
+    end
+
+    it { @stack.should be_full }  
+
+    it_should_behave_like "non-empty Stack"
+
+    it "should complain on #push" do
+      lambda { @stack.push Object.new }.should raise_error(StackOverflowError)
+    end
+  
+  end
+
+end

data/vendor/rspec/examples/passing/stubbing_example.rb

@@ -0,0 +1,67 @@
+describe "A consumer of a stub" do
+  it "should be able to stub methods on any Object" do
+    obj = Object.new
+    obj.stub!(:foobar).and_return {:return_value}
+    obj.foobar.should equal(:return_value)
+  end
+end
+
+class StubbableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+describe "A stubbed method on a class" do
+  it "should return the stubbed value" do
+    StubbableClass.stub!(:find).and_return(:stub_return)
+    StubbableClass.find(1).should equal(:stub_return)
+  end
+  
+  it "should revert to the original method after each spec" do
+    StubbableClass.find(1).should equal(:original_return)
+  end
+
+  it "can stub! and mock the same message" do
+    StubbableClass.stub!(:msg).and_return(:stub_value)
+    StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value)
+
+    StubbableClass.msg.should equal(:stub_value)
+    StubbableClass.msg(:other_arg).should equal(:stub_value)
+    StubbableClass.msg(:arg).should equal(:mock_value)
+    StubbableClass.msg(:another_arg).should equal(:stub_value)
+    StubbableClass.msg(:yet_another_arg).should equal(:stub_value)
+    StubbableClass.msg.should equal(:stub_value)
+  end
+end
+
+describe "A mock" do
+  it "can stub!" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:value)
+    (1..10).each {mock.msg.should equal(:value)}
+  end
+  
+  it "can stub! and mock" do
+    mock = mock("stubbing mock")
+    mock.stub!(:stub_message).and_return(:stub_value)
+    mock.should_receive(:mock_message).once.and_return(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+    mock.mock_message.should equal(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+  end
+  
+  it "can stub! and mock the same message" do
+    mock = mock("stubbing mock")
+    mock.stub!(:msg).and_return(:stub_value)
+    mock.should_receive(:msg).with(:arg).and_return(:mock_value)
+    mock.msg.should equal(:stub_value)
+    mock.msg(:other_arg).should equal(:stub_value)
+    mock.msg(:arg).should equal(:mock_value)
+    mock.msg(:another_arg).should equal(:stub_value)
+    mock.msg(:yet_another_arg).should equal(:stub_value)
+    mock.msg.should equal(:stub_value)
+  end
+end
+
+    

data/vendor/rspec/examples/passing/yielding_example.rb

@@ -0,0 +1,31 @@
+class MessageAppender
+  
+  def initialize(appendage)
+    @appendage = appendage
+  end
+  
+  def append_to(message)
+    if_told_to_yield do
+      message << @appendage
+    end
+  end
+    
+end
+
+describe "a message expectation yielding to a block" do
+  it "should yield if told to" do
+    appender = MessageAppender.new("appended to")
+    appender.should_receive(:if_told_to_yield).and_yield
+    message = ""
+    appender.append_to(message)
+    message.should == "appended to"
+  end
+
+  it "should not yield if not told to" do
+    appender = MessageAppender.new("appended to")
+    appender.should_receive(:if_told_to_yield)
+    message = ""
+    appender.append_to(message)
+    message.should == ""
+  end
+end

data/vendor/rspec/examples/ruby1.9.compatibility/access_to_constants_spec.rb

@@ -0,0 +1,85 @@
+# courtesy of Matthias Hennemeyer
+#
+# The following should pass against ruby 1.8 and 1.9. It currently only passes
+# 1.8 (as of 1/2/2009)
+#
+# Once cucumber supports ruby 1.9, this should be moved to cucumber scenarios instead. 
+module Foo 
+  module Bar
+    
+    module ModuleInEnclosingModule;end
+    class ClassInEnclosingModule;end 
+    def method_in_enclosing_module;end
+    CONSTANT_IN_ENCLOSING_MODULE = 0
+
+    describe "Examples trying to access constants defined in an enclosing module" do
+
+      it "can access Modules" do
+        ModuleInEnclosingModule
+      end
+      it "can access Classes" do
+        ClassInEnclosingModule.new
+      end
+      it "can access CONSTANTS" do
+        CONSTANT_IN_ENCLOSING_MODULE
+      end
+      it "can NOT access methods" do
+        lambda {method_in_enclosing_module}.should raise_error(/undefined/)
+      end
+
+      describe "from a nested example group" do
+
+        it "can access Modules" do
+          ModuleInEnclosingModule
+        end
+        it "can access Classes" do
+          ClassInEnclosingModule.new
+        end
+        it "can access CONSTANTS" do
+          CONSTANT_IN_ENCLOSING_MODULE
+        end
+        it "can NOT access methods" do
+          lambda {method_in_enclosing_module}.should raise_error(/undefined/)
+        end
+
+      end 
+
+    end
+    
+    describe "Examples trying to access constants defined in the example group" do
+      
+      module ModuleDefinedInGroup;end
+      class ClassDefinedInGroup; end 
+      def method_defined_in_group; end
+      CONSTANT_DEFINED_IN_GROUP = 0
+
+      it "can access Modules" do
+        ModuleDefinedInGroup
+      end
+      it "can access Classes" do
+        ClassDefinedInGroup.new
+      end
+      it "can access CONSTANTS" do
+        CONSTANT_DEFINED_IN_GROUP
+      end
+      it "can access methods" do
+        method_defined_in_group
+      end
+      
+      describe "that live inside a nested group" do
+        it "can access Modules" do
+          ModuleDefinedInGroup
+        end
+        it "can access Classes" do
+          ClassDefinedInGroup.new
+        end
+        it "can access CONSTANTS" do
+          CONSTANT_DEFINED_IN_GROUP
+        end
+        it "can access methods" do
+          method_defined_in_group
+        end
+      end
+    end 
+  end 
+end

data/vendor/rspec/features-pending/cli/conditional_exclusion.feature

@@ -0,0 +1,39 @@
+Feature: conditional exclusion of example groups
+  
+  Example groups can be excluded from a run by matching the value of the
+  --exclude argument against options passed to an example group. The value
+  can be a key or a key:value pair (separated by a ":").
+  
+  Scenario: exclusion using explicit value
+    Given the following spec:
+      """
+      describe "This should run" do
+        it { 5.should == 5 }
+      end
+      
+      describe "This should not run", :slow => true do
+        it { 1_000_000.times { 5.should == 5 } }
+      end
+      """
+    When I run it with the spec command --format specdoc --exclude slow:true
+    Then the exit code should be 0
+    And the stdout should match "1 example, 0 failures"
+    And the stdout should match /This should run$/m
+    But the stdout should not match "This should not run"
+
+  Scenario: exclusion using default value (true)
+    Given the following spec:
+      """
+      describe "This should run" do
+        it { 5.should == 5 }
+      end
+
+      describe "This should not run", :slow => true do
+        it { 1_000_000.times { 5.should == 5 } }
+      end
+      """
+    When I run it with the spec command --format specdoc --exclude slow
+    Then the exit code should be 0
+    And the stdout should match "1 example, 0 failures"
+    And the stdout should match /This should run$/m
+    But the stdout should not match "This should not run"

data/vendor/rspec/features-pending/heckle/heckle.feature

@@ -0,0 +1,56 @@
+Feature: heckle a class
+
+  As an RSpec user who wants to verify that
+    my specs cover what I think it covers
+  I want to heckle a class
+
+  Scenario: Heckle finds problems
+    Given a file named "heckle_fail_spec.rb" with:
+      """
+      class Thing
+        def a_or_b
+          if true
+            "a"
+          else
+            "b"
+          end
+        end
+      end
+
+      describe Thing do
+        it "returns a for true" do
+          Thing.new.a_or_b.should == "a"
+        end
+      end
+      """
+    When I run "spec heckle_fail_spec.rb --heckle Thing"
+    Then the stdout should match "The following mutations didn't cause test failures:"
+    But the stdout should not match "FAILED"
+
+  Scenario: Heckle does not find a problem
+    Given a file named "heckle_success_spec.rb" with:
+      """
+      class Thing
+        def a_or_b(key)
+          if key
+            "a"
+          else
+            "b"
+          end
+        end
+      end
+
+      describe Thing do
+        it "returns a for true" do
+          Thing.new.a_or_b(true).should == "a"
+        end
+
+        it "returns b for false" do
+          Thing.new.a_or_b(false).should == "b"
+        end
+      end
+      """
+    When I run "spec heckle_success_spec.rb --heckle Thing"
+    Then the stdout should match "No mutants survived"
+    But the stdout should not match "FAILED"
+