remarkable_rails 3.1.8 → 3.1.9

data/lib/remarkable_rails/action_controller/matchers/render_template_matcher.rb

@@ -1,149 +1,149 @@
-require File.join(File.dirname(__FILE__), 'respond_with_matcher') 
-
-module Remarkable
-  module ActionController
-    module Matchers
-      class RenderTemplateMatcher < RespondWithMatcher #:nodoc:
-        prepend_optional :template, :layout
-
-        assertions :rendered?, :template_matches?, :layout_matches?
-
-        protected
-
-          def rendered?
-            return true unless @options.key?(:template)
-
-            @actual = if @response.respond_to?(:rendered_file)
-              @response.rendered_file
-            elsif @response.respond_to?(:rendered)
-              case template = @response.rendered[:template]
-                when nil
-                  unless @response.rendered[:partials].empty?
-                    path_and_file(@response.rendered[:partials].keys.first).join("/_")
-                  end
-                when ::ActionView::Template
-                  template.path
-                when ::String
-                  template
-              end
-            else
-              @response.rendered_template.to_s
-            end
-
-            !@actual.blank?
-          end
-
-          def template_matches?
-            return true unless @options[:template] # only continue if not nil
-
-            actual_controller_path, actual_file     = path_and_file(@actual.to_s)
-            expected_controller_path, expected_file = path_and_file(@options[:template].to_s)
-
-            # Test if each given slice matches. Actual always return the full
-            # file name (new.html.erb), on the other hand, the user might supply
-            # only new. If the user supply all three pieces, we check if they
-            # are equal, in the given order.
-            #
-            actual_file = actual_file.split('.')
-            expected_file.split('.').each_with_index do |slice, i|
-              return false unless slice == actual_file[i] || actual_file[i].nil?
-            end
-
-            actual_controller_path == expected_controller_path 
-          end
-
-          def layout_matches?
-            return true unless @options.key?(:layout)
-            @response.layout.to_s.split('/').last.to_s == @options[:layout].to_s
-          end
-
-          def path_and_file(path)
-            parts = path.split('/')
-            file = parts.pop
-            controller = parts.empty? ? @controller.controller_path : parts.join('/')
-            return controller, file
-          end
-
-          def interpolation_options
-            if @response
-              super.merge!(:actual_layout => @response.layout.inspect, :actual_template => @actual.inspect)
-            else
-              super.merge!(:actual_template => @actual.inspect)
-            end
-          end
-
-      end
-
-      # Passes if the specified template (view file) is rendered by the
-      # response. This file can be any view file, including a partial.
-      #
-      # <code>template</code> can include the controller path. It can also
-      # include an optional extension, which you only need to use when there
-      # is ambiguity.
-      #
-      # Note that partials must be spelled with the preceding underscore.
-      #
-      # == Options
-      #
-      # * <tt>:layout</tt> - The layout used when rendering the template.
-      #
-      # All other options in <tt>respond_with</tt> are also available.
-      #
-      # == Examples
-      #
-      #   should_render_template 'list'
-      #   should_render_template 'same_controller/list'
-      #   should_render_template 'other_controller/list'
-      #
-      # # with extensions
-      #   should_render_template 'list.rjs'
-      #   should_render_template 'list.haml'
-      #   should_render_template 'same_controller/list.rjs'
-      #   should_render_template 'other_controller/list.rjs'
-      #
-      # # partials
-      #   should_render_template '_a_partial'
-      #   should_render_template 'same_controller/_a_partial'
-      #   should_render_template 'other_controller/_a_partial'
-      #
-      # # with options
-      #   should_render_template 'list', :layout => 'users'
-      #   should_render_template 'list', :content_type => :xml
-      #   should_render_template 'list', :content_type => /xml/
-      #   should_render_template 'list', :content_type => Mime::XML
-      #
-      #   it { should render_template('list').layout('users') }
-      #   it { should render_template('list').content_type(:xml) }
-      #   it { should render_template('list').content_type(/xml/) }
-      #   it { should render_template('list').content_type(Mime::XML) }
-      #
-      # == Gotcha
-      #
-      # Extensions check does not work in Rails 2.1.x.
-      #
-      def render_template(*args, &block)
+require File.join(File.dirname(__FILE__), 'respond_with_matcher') 
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class RenderTemplateMatcher < RespondWithMatcher #:nodoc:
+        prepend_optional :template, :layout
+
+        assertions :rendered?, :template_matches?, :layout_matches?
+
+        protected
+
+          def rendered?
+            return true unless @options.key?(:template)
+
+            @actual = if @response.respond_to?(:rendered_file)
+              @response.rendered_file
+            elsif @response.respond_to?(:rendered)
+              case template = @response.rendered[:template]
+                when nil
+                  unless @response.rendered[:partials].empty?
+                    path_and_file(@response.rendered[:partials].keys.first).join("/_")
+                  end
+                when ::ActionView::Template
+                  template.path
+                when ::String
+                  template
+              end
+            else
+              @response.rendered_template.to_s
+            end
+
+            !@actual.blank?
+          end
+
+          def template_matches?
+            return true unless @options[:template] # only continue if not nil
+
+            actual_controller_path, actual_file     = path_and_file(@actual.to_s)
+            expected_controller_path, expected_file = path_and_file(@options[:template].to_s)
+
+            # Test if each given slice matches. Actual always return the full
+            # file name (new.html.erb), on the other hand, the user might supply
+            # only new. If the user supply all three pieces, we check if they
+            # are equal, in the given order.
+            #
+            actual_file = actual_file.split('.')
+            expected_file.split('.').each_with_index do |slice, i|
+              return false unless slice == actual_file[i] || actual_file[i].nil?
+            end
+
+            actual_controller_path == expected_controller_path 
+          end
+
+          def layout_matches?
+            return true unless @options.key?(:layout)
+            @response.layout.to_s.split('/').last.to_s == @options[:layout].to_s
+          end
+
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? @controller.controller_path : parts.join('/')
+            return controller, file
+          end
+
+          def interpolation_options
+            if @response
+              super.merge!(:actual_layout => @response.layout.inspect, :actual_template => @actual.inspect)
+            else
+              super.merge!(:actual_template => @actual.inspect)
+            end
+          end
+
+      end
+
+      # Passes if the specified template (view file) is rendered by the
+      # response. This file can be any view file, including a partial.
+      #
+      # <code>template</code> can include the controller path. It can also
+      # include an optional extension, which you only need to use when there
+      # is ambiguity.
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Options
+      #
+      # * <tt>:layout</tt> - The layout used when rendering the template.
+      #
+      # All other options in <tt>respond_with</tt> are also available.
+      #
+      # == Examples
+      #
+      #   should_render_template 'list'
+      #   should_render_template 'same_controller/list'
+      #   should_render_template 'other_controller/list'
+      #
+      # # with extensions
+      #   should_render_template 'list.rjs'
+      #   should_render_template 'list.haml'
+      #   should_render_template 'same_controller/list.rjs'
+      #   should_render_template 'other_controller/list.rjs'
+      #
+      # # partials
+      #   should_render_template '_a_partial'
+      #   should_render_template 'same_controller/_a_partial'
+      #   should_render_template 'other_controller/_a_partial'
+      #
+      # # with options
+      #   should_render_template 'list', :layout => 'users'
+      #   should_render_template 'list', :content_type => :xml
+      #   should_render_template 'list', :content_type => /xml/
+      #   should_render_template 'list', :content_type => Mime::XML
+      #
+      #   it { should render_template('list').layout('users') }
+      #   it { should render_template('list').content_type(:xml) }
+      #   it { should render_template('list').content_type(/xml/) }
+      #   it { should render_template('list').content_type(Mime::XML) }
+      #
+      # == Gotcha
+      #
+      # Extensions check does not work in Rails 2.1.x.
+      #
+      def render_template(*args, &block)
         options = args.extract_options!
