deckshuffler 0.0.2

data/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/ivar_proxy.rb

@@ -0,0 +1,62 @@
+##
+# A wrapper that allows instance variables to be manipulated using +[]+ and
+# +[]=+
+
+module Spec
+  module Rails
+    module DSL
+      class IvarProxy #:nodoc:
+
+        ##
+        # Wraps +object+ allowing its instance variables to be manipulated.
+
+        def initialize(object)
+          @object = object
+        end
+
+        ##
+        # Retrieves +ivar+ from the wrapped object.
+
+        def [](ivar)
+          get_variable "@#{ivar}"
+        end
+
+        ##
+        # Sets +ivar+ to +val+ on the wrapped object.
+
+        def []=(ivar, val)
+          set_variable "@#{ivar}", val
+        end
+
+        def each
+          @object.instance_variables.each do |variable_full_name|
+            variable_name = variable_full_name[1...variable_full_name.length]
+            yield variable_name, get_variable(variable_full_name)
+          end
+        end
+
+        def delete(key)
+          var_name = "@#{key}"
+          if @object.instance_variables.include?(var_name)
+            @object.send(:remove_instance_variable, var_name)
+          else
+            return nil
+          end
+        end
+
+        def has_key?(key)
+          @object.instance_variables.include?("@#{key}")
+        end
+
+        protected
+        def get_variable(name)
+          @object.instance_variable_get name
+        end
+
+        def set_variable(name, value)
+          @object.instance_variable_set name, value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/extensions/object")
+require File.expand_path("#{dir}/extensions/active_record/base")
+require File.expand_path("#{dir}/extensions/action_controller/base")
+require File.expand_path("#{dir}/extensions/action_controller/rescue")
+require File.expand_path("#{dir}/extensions/action_controller/test_response")
+require File.expand_path("#{dir}/extensions/action_view/base")

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/base.rb

@@ -0,0 +1,11 @@
+module ActionController
+  class Base
+    class << self
+      def set_view_path(path)
+        method = respond_to?(:view_paths=) ? :view_paths= : :template_root=
+        send(method, path)
+      end
+    end
+  end
+end
+        

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/rescue.rb

@@ -0,0 +1,21 @@
+module ActionController
+  module Rescue
+    def use_rails_error_handling!
+      @use_rails_error_handling = true
+    end
+
+    def use_rails_error_handling?
+      @use_rails_error_handling ||= false
+    end
+
+    protected
+    def rescue_action_with_fast_errors(exception)
+      if use_rails_error_handling?
+        rescue_action_without_fast_errors exception
+      else
+        raise exception
+      end
+    end
+    alias_method_chain :rescue_action, :fast_errors
+  end
+end

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/test_response.rb

@@ -0,0 +1,11 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+
+    def capture(name)
+      template.instance_variable_get "@content_for_#{name.to_s}"
+    end
+    alias [] capture
+
+  end
+end

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_view/base.rb

