RubyGems - dirty_history - Versions diffs - 0.5.2 → 0.5.3 - Mend

dirty_history 0.5.2 → 0.5.3

Files changed (1429) hide show

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/shoulda-2.11.3/lib/shoulda/action_controller/matchers/redirect_to_matcher.rb DELETED Viewed

@@ -1,62 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures a controller redirected to the given url.
-      #
-      # Example:
-      #
-      #   it { should redirect_to('http://somewhere.com')  }
-      #   it { should redirect_to(users_path)  }
-      def redirect_to(url_or_description, &block)
-        RedirectToMatcher.new(url_or_description, self, &block)
-      end
-      class RedirectToMatcher # :nodoc:
-        def initialize(url_or_description, context, &block)
-          if block
-            @url_block = block
-            @location = @url_or_description
-          else
-            @url = url_or_description
-            @location = @url
-          end
-          @context = context
-        end
-        def in_context(context)
-          @context = context
-          self
-        end
-        def matches?(controller)
-          @controller = controller
-          redirects_to_url?
-        end
-        attr_reader :failure_message, :negative_failure_message
-        def description
-          "redirect to #{@location}"
-        end
-        private
-        def redirects_to_url?
-          @url = @context.instance_eval(&@url_block) if @url_block
-          begin
-            @context.send(:assert_redirected_to, @url)
-            @negative_failure_message = "Didn't expect to redirect to #{@url}"
-            true
-          rescue Test::Unit::AssertionFailedError => error
-            @failure_message = error.message
-            false
-          end
-        end
-      end
-    end
-  end
-end

@@ -1,54 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures a controller rendered the given template.
-      #
-      # Example:
-      #
-      #   it { should render_template(:show)  }
-      def render_template(template)
-        RenderTemplateMatcher.new(template, self)
-      end
-      class RenderTemplateMatcher # :nodoc:
-        def initialize(template, context)
-          @template = template.to_s
-          @context  = context
-        end
-        def matches?(controller)
-          @controller = controller
-          renders_template?
-        end
-        attr_reader :failure_message, :negative_failure_message
-        def description
-          "render template #{@template}"
-        end
-        def in_context(context)
-          @context = context
-          self
-        end
-        private
-        def renders_template?
-          begin
-            @context.send(:assert_template, @template)
-            @negative_failure_message = "Didn't expect to render #{@template}"
-            true
-          rescue Test::Unit::AssertionFailedError => error
-            @failure_message = error.message
-            false
-          end
-        end
-      end
-    end
-  end
-end

@@ -1,99 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures that the controller rendered with the given layout.
-      #
-      # Example:
-      #
-      #   it { should render_with_layout }
-      #   it { should render_with_layout(:special) }
-      #   it { should_not render_with_layout }
-      def render_with_layout(expected_layout = nil)
-        RenderWithLayout.new(expected_layout)
-      end
-      class RenderWithLayout # :nodoc:
-        def initialize(expected_layout)
-          @expected_layout = expected_layout.to_s unless expected_layout.nil?
-        end
-        # Used to provide access to layouts recorded by
-        # ActionController::TemplateAssertions in Rails 3
-        def in_context(context)
-          @context = context
-          self
-        end
-        def matches?(controller)
-          @controller = controller
-          rendered_with_layout? && rendered_with_expected_layout?
-        end
-        def failure_message
-          "Expected #{expectation}, but #{result}"
-        end
-        def negative_failure_message
-          "Did not expect #{expectation}, but #{result}"
-        end
-        def description
-          description = "render with "
-          if @expected_layout.nil?
-            description << "a layout"
-          else
-            description << "the #{@expected_layout.inspect} layout"
-          end
-          description
-        end
-        private
-        def rendered_with_layout?
-          !rendered_layouts.empty?
-        end
-        def rendered_with_expected_layout?
-          return true if @expected_layout.nil?
-          rendered_layouts.include?(@expected_layout)
-        end
-        def rendered_layouts
-          if recorded_layouts
-            recorded_layouts.keys.compact.map { |layout| layout.sub(%r{^layouts/}, '') }
-          else
-            layout = @controller.response.layout
-            if layout.nil?
-              []
-            else
-              [layout.split('/').last]
-            end
-          end
-        end
-        def recorded_layouts
-          if @context
-            @context.instance_variable_get('@layouts')
-          end
-        end
-        def expectation
-          "to #{description}"
-        end
-        def result
-          if rendered_with_layout?
-            "rendered with " <<
-              rendered_layouts.map { |layout| layout.inspect }.join(", ")
-          else
-            "rendered without a layout"
-          end
-        end
-      end
-    end
-  end
-end

