actionpack-2.3.17-rack-upgrade 2.3.17

data/lib/action_view/template_error.rb

@@ -0,0 +1,99 @@
+module ActionView
+  # The TemplateError exception is raised when the compilation of the template fails. This exception then gathers a
+  # bunch of intimate details and uses it to report a very precise exception message.
+  class TemplateError < ActionViewError #:nodoc:
+    SOURCE_CODE_RADIUS = 3
+
+    attr_reader :original_exception
+
+    def initialize(template, assigns, original_exception)
+      @template, @assigns, @original_exception = template, assigns.dup, original_exception
+      @backtrace = compute_backtrace
+    end
+
+    def file_name
+      @template.relative_path
+    end
+
+    def message
+      ActiveSupport::Deprecation.silence { original_exception.message }
+    end
+
+    def clean_backtrace
+      if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+        Rails.backtrace_cleaner.clean(original_exception.backtrace)
+      else
+        original_exception.backtrace
+      end
+    end
+
+    def sub_template_message
+      if @sub_templates
+        "Trace of template inclusion: " +
+        @sub_templates.collect { |template| template.relative_path }.join(", ")
+      else
+        ""
+      end
+    end
+
+    def source_extract(indentation = 0)
+      return unless num = line_number
+      num = num.to_i
+
+      source_code = @template.source.split("\n")
+
+      start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
+      end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
+
+      indent = ' ' * indentation
+      line_counter = start_on_line
+      return unless source_code = source_code[start_on_line..end_on_line]
+
+      source_code.sum do |line|
+        line_counter += 1
+        "#{indent}#{line_counter}: #{line}\n"
+      end
+    end
+
+    def sub_template_of(template_path)
+      @sub_templates ||= []
+      @sub_templates << template_path
+    end
+
+    def line_number
+      @line_number ||=
+        if file_name
+          regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
+
+          $1 if message =~ regexp or clean_backtrace.find { |line| line =~ regexp }
+        end
+    end
+
+    def to_s
+      "\n#{self.class} (#{message}) #{source_location}:\n" + 
+      "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
+    end
+
+    # don't do anything nontrivial here. Any raised exception from here becomes fatal 
+    # (and can't be rescued).
+    def backtrace
+      @backtrace
+    end
+
+    private
+      def compute_backtrace
+        [
+          "#{source_location.capitalize}\n\n#{source_extract(4)}\n    " +
+          clean_backtrace.join("\n    ")
+        ]
+      end
+
+      def source_location
+        if line_number
+          "on line ##{line_number} of "
+        else
+          'in '
+        end + file_name
+      end
+  end
+end

data/lib/action_view/template_handler.rb

@@ -0,0 +1,34 @@
+# Legacy TemplateHandler stub
+module ActionView
+  module TemplateHandlers #:nodoc:
+    module Compilable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def call(template)
+          new.compile(template)
+        end
+      end
+
+      def compile(template)
+         raise "Need to implement #{self.class.name}#compile(template)"
+       end
+    end
+  end
+
+  class TemplateHandler
+    def self.call(template)
+      "#{name}.new(self).render(template, local_assigns)"
+    end
+
+    def initialize(view = nil)
+      @view = view
+    end
+
+    def render(template, local_assigns)
+      raise "Need to implement #{self.class.name}#render(template, local_assigns)"
+    end
+  end
+end

data/lib/action_view/template_handlers.rb

@@ -0,0 +1,48 @@
+module ActionView #:nodoc:
+  module TemplateHandlers #:nodoc:
+    autoload :ERB, 'action_view/template_handlers/erb'
+    autoload :RJS, 'action_view/template_handlers/rjs'
+    autoload :Builder, 'action_view/template_handlers/builder'
+
+    def self.extended(base)
+      base.register_default_template_handler :erb, TemplateHandlers::ERB
+      base.register_template_handler :rjs, TemplateHandlers::RJS
+      base.register_template_handler :builder, TemplateHandlers::Builder
+
+      # TODO: Depreciate old template extensions
+      base.register_template_handler :rhtml, TemplateHandlers::ERB
+      base.register_template_handler :rxml, TemplateHandlers::Builder
+    end
+
+    @@template_handlers = {}
+    @@default_template_handlers = nil
+
+    # Register a class that knows how to handle template files with the given
+    # extension. This can be used to implement new template types.
+    # The constructor for the class must take the ActiveView::Base instance
+    # as a parameter, and the class must implement a +render+ method that
+    # takes the contents of the template to render as well as the Hash of
+    # local assigns available to the template. The +render+ method ought to
+    # return the rendered template as a string.
+    def register_template_handler(extension, klass)
+      @@template_handlers[extension.to_sym] = klass
+    end
+
+    def template_handler_extensions
+      @@template_handlers.keys.map(&:to_s).sort
+    end
+
+    def registered_template_handler(extension)
+      extension && @@template_handlers[extension.to_sym]
+    end
+
+    def register_default_template_handler(extension, klass)
+      register_template_handler(extension, klass)
+      @@default_template_handlers = klass
+    end
+
+    def handler_class_for_extension(extension)
+      registered_template_handler(extension) || @@default_template_handlers
+    end
+  end
+end

