deckshuffler 0.0.2

data/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/render_template.rb

@@ -0,0 +1,66 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected, controller)
+          @controller = controller
+          @expected = expected
+        end
+      
+        def matches?(response)
+          @actual = response.rendered_file
+          full_path(@actual) == full_path(@expected)
+        end
+
+        def failure_message
+          "expected #{@expected.inspect}, got #{@actual.inspect}"
+        end
+        
+        def description
+          "render template #{@expected.inspect}"
+        end
+      
+        private
+          def full_path(path)
+            return nil if path.nil?
+            path.include?('/') ? path : "#{@controller.class.to_s.underscore.gsub('_controller','')}/#{path}"
+          end
+        
+      end
+
+      # :call-seq:
+      #   response.should render_template(path)
+      #   response.should_not render_template(path)
+      #
+      # Passes if the specified template is rendered by the response.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # <code>path</code> can include the controller path or not. It
+      # can also include an optional extension (no extension assumes .rhtml).
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Examples
+      #
+      #   response.should render_template('list')
+      #   response.should render_template('same_controller/list')
+      #   response.should render_template('other_controller/list')
+      #
+      #   #rjs
+      #   response.should render_template('list.rjs')
+      #   response.should render_template('same_controller/list.rjs')
+      #   response.should render_template('other_controller/list.rjs')
+      #
+      #   #partials
+      #   response.should render_template('_a_partial')
+      #   response.should render_template('same_controller/_a_partial')
+      #   response.should render_template('other_controller/_a_partial')
+      def render_template(path)
+        RenderTemplate.new(path.to_s, @controller)
+      end
+
+    end
+  end
+end

data/vendor/plugins/rspec_on_rails/lib/spec/rails/story_adapter.rb

@@ -0,0 +1,47 @@
+# WARNING - THIS IS PURELY EXPERIMENTAL AT THIS POINT
+# Courtesy of Brian Takita and Yurii Rashkovskii
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec lib])
+require 'test_help'
+require 'test/unit/testresult'
+require 'spec'
+
+Test::Unit.run = true
+
+class RailsStory < ActionController::IntegrationTest
+  self.use_transactional_fixtures = true
+  include Spec::Rails::Matchers
+
+  def initialize #:nodoc:
+    @_result = Test::Unit::TestResult.new
+  end
+end
+
+class ActiveRecordSafetyListener
+  include Singleton
+  def scenario_started(*args)
+    ActiveRecord::Base.send :increment_open_transactions unless Rails::VERSION::STRING == "1.1.6"
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+  def scenario_succeeded(*args)
+    ActiveRecord::Base.connection.rollback_db_transaction
+    ActiveRecord::Base.send :decrement_open_transactions unless Rails::VERSION::STRING == "1.1.6"
+  end
+  alias :scenario_pending :scenario_succeeded
+  alias :scenario_failed :scenario_succeeded
+end
+
+class Spec::Story::Runner::ScenarioRunner
+  def initialize
+    @listeners = [ActiveRecordSafetyListener.instance]
+  end
+end
+
+class Spec::Story::GivenScenario
+  def perform(instance)
+    scenario = Spec::Story::Runner::StoryRunner.scenario_from_current_story @name
+    runner = Spec::Story::Runner::ScenarioRunner.new
+    runner.instance_variable_set(:@listeners,[])
+    runner.run(scenario, instance)
+  end
+end

data/vendor/plugins/rspec_on_rails/lib/spec/rails/version.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Rails
+    module VERSION #:nodoc:
+      unless defined?(REV)
+        # RANDOM_TOKEN: 0.66158247219848
+        REV = "$LastChangedRevision: 2717 $".match(/LastChangedRevision: (\d+)/)[1]
+      end
+    end
+  end
+end
+
+# Verifies that the plugin has the same revision as RSpec
+if Spec::VERSION::REV != Spec::Rails::VERSION::REV
+  raise <<-EOF
+
+############################################################################
+Your RSpec on Rails plugin is incompatible with your installed RSpec.
+
+RSpec          : #{Spec::VERSION::FULL_VERSION}
+RSpec on Rails : r#{Spec::Rails::VERSION::REV}
+
+Make sure your RSpec on Rails plugin is compatible with your RSpec gem.
+See http://rspec.rubyforge.org/documentation/rails/install.html for details.
+############################################################################
+EOF
+end

