media-path 0.1.2 → 0.1.3

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

@@ -1,29 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,85 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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"
-