pictrails 0.5.0

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

@@ -0,0 +1,69 @@
+module Spec
+  module Example
+    describe Pending do
+      
+      it 'should raise an ExamplePendingError if no block is supplied' do
+        lambda {
+          include Pending
+          pending "TODO"
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            raise "oops"
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected with a mock' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            m = mock('thing')
+            m.should_receive(:foo)
+            m.rspec_verify
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise a PendingExampleFixedError if a supplied block starts working' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            # success!
+          end
+        }.should raise_error(PendingExampleFixedError, /TODO/)
+      end
+    end
+    
+    describe ExamplePendingError do
+      it "should have the caller (from two calls from initialization)" do
+        two_calls_ago = caller[0]
+        ExamplePendingError.new("a message").pending_caller.should == two_calls_ago
+      end
+      
+      it "should keep the trace information from initialization" do
+        two_calls_ago = caller[0]
+        obj = ExamplePendingError.new("a message")
+        obj.pending_caller
+        def another_caller(obj)
+          obj.pending_caller
+        end
+        
+        another_caller(obj).should == two_calls_ago
+      end
+      
+      it "should have the message provided" do
+        ExamplePendingError.new("a message").message.should == "a message"
+      end
+
+      it "should use a 'ExamplePendingError' as it's default message" do
+        ExamplePendingError.new.message.should == "Spec::Example::ExamplePendingError"
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../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
+      predicate_matchers[:swim] = :can_swim?
+      it "should match matcher_method if method_on_object returns true" do
+        swim(100).matches?(Fish.new).should be_true
+      end
+      it "should not match matcher_method if method_on_object returns false" do
+        swim(10000).matches?(Fish.new).should be_false
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/example/shared_example_group_spec.rb

