deckshuffler 0.0.2

data/vendor/plugins/rspec/failing_examples/mocking_example.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Mocker" do
+
+  it "should be able to call mock()" do
+    mock = mock("poke me")
+    mock.should_receive(:poke)
+    mock.poke
+  end
+
+  it "should fail when expected message not received" do
+    mock = mock("poke me")
+    mock.should_receive(:poke)
+  end
+  
+  it "should fail when messages are received out of order" do
+    mock = mock("one two three")
+    mock.should_receive(:one).ordered
+    mock.should_receive(:two).ordered
+    mock.should_receive(:three).ordered
+    mock.one
+    mock.three
+    mock.two
+  end
+
+  it "should get yelled at when sending unexpected messages" do
+    mock = mock("don't talk to me")
+    mock.should_not_receive(:any_message_at_all)
+    mock.any_message_at_all
+  end
+
+  it "has a bug we need to fix" do
+    pending "here is the bug" do
+      # Actually, no. It's fixed. This will fail because it passes :-)
+      mock = mock("Bug")
+      mock.should_receive(:hello)
+      mock.hello
+    end
+  end
+end

data/vendor/plugins/rspec/failing_examples/mocking_with_flexmock.rb

@@ -0,0 +1,26 @@
+# stub frameworks like to gum up Object, so this is deliberately
+# set NOT to run so that you don't accidentally run it when you
+# run this dir.
+
+# To run it, stand in this directory and say:
+#
+#   RUN_FLEXMOCK_EXAMPLE=true ruby ../bin/spec mocking_with_flexmock.rb
+
+if ENV['RUN_FLEXMOCK_EXAMPLE']
+  Spec::Runner.configure do |config|
+    config.mock_with :flexmock
+  end
+
+  describe "Flexmocks" do
+    it "should fail when the expected message is received with wrong arguments" do
+      m = flexmock("now flex!")
+      m.should_receive(:msg).with("arg").once
+      m.msg("other arg")
+    end
+
+    it "should fail when the expected message is not received at all" do
+      m = flexmock("now flex!")
+      m.should_receive(:msg).with("arg").once
+    end
+  end
+end

data/vendor/plugins/rspec/failing_examples/mocking_with_mocha.rb

@@ -0,0 +1,25 @@
+# stub frameworks like to gum up Object, so this is deliberately
+# set NOT to run so that you don't accidentally run it when you
+# run this dir.
+
+# To run it, stand in this directory and say:
+#
+#   RUN_MOCHA_EXAMPLE=true ruby ../bin/spec mocking_with_mocha.rb
+
+if ENV['RUN_MOCHA_EXAMPLE']
+  Spec::Runner.configure do |config|
+    config.mock_with :mocha
+  end
+  describe "Mocha framework" do
+    it "should should be made available by saying config.mock_with :mocha" do
+      m = mock()
+      m.expects(:msg).with("arg")
+      m.msg
+    end
+    it "should should be made available by saying config.mock_with :mocha" do
+      o = Object.new
+      o.expects(:msg).with("arg")
+      o.msg
+    end
+  end
+end

data/vendor/plugins/rspec/failing_examples/mocking_with_rr.rb

@@ -0,0 +1,27 @@
+# stub frameworks like to gum up Object, so this is deliberately
+# set NOT to run so that you don't accidentally run it when you
+# run this dir.
+
+# To run it, stand in this directory and say:
+#
+#   RUN_RR_EXAMPLE=true ruby ../bin/spec mocking_with_rr.rb
+
+if ENV['RUN_RR_EXAMPLE']
+  Spec::Runner.configure do |config|
+    config.mock_with :rr
+  end
+  describe "RR framework" do
+    it "should should be made available by saying config.mock_with :rr" do
+      o = Object.new
+      mock(o).msg("arg")
+      o.msg
+    end
+    it "should should be made available by saying config.mock_with :rr" do
+      o = Object.new
+      mock(o) do |m|
+        m.msg("arg")
+      end
+      o.msg
+    end
+  end
+end

data/vendor/plugins/rspec/failing_examples/partial_mock_example.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MockableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+describe "A partial mock" do
+
+  it "should work at the class level (but fail here due to the type mismatch)" do
+    MockableClass.should_receive(:find).with(1).and_return {:stub_return}
+    MockableClass.find("1").should equal(:stub_return)
+  end
+
+  it "should revert to the original after each spec" do
+    MockableClass.find(1).should equal(:original_return)
+  end
+
+end

