remarkable_rails 3.1.8 → 3.1.9

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

@@ -1,109 +1,135 @@
-module Remarkable
-  module ActionController
-    module Matchers
-      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
-      class RouteMatcher < Remarkable::Base #:nodoc:
-        arguments :method, :path
-
-        assertions :map_to_path?, :generate_params?
-
-        before_assert do
-          @options[:controller] ||= controller_name
-          @populated_path = @path.dup
-
-          @options.each do |key, value|
-            @options[key] = value.to_param if value.respond_to?(:to_param)
-            @populated_path.gsub!(key.inspect, value.to_s)
-          end
-
-          ::ActionController::Routing::Routes.reload if ::ActionController::Routing::Routes.empty?
-        end
-
-        def controller
-          @controller ||= @spec.controller if @spec.respond_to?(:controller)
-        end
-
-        def request
-          controller.request if controller
-        end
-
-        private
-
-          def map_to_path?
-            route_for = ::ActionController::Routing::Routes.generate(@options) rescue nil
-            return route_for == @populated_path, :actual => route_for.inspect
-          end
-
-          def generate_params?
-            env = ::ActionController::Routing::Routes.extract_request_environment(controller.request) if controller
-
-            env ||= {}
-            env[:method] = @method.to_sym
-            params_from  = ::ActionController::Routing::Routes.recognize_path(@populated_path, env) rescue nil
-            return params_from == @options, :actual => params_from.inspect
-          end
-
-          # First tries to get the controller name from the subject, then from
-          # the spec class using controller class or finally, from the described
-          # class.
-          #
-          # We have to try the described class because we don't have neither the
-          # subject or the controller class in the RoutingExampleGroup.
-          #
-          def controller_name
-            if controller_class
-              controller_class.name.gsub(/Controller$/, '').tableize
-            else
-              raise ArgumentError, "I cannot guess the controller name in route. Please supply :controller as option"
-            end
-          end
-
-          def controller_class
-            @controller_class ||= begin
-              spec_class = @spec.class unless @spec.class == Class
-
-              attempts = []
-              attempts << controller.class if controller
-              attempts << @subject.class   if @subject
-              attempts << spec_class.controller_class if spec_class.respond_to?(:controller_class)
-              attempts << spec_class.described_class  if spec_class.respond_to?(:described_class)
-
-              attempts.find{ |controller| ::ActionController::Base >= controller }
-            end
-          end
-
-          def interpolation_options
-            { :options => @options.inspect, :method => @method.to_s.upcase, :path => @path.inspect }
-          end
-
-      end
-
-      # Assert route generation AND route recognition.
-      #
-      # == Examples
-      #
-      #   # autodetects the :controller
-      #   should_route :get,    '/posts',         :action => :index
-      #
-      #   # explicitly specify :controller
-      #   should_route :post,   '/posts',         :controller => :posts, :action => :create
-      #
-      #   # non-string parameter
-      #   should_route :get,    '/posts/1',       :controller => :posts, :action => :show,    :id => 1
-      #
-      #   # string-parameter
-      #   should_route :put,    '/posts/1',       :controller => :posts, :action => :update,  :id => "1"
-      #   should_route :delete, '/posts/1',       :controller => :posts, :action => :destroy, :id => 1
-      #   should_route :get,    '/posts/new',     :controller => :posts, :action => :new
-      #
-      #   # nested routes
-      #   should_route :get,    '/users/5/posts', :controller => :posts, :action => :index,   :user_id => 5
-      #   should_route :post,   '/users/5/posts', :controller => :posts, :action => :create,  :user_id => 5
-      #
-      def route(*params, &block)
-        RouteMatcher.new(*params, &block).spec(self)
-      end
-
-    end
-  end
-end
+module Remarkable
+  module ActionController
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+      class RouteMatcher < Remarkable::Base #:nodoc:
+        arguments :method, :path
+        assertions :map_to_path?, :generate_params?
+
+        # Small hack to allow should route().to/from syntax.
+        #
+        after_initialize do
+          if @path.is_a?(Hash)
+            @options.merge!(@path)
+            @path = nil
+          end
+        end
+
+        before_assert do
+          @options[:controller] ||= controller_name
+          @populated_path = @path.dup
+
+          @options.each do |key, value|
+            @options[key] = value.to_param if value.respond_to?(:to_param)
+            @populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          ::ActionController::Routing::Routes.reload if ::ActionController::Routing::Routes.empty?
+        end
+
+        def to(value)
+          @options.merge!(value)
+          self
+        end
+
+        def from(value)
+          @path = value
+          self
+        end
+
+        private
+
+          def map_to_path?
+            route_for = ::ActionController::Routing::Routes.generate(@options) rescue nil
+            return route_for == @populated_path, :actual => route_for.inspect
+          end
+
+          def generate_params?
+            env = ::ActionController::Routing::Routes.extract_request_environment(request) if request
+
+            env ||= {}
+            env[:method] = @method.to_sym
+            params_from  = ::ActionController::Routing::Routes.recognize_path(@populated_path, env) rescue nil
+            return params_from == @options, :actual => params_from.inspect
+          end
+
+          def controller
+            @controller ||= if @subject.is_a?(::ActionController::Base)
+              @subject
+            elsif @spec.respond_to?(:controller)
+              @spec.controller
+            else
+              raise "Could not find a controller for route specs."
+            end
+          end
+
+          # First tries to get the controller name from the subject, then from
+          # the spec class using controller class or finally, from the described
+          # class.
+          #
+          # We have to try the described class because we don't have neither the
+          # subject or the controller class in the RoutingExampleGroup.
+          #
+          def controller_name
+            if controller_class
+              controller_class.name.gsub(/Controller$/, '').tableize
+            else
+              raise ArgumentError, "I cannot guess the controller name in route. Please supply :controller as option"
+            end
+          end
+
+          def controller_class
+            @controller_class ||= begin
+              spec_class = @spec.class unless @spec.class == Class
+
+              attempts = []
+              attempts << controller.class            if controller
+              attempts << spec_class.controller_class if spec_class.respond_to?(:controller_class)
+              attempts << spec_class.described_class  if spec_class.respond_to?(:described_class)
+
+              # Check for not blank names to address an odd rspec/rails behavior.
+              attempts.find { |klass| ::ActionController::Base >= klass && !klass.name.blank? }
+            end
+          end
+
+          def request
+            controller.request
+          end
+
+          def interpolation_options
+            { :options => @options.inspect, :method => @method.to_s.upcase, :path => @path.inspect }
+          end
+      end
+
+      # Assert route generation AND route recognition.
+      #
+      # == Examples
+      #
+      #   # autodetects the :controller
+      #   should_route :get,    '/posts',         :action => :index
+      #
+      #   # explicitly specify :controller
+      #   should_route :post,   '/posts',         :controller => :posts, :action => :create
+      #
+      #   # non-string parameter
+      #   should_route :get,    '/posts/1',       :controller => :posts, :action => :show,    :id => 1
+      #
+      #   # string-parameter
+      #   should_route :put,    '/posts/1',       :controller => :posts, :action => :update,  :id => "1"
+      #   should_route :delete, '/posts/1',       :controller => :posts, :action => :destroy, :id => 1
+      #   should_route :get,    '/posts/new',     :controller => :posts, :action => :new
+      #
+      #   # nested routes
+      #   should_route :get,    '/users/5/posts', :controller => :posts, :action => :index,   :user_id => 5
+      #   should_route :post,   '/users/5/posts', :controller => :posts, :action => :create,  :user_id => 5
+      #
+      #   # it example
+      #   it { should route(:get, :action => :index).to('/users/5/posts') }
+      #
+      def route(*params, &block)
+        RouteMatcher.new(*params, &block).spec(self)
+      end
+
+    end
+  end
+end

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

