pupu 0.0.2 → 0.0.3.pre

data/vendor/rspec/spec/spec/example/example_matcher_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-    describe ExampleMatcher, "#matches?" do
-      def match_examples(examples)
-        simple_matcher do |actual, matcher|
-          matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false"
-          matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true"
-          actual.matches?(examples)
-        end
-      end
-      
-      it "should match correct example_group and example" do
-        matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_examples(["example_group example"])
-      end
-      
-      it "should not match wrong example" do
-        matcher = ExampleMatcher.new("example_group", "other example")
-        matcher.should_not match_examples(["example_group example"])
-      end
-      
-      it "should not match wrong example_group" do
-        matcher = ExampleMatcher.new("other example_group", "example")
-        matcher.should_not match_examples(["example_group example"])
-      end
-      
-      it "should match example only" do
-        matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_examples(["example"])
-      end
-
-      it "should match example_group only" do
-        matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_examples(["example_group"])
-      end
-
-      it "should match example_group ending with before(:all)" do
-        matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_examples(["example_group before(:all)"])
-      end
-      
-      it "should escape regexp chars" do
-        matcher = ExampleMatcher.new("(con|text)", "[example]")
-        matcher.should_not match_examples(["con p"])
-      end
-      
-      it "should match when example_group is modularized" do
-        matcher = ExampleMatcher.new("MyModule::MyClass", "example")
-        matcher.should match_examples(["MyClass example"])
-      end      
-    end
-
-    describe ExampleMatcher, "#matches? normal case" do
-      it "matches when passed in example matches" do
-        matcher = ExampleMatcher.new("Foo", "bar")
-        matcher.matches?(["no match", "Foo bar"]).should == true
-      end
-
-      it "does not match when no passed in examples match" do
-        matcher = ExampleMatcher.new("Foo", "bar")
-        matcher.matches?(["no match1", "no match2"]).should == false
-      end
-    end
-
-    describe ExampleMatcher, "#matches? where description has '::' in it" do
-      it "matches when passed in example matches" do
-        matcher = ExampleMatcher.new("Foo::Bar", "baz")
-        matcher.matches?(["no match", "Foo::Bar baz"]).should == true
-      end
-
-      it "does not match when no passed in examples match" do
-        matcher = ExampleMatcher.new("Foo::Bar", "baz")
-        matcher.matches?(["no match1", "no match2"]).should == false
-      end
-    end
-    
-    describe ExampleMatcher, "called with nil example" do
-      it "does not puke" do
-        matcher = ExampleMatcher.new("Foo::Bar", nil)
-        matcher.matches?(["anything"]).should == false
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/example/example_methods_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-class Thing
-  attr_reader :arg
-  def initialize(arg=nil)
-    @arg = arg || :default
-  end
-  def ==(other)
-    @arg == other.arg
-  end
-  def eql?(other)
-    @arg == other.arg
-  end
-end
-
-module Spec
-  module Example
-    describe ExampleMethods do
-      module ModuleThatIsReopened; end
-
-      module Spec::Example::ExampleMethods
-        include ModuleThatIsReopened
-      end
-
-      module ModuleThatIsReopened
-        def module_that_is_reopened_method; end
-      end
-      
-      describe "with an included module that is reopened" do
-        it "should have reopened methods" do
-          method(:module_that_is_reopened_method).should_not be_nil
-        end
-      end
-
-      describe "#should" do
-        before(:each) do
-          @example_group = Class.new(ExampleGroupDouble)
-          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
-        end
-        
-        context "in an ExampleGroup with an implicit subject" do
-          it "delegates matcher to the implied subject" do
-            @example_group.describe(::Thing)
-            @example_group.example { should == ::Thing.new(:default) }
-            @example_group.example { should eql(::Thing.new(:default)) }
-            @example_group.run(@options).should be_true
-          end
-        end
-        
-        context "in an ExampleGroup using an explicit subject" do
-          it "delegates matcher to the declared subject" do
-            @example_group.describe(::Thing)
-            @example_group.subject { ::Thing.new(:other) }
-            @example_group.example { should == ::Thing.new(:other) }
-            @example_group.example { should eql(::Thing.new(:other)) }
-            @example_group.run(@options).should be_true
-          end
-        end
-		
-        context "in an ExampleGroup using 'self' as an explicit subject" do
-          it "delegates matcher to the ExampleGroup" do
-            @example_group.describe(::Thing)
-            @example_group.subject { self }
-            @example_group.example { should == self }
-            @example_group.example { should eql(self) }
-            @example_group.example do
-              self.instance_eval("def method_ok?; true end")
-              should be_method_ok
-            end
-            @example_group.run(@options).should be_true
-          end
-        end
-      end
-
-      describe "#should_not" do
-        before(:each) do
-          @example_group = Class.new(ExampleGroupDouble)
-          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
-        end
-
-        context "in an ExampleGroup with an implicit subject" do
-          it "delegates matcher to the implied subject" do
-            @example_group.describe(::Thing)
-            @example_group.example { should_not == ::Thing.new(:other) }
-            @example_group.example { should_not eql(::Thing.new(:other)) }
-            @example_group.run(@options).should be_true
-          end
-        end
-        
-        context "in an ExampleGroup using an explicit subject" do
-          it "delegates matcher to the declared subject" do
-            @example_group.describe(::Thing)
-            @example_group.subject { ::Thing.new(:other) }
-            @example_group.example { should_not == ::Thing.new(:default) }
-            @example_group.example { should_not eql(::Thing.new(:default)) }
-            @example_group.run(@options).should be_true
-          end
-        end
-		
-        context "in an ExampleGroup using 'self' as an explicit subject" do
-          it "delegates matcher to the ExampleGroup" do
-            @example_group.describe(::Thing)
-            @example_group.subject { self }
-            @example_group.example { should_not == ::Thing.new(:default) }
-            @example_group.example { should_not eql(::Thing.new(:default)) }
-            @example_group.example do
-              self.instance_eval("def method_ok?; false end")
-              should_not be_method_ok
-            end
-            @example_group.run(@options).should be_true
-          end
-        end
-      end
-    end
-
-    describe "#options" do
-      it "should expose the options hash" do
-        example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end
-        example.options[:this].should == 'that'
-      end
-    end
-    
-    describe "#set_instance_variables_from_hash" do
-      it "preserves the options" do
-        example = ExampleGroupDouble.new ExampleProxy.new("name", :this => 'that') do; end
-        example.set_instance_variables_from_hash({:@_options => {}})
-        example.options[:this].should == 'that'
-      end
-    end
-    
-    describe "#description" do
-      it "returns the supplied description" do
-        example = ExampleGroupDouble.new ExampleProxy.new("name") do; end
-        example.description.should == "name"
-      end
-      it "returns the generated description if there is no description supplied" do
-        example = ExampleGroupDouble.new ExampleProxy.new do; end
-        Spec::Matchers.stub!(:generated_description).and_return('this message')
-        example.description.should == "this message"
-      end
-      it "warns if there is no supplied or generated description" do
-        example = ExampleGroupDouble.new ExampleProxy.new(nil, {}, "this backtrace") do; end
-        Spec::Matchers.stub!(:generated_description).and_return(nil)
-        Spec.should_receive(:warn).with("No description supplied for example declared on this backtrace")
-        example.description
-      end
-    end
-    
-    describe "#expect" do
-      it "aliases #should with #to on the proc" do
-        a = 3
-        expect { a += 1 }.to change{a}.from(3).to(4)
-      end
-
-      it "aliases #should_not with #to_not on the proc" do
-        a = 3
-        expect { nil }.to_not change{a}
-      end
-    end
-
-  end
-end