data/lib/action_view/template_handlers/builder.rb

@@ -0,0 +1,17 @@
+require 'builder'
+
+module ActionView
+  module TemplateHandlers
+    class Builder < TemplateHandler
+      include Compilable
+
+      def compile(template)
+        "_set_controller_content_type(Mime::XML);" +
+          "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+          "self.output_buffer = xml.target!;" +
+          template.source +
+          ";xml.target!;"
+      end
+    end
+  end
+end

data/lib/action_view/template_handlers/erb.rb

@@ -0,0 +1,25 @@
+module ActionView
+  module TemplateHandlers
+    class ERB < TemplateHandler
+      include Compilable
+
+      ##
+      # :singleton-method:
+      # Specify trim mode for the ERB compiler. Defaults to '-'.
+      # See ERb documentation for suitable values.
+      cattr_accessor :erb_trim_mode
+      self.erb_trim_mode = '-'
+
+      def compile(template)
+        magic = $1 if template.source =~ /\A(<%#.*coding[:=]\s*(\S+)\s*-?%>)/
+        erb = "#{magic}<% __in_erb_template=true %>#{template.source}"
+
+        if erb.respond_to?(:force_encoding)
+          erb.force_encoding(template.source.encoding)
+        end
+
+        ::ERB.new(erb, nil, erb_trim_mode, '@output_buffer').src
+      end
+    end
+  end
+end

data/lib/action_view/template_handlers/rjs.rb

@@ -0,0 +1,13 @@
+module ActionView
+  module TemplateHandlers
+    class RJS < TemplateHandler
+      include Compilable
+
+      def compile(template)
+        "@template_format = :html;" +
+        "controller.response.content_type ||= Mime::JS;" +
+          "update_page do |page|;#{template.source}\nend"
+      end
+    end
+  end
+end

data/lib/action_view/test_case.rb

@@ -0,0 +1,162 @@
+require 'active_support/test_case'
+
+module ActionView
+  class Base
+    alias_method :initialize_without_template_tracking, :initialize
+    def initialize(*args)
+      @_rendered = { :template => nil, :partials => Hash.new(0) }
+      initialize_without_template_tracking(*args)
+    end
+  end
+
+  module Renderable
+    alias_method :render_without_template_tracking, :render
+    def render(view, local_assigns = {})
+      if respond_to?(:path) && !is_a?(InlineTemplate)
+        rendered = view.instance_variable_get(:@_rendered)
+        rendered[:partials][self] += 1 if is_a?(RenderablePartial)
+        rendered[:template] ||= self
+      end
+      render_without_template_tracking(view, local_assigns)
+    end
+  end
+
+  class TestCase < ActiveSupport::TestCase
+    class TestController < ActionController::Base
+      attr_accessor :request, :response, :params
+
+      def self.controller_path
+        ''
+      end
+
+      def initialize
+        @request = ActionController::TestRequest.new
+        @response = ActionController::TestResponse.new
+
+        @params = {}
+        send(:initialize_current_url)
+      end
+    end
+
+    include ActionController::TestCase::Assertions
+    include ActionController::TestProcess
+
+    include ActionController::PolymorphicRoutes
+    include ActionController::RecordIdentifier
+
+    include ActionView::Helpers
+    include ActionController::Helpers
+
+    class_inheritable_accessor :helper_class
+    attr_accessor :controller, :output_buffer, :rendered
+
+    setup :setup_with_controller
+    def setup_with_controller
+      @controller = TestController.new
+      @output_buffer = ''
+      @rendered = ''
+
+      self.class.send(:include_helper_modules!)
+      make_test_case_available_to_view!
+    end
+
+    def render(options = {}, local_assigns = {}, &block)
+      @rendered << output = _view.render(options, local_assigns, &block)
+      output
+    end
+
+    def protect_against_forgery?
+      false
+    end
+
+    class << self
+      def tests(helper_class)
+        self.helper_class = helper_class
+      end
+
+      def helper_class
+        if current_helper_class = read_inheritable_attribute(:helper_class)
+          current_helper_class
+        else
+          self.helper_class = determine_default_helper_class(name)
+        end
+      end
+
+      def determine_default_helper_class(name)
+        name.sub(/Test$/, '').constantize
+      rescue NameError
+        nil
+      end
+
+      def helper_method(*methods)
+        # Almost a duplicate from ActionController::Helpers
+        methods.flatten.each do |method|
+          master_helper_module.module_eval <<-end_eval
+            def #{method}(*args, &block)                    # def current_user(*args, &block)
+              _test_case.send(%(#{method}), *args, &block)  #   test_case.send(%(current_user), *args, &block)
+            end                                             # end
+          end_eval
+        end
+      end
+
+      private
+        def include_helper_modules!
+          helper(helper_class) if helper_class
+          include master_helper_module
+        end
+    end
+
+    private
+      def make_test_case_available_to_view!
+        test_case_instance = self
+        master_helper_module.module_eval do
+          define_method(:_test_case) { test_case_instance }
+          private :_test_case
+        end
+      end
+
+      def _view
+        view = ActionView::Base.new(ActionController::Base.view_paths, _assigns, @controller)
+        view.helpers.include master_helper_module
+        view.output_buffer = self.output_buffer
+        view
+      end
+
+      # Support the selector assertions
+      #
+      # Need to experiment if this priority is the best one: rendered => output_buffer
+      def response_from_page_or_rjs
+        HTML::Document.new(rendered.blank? ? output_buffer : rendered).root
+      end
+
+      EXCLUDE_IVARS = %w{
+        @output_buffer
+        @fixture_cache
+        @method_name
+        @_result
+        @loaded_fixtures
+        @test_passed
+        @view
+      }
+
+      def _instance_variables
+        instance_variables - EXCLUDE_IVARS
+      end
+
+      def _assigns
+        _instance_variables.inject({}) do |hash, var|
+          name = var[1..-1].to_sym
+          hash[name] = instance_variable_get(var)
+          hash
+        end
+      end
+
+      def method_missing(selector, *args)
+        if ActionController::Routing::Routes.named_routes.helpers.include?(selector)
+          @controller.__send__(selector, *args)
+        else
+          super
+        end
+      end
+  end
+end

data/lib/actionpack.rb

@@ -0,0 +1,2 @@
+require 'action_pack'
+ActiveSupport::Deprecation.warn 'require "actionpack" is deprecated and will be removed in Rails 3. Use require "action_pack" instead.'

data/test/abstract_unit.rb

@@ -0,0 +1,78 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+$:.unshift File.expand_path('../../../activesupport/lib', __FILE__)
+$:.unshift File.expand_path('../fixtures/helpers', __FILE__)
+$:.unshift File.expand_path('../fixtures/alternate_helpers', __FILE__)
+
+require 'rubygems'
+require 'yaml'
+require 'stringio'
+require 'test/unit'
+
+gem 'mocha', '>= 0.9.7'
+require 'mocha'
+
+begin
+  require 'ruby-debug'
+  Debugger.settings[:autoeval] = true
+  Debugger.start
+rescue LoadError
+  # Debugging disabled. `gem install ruby-debug` to enable.
+end
+
+require 'action_controller'
+require 'action_controller/cgi_ext'
+require 'action_controller/test_process'
+require 'action_view/test_case'
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+ActionController::Base.logger = nil
+ActionController::Routing::Routes.reload rescue nil
+
+ActionController::Base.session_store = nil
+
+# Register languages for testing
+I18n.backend.store_translations 'da', "da" => {}
+I18n.backend.store_translations 'pt-BR', "pt-BR" => {}
+ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
+
+FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
+ActionView::Base.cache_template_loading = true
+ActionController::Base.view_paths = FIXTURE_LOAD_PATH
+CACHED_VIEW_PATHS = ActionView::Base.cache_template_loading? ?
+                      ActionController::Base.view_paths :
+                      ActionController::Base.view_paths.map {|path| ActionView::Template::EagerPath.new(path.to_s)}
+
+class DummyMutex
+  def lock
+    @locked = true
+  end
+
+  def unlock
+    @locked = false
+  end
+
+  def locked?
+    @locked
+  end
+end
+
+class ActionController::IntegrationTest < ActiveSupport::TestCase
+  def with_autoload_path(path)
+    path = File.join(File.dirname(__FILE__), "fixtures", path)  
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end              
+    end
+  end
+end
+
+ActionController::Reloader.default_lock = DummyMutex.new