@@ -1,9 +1,9 @@
-require File.join(File.dirname(__FILE__), 'set_session_matcher')
-
-module Remarkable
-  module ActionController
-    module Matchers
-      class SetCookiesMatcher < SetSessionMatcher #:nodoc:
+require File.join(File.dirname(__FILE__), 'set_session_matcher')
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetCookiesMatcher < SetSessionMatcher #:nodoc:
 
         # For cookies to work properly, we have:
         #
@@ -36,50 +36,50 @@ module Remarkable
 
           @keys.collect!(&:to_s)
         end
-
-        protected
-          def session
-            @subject ? (@subject.response.cookies || {}) : {}
-          end
-
-          def interpolation_options
-            { :cookies_inspect => session.symbolize_keys!.inspect }
-          end
-
-      end
-
+
+        protected
+          def session
+            @subject ? (@subject.response.cookies || {}) : {}
+          end
+
+          def interpolation_options
+            { :cookies_inspect => session.symbolize_keys!.inspect }
+          end
+
+      end
+
       # Ensures that the given cookie keys were set. If you want to check that
-      # a cookie is not being set, just do:
-      #
-      #   should_not_set_cookies :user
-      #
-      # If you want to assure that a cookie is being set to nil, do instead:
-      #
-      #   should_set_cookies :user, :to => nil
+      # a cookie is not being set, just do:
+      #
+      #   should_not_set_cookies :user
+      #
+      # If you want to assure that a cookie is being set to nil, do instead:
+      #
+      #   should_set_cookies :user, :to => nil
       #
       # Note: this method is also aliased as <tt>set_cookie</tt>.