@@ -1,74 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures a controller responded with expected 'response' content type.
-      #
-      # You can pass an explicit content type such as 'application/rss+xml'
-      # or its symbolic equivalent :rss
-      # or a regular expression such as /rss/
-      #
-      # Example:
-      #
-      #   it { should respond_with_content_type(:xml)  }
-      #   it { should respond_with_content_type(:csv)  }
-      #   it { should respond_with_content_type(:atom) }
-      #   it { should respond_with_content_type(:yaml) }
-      #   it { should respond_with_content_type(:text) }
-      #   it { should respond_with_content_type('application/rss+xml')  }
-      #   it { should respond_with_content_type(/json/) }
-      def respond_with_content_type(content_type)
-        RespondWithContentTypeMatcher.new(content_type)
-      end
-      class RespondWithContentTypeMatcher # :nodoc:
-        def initialize(content_type)
-          @content_type = if content_type.is_a?(Symbol)
-            lookup_by_extension(content_type)
-          else
-            content_type
-          end
-        end
-        def description
-          "respond with content type of #{@content_type}"
-        end
-        def matches?(controller)
-          @controller = controller
-          if @content_type.is_a?(Regexp)
-            response_content_type =~ @content_type
-          else
-            response_content_type == @content_type
-          end
-        end
-        def failure_message
-          "Expected #{expectation}"
-        end
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-        protected
-        def response_content_type
-          @controller.response.content_type.to_s
-        end
-        def lookup_by_extension(extension)
-          Mime::Type.lookup_by_extension(extension.to_s).to_s
-        end
-        def expectation
-          "content type to be #{@content_type}, " <<
-          "but was #{response_content_type}"
-        end
-      end
-    end
-  end
-end

@@ -1,85 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures a controller responded with expected 'response' status code.
-      #
-      # You can pass an explicit status number like 200, 301, 404, 500
-      # or its symbolic equivalent :success, :redirect, :missing, :error.
-      # See ActionController::StatusCodes for a full list.
-      #
-      # Example:
-      #
-      #   it { should respond_with(:success)  }
-      #   it { should respond_with(:redirect) }
-      #   it { should respond_with(:missing)  }
-      #   it { should respond_with(:error)    }
-      #   it { should respond_with(501)       }
-      def respond_with(status)
-        RespondWithMatcher.new(status)
-      end
-      class RespondWithMatcher # :nodoc:
-        def initialize(status)
-          @status = symbol_to_status_code(status)
-        end
-        def matches?(controller)
-          @controller = controller
-          correct_status_code? || correct_status_code_range?
-        end
-        def failure_message
-          "Expected #{expectation}"
-        end
-        def negative_failure_message
-          "Did not expect #{expectation}"
-        end
-        def description
-          "respond with #{@status}"
-        end
-        protected
-        def correct_status_code?
-          response_code == @status
-        end
-        def correct_status_code_range?
-          @status.is_a?(Range) &&
-            @status.include?(response_code)
-        end
-        def response_code
-          @controller.response.response_code
-        end
-        def symbol_to_status_code(potential_symbol)
-          case potential_symbol
-          when :success  then 200
-          when :redirect then 300..399
-          when :missing  then 404
-          when :error    then 500..599
-          when Symbol
-            if defined?(::Rack::Utils::SYMBOL_TO_STATUS_CODE)
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
-            else
-              ::ActionController::Base::SYMBOL_TO_STATUS_CODE[potential_symbol]
-            end
-          else
-            potential_symbol
-          end
-        end
-        def expectation
-          "response to be a #{@status}, but was #{response_code}"
-        end
-      end
-    end
-  end
-end

@@ -1,93 +0,0 @@
-module Shoulda # :nodoc:
-  module ActionController # :nodoc:
-    module Matchers
-      # Ensures that requesting +path+ using +method+ routes to +options+.
-      #
-      # If you don't specify a controller, it will use the controller from the
-      # example group.
-      #
-      # +to_param+ is called on the +options+ given.
-      #
-      # Examples:
-      #
-      #   it { should route(:get, "/posts").
-      #                 to(:controller => :posts, :action => :index) }
-      #   it { should route(:get, "/posts/new").to(:action => :new) }
-      #   it { should route(:post, "/posts").to(:action => :create) }
-      #   it { should route(:get, "/posts/1").to(:action => :show, :id => 1) }
-      #   it { should route(:edit, "/posts/1").to(:action => :show, :id => 1) }
-      #   it { should route(:put, "/posts/1").to(:action => :update, :id => 1) }
-      #   it { should route(:delete, "/posts/1").
-      #                 to(:action => :destroy, :id => 1) }
-      #   it { should route(:get, "/users/1/posts/1").
-      #                 to(:action => :show, :id => 1, :user_id => 1) }
-      def route(method, path)
-        RouteMatcher.new(method, path, self)
-      end
-      class RouteMatcher # :nodoc:
-        def initialize(method, path, context)
-          @method  = method
-          @path    = path
-          @context = context
-        end
-        def to(params)
-          @params = params
-          stringify_params!
-          self
-        end
-        def in_context(context)
-          @context = context
-          self
-        end
-        def matches?(controller)
-          @controller = controller
-          guess_controller!
-          route_recognized?
-        end
-        attr_reader :failure_message, :negative_failure_message
-        def description
-          "route #{@method.to_s.upcase} #{@path} to/from #{@params.inspect}"
-        end
-        private
-        def guess_controller!
-          @params[:controller] ||= @controller.controller_path
-        end
-        def stringify_params!
-          @params.each do |key, value|
-            @params[key] = value.is_a?(Array) ? value.collect {|v| v.to_param } : value.to_param
-          end
-        end
-        def route_recognized?
-          begin
-            @context.send(:assert_routing,
-                          { :method => @method, :path => @path },
-                          @params)
-            @negative_failure_message = "Didn't expect to #{description}"
-            true
-          rescue ::ActionController::RoutingError => error
-            @failure_message = error.message
-            false
-          rescue Test::Unit::AssertionFailedError => error
-            @failure_message = error.message
-            false
-          end
-        end
-      end
-    end
-  end
-end