-        options.merge!(:template => args.first)
-        RenderTemplateMatcher.new(options, &block).spec(self)
-      end
-
-      # This is just a shortcut for render_template :layout => layout. It's also
-      # used for Shoulda compatibility. Check render_template for more information.
-      #
-      def render_with_layout(*args, &block)
+        options.merge!(:template => args.first)
+        RenderTemplateMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for render_template :layout => layout. It's also
+      # used for Shoulda compatibility. Check render_template for more information.
+      #
+      def render_with_layout(*args, &block)
         options = args.extract_options!
-        options.merge!(:layout => args.first)
-        RenderTemplateMatcher.new(options, &block).spec(self)
-      end
-
-      # This is just a shortcut for render_template :layout => nil. It's also
-      # used for Shoulda compatibility. Check render_template for more information.
-      #
+        options.merge!(:layout => args.first)
+        RenderTemplateMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for render_template :layout => nil. It's also
+      # used for Shoulda compatibility. Check render_template for more information.
+      #
       def render_without_layout(options={}, &block)
-        options.merge!(:layout => nil)
-        RenderTemplateMatcher.new(options, &block).spec(self)
-      end
-
-    end
-  end
-end
+        options.merge!(:layout => nil)
+        RenderTemplateMatcher.new(options, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb

@@ -1,136 +1,136 @@
-module Remarkable
-  module ActionController
-    module Matchers
-      class RespondWithMatcher < Remarkable::ActionController::Base #:nodoc:
-        arguments :block => true
-
-        optional :with, :body, :content_type
-
-        before_assert do
-          @response   = @subject.respond_to?(:response) ? @subject.response : @subject
-          @controller = @spec.instance_variable_get('@controller')
-        end
-
-        before_assert :evaluate_content_type, :evaluate_body
-
-        assertions :status_matches?, :body_matches?, :content_type_matches?
-
-        protected
-
-          def status_matches?
-            return true unless @options[:with] # only continue if not nil
-
-            case @options[:with]
-              when :success, :missing, :redirect, :error
-                @response.send("#{@options[:with]}?")
-              when Fixnum
-                @response.response_code == @options[:with]
-              when Symbol, String
-                @response.response_code == ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@options[:with].to_sym]
-              when Range
-                @options[:with].include?(@response.response_code)
-              else
-                raise ArgumentError, "I don't know how to interpret status #{@options[:with].inspect}, " <<
-                                      "please give me a Fixnum, Symbol, String or Range."
-            end
-          end
-
-          def body_matches?
-            return true unless @options.key?(:body)
-            assert_contains(@response.body, @options[:body])
-          end
-
-          def content_type_matches?
-            return true unless @options.key?(:content_type)
-            assert_contains(@response.content_type, @options[:content_type])
-          end
-
-          def evaluate_content_type
-            return unless @options.key?(:content_type)
-
-            @options[:content_type] = case @options[:content_type]
-              when Symbol
-                Mime::Type.lookup_by_extension(@options[:content_type].to_s).to_s
-              when Regexp
-                @options[:content_type]
-              else
-                @options[:content_type].to_s
-            end
+module Remarkable
+  module ActionController
+    module Matchers
+      class RespondWithMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :block => true
+
+        optional :with, :body, :content_type
+
+        before_assert do
+          @response   = @subject.respond_to?(:response) ? @subject.response : @subject
+          @controller = @spec.instance_variable_get('@controller')
+        end
+
+        before_assert :evaluate_content_type, :evaluate_body
+
+        assertions :status_matches?, :body_matches?, :content_type_matches?
+
+        protected
+
+          def status_matches?
+            return true unless @options[:with] # only continue if not nil
+
+            case @options[:with]
+              when :success, :missing, :redirect, :error
+                @response.send("#{@options[:with]}?")
+              when Fixnum
+                @response.response_code == @options[:with]
+              when Symbol, String
+                @response.response_code == ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@options[:with].to_sym]
+              when Range
+                @options[:with].include?(@response.response_code)
+              else
+                raise ArgumentError, "I don't know how to interpret status #{@options[:with].inspect}, " <<
+                                      "please give me a Fixnum, Symbol, String or Range."
+            end
+          end
+
+          def body_matches?
+            return true unless @options.key?(:body)
+            assert_contains(@response.body, @options[:body])
+          end
+
+          def content_type_matches?
+            return true unless @options.key?(:content_type)
+            assert_contains(@response.content_type, @options[:content_type])
+          end
+
+          def evaluate_content_type
+            return unless @options.key?(:content_type)
+
+            @options[:content_type] = case @options[:content_type]
+              when Symbol
+                Mime::Type.lookup_by_extension(@options[:content_type].to_s).to_s
+              when Regexp
+                @options[:content_type]
+              else
+                @options[:content_type].to_s
+            end
           end
 
           def evaluate_body