-      #
-      # == Options
-      #
-      # * <tt>:to</tt> - The value to compare the session key.
-      #   It accepts procs and be also given as a block (see examples below).
-      #
-      # == Examples
-      #
-      #   should_set_cookies :user_id, :user
-      #   should_set_cookies :user_id, :to => 2
-      #   should_set_cookies :user, :to => proc{ users(:first) }
-      #   should_set_cookies(:user){ users(:first) }
-      #
-      #   it { should set_cookies(:user_id, :user) }
-      #   it { should set_cookies(:user_id, :to => 2) }
-      #   it { should set_cookies(:user, :to => users(:first)) }
-      #
-      def set_cookies(*args, &block)
-        SetCookiesMatcher.new(*args, &block).spec(self)
+      #
+      # == Options
+      #
+      # * <tt>:to</tt> - The value to compare the session key.
+      #   It accepts procs and be also given as a block (see examples below).
+      #
+      # == Examples
+      #
+      #   should_set_cookies :user_id, :user
+      #   should_set_cookies :user_id, :to => 2
+      #   should_set_cookies :user, :to => proc{ users(:first) }
+      #   should_set_cookies(:user){ users(:first) }
+      #
+      #   it { should set_cookies(:user_id, :user) }
+      #   it { should set_cookies(:user_id, :to => 2) }
+      #   it { should set_cookies(:user, :to => users(:first)) }
+      #
+      def set_cookies(*args, &block)
+        SetCookiesMatcher.new(*args, &block).spec(self)
       end
-      alias :set_cookie :set_cookies
-
-    end
-  end
-end
+      alias :set_cookie :set_cookies
+
+    end
+  end
+end

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

@@ -1,108 +1,108 @@
-module Remarkable
-  module ActionController
-    module Matchers
-      class SetSessionMatcher < Remarkable::ActionController::Base #:nodoc:
-        arguments :collection => :keys, :as => :key, :block => true
-
-        optional :to, :block => true
-
-        assertion :is_not_empty?, :contains_value?
-        collection_assertions :assigned_value?, :is_equal_value?
-
-        before_assert :evaluate_expected_value
-
-        private
-
-          # When no keys are given:
-          #
-          #   should set_session
-          #
-          # We check if the session is not empty.
-          #
-          def is_not_empty?
-            !(@keys.empty? && session.empty?)
-          end
-
-          # When no keys are given and a comparision value is given:
-          #
-          #   should set_session.to(1)
-          #
-          # We check if any of the session data contains the given value.
-          #
-          def contains_value?
-            return true unless @keys.empty? && value_to_compare?
-            assert_contains(session.values, @options[:to])
-          end
-
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetSessionMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :collection => :keys, :as => :key, :block => true
+
+        optional :to, :block => true
+
+        assertion :is_not_empty?, :contains_value?
+        collection_assertions :assigned_value?, :is_equal_value?
+
+        before_assert :evaluate_expected_value
+
+        private
+
+          # When no keys are given:
+          #
+          #   should set_session
+          #
+          # We check if the session is not empty.
+          #
+          def is_not_empty?
+            !(@keys.empty? && session.empty?)
+          end
+
+          # When no keys are given and a comparision value is given:
+          #
+          #   should set_session.to(1)
+          #
+          # We check if any of the session data contains the given value.
+          #
+          def contains_value?
+            return true unless @keys.empty? && value_to_compare?
+            assert_contains(session.values, @options[:to])
+          end
+
           def assigned_value?