data/vendor/plugins/rspec/failing_examples/predicate_example.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class BddFramework
+  def intuitive?
+    true
+  end
+
+  def adopted_quickly?
+    #this will cause failures because it reallly SHOULD be adopted quickly
+    false
+  end
+end
+
+describe "BDD framework" do
+
+  before(:each) do
+    @bdd_framework = BddFramework.new
+  end
+
+  it "should be adopted quickly" do
+    #this will fail because it reallly SHOULD be adopted quickly
+    @bdd_framework.should be_adopted_quickly
+  end
+
+  it "should be intuitive" do
+    @bdd_framework.should be_intuitive
+  end
+
+end

data/vendor/plugins/rspec/failing_examples/raising_example.rb

@@ -0,0 +1,47 @@
+describe "This example" do
+  
+  it "should show that a NoMethodError is raised but an Exception was expected" do
+    proc { ''.nonexistent_method }.should raise_error
+  end
+  
+  it "should pass" do
+    proc { ''.nonexistent_method }.should raise_error(NoMethodError)
+  end
+  
+  it "should show that a NoMethodError is raised but a SyntaxError was expected" do
+    proc { ''.nonexistent_method }.should raise_error(SyntaxError)
+  end
+  
+  it "should show that nothing is raised when SyntaxError was expected" do
+    proc { }.should raise_error(SyntaxError)
+  end
+
+  it "should show that a NoMethodError is raised but a Exception was expected" do
+    proc { ''.nonexistent_method }.should_not raise_error
+  end
+  
+  it "should show that a NoMethodError is raised" do
+    proc { ''.nonexistent_method }.should_not raise_error(NoMethodError)
+  end
+  
+  it "should also pass" do
+    proc { ''.nonexistent_method }.should_not raise_error(SyntaxError)
+  end
+  
+  it "should show that a NoMethodError is raised when nothing expected" do
+    proc { ''.nonexistent_method }.should_not raise_error(Exception)
+  end
+  
+  it "should show that the wrong message was received" do
+    proc { raise StandardError.new("what is an enterprise?") }.should raise_error(StandardError, "not this")
+  end
+  
+  it "should show that the unexpected error/message was thrown" do
+    proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "abc")
+  end
+  
+  it "should pass too" do
+    proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "xyz")
+  end
+  
+end

data/vendor/plugins/rspec/failing_examples/spec_helper.rb

@@ -0,0 +1,3 @@
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+require "spec"

data/vendor/plugins/rspec/failing_examples/syntax_error_example.rb

@@ -0,0 +1,7 @@
+describe "when passing a block to a matcher" do
+  it "you should use {} instead of do/end" do
+    Object.new.should satisfy do
+      "this block is being passed to #should instead of #satisfy - use {} instead"
+    end
+  end
+end

data/vendor/plugins/rspec/failing_examples/team_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+class Team
+  attr_reader :players
+  def initialize
+    @players = Players.new
+  end
+end
+
+class Players
+  def initialize
+    @players = []
+  end
+  def size
+    @players.size
+  end
+  def include? player
+    raise "player must be a string" unless player.is_a?(String)
+    @players.include? player
+  end
+end
+
+describe "A new team" do
+  
+  before(:each) do
+    @team = Team.new
+  end
+  
+  it "should have 3 players (failing example)" do
+    @team.should have(3).players
+  end
+  
+  it "should include some player (failing example)" do
+    @team.players.should include("Some Player")
+  end
+
+  it "should include 5 (failing example)" do
+    @team.players.should include(5)
+  end
+  
+  it "should have no players"
+  
+end

data/vendor/plugins/rspec/failing_examples/timeout_behaviour.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Something really slow" do
+  it "should be failed by RSpec when it takes longer than --timeout" do
+    sleep(2)
+  end
+end

data/vendor/plugins/rspec/init.rb

@@ -0,0 +1,3 @@
+if ENV['RAILS_ENV'] == 'test'
+  require 'spec'
+end

data/vendor/plugins/rspec/lib/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rspec" if File.exist?('spec')
+end

data/vendor/plugins/rspec/lib/autotest/rspec.rb

