actionpack-rack-upgrade-2 2.3.15

data/Rakefile

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rake/packagetask'
+require 'rubygems/package_task'
+require File.join(File.dirname(__FILE__), 'lib', 'action_pack', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'actionpack-rack-upgrade-2'
+PKG_VERSION   = ActionPack::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "actionpack"
+RUBY_FORGE_USER    = "webster132"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+
+desc "Run all unit tests"
+task :test => [:test_action_pack, :test_active_record_integration]
+
+Rake::TestTask.new(:test_action_pack) do |t|
+  t.libs << "test"
+
+  # make sure we include the tests in alphabetical order as on some systems
+  # this will not happen automatically and the tests (as a whole) will error
+  t.test_files = Dir.glob( "test/[cftv]*/**/*_test.rb" ).sort
+
+  t.verbose = true
+  #t.warning = true
+end
+
+desc 'ActiveRecord Integration Tests'
+Rake::TestTask.new(:test_active_record_integration) do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/activerecord/*_test.rb")
+  t.verbose = true
+end
+
+
+# Genereate the RDoc documentation
+
+RDoc::Task.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Action Pack -- On rails from request to response"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
+  if ENV['DOC_FILES'] 
+    rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+  else
+    rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
+    rdoc.rdoc_files.include(Dir['lib/**/*.rb'] -
+                            Dir['lib/*/vendor/**/*.rb'])
+    rdoc.rdoc_files.exclude('lib/actionpack.rb')
+  end
+}
+
+# Create compressed packages
+dist_dirs = [ "lib", "test" ]
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Web-flow and rendering framework putting the VC in MVC."
+  s.description = %q{Eases web-request routing, handling, and response as a half-way front, half-way page controller. Implemented with specific emphasis on enabling easy unit/integration testing that doesn't require a browser.} #'
+
+  s.author = "David Heinemeier Hansson"
+  s.email = "david@loudthinking.com"
+  s.rubyforge_project = "actionpack"
+  s.homepage = "http://www.rubyonrails.org"
+
+  s.requirements << 'none'
+
+  s.add_dependency('activesupport', '= 2.3.15' + PKG_BUILD)
+  s.add_dependency('rack', '~> 1.1.3')
+
+  s.require_path = 'lib'
+
+  s.files = [ "Rakefile", "install.rb", "README", "RUNNING_UNIT_TESTS", "CHANGELOG", "MIT-LICENSE" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+end
+  
+Gem::PackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+# Publishing ------------------------------------------------------
+
+task :update_scriptaculous do
+  for js in %w( controls dragdrop effects )
+    system("svn export --force http://dev.rubyonrails.org/svn/rails/spinoffs/scriptaculous/src/#{js}.js #{File.dirname(__FILE__)}/lib/action_view/helpers/javascripts/#{js}.js")
+  end
+end
+
+desc "Updates actionpack to the latest version of the javascript spinoffs"
+task :update_js => [ :update_scriptaculous ]
+
+# Publishing ------------------------------------------------------
+
+desc "Publish the API documentation"
+task :pgem => [:package] do 
+  require 'rake/contrib/sshpublisher'
+  Rake::SshFilePublisher.new("gems.rubyonrails.org", "/u/sites/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh gems.rubyonrails.org '/u/sites/gems/gemupdate.sh'`
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  require 'rake/contrib/sshpublisher'
+  Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/ap", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+  require 'rake/contrib/rubyforgepublisher'
+
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by way of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the actual gruntwork
+Dir.chdir("lib")
+
+Find.find("action_controller", "action_controller.rb", "action_view", "action_view.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/lib/action_controller.rb

@@ -0,0 +1,113 @@
+#--
+# Copyright (c) 2004-2010 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+begin
+  require 'active_support'
+rescue LoadError
+  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+  if File.directory?(activesupport_path)
+    $:.unshift activesupport_path
+    require 'active_support'
+  end
+end
+
+gem 'rack', '> 1.1.3'
+require 'rack'
+require 'action_controller/cgi_ext'
+
+module ActionController
+  # TODO: Review explicit to see if they will automatically be handled by
+  # the initilizer if they are really needed.
+  def self.load_all!
+    [Base, CGIHandler, CgiRequest, Request, Response, Http::Headers, UrlRewriter, UrlWriter]
+  end
+
+  autoload :Base, 'action_controller/base'
+  autoload :Benchmarking, 'action_controller/benchmarking'
+  autoload :Caching, 'action_controller/caching'
+  autoload :Cookies, 'action_controller/cookies'
+  autoload :Dispatcher, 'action_controller/dispatcher'
+  autoload :Failsafe, 'action_controller/failsafe'
+  autoload :Filters, 'action_controller/filters'
+  autoload :Flash, 'action_controller/flash'
+  autoload :Helpers, 'action_controller/helpers'
+  autoload :HttpAuthentication, 'action_controller/http_authentication'
+  autoload :Integration, 'action_controller/integration'
+  autoload :IntegrationTest, 'action_controller/integration'
+  autoload :Layout, 'action_controller/layout'
+  autoload :MiddlewareStack, 'action_controller/middleware_stack'
+  autoload :MimeResponds, 'action_controller/mime_responds'
+  autoload :ParamsParser, 'action_controller/params_parser'
+  autoload :PolymorphicRoutes, 'action_controller/polymorphic_routes'
+  autoload :RecordIdentifier, 'action_controller/record_identifier'
+  autoload :Reloader, 'action_controller/reloader'
+  autoload :Request, 'action_controller/request'
+  autoload :RequestForgeryProtection, 'action_controller/request_forgery_protection'
+  autoload :Rescue, 'action_controller/rescue'
+  autoload :Resources, 'action_controller/resources'
+  autoload :Response, 'action_controller/response'
+  autoload :RewindableInput, 'action_controller/rewindable_input'
+  autoload :Routing, 'action_controller/routing'
+  autoload :SessionManagement, 'action_controller/session_management'
+  autoload :StatusCodes, 'action_controller/status_codes'
+  autoload :Streaming, 'action_controller/streaming'
+  autoload :StringCoercion, 'action_controller/string_coercion'
+  autoload :TestCase, 'action_controller/test_case'
+  autoload :TestProcess, 'action_controller/test_process'
+  autoload :Translation, 'action_controller/translation'
+  autoload :UploadedFile, 'action_controller/uploaded_file'
+  autoload :UploadedStringIO, 'action_controller/uploaded_file'
+  autoload :UploadedTempfile, 'action_controller/uploaded_file'
+  autoload :UrlRewriter, 'action_controller/url_rewriter'
+  autoload :UrlWriter, 'action_controller/url_rewriter'
+  autoload :Verification, 'action_controller/verification'
+
+  module Assertions
+    autoload :DomAssertions, 'action_controller/assertions/dom_assertions'
+    autoload :ModelAssertions, 'action_controller/assertions/model_assertions'
+    autoload :ResponseAssertions, 'action_controller/assertions/response_assertions'
+    autoload :RoutingAssertions, 'action_controller/assertions/routing_assertions'
+    autoload :SelectorAssertions, 'action_controller/assertions/selector_assertions'
+    autoload :TagAssertions, 'action_controller/assertions/tag_assertions'
+  end
+
+  module Http
+    autoload :Headers, 'action_controller/headers'
+  end
+
+  module Session
+    autoload :AbstractStore, 'action_controller/session/abstract_store'
+    autoload :CookieStore, 'action_controller/session/cookie_store'
+    autoload :MemCacheStore, 'action_controller/session/mem_cache_store'
+  end
+
+  # DEPRECATE: Remove CGI support
+  autoload :CgiRequest, 'action_controller/cgi_process'
+  autoload :CGIHandler, 'action_controller/cgi_process'
+end
+
+autoload :Mime, 'action_controller/mime_type'
+
+autoload :HTML, 'action_controller/vendor/html-scanner'
+
+require 'action_view'

data/lib/action_controller/assertions/dom_assertions.rb

@@ -0,0 +1,55 @@
+module ActionController
+  module Assertions
+    module DomAssertions
+      def self.strip_whitespace!(nodes)
+        nodes.reject! do |node|
+          if node.is_a?(HTML::Text)
+            node.content.strip!
+            node.content.empty?
+          else
+            strip_whitespace! node.children
+            false
+          end
+        end
+      end
+      
+      # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method generates the appropriate HTML string
+      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
+      #
+      def assert_dom_equal(expected, actual, message = "")
+        clean_backtrace do
+          expected_dom = HTML::Document.new(expected).root
+          actual_dom   = HTML::Document.new(actual).root
+          DomAssertions.strip_whitespace!(expected_dom.children)
+          DomAssertions.strip_whitespace!(actual_dom.children)
+
+          full_message = build_message(message, "<?> expected but was\n<?>.", expected_dom.to_s, actual_dom.to_s)
+          assert_block(full_message) { expected_dom == actual_dom }
+        end
+      end
+      
+      # The negated form of +assert_dom_equal+.
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method does not generate the specified HTML string
+      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
+      #
+      def assert_dom_not_equal(expected, actual, message = "")
+        clean_backtrace do
+          expected_dom = HTML::Document.new(expected).root
+          actual_dom   = HTML::Document.new(actual).root
+          DomAssertions.strip_whitespace!(expected_dom.children)
+          DomAssertions.strip_whitespace!(actual_dom.children)
+
+          full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+          assert_block(full_message) { expected_dom != actual_dom }
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/assertions/model_assertions.rb

@@ -0,0 +1,21 @@
+module ActionController
+  module Assertions
+    module ModelAssertions
+      # Ensures that the passed record is valid by Active Record standards and
+      # returns any error messages if it is not.
+      #
+      # ==== Examples
+      #
+      #   # assert that a newly created record is valid
+      #   model = Model.new
+      #   assert_valid(model)
+      #
+      def assert_valid(record)
+        ::ActiveSupport::Deprecation.warn("assert_valid is deprecated. Use assert record.valid? instead", caller)
+        clean_backtrace do
+          assert record.valid?, record.errors.full_messages.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/assertions/response_assertions.rb

@@ -0,0 +1,169 @@
+module ActionController
+  module Assertions
+    # A small suite of assertions that test responses from Rails applications.
+    module ResponseAssertions
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was 200
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like assert_response(501)
+      # or its symbolic equivalent assert_response(:not_implemented).
+      # See ActionController::StatusCodes for a full list.
+      #
+      # ==== Examples
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      #
+      def assert_response(type, message = nil)
+        clean_backtrace do
+          if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
+            assert_block("") { true } # to count the assertion
+          elsif type.is_a?(Fixnum) && @response.response_code == type
+            assert_block("") { true } # to count the assertion
+          elsif type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+            assert_block("") { true } # to count the assertion
+          else
+            if @response.error?
+              exception = @response.template.instance_variable_get(:@exception)
+              exception_message = exception && exception.message
+              assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
+            else
+              assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
+            end
+          end
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action.
+      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
+      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
+      #
+      # ==== Examples
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to :controller => "weblog", :action => "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # assert that the redirection was to the url for @customer
+      #   assert_redirected_to @customer
+      #
+      def assert_redirected_to(options = {}, message=nil)
+        clean_backtrace do
+          assert_response(:redirect, message)
+          return true if options == @response.redirected_to
+
+          # Support partial arguments for hash redirections
+          if options.is_a?(Hash) && @response.redirected_to.is_a?(Hash)
+            if options.all? {|(key, value)| @response.redirected_to[key] == value}
+              callstack = caller.dup
+              callstack.slice!(0, 2)
+              ::ActiveSupport::Deprecation.warn("Using assert_redirected_to with partial hash arguments is deprecated. Specify the full set arguments instead", callstack)
+              return true
+            end
+          end
+
+          redirected_to_after_normalisation = normalize_argument_to_redirection(@response.redirected_to)
+          options_after_normalisation       = normalize_argument_to_redirection(options)
+
+          if redirected_to_after_normalisation != options_after_normalisation
+            flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
+          end
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file or partials
+      #
+      # ==== Examples
+      #
+      #   # assert that the "new" view template was rendered
+      #   assert_template "new"
+      #
+      #   # assert that the "new" view template was rendered with Symbol
+      #   assert_template :new
+      #
+      #   # assert that the "_customer" partial was rendered twice
+      #   assert_template :partial => '_customer', :count => 2
+      #
+      #   # assert that no partials were rendered
+      #   assert_template :partial => false
+      #
+      def assert_template(options = {}, message = nil)
+        clean_backtrace do
+          case options
+           when NilClass, String, Symbol
+            rendered = @response.rendered[:template].to_s
+            msg = build_message(message,
+                    "expecting <?> but rendering with <?>",
+                    options, rendered)
+            assert_block(msg) do
+              if options.nil?
+                @response.rendered[:template].blank?
+              else
+                rendered.to_s.match(options.to_s)
+              end
+            end
+          when Hash
+            if expected_partial = options[:partial]
+              partials = @response.rendered[:partials]
+              if expected_count = options[:count]
+                found = partials.detect { |p, _| p.to_s.match(expected_partial) }
+                actual_count = found.nil? ? 0 : found.second
+                msg = build_message(message,
+                        "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+                         expected_partial, expected_count, actual_count)
+                assert(actual_count == expected_count.to_i, msg)
+              else
+                msg = build_message(message,
+                        "expecting partial <?> but action rendered <?>",
+                        options[:partial], partials.keys)
+                assert(partials.keys.any? { |p| p.to_s.match(expected_partial) }, msg)
+              end
+            else
+              assert @response.rendered[:partials].empty?,
+                "Expected no partials to be rendered"
+            end
+          else
+            raise ArgumentError  
+          end
+        end
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          case fragment
+          when %r{^\w[\w\d+.-]*:.*}
+            fragment
+          when String
+            if fragment =~ %r{^\w[\w\d+.-]*:.*}
+              fragment
+            else
+              if fragment !~ /^\//
+                ActiveSupport::Deprecation.warn "Omitting the leading slash on a path with assert_redirected_to is deprecated. Use '/#{fragment}' instead.", caller(2)
+                fragment = "/#{fragment}"
+              end
+              @request.protocol + @request.host_with_port + fragment
+            end
+          when :back
+            raise RedirectBackError unless refer = @request.headers["Referer"]
+            refer
+          else
+            @controller.url_for(fragment)
+          end.gsub(/[\r\n]/, '')
+        end
+    end
+  end
+end