remarkable_rails 3.0.1 → 3.0.2

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

@@ -3,86 +3,86 @@ module Remarkable
     module Matchers
       class AssignToMatcher < Remarkable::ActionController::Base #:nodoc:
         arguments :collection => :names, :as => :name, :block => :block
-
-        optional :with, :with_kind_of
-        collection_assertions :assigned_value?, :is_kind_of?, :is_equal_value?
-
-        before_assert :evaluate_expected_value
-
-        default_options :with_expectations => true
+
+        optional :with, :with_kind_of
+        collection_assertions :assigned_value?, :is_kind_of?, :is_equal_value?
+
+        before_assert :evaluate_expected_value
+
+        default_options :with_expectations => true
 
         protected
-
-          def assigned_value?
-            assigns.key?(@name)
-          end
-
-          def is_kind_of?
-            return true unless @options[:with_kind_of]
-            return assigns[@name].kind_of?(@options[:with_kind_of])
-          end
-
-          # Returns true if :with is not given and no block is given.
-          # In case :with is a proc or a block is given, we evaluate it in the
-          # @spec scope.
-          #
-          def is_equal_value?
-            return true unless value_to_compare?
-            assigns[@name] == @options[:with]
-          end
-
-          def assigns
-            @subject.response.template.assigns.with_indifferent_access
-          end
-
-          def value_to_compare?
-            @options.key?(:with) || @block
-          end 
-
-          # Update interpolation options
-          def interpolation_options
-            if @subject && @subject.response
-              { :assign_inspect => assigns[@name].inspect, :assign_class => assigns[@name].class.name }
-            else
-              { }
-            end
-          end
-
-          # Evaluate procs before assert to avoid them appearing in descriptions.
-          def evaluate_expected_value
-            if value_to_compare?
-              value = @options.key?(:with) ? @options[:with] : @block
-              value = @spec.instance_eval(&value) if value.is_a?(Proc)
-              @options[:with] = value
-            end
-          end
-
+
+          def assigned_value?
+            assigns.key?(@name)
+          end
+
+          def is_kind_of?
+            return true unless @options[:with_kind_of]
+            return assigns[@name].kind_of?(@options[:with_kind_of])
+          end
+
+          # Returns true if :with is not given and no block is given.
+          # In case :with is a proc or a block is given, we evaluate it in the
+          # @spec scope.
+          #
+          def is_equal_value?
+            return true unless value_to_compare?
+            assigns[@name] == @options[:with]
+          end
+
+          def assigns
+            @subject.response.template.assigns.with_indifferent_access
+          end
+
+          def value_to_compare?
+            @options.key?(:with) || @block
+          end 
+
+          # Update interpolation options
+          def interpolation_options
+            if @subject && @subject.response
+              { :assign_inspect => assigns[@name].inspect, :assign_class => assigns[@name].class.name }
+            else
+              { }
+            end
+          end
+
+          # Evaluate procs before assert to avoid them appearing in descriptions.
+          def evaluate_expected_value
+            if value_to_compare?
+              value = @options.key?(:with) ? @options[:with] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:with] = value
+            end
+          end
+
       end
 
-      # Checks if the controller assigned the variables given by name. If you
-      # want to check that a variable is not being assigned, please do:
-      #
-      #   should_not_assign_to(:user)
-      #
-      # If you want to assure that a variable is being assigned to nil, do instead:
-      #
-      #   should_assign_to(:user).with(nil)
-      #
-      # == Options
-      #
-      # * <tt>:with</tt> - The value to compare the assign.
-      #   It can be also be supplied as proc or as a block (see examples below)
-      #
+      # Checks if the controller assigned the variables given by name. If you
+      # want to check that a variable is not being assigned, please do:
+      #
+      #   should_not_assign_to(:user)
+      #
+      # If you want to assure that a variable is being assigned to nil, do instead:
+      #
+      #   should_assign_to(:user).with(nil)
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The value to compare the assign.
+      #   It can be also be supplied as proc or as a block (see examples below)
+      #
       # * <tt>:with_kind_of</tt> - The expected class of the assign.
       #
       # == Examples