@@ -0,0 +1,94 @@
+require 'autotest'
+
+class RspecCommandError < StandardError; end
+
+class Autotest::Rspec < Autotest
+  
+  def initialize(kernel=Kernel, separator=File::SEPARATOR, alt_separator=File::ALT_SEPARATOR) # :nodoc:
+    super()
+    @kernel, @separator, @alt_separator = kernel, separator, alt_separator
+    @spec_command = spec_command
+
+    # watch out: Ruby bug (1.8.6):
+    # %r(/) != /\//
+    # since Ruby compares the REGEXP source, not the resulting pattern
+    @test_mappings = {
+      %r%^spec/.*\.rb$% => kernel.proc { |filename, _| 
+        filename 
+      },
+      %r%^lib/(.*)\.rb$% => kernel.proc { |_, m| 
+        ["spec/#{m[1]}_spec.rb"] 
+      },
+      %r%^spec/(spec_helper|shared/.*)\.rb$% => kernel.proc { 
+        files_matching %r%^spec/.*_spec\.rb$% 
+      }
+    }
+  end
+  
+  def tests_for_file(filename)
+    super.select { |f| @files.has_key? f }
+  end
+  
+  alias :specs_for_file :tests_for_file
+  
+  def failed_results(results)
+    results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m)
+  end
+
+  def handle_results(results)
+    @files_to_test = consolidate_failures failed_results(results)
+    unless @files_to_test.empty? then
+      hook :red
+    else
+      hook :green
+    end unless $TESTING
+    @tainted = true unless @files_to_test.empty?
+  end
+
+  def consolidate_failures(failed)
+    filters = Hash.new { |h,k| h[k] = [] }
+    failed.each do |spec, failed_trace|
+      @files.keys.select{|f| f =~ /spec\//}.each do |f|
+        if failed_trace =~ Regexp.new(f)
+          filters[f] << spec
+          break
+        end
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return "#{ruby} -S #{@spec_command} #{add_options_if_present} #{files_to_test.keys.flatten.join(' ')}"
+  end
+  
+  def add_options_if_present
+    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+  end
+
+  # Finds the proper spec command to use.  Precendence
+  # is set in the lazily-evaluated method spec_commands.  Alias + Override
+  # that in ~/.autotest to provide a different spec command
+  # then the default paths provided.
+  def spec_command
+    spec_commands.each do |command|
+      if File.exists?(command)
+        return @alt_separator ? (command.gsub @separator, @alt_separator) : command
+      end
+    end
+    raise RspecCommandError, "No spec command could be found!"
+  end
+  
+  # Autotest will look for spec commands in the following
+  # locations, in this order:
+  #
+  #   * bin/spec
+  #   * default spec bin/loader installed in Rubygems
+  def spec_commands
+    [
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec')),
+      File.join(Config::CONFIG['bindir'], 'spec')
+    ]
+  end
+
+end

data/vendor/plugins/rspec/lib/spec.rb

@@ -0,0 +1,12 @@
+require 'spec/version'
+require 'spec/matchers'
+require 'spec/expectations'
+require 'spec/translator'
+require 'spec/dsl'
+require 'spec/extensions'
+require 'spec/runner'
+require 'spec/story'
+require 'spec/test' if Object.const_defined?(:Test)
+at_exit do
+  unless $! || rspec_options.examples_run?; exit rspec_options.run_examples; end
+end

data/vendor/plugins/rspec/lib/spec/dsl.rb

@@ -0,0 +1,16 @@
+require 'timeout'
+require 'forwardable'
+require 'spec/dsl/pending'
+require 'spec/dsl/behaviour'
+require 'spec/dsl/behaviour_description'
+require 'spec/dsl/shared_behaviour'
+require 'spec/dsl/example_module'
+require 'spec/dsl/example'
+require 'spec/dsl/behaviour_factory'
+require 'spec/dsl/errors'
+require 'spec/dsl/configuration'
+require 'spec/dsl/example_suite'
+require 'spec/dsl/example_definition'
+require 'spec/dsl/example_runner'
+require 'spec/dsl/example_matcher'
+require 'spec/dsl/should_raise_handler'

data/vendor/plugins/rspec/lib/spec/dsl/behaviour.rb

@@ -0,0 +1,183 @@
+module Spec
+  module DSL
+    # See http://rspec.rubyforge.org/documentation/before_and_after.html
+    module Behaviour
+      attr_accessor :description
+
+      def describe(*args, &behaviour_block)
+        set_description(*args)
+        before_eval
+        module_eval(&behaviour_block) if behaviour_block
+        self
+      end
+
+      # Use this to pull in example_definitions from shared behaviours.
+      # See Spec::Runner for information about shared behaviours.
+      def it_should_behave_like(behaviour_description)
+        behaviour = SharedBehaviour.find_shared_behaviour(behaviour_description)
+        unless behaviour
+          raise RuntimeError.new("Shared Example '#{behaviour_description}' can not be found")
+        end
+        include(behaviour)
+      end
+
+      # :call-seq:
+      #   predicate_matchers[matcher_name] = method_on_object
+      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
+      #
+      # Dynamically generates a custom matcher that will match
+      # a predicate on your class. RSpec provides a couple of these
+      # out of the box:
+      #
+      #   exist (or state expectations)
+      #     File.should exist("path/to/file")
+      #
+      #   an_instance_of (for mock argument constraints)
+      #     mock.should_receive(:message).with(an_instance_of(String))
+      #
+      # == Examples
+      #
+      #   class Fish
+      #     def can_swim?
+      #       true
+      #     end
+      #   end
+      #
+      #   describe Fish do
+      #     predicate_matchers[:swim] = :can_swim?
+      #     it "should swim" do
+      #       Fish.new.should swim
+      #     end
+      #   end
+      def predicate_matchers
+        @predicate_matchers ||= {:exist => :exist?, :an_instance_of => :is_a?}
+      end
+
+      # Creates an instance of Spec::DSL::ExampleDefinition and adds
+      # it to a collection of example_definitions of the current behaviour.
+      def it(description=:__generate_description, opts={}, &block)
+        example_definitions << create_example_definition(description, opts, &block)
+      end
+      
+      alias_method :specify, :it
+      
+      # Use this to temporarily disable an example.
+      def xit(description=:__generate_description, opts={}, &block)
+        Kernel.warn("Example disabled: #{description}")
+      end
+
+      def behaviour_type #:nodoc:
+        description[:behaviour_type]
+      end
+
+      def described_type
+        description.described_type
+      end
+
+      def example_definitions
+        @example_definitions ||= []
+      end
+
+      def number_of_examples
+        example_definitions.length
+      end
+
+      def create_example_definition(description, options={}, &block)
+        ExampleDefinition.new(description, options, &block)
+      end
+
+      def prepend_before(*args, &block)
+        scope, options = scope_and_options(*args)
+        add(scope, options, :before, :unshift, &block)
+      end
+      def append_before(*args, &block)
+        scope, options = scope_and_options(*args)
+        add(scope, options, :before, :<<, &block)
+      end
+      alias_method :before, :append_before
+
+      def prepend_after(*args, &block)
+        scope, options = scope_and_options(*args)
+        add(scope, options, :after, :unshift, &block)
+      end
+      alias_method :after, :prepend_after
+      def append_after(*args, &block)
+        scope, options = scope_and_options(*args)
+        add(scope, options, :after, :<<, &block)
+      end
+
+      def scope_and_options(*args)
+        args, options = args_and_options(*args)
+        scope = (args[0] || :each), options
+      end
+
+      def add(scope, options, where, how, &block)
+        scope ||= :each
+        options ||= {}
+        behaviour_type = options[:behaviour_type]
+        case scope
+          when :each; self.__send__("#{where}_each_parts", behaviour_type).__send__(how, block)
+          when :all;  self.__send__("#{where}_all_parts", behaviour_type).__send__(how, block)
+        end
+      end
+
+      def remove_after(scope, &block)
+        after_each_parts.delete(block)
+      end
+
+      # Deprecated. Use before(:each)
+      def setup(&block)
+        before(:each, &block)
+      end
+
+      # Deprecated. Use after(:each)
+      def teardown(&block)
+        after(:each, &block)
+      end
+
+      def before_all_parts(behaviour_type=nil) # :nodoc:
+        @before_all_parts ||= {}
+        @before_all_parts[behaviour_type] ||= []
+      end
+
+      def after_all_parts(behaviour_type=nil) # :nodoc:
+        @after_all_parts ||= {}
+        @after_all_parts[behaviour_type] ||= []
+      end
+
+      def before_each_parts(behaviour_type=nil) # :nodoc:
+        @before_each_parts ||= {}
+        @before_each_parts[behaviour_type] ||= []
+      end
+
+      def after_each_parts(behaviour_type=nil) # :nodoc:
+        @after_each_parts ||= {}
+        @after_each_parts[behaviour_type] ||= []
+      end
+
+      def clear_before_and_after! # :nodoc:
+        @before_all_parts = nil
+        @after_all_parts = nil
+        @before_each_parts = nil
+        @after_each_parts = nil
+      end
+      
+      protected
+
+      def before_eval
+      end
+
+      def set_description(*args)
+        unless self.class == Example
+          args << {} unless Hash === args.last
+          args.last[:behaviour_class] = self
+        end
+        self.description = BehaviourDescription.new(*args)
+        if described_type.class == Module
+          include described_type
+        end
+        self.description
+      end
+    end
+  end
+end