actionpack 1.13.6 → 2.0.0

data/lib/action_controller/assertions/deprecated_assertions.rb

@@ -1,228 +0,0 @@
-require 'rexml/document'
-
-module ActionController #:nodoc:
-  module Assertions #:nodoc:
-    module DeprecatedAssertions #:nodoc:
-      def assert_success(message=nil) #:nodoc:
-        assert_response(:success, message)
-      end
-      deprecate :assert_success => "use assert_response(:success)"
-
-      def assert_redirect(message=nil) #:nodoc:
-        assert_response(:redirect, message)
-      end
-      deprecate :assert_redirect => "use assert_response(:redirect)"
-
-      def assert_rendered_file(expected=nil, message=nil) #:nodoc:
-        assert_template(expected, message)
-      end
-      deprecate :assert_rendered_file => :assert_template
-
-      # ensure that the session has an object with the specified name
-      def assert_session_has(key=nil, message=nil) #:nodoc:
-        msg = build_message(message, "<?> is not in the session <?>", key, @response.session)
-        assert_block(msg) { @response.has_session_object?(key) }
-      end
-      deprecate :assert_session_has => "use assert(@response.has_session_object?(key))"
-
-      # ensure that the session has no object with the specified name
-      def assert_session_has_no(key=nil, message=nil) #:nodoc:
-        msg = build_message(message, "<?> is in the session <?>", key, @response.session)
-        assert_block(msg) { !@response.has_session_object?(key) }
-      end
-      deprecate :assert_session_has_no => "use assert(!@response.has_session_object?(key))"
-
-      def assert_session_equal(expected = nil, key = nil, message = nil) #:nodoc:
-        msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, @response.session[key])
-        assert_block(msg) { expected == @response.session[key] }
-      end
-      deprecate :assert_session_equal => "use assert_equal(expected, @response[key])"
-
-      # -- cookie assertions ---------------------------------------------------
-
-      def assert_no_cookie(key = nil, message = nil) #:nodoc:
-        actual = @response.cookies[key]
-        msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
-        assert_block(msg) { actual.nil? or actual.empty? }
-      end
-      deprecate :assert_no_cookie => "use assert(!@response.cookies.key?(key))"
-    
-      def assert_cookie_equal(expected = nil, key = nil, message = nil) #:nodoc:
-        actual = @response.cookies[key]
-        actual = actual.first if actual
-        msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
-        assert_block(msg) { expected == actual }
-      end
-      deprecate :assert_cookie_equal => "use assert(@response.cookies.key?(key))"
-    
-      # -- flash assertions ---------------------------------------------------
-
-      # ensure that the flash has an object with the specified name
-      def assert_flash_has(key=nil, message=nil) #:nodoc:
-        msg = build_message(message, "<?> is not in the flash <?>", key, @response.flash)
-        assert_block(msg) { @response.has_flash_object?(key) }
-      end
-      deprecate :assert_flash_has => "use assert(@response.has_flash_object?(key))"
-
-      # ensure that the flash has no object with the specified name
-      def assert_flash_has_no(key=nil, message=nil) #:nodoc:
-        msg = build_message(message, "<?> is in the flash <?>", key, @response.flash)
-        assert_block(msg) { !@response.has_flash_object?(key) }
-      end
-      deprecate :assert_flash_has_no => "use assert(!@response.has_flash_object?(key))"
-
-      # ensure the flash exists
-      def assert_flash_exists(message=nil) #:nodoc:
-        msg = build_message(message, "the flash does not exist <?>", @response.session['flash'] )
-        assert_block(msg) { @response.has_flash? }
-      end
-      deprecate :assert_flash_exists => "use assert(@response.has_flash?)"
-
-      # ensure the flash does not exist
-      def assert_flash_not_exists(message=nil) #:nodoc:
-        msg = build_message(message, "the flash exists <?>", @response.flash)
-        assert_block(msg) { !@response.has_flash? }
-      end
-      deprecate :assert_flash_not_exists => "use assert(!@response.has_flash?)"
-    
-      # ensure the flash is empty but existent
-      def assert_flash_empty(message=nil) #:nodoc:
-        msg = build_message(message, "the flash is not empty <?>", @response.flash)
-        assert_block(msg) { !@response.has_flash_with_contents? }
-      end
-      deprecate :assert_flash_empty => "use assert(!@response.has_flash_with_contents?)"
-
-      # ensure the flash is not empty
-      def assert_flash_not_empty(message=nil) #:nodoc:
-        msg = build_message(message, "the flash is empty")
-        assert_block(msg) { @response.has_flash_with_contents? }
-      end
-      deprecate :assert_flash_not_empty => "use assert(@response.has_flash_with_contents?)"
-    
-      def assert_flash_equal(expected = nil, key = nil, message = nil) #:nodoc:
-        msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, @response.flash[key])
-        assert_block(msg) { expected == @response.flash[key] }
-      end
-      deprecate :assert_flash_equal => "use assert_equal(expected, @response.flash[key])"
-    
-
-      # ensure our redirection url is an exact match
-      def assert_redirect_url(url=nil, message=nil) #:nodoc:
-        assert_redirect(message)
-        msg = build_message(message, "<?> is not the redirected location <?>", url, @response.redirect_url)
-        assert_block(msg) { @response.redirect_url == url }
-      end
-      deprecate :assert_redirect_url => "use assert_equal(url, @response.redirect_url)"
-
-      # ensure our redirection url matches a pattern
-      def assert_redirect_url_match(pattern=nil, message=nil) #:nodoc:
-        assert_redirect(message)
-        msg = build_message(message, "<?> was not found in the location: <?>", pattern, @response.redirect_url)
-        assert_block(msg) { @response.redirect_url_match?(pattern) }
-      end
-      deprecate :assert_redirect_url_match => "use assert(@response.redirect_url_match?(pattern))"
-
-    
-      # -- template assertions ------------------------------------------------
-
-      # ensure that a template object with the given name exists
-      def assert_template_has(key=nil, message=nil) #:nodoc:
-        msg = build_message(message, "<?> is not a template object", key )
-        assert_block(msg) { @response.has_template_object?(key) }
-      end
-      deprecate :assert_template_has => "use assert(@response.has_template_object?(key))"
-
-      # ensure that a template object with the given name does not exist
-      def assert_template_has_no(key=nil,message=nil) #:nodoc:
-        msg = build_message(message, "<?> is a template object <?>", key, @response.template_objects[key])
-        assert_block(msg) { !@response.has_template_object?(key) }
-      end
-      deprecate :assert_template_has_no => "use assert(!@response.has_template_object?(key))"
-
-      # ensures that the object assigned to the template on +key+ is equal to +expected+ object.
-      def assert_template_equal(expected = nil, key = nil, message = nil) #:nodoc:
-        msg = build_message(message, "<?> expected in assigns['?'] but was <?>", expected, key, @response.template.assigns[key.to_s])
-        assert_block(msg) { expected == @response.template.assigns[key.to_s] }
-      end
-      alias_method :assert_assigned_equal, :assert_template_equal
-      deprecate :assert_assigned_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
-      deprecate :assert_template_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
-
-      # Asserts that the template returns the +expected+ string or array based on the XPath +expression+.
-      # This will only work if the template rendered a valid XML document.
-      def assert_template_xpath_match(expression=nil, expected=nil, message=nil) #:nodoc:
-        xml, matches = REXML::Document.new(@response.body), []
-        xml.elements.each(expression) { |e| matches << e.text }
-        if matches.empty? then
-          msg = build_message(message, "<?> not found in document", expression)
-          flunk(msg)
-          return
-        elsif matches.length < 2 then
-          matches = matches.first
-        end
-
-        msg = build_message(message, "<?> found <?>, not <?>", expression, matches, expected)
-        assert_block(msg) { matches == expected }
-      end
-      deprecate :assert_template_xpath_match => "you should use assert_tag, instead"
-
-      # Assert the template object with the given name is an Active Record descendant and is valid.
-      def assert_valid_record(key = nil, message = nil) #:nodoc:
-        record = find_record_in_template(key)
-        msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
-        assert_block(msg) { record.valid? }
-      end
-      deprecate :assert_valid_record => "use assert(assigns(key).valid?)"
-
-      # Assert the template object with the given name is an Active Record descendant and is invalid.
-      def assert_invalid_record(key = nil, message = nil) #:nodoc:
-        record = find_record_in_template(key)
-        msg = build_message(message, "Active Record is valid)")
-        assert_block(msg) { !record.valid? }
-      end
-      deprecate :assert_invalid_record => "use assert(!assigns(key).valid?)"
-
-      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are valid.
-      def assert_valid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
-        record = find_record_in_template(key)
-        record.send(:validate)
-
-        cols = glue_columns(columns)
-        cols.delete_if { |col| !record.errors.invalid?(col) }
-        msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
-        assert_block(msg) { cols.empty? }
-      end
-      deprecate :assert_valid_column_on_record => "use assert(!record.errors.invalid?(column)) instead"
-
-      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are invalid.
-      def assert_invalid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
-        record = find_record_in_template(key)
-        record.send(:validate)
-
-        cols = glue_columns(columns)
-        cols.delete_if { |col| record.errors.invalid?(col) }
-        msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
-        assert_block(msg) { cols.empty? }
-      end
-      deprecate :assert_invalid_column_on_record => "use assert(record.errors.invalid?(column)) instead"
-
-      private
-        def glue_columns(columns)
-          cols = []
-          cols << columns if columns.class == String
-          cols += columns if columns.class == Array
-          cols
-        end
-
-        def find_record_in_template(key = nil)
-          assert_not_nil assigns(key)
-          record = @response.template_objects[key]
-
-          assert_not_nil(record)
-          assert_kind_of ActiveRecord::Base, record
-
-          return record
-        end
-    end
-  end
-end