-            if @options.key?(:body) || @block
-              value = @options.key?(:body) ? @options[:body] : @block
-              value = @spec.instance_eval(&value) if value.is_a?(Proc)
-              @options[:body] = value
+            if @options.key?(:body) || @block
+              value = @options.key?(:body) ? @options[:body] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:body] = value
+            end
+          end
+
+          def interpolation_options
+            if @response
+              { :actual_body => @response.body.inspect,
+                :actual_status => @response.response_code.inspect,
+                :actual_content_type => @response.content_type.inspect }
+            else
+              { }
             end
-          end
-
-          def interpolation_options
-            if @response
-              { :actual_body => @response.body.inspect,
-                :actual_status => @response.response_code.inspect,
-                :actual_content_type => @response.content_type.inspect }
-            else
-              { }
-            end
-          end
-
-      end
-
-      # Passes if the response has the given status. Status can be a Symbol lik
-      # :success, :missing, :redirect and :error. Can be also a Fixnum, Range o
-      # any other symbol which matches to any of Rails status codes. 
-      #
-      # == Options
-      #
-      # * <tt>:body</tt> - The body of the response. It accepts strings and or
-      #   regular expressions. Altought you might be running your tests without
-      #   integrating your views, this is useful when rendering :xml or :text.
-      #
-      # * <tt>:content_type</tt> - The content type of the response.
-      #   It accepts strings ('application/rss+xml'), mime constants (Mime::RSS),
-      #   symbols (:rss) and regular expressions /rss/.
-      #
-      # == Examples
-      #
-      #   should_respond_with :success
-      #   should_respond_with :error,   :body => /System error/
-      #   should_respond_with 301,      :content_type => Mime::XML
-      #   should_respond_with 300..399, :content_type => Mime::XML
-      #
-      #   it { should respond_with(:success)                              }
-      #   it { should respond_with(:error).body(/System error/)           }
-      #   it { should respond_with(301).content_type(Mime::XML)      }
-      #   it { should respond_with(300..399).content_type(Mime::XML) }
-      #
-      def respond_with(*args, &block)
+          end
+
+      end
+
+      # Passes if the response has the given status. Status can be a Symbol lik
+      # :success, :missing, :redirect and :error. Can be also a Fixnum, Range o
+      # any other symbol which matches to any of Rails status codes. 
+      #
+      # == Options
+      #
+      # * <tt>:body</tt> - The body of the response. It accepts strings and or
+      #   regular expressions. Altought you might be running your tests without
+      #   integrating your views, this is useful when rendering :xml or :text.
+      #
+      # * <tt>:content_type</tt> - The content type of the response.
+      #   It accepts strings ('application/rss+xml'), mime constants (Mime::RSS),
+      #   symbols (:rss) and regular expressions /rss/.
+      #
+      # == Examples
+      #
+      #   should_respond_with :success
+      #   should_respond_with :error,   :body => /System error/
+      #   should_respond_with 301,      :content_type => Mime::XML
+      #   should_respond_with 300..399, :content_type => Mime::XML
+      #
+      #   it { should respond_with(:success)                              }
+      #   it { should respond_with(:error).body(/System error/)           }
+      #   it { should respond_with(301).content_type(Mime::XML)      }
+      #   it { should respond_with(300..399).content_type(Mime::XML) }
+      #
+      def respond_with(*args, &block)
         options = args.extract_options!