data/vendor/rspec/spec/spec/example/example_proxy_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-
-    describe ExampleProxy do
-
-      describe "#description" do
-        it "provides the submitted description" do
-          proxy = ExampleProxy.new("the description")
-          proxy.description.should   == "the description"
-        end
-      end
-      
-      describe "#update" do
-        it "updates the description" do
-          proxy = ExampleProxy.new("old description")
-          proxy.update("new description")
-          proxy.description.should == "new description"
-        end
-      end
-
-      describe "#options" do
-        it "provides the submitted options" do
-          proxy = ExampleProxy.new(:ignore, {:these => :options})
-          proxy.options.should           == {:these => :options}
-        end
-      end
-
-      describe "#backtrace (DEPRECATED - use #location)" do
-        before(:each) do
-          Spec.stub!(:deprecate)
-        end
-        
-        it "is deprecated" do
-          Spec.should_receive(:deprecate)
-          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
-          proxy.backtrace
-        end
-        
-        it "provides the location of the declaration of this group" do
-          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
-          proxy.backtrace.should             == "path/to/location:37"
-        end
-      end
-      
-      describe "#location" do
-        it "provides the location of the declaration of this group" do
-          proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37")
-          proxy.location.should              == "path/to/location:37"
-        end
-      end
-      
-    end
-
-  end
-end

