actionpack 2.3.18 → 3.0.0.beta

data/lib/action_controller/uploaded_file.rb

@@ -1,44 +0,0 @@
-module ActionController
-  module UploadedFile
-    def self.included(base)
-      base.class_eval do
-        attr_accessor :original_path, :content_type
-        alias_method :local_path, :path if method_defined?(:path)
-      end
-    end
-
-    def self.extended(object)
-      object.class_eval do
-        attr_accessor :original_path, :content_type
-        alias_method :local_path, :path if method_defined?(:path)
-      end
-    end
-
-    # 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
-      unless defined? @original_filename
-        @original_filename =
-          unless original_path.blank?
-            if original_path =~ /^(?:.*[:\\\/])?(.*)/m
-              $1
-            else
-              File.basename original_path
-            end
-          end
-      end
-      @original_filename
-    end
-  end
-
-  class UploadedStringIO < StringIO
-    include UploadedFile
-  end
-
-  class UploadedTempfile < Tempfile
-    include UploadedFile
-  end
-end

data/lib/action_view/helpers/benchmark_helper.rb

@@ -1,54 +0,0 @@
-require 'benchmark'
-
-module ActionView
-  module Helpers
-    # This helper offers a method to measure the execution time of a block 
-    # in a template.
-    module BenchmarkHelper
-      # Allows you to measure the execution time of a block 
-      # in a template and records the result to the log. Wrap this block around
-      # expensive operations or possible bottlenecks to get a time reading
-      # for the operation.  For example, let's say you thought your file 
-      # processing method was taking too long; you could wrap it in a benchmark block.
-      #
-      #  <% benchmark "Process data files" do %>
-      #    <%= expensive_files_operation %>
-      #  <% end %>
-      #
-      # That would add something like "Process data files (345.2ms)" to the log,
-      # which you can then use to compare timings when optimizing your code.
-      #
-      # You may give an optional logger level as the :level option.
-      # (:debug, :info, :warn, :error); the default value is :info.
-      #
-      #  <% benchmark "Low-level files", :level => :debug do %>
-      #    <%= lowlevel_files_operation %>
-      #  <% end %>
-      #
-      # Finally, you can pass true as the third argument to silence all log activity 
-      # inside the block. This is great for boiling down a noisy block to just a single statement:
-      #
-      #  <% benchmark "Process data files", :level => :info, :silence => true do %>
-      #    <%= expensive_and_chatty_files_operation %>
-      #  <% end %>
-      def benchmark(message = "Benchmarking", options = {})
-        if controller.logger
-          if options.is_a?(Symbol)
-            ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
-            options = { :level => options, :silence => false }
-          else
-            options.assert_valid_keys(:level, :silence)
-            options[:level] ||= :info
-          end
-          
-          result = nil
-          ms = Benchmark.ms { result = options[:silence] ? controller.logger.silence { yield } : yield }
-          controller.logger.send(options[:level], '%s (%.1fms)' % [ message, ms ])
-          result
-        else
-          yield
-        end
-      end
-    end
-  end
-end

data/lib/action_view/inline_template.rb

@@ -1,19 +0,0 @@
-module ActionView #:nodoc:
-  class InlineTemplate #:nodoc:
-    include Renderable
-
-    attr_reader :source, :extension, :method_segment
-
-    def initialize(source, type = nil)
-      @source = source
-      @extension = type
-      @method_segment = "inline_#{@source.hash.abs}"
-    end
-
-    private
-      # Always recompile inline templates
-      def recompile?
-        true
-      end
-  end
-end

data/lib/action_view/reloadable_template.rb