@@ -0,0 +1,265 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe ExampleGroup, "with :shared => true" do
+      include SandboxedOptions
+      attr_reader :formatter, :example_group
+      before(:each) do
+        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
+        options.formatters << formatter
+        @example_group = Class.new(ExampleGroup).describe("example_group")
+        class << example_group
+          public :include
+        end
+      end
+
+      after(:each) do
+        @formatter.rspec_verify
+        @example_group = nil
+        $shared_example_groups.clear unless $shared_example_groups.nil?
+      end
+
+      def make_shared_example_group(name, opts=nil, &block)
+        example_group = SharedExampleGroup.new(name, :shared => true, &block)
+        SharedExampleGroup.add_shared_example_group(example_group)
+        example_group
+      end
+
+      def non_shared_example_group()
+        @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
+      end
+
+      it "should accept an optional options hash" do
+        lambda { Class.new(ExampleGroup).describe("context") }.should_not raise_error(Exception)
+        lambda { Class.new(ExampleGroup).describe("context", :shared => true) }.should_not raise_error(Exception)
+      end
+
+      it "should return all shared example_groups" do
+        b1 = make_shared_example_group("b1", :shared => true) {}
+        b2 = make_shared_example_group("b2", :shared => true) {}
+
+        b1.should_not be(nil)
+        b2.should_not be(nil)
+
+        SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
+        SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
+      end
+
+      it "should register as shared example_group" do
+        example_group = make_shared_example_group("example_group") {}
+        SharedExampleGroup.shared_example_groups.should include(example_group)
+      end
+
+      it "should not be shared when not configured as shared" do
+        example_group = non_shared_example_group
+        SharedExampleGroup.shared_example_groups.should_not include(example_group)
+      end
+
+      it "should complain when adding a second shared example_group with the same description" do
+        describe "shared example_group", :shared => true do
+        end
+        lambda do
+          describe "shared example_group", :shared => true do
+          end
+        end.should raise_error(ArgumentError)
+      end
+
+      it "should NOT complain when adding the same shared example_group instance again" do
+        shared_example_group = Class.new(ExampleGroup).describe("shared example_group", :shared => true)
+        SharedExampleGroup.add_shared_example_group(shared_example_group)
+        SharedExampleGroup.add_shared_example_group(shared_example_group)
+      end
+
+      it "should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
+        lambda do
+          2.times do
+            describe "shared example_group which gets loaded twice", :shared => true do
+            end
+          end
+        end.should_not raise_error(ArgumentError)
+      end
+
+      it "should NOT complain when adding the same shared example_group in same file with different absolute path" do
+        shared_example_group_1 = Class.new(ExampleGroup).describe(
+          "shared example_group",
+          :shared => true,
+          :spec_path => "/my/spec/a/../shared.rb"
+        )
+        shared_example_group_2 = Class.new(ExampleGroup).describe(
+          "shared example_group",
+          :shared => true,
+          :spec_path => "/my/spec/b/../shared.rb"
+        )
+
+        SharedExampleGroup.add_shared_example_group(shared_example_group_1)
+        SharedExampleGroup.add_shared_example_group(shared_example_group_2)
+      end
+
+      it "should complain when adding a different shared example_group with the same name in a different file with the same basename" do
+        shared_example_group_1 = Class.new(ExampleGroup).describe(
+          "shared example_group",
+          :shared => true,
+          :spec_path => "/my/spec/a/shared.rb"
+        )
+        shared_example_group_2 = Class.new(ExampleGroup).describe(
+          "shared example_group",
+          :shared => true,
+          :spec_path => "/my/spec/b/shared.rb"
+        )
+
+        SharedExampleGroup.add_shared_example_group(shared_example_group_1)
+        lambda do
+          SharedExampleGroup.add_shared_example_group(shared_example_group_2)
+        end.should raise_error(ArgumentError, /already exists/)
+      end
+
+      it "should add examples to current example_group using it_should_behave_like" do
+        shared_example_group = make_shared_example_group("shared example_group") do
+          it("shared example") {}
+          it("shared example 2") {}
+        end
+
+        example_group.it("example") {}
+        example_group.number_of_examples.should == 1
+        example_group.it_should_behave_like("shared example_group")
+        example_group.number_of_examples.should == 3
+      end
+
+      it "should add examples to current example_group using include" do
+        shared_example_group = describe "all things", :shared => true do
+          it "should do stuff" do end
+        end
+        
+        example_group = describe "one thing" do
+          include shared_example_group
+        end
+        
+        example_group.number_of_examples.should == 1
+      end
+
+      it "should add examples to current example_group using it_should_behave_like with a module" do
+        AllThings = describe "all things", :shared => true do
+          it "should do stuff" do end
+        end
+        
+        example_group = describe "one thing" do
+          it_should_behave_like AllThings
+        end
+        
+        example_group.number_of_examples.should == 1
+      end
+
+      it "should run shared examples" do
+        shared_example_ran = false
+        shared_example_group = make_shared_example_group("shared example_group") do
+          it("shared example") { shared_example_ran = true }
+        end
+
+        example_ran = false
+
+        example_group.it_should_behave_like("shared example_group")
+        example_group.it("example") {example_ran = true}
+        example_group.run
+        example_ran.should be_true
+        shared_example_ran.should be_true
+      end
+
+      it "should run setup and teardown from shared example_group" do
+        shared_setup_ran = false
+        shared_teardown_ran = false
+        shared_example_group = make_shared_example_group("shared example_group") do
+          before { shared_setup_ran = true }
+          after { shared_teardown_ran = true }
+          it("shared example") { shared_example_ran = true }
+        end
+
+        example_ran = false
+
+        example_group.it_should_behave_like("shared example_group")
+        example_group.it("example") {example_ran = true}
+        example_group.run
+        example_ran.should be_true
+        shared_setup_ran.should be_true
+        shared_teardown_ran.should be_true
+      end
+
+      it "should run before(:all) and after(:all) only once from shared example_group" do
+        shared_before_all_run_count = 0
+        shared_after_all_run_count = 0
+        shared_example_group = make_shared_example_group("shared example_group") do
+          before(:all) { shared_before_all_run_count += 1}
+          after(:all) { shared_after_all_run_count += 1}
+          it("shared example") { shared_example_ran = true }
+        end
+
+        example_ran = false
+
+        example_group.it_should_behave_like("shared example_group")
+        example_group.it("example") {example_ran = true}
+        example_group.run
+        example_ran.should be_true
+        shared_before_all_run_count.should == 1
+        shared_after_all_run_count.should == 1
+      end
+
+      it "should include modules, included into shared example_group, into current example_group" do
+        @formatter.should_receive(:add_example_group).with(any_args)
+
+        shared_example_group = make_shared_example_group("shared example_group") do
+          it("shared example") { shared_example_ran = true }
+        end
+
+        mod1_method_called = false
+        mod1 = Module.new do
+          define_method :mod1_method do
+            mod1_method_called = true
+          end
+        end
+
+        mod2_method_called = false
+        mod2 = Module.new do
+          define_method :mod2_method do
+            mod2_method_called = true
+          end
+        end
+
+        shared_example_group.include mod2
+
+        example_group.it_should_behave_like("shared example_group")
+        example_group.include mod1
+
+        example_group.it("test") do
+          mod1_method
+          mod2_method
+        end
+        example_group.run
+        mod1_method_called.should be_true
+        mod2_method_called.should be_true
+      end
+
+      it "should make methods defined in the shared example_group available in consuming example_group" do
+        shared_example_group = make_shared_example_group("shared example_group xyz") do
+          def a_shared_helper_method
+            "this got defined in a shared example_group"
+          end
+        end
+        example_group.it_should_behave_like("shared example_group xyz")
+        success = false
+        example_group.it("should access a_shared_helper_method") do
+          a_shared_helper_method
+          success = true
+        end
+        example_group.run
+        success.should be_true
+      end
+
+      it "should raise when named shared example_group can not be found" do
+        lambda {
+          example_group.it_should_behave_like("non-existent shared example group")
+          violated
+        }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/example/subclassing_example_group_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    class GrandParentExampleGroup < Spec::Example::ExampleGroup
+      describe "Grandparent ExampleGroup"
+    end
+
+    class ParentExampleGroup < GrandParentExampleGroup
+      describe "Parent ExampleGroup"
+      it "should bar" do
+      end
+    end
+
+    class ChildExampleGroup < ParentExampleGroup
+      describe "Child ExampleGroup"
+      it "should bam" do
+      end
+    end
+
+    describe ChildExampleGroup do
+
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/expectations/differs/default_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/../../../spec_helper.rb'
+
+module Spec
+  module Fixtures
+    class Animal
+      def initialize(name,species)
+        @name,@species = name,species
+      end
+
+      def inspect
+        <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+        EOA
+      end
+    end
+  end
+end
+
+describe "Diff" do
+  before(:each) do
+    @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+    @differ = Spec::Expectations::Differs::Default.new(@options)
+  end
+
+  it "should output unified diff of two strings" do
+    expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+    actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+    expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+    diff = @differ.diff_as_string(expected, actual)
+    diff.should eql(expected_diff)
+  end
+
+  it "should output unified diff message of two arrays" do
+    expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+    actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+    expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+
+  it "should output unified diff message of two objects" do
+    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+
+end
+
+
+describe "Diff in context format" do
+  before(:each) do
+    @options = Spec::Runner::Options.new(StringIO.new, StringIO.new)
+    @options.diff_format = :context
+    @differ = Spec::Expectations::Differs::Default.new(@options)
+  end
+
+  it "should output unified diff message of two objects" do
+    expected = Spec::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Spec::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+***************
+*** 1,5 ****
+  <Animal
+    name=bob,
+!   species=tortoise
+  >
+--- 1,5 ----
+  <Animal
+    name=bob,
+!   species=giraffe
+  >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+end