data/lib/action_controller/cgi_ext/cgi_ext.rb

@@ -1,36 +0,0 @@
-require 'cgi'
-require 'cgi/session'
-require 'cgi/session/pstore'
-require 'action_controller/cgi_ext/cgi_methods'
-
-# Wrapper around the CGIMethods that have been secluded to allow testing without 
-# an instantiated CGI object
-class CGI #:nodoc:
-  class << self
-    alias :escapeHTML_fail_on_nil :escapeHTML
-
-    def escapeHTML(string)
-      escapeHTML_fail_on_nil(string) unless string.nil?
-    end
-  end
-  
-  # Returns a parameter hash including values from both the request (POST/GET)
-  # and the query string with the latter taking precedence.
-  def parameters
-    request_parameters.update(query_parameters)
-  end
-
-  def query_parameters
-    CGIMethods.parse_query_parameters(query_string)
-  end
-
-  def request_parameters
-    CGIMethods.parse_request_parameters(params, env_table)
-  end
-  
-  def session(parameters = nil)
-    parameters = {} if parameters.nil?
-    parameters['database_manager'] = CGI::Session::PStore
-    CGI::Session.new(self, parameters)
-  end
-end

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -1,211 +0,0 @@
-require 'cgi'
-require 'action_controller/vendor/xml_node'
-require 'strscan'
-
-# Static methods for parsing the query and request parameters that can be used in
-# a CGI extension class or testing in isolation.
-class CGIMethods #:nodoc:
-  class << self
-    # DEPRECATED: Use parse_form_encoded_parameters
-    def parse_query_parameters(query_string)
-      pairs = query_string.split('&').collect do |chunk|
-        next if chunk.empty?
-        key, value = chunk.split('=', 2)
-        next if key.empty?
-        value = (value.nil? || value.empty?) ? nil : CGI.unescape(value)
-        [ CGI.unescape(key), value ]
-      end.compact
-
-      FormEncodedPairParser.new(pairs).result
-    end
-
-    # DEPRECATED: Use parse_form_encoded_parameters
-    def parse_request_parameters(params)
-      parser = FormEncodedPairParser.new
-
-      params = params.dup
-      until params.empty?
-        for key, value in params
-          if key.blank?
-            params.delete key
-          elsif !key.include?('[')
-            # much faster to test for the most common case first (GET)
-            # and avoid the call to build_deep_hash
-            parser.result[key] = get_typed_value(value[0])
-            params.delete key
-          elsif value.is_a?(Array)
-            parser.parse(key, get_typed_value(value.shift))
-            params.delete key if value.empty?
-          else
-            raise TypeError, "Expected array, found #{value.inspect}"
-          end
-        end
-      end
-    
-      parser.result
-    end
-
-    def parse_formatted_request_parameters(mime_type, raw_post_data)
-      case strategy = ActionController::Base.param_parsers[mime_type]
-        when Proc
-          strategy.call(raw_post_data)
-        when :xml_simple
-          raw_post_data.blank? ? {} : Hash.from_xml(raw_post_data)
-        when :yaml
-          YAML.load(raw_post_data)
-        when :xml_node
-          node = XmlNode.from_xml(raw_post_data)
-          { node.node_name => node }
-      end
-    rescue Exception => e # YAML, XML or Ruby code block errors
-      { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
-        "raw_post_data" => raw_post_data, "format" => mime_type }
-    end
-
-    private
-      def get_typed_value(value)
-        case value
-          when String
-            value
-          when NilClass
-            ''
-          when Array
-            value.map { |v| get_typed_value(v) }
-          else
-            # Uploaded file provides content type and filename.
-            if value.respond_to?(:content_type) &&
-                  !value.content_type.blank? &&
-                  !value.original_filename.blank?
-              unless value.respond_to?(:full_original_filename)
-                class << value
-                  alias_method :full_original_filename, :original_filename
-
-                  # Take the basename of the upload's original filename.
-                  # This handles the full Windows paths given by Internet Explorer
-                  # (and perhaps other broken user agents) without affecting
-                  # those which give the lone filename.
-                  # The Windows regexp is adapted from Perl's File::Basename.
-                  def original_filename
-                    if md = /^(?:.*[:\\\/])?(.*)/m.match(full_original_filename)
-                      md.captures.first
-                    else
-                      File.basename full_original_filename
-                    end
-                  end
-                end
-              end
-
-              # Return the same value after overriding original_filename.
-              value
-
-            # Multipart values may have content type, but no filename.
-            elsif value.respond_to?(:read)
-              result = value.read
-              value.rewind
-              result
-
-            # Unknown value, neither string nor multipart.
-            else
-              raise "Unknown form value: #{value.inspect}"
-            end
-        end
-      end
-  end
-
-  class FormEncodedPairParser < StringScanner #:nodoc:
-    attr_reader :top, :parent, :result
-
-    def initialize(pairs = [])
-      super('')
-      @result = {}
-      pairs.each { |key, value| parse(key, value) }
-    end
-     
-    KEY_REGEXP = %r{([^\[\]=&]+)}
-    BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
-    
-    # Parse the query string
-    def parse(key, value)
-      self.string = key
-      @top, @parent = result, nil
-      
-      # First scan the bare key
-      key = scan(KEY_REGEXP) or return
-      key = post_key_check(key)
-            
-      # Then scan as many nestings as present
-      until eos? 
-        r = scan(BRACKETED_KEY_REGEXP) or return
-        key = self[1]
-        key = post_key_check(key)
-      end
- 
-      bind(key, value)
-    end
-
-    private
-      # After we see a key, we must look ahead to determine our next action. Cases:
-      # 
-      #   [] follows the key. Then the value must be an array.
-      #   = follows the key. (A value comes next)
-      #   & or the end of string follows the key. Then the key is a flag.
-      #   otherwise, a hash follows the key. 
-      def post_key_check(key)
-        if scan(/\[\]/) # a[b][] indicates that b is an array
-          container(key, Array)
-          nil
-        elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
-          container(key, Hash)
-          nil
-        else # End of key? We do nothing.
-          key
-        end
-      end
-    
-      # Add a container to the stack.
-      # 
-      def container(key, klass)
-        type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
-        value = bind(key, klass.new)
-        type_conflict! klass, value unless value.is_a?(klass)
-        push(value)
-      end
-    
-      # Push a value onto the 'stack', which is actually only the top 2 items.
-      def push(value)
-        @parent, @top = @top, value
-      end
-    
-      # Bind a key (which may be nil for items in an array) to the provided value.
-      def bind(key, value)
-        if top.is_a? Array
-          if key
-            if top[-1].is_a?(Hash) && ! top[-1].key?(key)
-              top[-1][key] = value
-            else
-              top << {key => value}.with_indifferent_access
-              push top.last
-            end
-          else
-            top << value
-          end
-        elsif top.is_a? Hash
-          key = CGI.unescape(key)
-          parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
-          return top[key] ||= value
-        else
-          raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
-        end
-
-        return value
-      end
-      
-      def type_conflict!(klass, value)
-        raise TypeError, 
-          "Conflicting types for parameter containers. " +
-          "Expected an instance of #{klass}, but found an instance of #{value.class}. " +
-          "This can be caused by passing Array and Hash based paramters qs[]=value&qs[key]=value. "
-      end
-      
-    end
-end