@@ -1,117 +0,0 @@
-module ActionView #:nodoc:
-  class ReloadableTemplate < Template
-
-    class TemplateDeleted < ActionView::ActionViewError
-    end
-
-    class ReloadablePath < Template::Path
-
-      def initialize(path)
-        super
-        @paths = {}
-        new_request!
-      end
-
-      def new_request!
-        @disk_cache = {}
-      end
-      alias_method :load!, :new_request!
-
-      def [](path)
-        if found_template = @paths[path]
-          begin
-            found_template.reset_cache_if_stale!
-          rescue TemplateDeleted
-            unregister_template(found_template)
-            self[path]
-          end
-        else
-          load_all_templates_from_dir(templates_dir_from_path(path))
-          # don't ever hand out a template without running a stale check
-          (new_template = @paths[path]) && new_template.reset_cache_if_stale!
-        end
-      end
-
-      private
-        def register_template_from_file(template_full_file_path)
-          if !@paths[relative_path = relative_path_for_template_file(template_full_file_path)] && File.file?(template_full_file_path)
-            register_template(ReloadableTemplate.new(relative_path, self))
-          end
-        end
-
-        def register_template(template)
-          template.accessible_paths.each do |path|
-            @paths[path] = template
-          end
-        end
-
-        # remove (probably deleted) template from cache
-        def unregister_template(template)
-          template.accessible_paths.each do |template_path|
-            @paths.delete(template_path) if @paths[template_path] == template
-          end
-          # fill in any newly created gaps
-          @paths.values.uniq.each do |template|
-            template.accessible_paths.each {|path| @paths[path] ||= template}
-          end
-        end
-
-        # load all templates from the directory of the requested template
-        def load_all_templates_from_dir(dir)
-          # hit disk only once per template-dir/request
-          @disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
-        end
-
-        def templates_dir_from_path(path)
-          dirname = File.dirname(path)
-          File.join(@path, dirname == '.' ? '' : dirname)
-        end
-
-        # get all the template filenames from the dir
-        def template_files_from_dir(dir)
-          Dir.glob(File.join(dir, '*'))
-        end
-    end
-
-    module Unfreezable
-      def freeze; self; end
-    end
-
-    def initialize(*args)
-      super
-      
-      # we don't ever want to get frozen
-      extend Unfreezable
-    end
-
-    def mtime
-      File.mtime(filename)
-    end
-
-    attr_accessor :previously_last_modified
-
-    def stale?
-      previously_last_modified.nil? || previously_last_modified < mtime
-    rescue Errno::ENOENT => e
-      undef_my_compiled_methods!
-      raise TemplateDeleted
-    end
-
-    def reset_cache_if_stale!
-      if stale?
-        flush_cache 'source', 'compiled_source'
-        undef_my_compiled_methods!
-        @previously_last_modified = mtime
-      end
-      self
-    end
-
-    # remove any compiled methods that look like they might belong to me
-    def undef_my_compiled_methods!
-      ActionView::Base::CompiledTemplates.public_instance_methods.grep(/#{Regexp.escape(method_name_without_locals)}(?:_locals_)?/).each do |m|
-        ActionView::Base::CompiledTemplates.send(:remove_method, m)
-      end
-    end
-
-  end
-end

data/lib/action_view/renderable.rb

@@ -1,109 +0,0 @@
-# encoding: utf-8
-
-module ActionView
-  # NOTE: The template that this mixin is being included into is frozen
-  # so you cannot set or modify any instance variables
-  module Renderable #:nodoc:
-    extend ActiveSupport::Memoizable
-
-    def filename
-      'compiled-template'
-    end
-
-    def handler
-      Template.handler_class_for_extension(extension)
-    end
-    memoize :handler
-
-    def compiled_source
-      handler.call(self)
-    end
-
-    def method_name_without_locals
-      ['_run', extension, method_segment].compact.join('_')
-    end
-    memoize :method_name_without_locals
-
-    def render(view, local_assigns = {})
-      compile(local_assigns)
-
-      view.with_template self do
-        view.send(:_evaluate_assigns_and_ivars)
-        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
-
-        view.send(method_name(local_assigns), local_assigns) do |*names|
-          ivar = :@_proc_for_layout
-          if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
-            view.capture(*names, &proc)
-          elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
-            view.instance_variable_get(ivar)
-          end
-        end
-      end
-    end
-
-    def method_name(local_assigns)
-      if local_assigns && local_assigns.any?
-        method_name = method_name_without_locals.dup
-        method_name << "_locals_#{local_assigns.keys.map { |k| k.to_s }.sort.join('_')}"
-      else
-        method_name = method_name_without_locals
-      end
-      method_name.to_sym
-    end
-
-    private
-      # Compile and evaluate the template's code (if necessary)
-      def compile(local_assigns)
-        render_symbol = method_name(local_assigns)
-
-        if !Base::CompiledTemplates.method_defined?(render_symbol) || recompile?
-          compile!(render_symbol, local_assigns)
-        end
-      end
-
-      def compile!(render_symbol, local_assigns)
-        locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join
-
-        code = compiled_source
-        if code.sub!(/\A(#.*coding.*)\n/, '')
-          encoding_comment = $1
-        elsif defined?(Encoding) && Encoding.respond_to?(:default_external)
-          encoding_comment = "#coding:#{Encoding.default_external}"
-        end
-
-        source = <<-end_src
-          def #{render_symbol}(local_assigns)
-            old_output_buffer = output_buffer;#{locals_code};#{code}
-          ensure
-            self.output_buffer = old_output_buffer
-          end
-        end_src
-
-        if encoding_comment
-          source = "#{encoding_comment}\n#{source}"
-          line = -1
-        else
-          line = 0
-        end
-
-        begin
-          ActionView::Base::CompiledTemplates.module_eval(source, filename, line)
-        rescue Errno::ENOENT => e
-          raise e # Missing template file, re-raise for Base to rescue
-        rescue Exception => e # errors from template code
-          if logger = defined?(ActionController) && Base.logger
-            logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
-            logger.debug "Function body: #{source}"
-            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-          end
-
-          raise ActionView::TemplateError.new(self, {}, e)
-        end
-      end
-
-      def recompile?
-        false
-      end
-  end
-end

data/lib/action_view/renderable_partial.rb

@@ -1,53 +0,0 @@
-module ActionView
-  # NOTE: The template that this mixin is being included into is frozen
-  # so you cannot set or modify any instance variables
-  module RenderablePartial #:nodoc:
-    extend ActiveSupport::Memoizable
-
-    def variable_name
-      name.sub(/\A_/, '').to_sym
-    end
-    memoize :variable_name
-
-    def counter_name
-      "#{variable_name}_counter".to_sym
-    end
-    memoize :counter_name
-
-    def render(view, local_assigns = {})
-      if defined? ActionController
-        ActionController::Base.benchmark("Rendered #{path_without_format_and_extension}", Logger::DEBUG, false) do
-          super
-        end
-      else
-        super
-      end
-    end
-
-    def render_partial(view, object = nil, local_assigns = {}, as = nil)
-      object ||= local_assigns[:object] || local_assigns[variable_name]
-
-      if object.nil? && !local_assigns_key?(local_assigns) && view.respond_to?(:controller)
-        ivar = :"@#{variable_name}"
-        object =
-          if view.controller.instance_variable_defined?(ivar)
-            ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
-              view.controller.instance_variable_get(ivar),
-              "#{ivar} will no longer be implicitly assigned to #{variable_name}")
-          end
-      end
-
-      # Ensure correct object is reassigned to other accessors
-      local_assigns[:object] = local_assigns[variable_name] = object
-      local_assigns[as] = object if as
-
-      render_template(view, local_assigns)
-    end
-
-    private
-
-      def local_assigns_key?(local_assigns)
-        local_assigns.key?(:object) || local_assigns.key?(variable_name)
-      end
-  end
-end

data/lib/action_view/template_error.rb

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