-            session.key?(@key)
-          end
-
-          # Returns true if :to is not given and no block is given.
-          # In case :to 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?
-            assert_contains([session[@key]], @options[:to])
-          end
-
-          def session
-            raw_session.with_indifferent_access.except(:flash)
-          end
-
-          def raw_session
-            @subject ? @subject.response.session.data : {}
-          end
-
-          def value_to_compare?
-            @options.key?(:to) || @block
-          end
-
-          def interpolation_options
-            { :session_inspect => raw_session.except('flash').symbolize_keys!.inspect }
-          end
-
-          # Evaluate procs before assert to avoid them appearing in descriptions.
-          def evaluate_expected_value
-            if value_to_compare?
-              value = @options.key?(:to) ? @options[:to] : @block
-              value = @spec.instance_eval(&value) if value.is_a?(Proc)
-              @options[:to] = value
-            end
-          end
-
-      end
-
+            session.key?(@key)
+          end
+
+          # Returns true if :to is not given and no block is given.
+          # In case :to 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?
+            assert_contains([session[@key]], @options[:to])
+          end
+
+          def session
+            raw_session.with_indifferent_access.except(:flash)
+          end
+
+          def raw_session
+            @subject ? @subject.response.session.data : {}
+          end
+
+          def value_to_compare?
+            @options.key?(:to) || @block
+          end
+
+          def interpolation_options
+            { :session_inspect => raw_session.except('flash').symbolize_keys!.inspect }
+          end
+
+          # Evaluate procs before assert to avoid them appearing in descriptions.
+          def evaluate_expected_value
+            if value_to_compare?
+              value = @options.key?(:to) ? @options[:to] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:to] = value
+            end
+          end
+
+      end
+
       # Ensures that the given session keys were set. If you want to check that
-      # a variable is not being set, just do:
-      #
-      #   should_not_set_session :user
-      #
-      # If you want to assure that a variable is being set to nil, do instead:
-      #
-      #   should_set_session :user, :to => nil
-      #
-      # == Options
-      #
-      # * <tt>:to</tt> - The value to compare the session key.
-      #   It accepts procs and be also given as a block (see examples below).
-      #
-      # == Examples
-      #
-      #   should_set_session :user_id, :user
-      #   should_set_session :user_id, :to => 2
-      #   should_set_session :user, :to => proc{ users(:first) }
-      #   should_set_session(:user){ users(:first) }
-      #
-      #   it { should set_session(:user_id, :user) }
-      #   it { should set_session(:user_id, :to => 2) }
-      #   it { should set_session(:user, :to => users(:first)) }
-      #
-      def set_session(*args, &block)
-        SetSessionMatcher.new(*args, &block).spec(self)
-      end
-
-    end
-  end
-end
+      # a variable is not being set, just do:
+      #
+      #   should_not_set_session :user
+      #
+      # If you want to assure that a variable is being set to nil, do instead:
+      #
+      #   should_set_session :user, :to => nil
+      #
+      # == Options
+      #
+      # * <tt>:to</tt> - The value to compare the session key.
+      #   It accepts procs and be also given as a block (see examples below).
+      #
+      # == Examples
+      #
+      #   should_set_session :user_id, :user
+      #   should_set_session :user_id, :to => 2
+      #   should_set_session :user, :to => proc{ users(:first) }
+      #   should_set_session(:user){ users(:first) }
+      #
+      #   it { should set_session(:user_id, :user) }
+      #   it { should set_session(:user_id, :to => 2) }
+      #   it { should set_session(:user, :to => users(:first)) }
+      #
+      def set_session(*args, &block)
+        SetSessionMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end