data/vendor/plugins/rspec_on_rails/spec/rails/autotest/mappings_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "autotest", "rails_rspec")
+
+describe Autotest::RailsRspec, "file mapping" do
+  before(:each) do
+    @autotest = Autotest::RailsRspec.new
+    @autotest.output = StringIO.new
+    @autotest.files.clear
+    @autotest.last_mtime = Time.at(0)
+  end
+  
+  def ensure_mapping(examples, impl)
+    @autotest.files[@impl] = Time.at(0)
+    examples.each do |example|
+      @autotest.files[example] = Time.at(0)
+    end
+    @autotest.tests_for_file(impl).should == examples
+  end
+  
+  it "should map model example to model" do
+    ensure_mapping(['spec/models/thing_spec.rb'], 'app/models/thing.rb')
+  end
+  
+  it "should map controller example to controller" do
+    ensure_mapping(['spec/controllers/things_controller_spec.rb'], 'app/controllers/things_controller.rb')
+  end
+  
+  it "should map view.rhtml" do
+    ensure_mapping(['spec/views/things/index.rhtml_spec.rb'], 'app/views/things/index.rhtml')
+  end
+  
+  it "should map view.rhtml with underscores in example filename" do
+    ensure_mapping(['spec/views/things/index_rhtml_spec.rb'], 'app/views/things/index.rhtml')
+  end
+  
+  it "should map view.html.erb" do
+    ensure_mapping(['spec/views/things/index.html.erb_spec.rb'], 'app/views/things/index.html.erb')
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/autotest/rails_rspec_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "autotest", "rails_rspec")
+
+describe Autotest::RailsRspec do
+  it "should provide the correct spec_command" do
+    Autotest::RailsRspec.new.spec_command.should == "script/spec"
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/dsl/assigns_hash_proxy_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "An AssignsHashProxy" do
+  before(:each) do
+    @object = Object.new
+    @assigns = Hash.new
+    @object.stub!(:assigns).and_return(@assigns)
+    @proxy = Spec::Rails::DSL::AssignsHashProxy.new(@object)
+  end
+
+  it "has [] accessor" do
+    @proxy['foo'] = 'bar'
+    @assigns['foo'].should == 'bar'
+    @proxy['foo'].should == 'bar'
+  end
+
+  it "checks for string key before symbol key" do
+    @assigns[:foo] = 2
+    @proxy[:foo].should == 2
+  end
+
+  it "checks for string key before symbol key" do
+    @assigns['foo'] = false
+    @assigns[:foo] = 2
+    @proxy[:foo].should == false
+  end
+
+  it "each method iterates through each element like a Hash" do
+    values = {
+      'foo' => 1,
+      'bar' => 2,
+      'baz' => 3
+    }
+    @proxy['foo'] = values['foo']
+    @proxy['bar'] = values['bar']
+    @proxy['baz'] = values['baz']
+
+    @proxy.each do |key, value|
+      key.should == key
+      value.should == values[key]
+    end
+  end
+
+  it "delete method deletes the element of passed in key" do
+    @proxy['foo'] = 'bar'
+    @proxy.delete('foo').should == 'bar'
+    @proxy['foo'].should be_nil
+  end
+
+  it "has_key? detects the presence of a key" do
+    @proxy['foo'] = 'bar'
+    @proxy.has_key?('foo').should == true
+    @proxy.has_key?('bar').should == false
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/dsl/behaviour_factory_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "the BehaviourFactory" do
+  it "should return a ModelExample when given :behaviour_type => :model" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :model)
+    behaviour.superclass.should == Spec::Rails::DSL::ModelExample
+  end
+
+  it "should return a ModelExample when given :spec_path => '/blah/spec/models/'" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ModelExample
+  end
+
+  it "should return a ModelExample when given :spec_path => '\\blah\\spec\\models\\' (windows format)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '\\blah\\spec\\models\\blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ModelExample
+  end
+
+  it "should return a RailsExample when given :spec_path => '/blah/spec/foo/' (anything other than controllers, views and helpers)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/foo/blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::RailsExample
+  end
+
+  it "should return a RailsExample when given :spec_path => '\\blah\\spec\\foo\\' (windows format)  (anything other than controllers, views and helpers)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '\\blah\\spec\\foo\\blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::RailsExample
+  end
+
+  it "should return a ViewExample when given :behaviour_type => :model" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :view)
+    behaviour.superclass.should == Spec::Rails::DSL::ViewExample
+  end
+
+  it "should return a ViewExample when given :spec_path => '/blah/spec/views/'" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/views/blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ViewExample
+  end
+
+  it "should return a ModelExample when given :spec_path => '\\blah\\spec\\views\\' (windows format)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '\\blah\\spec\\views\\blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ViewExample
+  end
+
+  it "should return a HelperExample when given :behaviour_type => :helper" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :helper)
+    behaviour.superclass.should == Spec::Rails::DSL::HelperExample
+  end
+
+  it "should return a HelperExample when given :spec_path => '/blah/spec/helpers/'" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/helpers/blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::HelperExample
+  end
+
+  it "should return a ModelExample when given :spec_path => '\\blah\\spec\\helpers\\' (windows format)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '\\blah\\spec\\helpers\\blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::HelperExample
+  end
+
+  it "should return a ControllerExample when given :behaviour_type => :controller" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :behaviour_type => :controller)
+    behaviour.superclass.should == Spec::Rails::DSL::ControllerExample
+  end
+
+  it "should return a ControllerExample when given :spec_path => '/blah/spec/controllers/'" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/controllers/blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ControllerExample
+  end
+
+  it "should return a ModelExample when given :spec_path => '\\blah\\spec\\controllers\\' (windows format)" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '\\blah\\spec\\controllers\\blah.rb')
+    behaviour.superclass.should == Spec::Rails::DSL::ControllerExample
+  end
+
+  it "should favor the :behaviour_type over the :spec_path" do
+    behaviour = Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :controller)
+    behaviour.superclass.should == Spec::Rails::DSL::ControllerExample
+  end
+
+  it "should create a Spec::DSL::Example if :shared => true" do
+    Spec::DSL::BehaviourFactory.create("name", :spec_path => '/blah/spec/models/blah.rb', :behaviour_type => :controller, :shared => true) {
+    }.should be_an_instance_of(Spec::DSL::SharedBehaviour)
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/dsl/configuration_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module DSL
+    describe Configuration do
+      before(:each) { @config = Configuration.new }
+      
+      it "should default use_transactional_fixtures to true" do
+        @config.use_transactional_fixtures.should be(true)
+      end
+
+      it "should let you set use_transactional_fixtures false" do
+        @config.use_transactional_fixtures = false
+        @config.use_transactional_fixtures.should be(false)
+      end
+
+      it "should let you set use_transactional_fixtures true" do
+        @config.use_transactional_fixtures = true
+        @config.use_transactional_fixtures.should be(true)
+      end
+
+      it "should default use_instantiated_fixtures to false" do
+        @config.use_instantiated_fixtures.should be(false)
+      end
+
+      it "should let you set use_instantiated_fixtures false" do
+        @config.use_instantiated_fixtures = false
+        @config.use_instantiated_fixtures.should be(false)
+      end
+
+      it "should let you set use_instantiated_fixtures true" do
+        @config.use_instantiated_fixtures = true
+        @config.use_instantiated_fixtures.should be(true)
+      end
+
+      it "should default fixture_path to RAILS_ROOT + '/spec/fixtures'" do
+        @config.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
+      end
+
+      it "should let you set fixture_path false" do
+        @config.fixture_path = "/new/path"
+        @config.fixture_path.should == "/new/path"
+      end
+
+      it "should default global_fixtures to []" do
+        @config.global_fixtures.should == []
+      end
+
+      it "should let you set global_fixtures false" do
+        @config.global_fixtures << :blah
+        @config.global_fixtures.should == [:blah]
+      end
+
+    end
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/dsl/controller_isolation_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'controller_spec_controller'
+
+describe "a controller spec running in isolation mode", :behaviour_type => :controller do
+  controller_name :controller_spec
+
+  it "should not care if the template doesn't exist" do
+    get 'some_action'
+    response.should be_success
+    response.should render_template("template/that/does/not/actually/exist")
+  end
+
+  it "should not care if the template has errors" do
+    get 'action_with_errors_in_template'
+    response.should be_success
+    response.should render_template("action_with_errors_in_template")
+  end
+end
+
+describe "a controller spec running in integration mode", :behaviour_type => :controller do
+  controller_name :controller_spec
+  integrate_views
+  
+  before(:each) do
+    controller.class.send(:define_method, :rescue_action) { |e| raise e }
+  end
+
+  it "should render a template" do
+    get 'action_with_template'
+    response.should be_success
+    response.should have_tag('div', 'This is action_with_template.rhtml')
+  end
+
+  it "should choke if the template doesn't exist" do
+    lambda { get 'some_action' }.should raise_error(ActionController::MissingTemplate)
+    response.should_not be_success
+  end
+
+  it "should choke if the template has errors" do
+    lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
+    response.should_not be_success
+  end
+end