@@ -0,0 +1,27 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    include Spec::Rails::DSL::RenderObserver
+    cattr_accessor :base_view_path
+    def render_partial(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+      if partial_path.is_a?(String)
+        unless partial_path.include?("/")
+          unless self.class.base_view_path.nil?
+            partial_path = "#{self.class.base_view_path}/#{partial_path}"
+          end
+        end
+      end
+      super(partial_path, local_assigns, deprecated_local_assigns)
+    end
+
+    alias_method :orig_render, :render
+    def render(options = {}, old_local_assigns = {}, &block)
+      if expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
+        expect_render_mock_proxy.render(options)
+      else
+        unless expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
+          orig_render(options, old_local_assigns, &block)
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/base.rb

@@ -0,0 +1,29 @@
+module ActiveRecord #:nodoc:
+  class Base
+
+    (class << self; self; end).class_eval do
+      # Extension for <tt>should have</tt> on AR Model classes
+      #
+      #   ModelClass.should have(:no).records
+      #   ModelClass.should have(1).record
+      #   ModelClass.should have(n).records
+      def records
+        find(:all)
+      end
+      alias :record :records
+    end
+
+    # Extension for <tt>should have</tt> on AR Model instances
+    #
+    #   model.should have(:no).errors_on(:attribute)
+    #   model.should have(1).error_on(:attribute)
+    #   model.should have(n).errors_on(:attribute)
+    def errors_on(attribute)
+      self.valid?
+      [self.errors.on(attribute)].flatten.compact
+    end
+    alias :error_on :errors_on
+
+  end
+end
+

data/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/object.rb

@@ -0,0 +1,5 @@
+class Object # :nodoc:
+  def self.path2class(klassname)
+    klassname.split('::').inject(Object) { |k,n| k.const_get n }
+  end
+end

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

@@ -0,0 +1,29 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/matchers/assert_select")
+require File.expand_path("#{dir}/matchers/have_text")
+require File.expand_path("#{dir}/matchers/redirect_to")
+require File.expand_path("#{dir}/matchers/render_template")
+
+module Spec
+  module Rails
+    # Spec::Rails::Expectations::Matchers provides several expectation matchers
+    # intended to work with Rails components like models and responses. For example:
+    #
+    #   response.should redirect_to("some/url") #redirect_to(url) is the matcher.
+    #
+    # In addition to those you see below, the arbitrary predicate feature of RSpec
+    # makes the following available as well:
+    #
+    #   response.should be_success #passes if response.success?
+    #   response.should be_redirect #passes if response.redirect?
+    #
+    # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
+    # the documentation comes straight from that with some slight modifications.
+    # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
+    # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
+    #
+    # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
+    module Matchers
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+
+      class AssertSelect #:nodoc:
+
+        def initialize(assertion, spec_scope, *args, &block)
+          @assertion = assertion
+          @spec_scope = spec_scope
+          @args = args
+          @block = block
+        end
+        
+        def matches?(response_or_text, &block)
+          if ActionController::TestResponse === response_or_text and
+                   response_or_text.headers.key?('Content-Type') and
+                   response_or_text.headers['Content-Type'].to_sym == :xml
+            @args.unshift(HTML::Document.new(response_or_text.body, false, true).root)           
+          elsif String === response_or_text
+            @args.unshift(HTML::Document.new(response_or_text).root)
+          end
+          @block = block if block
+          begin
+            @spec_scope.send(@assertion, *@args, &@block)
+          rescue ::Test::Unit::AssertionFailedError => @error
+          end
+          
+          @error.nil?
+        end
+
+        def failure_message; @error.message; end
+        def negative_failure_message; "should not #{description}, but did"; end
+
+        def description
+          {
+            :assert_select => "have tag#{format_args(*@args)}",
+            :assert_select_email => "send email#{format_args(*@args)}",
+          }[@assertion]
+        end
+
+      private
+
+        def format_args(*args)
+          return "" if args.empty?
+          return "(#{arg_list(*args)})"
+        end
+
+        def arg_list(*args)
+          args.collect do |arg|
+            arg.respond_to?(:description) ? arg.description : arg.inspect
+          end.join(", ")
+        end
+        
+      end
+      
+      # :call-seq:
+      #   response.should have_tag(*args, &block)
+      #   string.should have_tag(*args, &block)
+      #
+      # wrapper for assert_select with additional support for using
+      # css selectors to set expectation on Strings. Use this in
+      # helper specs, for example, to set expectations on the results
+      # of helper methods.
+      #
+      # == Examples
+      #
+      #   # in a controller spec
+      #   response.should have_tag("div", "some text")
+      #
+      #   # in a helper spec (person_address_tag is a method in the helper)
+      #   person_address_tag.should have_tag("input#person_address")
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def have_tag(*args, &block)
+        AssertSelect.new(:assert_select, self, *args, &block)
+      end
+    
+      # wrapper for a nested assert_select
+      #
+      #   response.should have_tag("div#form") do
+      #     with_tag("input#person_name[name=?]", "person[name]")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def with_tag(*args, &block)
+        should have_tag(*args, &block)
+      end
+    
+      # wrapper for a nested assert_select with false
+      #
+      #   response.should have_tag("div#1") do
+      #     without_tag("span", "some text that shouldn't be there")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def without_tag(*args, &block)
+        should_not have_tag(*args, &block)
+      end
+    
+      # :call-seq:
+      #   response.should have_rjs(*args, &block)
+      #
+      # wrapper for assert_select_rjs
+      #
+      # see documentation for assert_select_rjs at http://api.rubyonrails.org/
+      def have_rjs(*args, &block)
+        AssertSelect.new(:assert_select_rjs, self, *args, &block)
+      end
+      
+      # :call-seq:
+      #   response.should send_email(*args, &block)
+      #
+      # wrapper for assert_select_email
+      #
+      # see documentation for assert_select_email at http://api.rubyonrails.org/
+      def send_email(*args, &block)
+        AssertSelect.new(:assert_select_email, self, *args, &block)
+      end
+      
+      # wrapper for assert_select_encoded
+      #
+      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+      def with_encoded(*args, &block)
+        should AssertSelect.new(:assert_select_encoded, self, *args, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class HaveText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response)
+          @actual = response.body
+          return actual =~ expected if Regexp === expected
+          return actual == expected unless Regexp === expected
+        end
+      
+        def failure_message
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def negative_failure_message
+          "expected not to have text #{expected.inspect}"
+        end
+        
+        def to_s
+          "have text #{expected.inspect}"
+        end
+      
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   response.should have_text(expected)
+      #   response.should_not have_text(expected)
+      #
+      # Accepts a String or a Regexp, matching a String using ==
+      # and a Regexp using =~.
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class RedirectTo  #:nodoc:
+
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response)
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+          if @expected.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash
+          else
+            return @actual == expected_url
+          end
+        end
+
+        def actual_hash
+          hash_from_url @actual
+        end
+
+        def expected_hash
+          hash_from_url expected_url
+        end
+
+        def actual_redirect_to_valid_route
+          actual_hash
+        end
+
+        def hash_from_url(url)
+          query_hash(url).merge(path_hash(url)).with_indifferent_access
+        end
+
+        def path_hash(url)
+          path = url.sub(%r{^\w+://#{@request.host}}, "").split("?", 2)[0]
+          path = path.split("/")[1..-1] if ::Rails::VERSION::MINOR < 2
+          ActionController::Routing::Routes.recognize_path path
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          QueryParameterParser.parse_query_parameters(query, @request)
+        end
+
+       def expected_url
+          case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+          end
+        end
+
+        def failure_message
+          if @redirected
+            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+
+        def negative_failure_message
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+        end
+
+        def description
+          "redirect to #{@actual.inspect}"
+        end
+
+        class QueryParameterParser
+          def self.parse_query_parameters(query, request)
+            if defined?(CGIMethods)
+              CGIMethods.parse_query_parameters(query)
+            else
+              request.class.parse_query_parameters(query)
+            end
+          end
+        end
+      end
+
+      # :call-seq:
+      #   response.should redirect_to(url)
+      #   response.should redirect_to(:action => action_name)
+      #   response.should redirect_to(:controller => controller_name, :action => action_name)
+      #   response.should_not redirect_to(url)
+      #   response.should_not redirect_to(:action => action_name)
+      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+      #
+      # Passes if the response is a redirect to the url, action or controller/action.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # == Examples
+      #
+      #   response.should redirect_to("path/to/action")
+      #   response.should redirect_to("http://test.host/path/to/action")
+      #   response.should redirect_to(:action => 'list')
+      def redirect_to(opts)
+        RedirectTo.new(request, opts)
+      end
+    end
+
+  end
+end