-      #
-      #   should_assign_to :user, :with_kind_of => User
+      #
+      #   should_assign_to :user, :with_kind_of => User
       #   should_assign_to :user, :with => proc{ users(:first) }
-      #   should_assign_to(:user){ users(:first) }
-      #
-      #   it { should assign_to(:user) }
-      #   it { should assign_to(:user, :with => users(:first)) }
+      #   should_assign_to(:user){ users(:first) }
+      #
+      #   it { should assign_to(:user) }
+      #   it { should assign_to(:user, :with => users(:first)) }
       #   it { should assign_to(:user, :with_kind_of => User) }
       #
       def assign_to(*args, &block)

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

@@ -1,39 +1,39 @@
 module Remarkable
   module ActionController
-    module Matchers
-      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
       class FilterParamsMatcher < Remarkable::Base #:nodoc:
         arguments :collection => :params, :as => :param
-
-        assertions :respond_to_filter_params?
-        collection_assertions :is_filtered?
-
+
+        assertions :respond_to_filter_params?
+        collection_assertions :is_filtered?
+
         protected
-
-          def respond_to_filter_params?
+
+          def respond_to_filter_params?
             @subject.respond_to?(:filter_parameters)
           end
 
-          def is_filtered?
-            filtered = @subject.send(:filter_parameters, { @param.to_s => @param.to_s })
+          def is_filtered?
+            filtered = @subject.send(:filter_parameters, { @param.to_s => @param.to_s })
             filtered[@param.to_s] == '[FILTERED]'
-          end
-
+          end
+
       end
 
-      # Checks if the controller filters the given params.
-      #
+      # Checks if the controller filters the given params.
+      #
       # == Examples
-      #
-      #   should_filter_params :password
-      #   should_not_filter_params :username
-      #
-      #   it { should filter_params(:password) }
-      #   it { should_not filter_params(:username) }
+      #
+      #   should_filter_params :password
+      #   should_not_filter_params :username
+      #
+      #   it { should filter_params(:password) }
+      #   it { should_not filter_params(:username) }
       #
       def filter_params(*params)
         FilterParamsMatcher.new(*params).spec(self)
-      end
+      end
       alias :filter_param :filter_params
 
     end

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

@@ -1,118 +1,118 @@
 module Remarkable
   module ActionController
     module Matchers