data/vendor/plugins/rspec_on_rails/spec/rails/dsl/controller_spec_spec.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'controller_spec_controller'
+
+['integration', 'isolation'].each do |mode|
+  describe "A controller example running in #{mode} mode", :behaviour_type => :controller do
+    controller_name :controller_spec
+    integrate_views if mode == 'integration'
+  
+    it "should provide controller.session as session" do
+      get 'action_with_template'
+      session.should equal(controller.session)
+    end
+  
+    it "should provide the same session object before and after the action" do
+      session_before = session
+      get 'action_with_template'
+      session.should equal(session_before)
+    end
+  
+    it "should ensure controller.session is NOT nil before the action" do
+      controller.session.should_not be_nil
+      get 'action_with_template'
+    end
+    
+    it "should ensure controller.session is NOT nil after the action" do
+      get 'action_with_template'
+      controller.session.should_not be_nil
+    end
+    
+    it "should allow specifying a partial with partial name only" do
+      get 'action_with_partial'
+      response.should render_template("_partial")
+    end
+    
+    it "should allow specifying a partial with expect_render" do
+      controller.expect_render(:partial => "controller_spec/partial")
+      get 'action_with_partial'
+    end
+    
+    it "should allow specifying a partial with expect_render with object" do
+      controller.expect_render(:partial => "controller_spec/partial", :object => "something")
+      get 'action_with_partial_with_object', :thing => "something"
+    end
+    
+    it "should allow specifying a partial with expect_render with locals" do
+      controller.expect_render(:partial => "controller_spec/partial", :locals => {:thing => "something"})
+      get 'action_with_partial_with_locals', :thing => "something"
+    end
+    
+    it "should allow a path relative to RAILS_ROOT/app/views/ when specifying a partial" do
+      get 'action_with_partial'
+      response.should render_template("controller_spec/_partial")
+    end
+    
+    it "should provide access to flash" do
+      get 'action_with_template'
+      flash[:flash_key].should == "flash value"
+    end
+    
+    it "should provide access to flash values set after a session reset" do
+      get 'action_setting_flash_after_session_reset'
+      flash[:after_reset].should == "available"
+    end
+    
+    it "should not provide access to flash values set before a session reset" do
+      get 'action_setting_flash_before_session_reset'
+      flash[:before_reset].should_not == "available"
+    end
+
+    it "should provide access to session" do
+      get 'action_with_template'
+      session[:session_key].should == "session value"
+    end
+
+    it "should support custom routes" do
+      route_for(:controller => "custom_route_spec", :action => "custom_route").should == "/custom_route"
+    end
+
+    it "should support existing routes" do
+      route_for(:controller => "controller_spec", :action => "some_action").should == "/controller_spec/some_action"
+    end
+
+    it "should generate params for custom routes" do
+      params_from(:get, '/custom_route').should == {:controller => "custom_route_spec", :action => "custom_route"}
+    end
+    
+    it "should generate params for existing routes" do
+      params_from(:get, '/controller_spec/some_action').should == {:controller => "controller_spec", :action => "some_action"}
+    end
+    
+    it "should expose the assigns hash directly" do
+      get 'action_setting_the_assigns_hash'
+      assigns[:direct_assigns_key].should == :direct_assigns_key_value
+    end
+    
+    it "should complain when calling should_receive(:render) on the controller" do
+      lambda {
+        controller.should_receive(:render)
+      }.should raise_error(RuntimeError, /should_receive\(:render\) has been disabled/)
+    end
+
+    it "should complain when calling stub!(:render) on the controller" do
+      lambda {
+        controller.stub!(:render)
+      }.should raise_error(RuntimeError, /stub!\(:render\) has been disabled/)
+    end
+    
+    it "should NOT complain when calling should_receive with arguments other than :render" do
+      controller.should_receive(:anything_besides_render)
+      lambda {
+        controller.rspec_verify
+      }.should raise_error(Exception, /expected :anything_besides_render/)
+    end
+  end
+
+  describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :behaviour_type => :controller do
+    controller_name :redirect_spec
+    integrate_views if mode == 'integration'
+
+    it "a redirect should ignore the absence of a template" do
+      get 'action_with_redirect_to_somewhere'
+      response.should be_redirect
+      response.redirect_url.should == "http://test.host/redirect_spec/somewhere"
+      response.should redirect_to("http://test.host/redirect_spec/somewhere")
+    end
+    
+    it "a call to response.should redirect_to should fail if no redirect" do
+      get 'action_with_no_redirect'
+      lambda {
+        response.redirect?.should be_true
+      }.should fail
+      lambda {
+        response.should redirect_to("http://test.host/redirect_spec/somewhere")
+      }.should fail_with("expected redirect to \"http://test.host/redirect_spec/somewhere\", got no redirect")
+    end
+  end
+  
+  describe "Given a controller spec running in #{mode} mode", :behaviour_type => :controller do
+    integrate_views if mode == 'integration'
+    it "a spec in a context without controller_name set should fail with a useful warning",
+      :should_raise => [
+        Spec::Expectations::ExpectationNotMetError,
+        /You have to declare the controller name in controller specs/
+      ] do
+    end
+  end
+  
+end
+
+describe ControllerSpecController, :behaviour_type => :controller do
+  it "should not require naming the controller if describe is passed a type" do
+  end
+end
+
+module Spec
+  module Rails
+    module DSL
+      describe ControllerExample do
+        it "should tell you its behaviour_type is :controller" do
+          behaviour = Class.new(ControllerExample).describe("")
+          behaviour.behaviour_type.should == :controller
+        end
+      end
+    end
+  end
+end