actionpack 2.3.18 → 3.0.0.beta

data/RUNNING_UNIT_TESTS

@@ -1,24 +0,0 @@
-== Running with Rake
-
-The easiest way to run the unit tests is through Rake. The default task runs
-the entire test suite for all classes. For more information, checkout the 
-full array of rake tasks with "rake -T"
-
-Rake can be found at http://rake.rubyforge.org
-
-== Running by hand
-
-If you only want to run a single test suite, or don't want to bother with Rake,
-you can do so with something like:
-
-   ruby controller/base_tests.rb
-
-== Dependency on ActiveRecord and database setup
-
-Test cases in the test/controller/active_record/ directory depend on having
-activerecord and sqlite installed. If ActiveRecord is not in 
-actionpack/../activerecord directory, or the sqlite rubygem is not installed,
-these tests are skipped.
-
-Other tests are runnable from a fresh copy of actionpack without any configuration.
-

data/Rakefile

@@ -1,158 +0,0 @@
-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'
-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.18' + PKG_BUILD)
-  s.add_dependency('rack', '~> 1.1.0')
-
-  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

@@ -1,30 +0,0 @@
-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/assertions/dom_assertions.rb

@@ -1,55 +0,0 @@
-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/response_assertions.rb

@@ -1,169 +0,0 @@
-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

data/lib/action_controller/benchmarking.rb

@@ -1,107 +0,0 @@
-require 'benchmark'
-
-module ActionController #:nodoc:
-  # The benchmarking module times the performance of actions and reports to the logger. If the Active Record
-  # package has been included, a separate timing section for database calls will be added as well.
-  module Benchmarking #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        alias_method_chain :perform_action, :benchmark
-        alias_method_chain :render, :benchmark
-      end
-    end
-
-    module ClassMethods
-      # Log and benchmark the workings of a single block and silence whatever logging that may have happened inside it 
-      # (unless <tt>use_silence</tt> is set to false).
-      #
-      # The benchmark is only recorded if the current level of the logger matches the <tt>log_level</tt>, which makes it
-      # easy to include benchmarking statements in production software that will remain inexpensive because the benchmark
-      # will only be conducted if the log level is low enough.
-      def benchmark(title, log_level = Logger::DEBUG, use_silence = true)
-        if logger && logger.level == log_level
-          result = nil
-          ms = Benchmark.ms { result = use_silence ? silence { yield } : yield }
-          logger.add(log_level, "#{title} (#{('%.1f' % ms)}ms)")
-          result
-        else
-          yield
-        end
-      end
-
-      # Silences the logger for the duration of the block.
-      def silence
-        old_logger_level, logger.level = logger.level, Logger::ERROR if logger
-        yield
-      ensure
-        logger.level = old_logger_level if logger
-      end
-    end
-
-    protected
-      def render_with_benchmark(options = nil, extra_options = {}, &block)
-        if logger
-          if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
-            db_runtime = ActiveRecord::Base.connection.reset_runtime
-          end
-
-          render_output = nil
-          @view_runtime = Benchmark.ms { render_output = render_without_benchmark(options, extra_options, &block) }
-
-          if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
-            @db_rt_before_render = db_runtime
-            @db_rt_after_render = ActiveRecord::Base.connection.reset_runtime
-            @view_runtime -= @db_rt_after_render
-          end
-
-          render_output
-        else
-          render_without_benchmark(options, extra_options, &block)
-        end
-      end    
-
-    private
-      def perform_action_with_benchmark
-        if logger
-          ms = [Benchmark.ms { perform_action_without_benchmark }, 0.01].max
-          logging_view          = defined?(@view_runtime)
-          logging_active_record = Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
-
-          log_message  = 'Completed in %.0fms' % ms
-
-          if logging_view || logging_active_record
-            log_message << " ("
-            log_message << view_runtime if logging_view
-
-            if logging_active_record
-              log_message << ", " if logging_view
-              log_message << active_record_runtime + ")"
-            else
-              ")"
-            end
-          end
-
-          log_message << " | #{response.status}"
-          log_message << " [#{complete_request_uri rescue "unknown"}]"
-
-          logger.info(log_message)
-          response.headers["X-Runtime"] = "%.0f" % ms
-        else
-          perform_action_without_benchmark
-        end
-      end
-
-      def view_runtime
-        "View: %.0f" % @view_runtime
-      end
-
-      def active_record_runtime
-        db_runtime = ActiveRecord::Base.connection.reset_runtime
-        db_runtime += @db_rt_before_render if @db_rt_before_render
-        db_runtime += @db_rt_after_render if @db_rt_after_render
-        "DB: %.0f" % db_runtime
-      end
-  end
-end