-        options.merge!(:with => args.first)
-        RespondWithMatcher.new(options, &block).spec(self)
-      end
-
-      # This is just a shortcut for respond_with :body => body. Check respond_with
-      # for more information.
-      #
-      def respond_with_body(*args, &block)
+        options.merge!(:with => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :body => body. Check respond_with
+      # for more information.
+      #
+      def respond_with_body(*args, &block)
         options = args.extract_options!
         # Since body can be also given as block, only merge if any arguments was
         # actually sent.
         options.merge!(:body => args.first) unless args.empty?
-        RespondWithMatcher.new(options, &block).spec(self)
-      end
-
-      # This is just a shortcut for respond_with :content_type => content_type.
-      # It's also used for Shoulda compatibility. Check respond_with for more
-      # information.
-      #
-      def respond_with_content_type(*args, &block)
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+      # This is just a shortcut for respond_with :content_type => content_type.
+      # It's also used for Shoulda compatibility. Check respond_with for more
+      # information.
+      #
+      def respond_with_content_type(*args, &block)
         options = args.extract_options!
-        options.merge!(:content_type => args.first)
-        RespondWithMatcher.new(options, &block).spec(self)
-      end
-
-    end
-  end
-end
+        options.merge!(:content_type => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
+      end
+
+    end
+  end
+end