-      class RedirectToMatcher < Remarkable::ActionController::Base #:nodoc:
-        include ::ActionController::StatusCodes
-
-        arguments :expected, :block => :block
-        optional :with
-
-        assertions :redirected?, :status_matches?, :url_matches?
-
-        before_assert :evaluate_expected_value
-
-        before_assert do
-          @response = @subject.respond_to?(:response) ? @subject.response : @subject
-          @request  = @response.instance_variable_get('@request')
-        end
-
-        protected
-
-          def redirected?
-            @response.redirect?
-          end
-
-          def status_matches?
-            return true unless @options.key?(:with)
-
-            actual_status   = interpret_status(@response.response_code)
-            expected_status = interpret_status(@options[:with])
-
-            return actual_status == expected_status, :status => @response.response_code.inspect
-          end
-
-          def url_matches?
-            @actual = @response.redirect_url
-
-            if @expected.instance_of?(Hash)
-              return false unless @actual =~ /^\w+:\/\/#{@request.host}/ && actual_hash
-              actual_hash == expected_hash
-            else
-              @actual == expected_url
-            end
-          end
-
-          def actual_hash
-            hash_from_url @actual
-          end
-
-          def expected_hash
-            hash_from_url expected_url
-          end
-
-          def hash_from_url(url)
-            query_hash(url).merge(path_hash(url)).with_indifferent_access
-          end
-
-          def path_hash(url)
-            path = url.sub(/^\w+:\/\/#{@request.host}(?::\d+)?/, "").split("?", 2)[0]
-            ::ActionController::Routing::Routes.recognize_path path, { :method => :get }
-          end
-
-          def query_hash(url)
-            query = url.split("?", 2)[1] || ""
-
-            if defined?(::Rack::Utils)
-              ::Rack::Utils.parse_query(query)
-            else
-              @request.class.parse_query_parameters(query)
-            end
-          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 interpolation_options
-            { :expected => @expected.inspect, :actual => @actual.inspect }
-          end
-
-          def evaluate_expected_value
-            @expected ||= @block if @block
-            @expected = @spec.instance_eval(&@expected) if @expected.is_a?(Proc)
-          end
-
-      end
-
-      # Passes if the response redirects to the given url. The url can be a string,
-      # a hash or can be supplied as a block (see examples below).
-      #
-      # == Options
-      #
-      # * <tt>:with</tt> - The status 30X used when redirecting.
-      #
-      # == Examples
-      #
-      #   should_redirect_to{ users_url }
-      #   should_redirect_to(:action => 'index')
-      #   should_not_redirect_to(:controller => 'users', :action => 'new')
-      #
-      #   it { should redirect_to(users_url).with(302) }
-      #   it { should redirect_to(:action => 'index') }
-      #   it { should_not redirect_to(:controller => 'users', :action => 'new') }
-      #
-      def redirect_to(expected=nil, options={}, &block)
-        RedirectToMatcher.new(expected, options, &block).spec(self)
-      end
+      class RedirectToMatcher < Remarkable::ActionController::Base #:nodoc:
+        include ::ActionController::StatusCodes
+
+        arguments :expected, :block => :block
+        optional :with
+
+        assertions :redirected?, :status_matches?, :url_matches?
+
+        before_assert :evaluate_expected_value
+
+        before_assert do
+          @response = @subject.respond_to?(:response) ? @subject.response : @subject
+          @request  = @response.instance_variable_get('@request')
+        end
+
+        protected
+
+          def redirected?
+            @response.redirect?
+          end
+
+          def status_matches?
+            return true unless @options.key?(:with)
+
+            actual_status   = interpret_status(@response.response_code)
+            expected_status = interpret_status(@options[:with])
+
+            return actual_status == expected_status, :status => @response.response_code.inspect
+          end
+
+          def url_matches?
+            @actual = @response.redirect_url
+
+            if @expected.instance_of?(Hash)
+              return false unless @actual =~ /^\w+:\/\/#{@request.host}/ && actual_hash
+              actual_hash == expected_hash
+            else
+              @actual == expected_url
+            end
+          end
+
+          def actual_hash
+            hash_from_url @actual
+          end
+
+          def expected_hash
+            hash_from_url expected_url
+          end
+
+          def hash_from_url(url)
+            query_hash(url).merge(path_hash(url)).with_indifferent_access
+          end
+
+          def path_hash(url)
+            path = url.sub(/^\w+:\/\/#{@request.host}(?::\d+)?/, "").split("?", 2)[0]
+            ::ActionController::Routing::Routes.recognize_path path, { :method => :get }
+          end
+
+          def query_hash(url)
+            query = url.split("?", 2)[1] || ""
+
+            if defined?(::Rack::Utils)
+              ::Rack::Utils.parse_query(query)
+            else
+              @request.class.parse_query_parameters(query)
+            end
+          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 interpolation_options
+            { :expected => @expected.inspect, :actual => @actual.inspect }
+          end
+
+          def evaluate_expected_value
+            @expected ||= @block if @block
+            @expected = @spec.instance_eval(&@expected) if @expected.is_a?(Proc)
+          end
+
+      end
+
+      # Passes if the response redirects to the given url. The url can be a string,
+      # a hash or can be supplied as a block (see examples below).
+      #
+      # == Options
+      #
+      # * <tt>:with</tt> - The status 30X used when redirecting.
+      #
+      # == Examples
+      #
+      #   should_redirect_to{ users_url }
+      #   should_redirect_to(:action => 'index')
+      #   should_not_redirect_to(:controller => 'users', :action => 'new')
+      #
+      #   it { should redirect_to(users_url).with(302) }
+      #   it { should redirect_to(:action => 'index') }
+      #   it { should_not redirect_to(:controller => 'users', :action => 'new') }
+      #
+      def redirect_to(expected=nil, options={}, &block)
+        RedirectToMatcher.new(expected, options, &block).spec(self)
+      end
 
     end
   end