data/vendor/rspec/spec/spec/example/helper_method_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-# This was added to prove that http://rspec.lighthouseapp.com/projects/5645/tickets/211
-# was fixed in ruby 1.9.1
-
-module HelperMethodExample
-  describe "a helper method" do
-    def helper_method
-      "received call"
-    end
-  
-    it "is available to examples in the same group" do
-      helper_method.should == "received call"
-    end
-    
-    describe "from a nested group" do
-      it "is available to examples in a nested group" do
-        helper_method.should == "received call"
-      end
-    end
-    
-  end
-end
-

data/vendor/rspec/spec/spec/example/nested_example_group_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-    describe 'Nested Example Groups' do
-      parent = self
-      
-      def count
-        @count ||= 0
-        @count = @count + 1
-        @count
-      end
-
-      before(:all) do
-        count.should == 1
-      end
-
-      before(:all) do
-        count.should == 2
-      end
-
-      before(:each) do
-        count.should == 3
-      end
-
-      before(:each) do
-        count.should == 4
-      end
-
-      it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do
-        count.should == 5
-      end
-
-      after(:each) do
-        count.should == 7
-      end
-
-      after(:each) do
-        count.should == 6
-      end
-
-      after(:all) do
-        count.should == 9
-      end
-
-      after(:all) do
-        count.should == 8
-      end
-
-      describe 'nested example group' do
-        self.superclass.should == parent
-        
-        it "should run all before and after callbacks" do
-          count.should == 5
-        end
-      end
-    end
-
-    describe "Nested Example Groups" do
-      describe "description options", :other_options => "other options" do
-        it "includes :location" do
-          self.class.options[:location].should match(/#{__FILE__}/)
-        end
-
-        it "includes any other options" do
-          self.class.options[:other_options].should == "other options"
-        end
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/example/pending_module_spec.rb

@@ -1,58 +0,0 @@
-module Spec
-  module Example
-    describe Pending do
-      
-      context "when no block is supplied" do
-        it "raises an ExamplePendingError if no block is supplied" do
-          lambda {
-            pending "TODO"
-          }.should raise_error(ExamplePendingError, /TODO/)
-        end
-      end
-      
-      context "when the supplied block fails" do
-        it "raises an ExamplePendingError if a supplied block fails as expected" do
-          lambda {
-            pending "TODO" do
-              raise "oops"
-            end
-          }.should raise_error(ExamplePendingError, /TODO/)
-        end
-      end
-      
-      context "when the supplied block fails with a mock" do
-        it "raises an ExamplePendingError if a supplied block fails as expected with a mock" do
-          lambda {
-            pending "TODO" do
-              m = mock("thing")
-              m.should_receive(:foo)
-              m.rspec_verify
-            end
-          }.should raise_error(ExamplePendingError, /TODO/)
-        end
-      end
-      
-      context "when the supplied block passes" do
-        it "raises a PendingExampleFixedError" do
-          lambda {
-            pending "TODO" do
-              # success!
-            end
-          }.should raise_error(PendingExampleFixedError, /TODO/)
-        end
-      end
-    end
-    
-    describe ExamplePendingError do
-      it "should have the message provided" do
-        ExamplePendingError.new("a message").message.should == "a message"
-      end
-    end
-    
-    describe NotYetImplementedError do
-      it "should have the message 'Not Yet Implemented'" do
-        NotYetImplementedError.new.message.should == "Not Yet Implemented"
-      end
-    end
-  end
-end

data/vendor/rspec/spec/spec/example/predicate_matcher_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-    class Fish
-      def can_swim?(distance_in_yards)
-        distance_in_yards < 1000
-      end
-    end
-    
-    describe "predicate_matcher[method_on_object] = matcher_method" do
-      before(:each) do
-        Spec.stub!(:deprecate)
-      end
-      
-      it "is deprecated" do
-        Spec.should_receive(:deprecate)
-        group = ExampleGroupDouble.describe("foo") do
-          predicate_matchers[:swim] = :can_swim?
-        end
-        group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new))
-      end
-
-      it "should match matcher_method if method_on_object returns true" do
-        group = ExampleGroupDouble.describe(Fish) do
-          predicate_matchers[:swim] = :can_swim?
-          it { should swim(100) }
-        end
-        group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new))
-      end
-
-      it "should not match matcher_method if method_on_object returns false" do
-        group = ExampleGroupDouble.describe(Fish) do
-          predicate_matchers[:swim] = :can_swim?
-          it { should_not swim(1000) }
-        end
-        group.run(Spec::Runner::Options.new(StringIO.new, StringIO.new))
-      end
-    end
-  end
-end