actionpack 4.0.1 → 4.2.11.1

data/lib/action_view/renderer/template_renderer.rb

@@ -1,96 +0,0 @@
-require 'active_support/core_ext/object/try'
-
-module ActionView
-  class TemplateRenderer < AbstractRenderer #:nodoc:
-    def render(context, options)
-      @view    = context
-      @details = extract_details(options)
-      template = determine_template(options)
-      context  = @lookup_context
-
-      prepend_formats(template.formats)
-
-      unless context.rendered_format
-        context.rendered_format = template.formats.first || formats.first
-      end
-
-      render_template(template, options[:layout], options[:locals])
-    end
-
-    # Determine the template to be rendered using the given options.
-    def determine_template(options) #:nodoc:
-      keys = options.fetch(:locals, {}).keys
-
-      if options.key?(:text)
-        Template::Text.new(options[:text], formats.first)
-      elsif options.key?(:file)
-        with_fallbacks { find_template(options[:file], nil, false, keys, @details) }
-      elsif options.key?(:inline)
-        handler = Template.handler_for_extension(options[:type] || "erb")
-        Template.new(options[:inline], "inline template", handler, :locals => keys)
-      elsif options.key?(:template)
-        if options[:template].respond_to?(:render)
-          options[:template]
-        else
-          find_template(options[:template], options[:prefixes], false, keys, @details)
-        end
-      else
-        raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file or :text option."
-      end
-    end
-
-    # Renders the given template. A string representing the layout can be
-    # supplied as well.
-    def render_template(template, layout_name = nil, locals = nil) #:nodoc:
-      view, locals = @view, locals || {}
-
-      render_with_layout(layout_name, locals) do |layout|
-        instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
-          template.render(view, locals) { |*name| view._layout_for(*name) }
-        end
-      end
-    end
-
-    def render_with_layout(path, locals) #:nodoc:
-      layout  = path && find_layout(path, locals.keys)
-      content = yield(layout)
-
-      if layout
-        view = @view
-        view.view_flow.set(:layout, content)
-        layout.render(view, locals){ |*name| view._layout_for(*name) }
-      else
-        content
-      end
-    end
-
-    # This is the method which actually finds the layout using details in the lookup
-    # context object. If no layout is found, it checks if at least a layout with
-    # the given name exists across all details before raising the error.
-    def find_layout(layout, keys)
-      with_layout_format { resolve_layout(layout, keys) }
-    end
-
-    def resolve_layout(layout, keys)
-      case layout
-      when String
-        begin
-          if layout =~ /^\//
-            with_fallbacks { find_template(layout, nil, false, keys, @details) }
-          else
-            find_template(layout, nil, false, keys, @details)
-          end
-        rescue ActionView::MissingTemplate
-          all_details = @details.merge(:formats => @lookup_context.default_formats)
-          raise unless template_exists?(layout, nil, false, keys, all_details)
-        end
-      when Proc
-        resolve_layout(layout.call, keys)
-      when FalseClass
-        nil
-      else
-        layout
-      end
-    end
-  end
-end

data/lib/action_view/routing_url_for.rb

@@ -1,107 +0,0 @@
-module ActionView
-  module RoutingUrlFor
-
-    # Returns the URL for the set of +options+ provided. This takes the
-    # same options as +url_for+ in Action Controller (see the
-    # documentation for <tt>ActionController::Base#url_for</tt>). Note that by default
-    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative "/controller/action"
-    # instead of the fully qualified URL like "http://example.com/controller/action".
-    #
-    # ==== Options
-    # * <tt>:anchor</tt> - Specifies the anchor name to be appended to the path.
-    # * <tt>:only_path</tt> - If true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified).
-    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2005/". Note that this
-    #   is currently not recommended since it breaks caching.
-    # * <tt>:host</tt> - Overrides the default (current) host if provided.
-    # * <tt>:protocol</tt> - Overrides the default (current) protocol if provided.
-    # * <tt>:user</tt> - Inline HTTP authentication (only plucked out if <tt>:password</tt> is also present).
-    # * <tt>:password</tt> - Inline HTTP authentication (only plucked out if <tt>:user</tt> is also present).
-    #
-    # ==== Relying on named routes
-    #
-    # Passing a record (like an Active Record) instead of a hash as the options parameter will
-    # trigger the named route for that record. The lookup will happen on the name of the class. So passing a
-    # Workshop object will attempt to use the +workshop_path+ route. If you have a nested route, such as
-    # +admin_workshop_path+ you'll have to call that explicitly (it's impossible for +url_for+ to guess that route).
-    #
-    # ==== Implicit Controller Namespacing
-    #
-    # Controllers passed in using the +:controller+ option will retain their namespace unless it is an absolute one.
-    #
-    # ==== Examples
-    #   <%= url_for(action: 'index') %>
-    #   # => /blog/
-    #
-    #   <%= url_for(action: 'find', controller: 'books') %>
-    #   # => /books/find
-    #
-    #   <%= url_for(action: 'login', controller: 'members', only_path: false, protocol: 'https') %>
-    #   # => https://www.example.com/members/login/
-    #
-    #   <%= url_for(action: 'play', anchor: 'player') %>
-    #   # => /messages/play/#player
-    #
-    #   <%= url_for(action: 'jump', anchor: 'tax&ship') %>
-    #   # => /testing/jump/#tax&ship
-    #
-    #   <%= url_for(Workshop.new) %>
-    #   # relies on Workshop answering a persisted? call (and in this case returning false)
-    #   # => /workshops
-    #
-    #   <%= url_for(@workshop) %>
-    #   # calls @workshop.to_param which by default returns the id
-    #   # => /workshops/5
-    #
-    #   # to_param can be re-defined in a model to provide different URL names:
-    #   # => /workshops/1-workshop-name
-    #
-    #   <%= url_for("http://www.example.com") %>
-    #   # => http://www.example.com
-    #
-    #   <%= url_for(:back) %>
-    #   # if request.env["HTTP_REFERER"] is set to "http://www.example.com"
-    #   # => http://www.example.com
-    #
-    #   <%= url_for(:back) %>
-    #   # if request.env["HTTP_REFERER"] is not set or is blank
-    #   # => javascript:history.back()
-    #
-    #   <%= url_for(action: 'index', controller: 'users') %>
-    #   # Assuming an "admin" namespace
-    #   # => /admin/users
-    #
-    #   <%= url_for(action: 'index', controller: '/users') %>
-    #   # Specify absolute path with beginning slash
-    #   # => /users
-    def url_for(options = nil)
-      case options
-      when String
-        options
-      when nil, Hash
-        options ||= {}
-        options = { :only_path => options[:host].nil? }.merge!(options.symbolize_keys)
-        super
-      when :back
-        _back_url
-      else
-        polymorphic_path(options)
-      end
-    end
-
-    def url_options #:nodoc:
-      return super unless controller.respond_to?(:url_options)
-      controller.url_options
-    end
-
-    def _routes_context #:nodoc:
-      controller
-    end
-    protected :_routes_context
-
-    def optimize_routes_generation? #:nodoc:
-      controller.respond_to?(:optimize_routes_generation?, true) ?
-        controller.optimize_routes_generation? : super
-    end
-    protected :optimize_routes_generation?
-  end
-end

data/lib/action_view/tasks/dependencies.rake

@@ -1,17 +0,0 @@
-namespace :cache_digests do
-  desc 'Lookup nested dependencies for TEMPLATE (like messages/show or comments/_comment.html)'
-  task :nested_dependencies => :environment do
-    abort 'You must provide TEMPLATE for the task to run' unless ENV['TEMPLATE'].present?
-    template, format = ENV['TEMPLATE'].split(".")
-    format ||= :html
-    puts JSON.pretty_generate ActionView::Digestor.new(template, format, ApplicationController.new.lookup_context).nested_dependencies
-  end
-
-  desc 'Lookup first-level dependencies for TEMPLATE (like messages/show or comments/_comment.html)'
-  task :dependencies => :environment do
-    abort 'You must provide TEMPLATE for the task to run' unless ENV['TEMPLATE'].present?
-    template, format = ENV['TEMPLATE'].split(".")
-    format ||= :html
-    puts JSON.pretty_generate ActionView::Digestor.new(template, format, ApplicationController.new.lookup_context).dependencies
-  end
-end

data/lib/action_view/template/error.rb

@@ -1,138 +0,0 @@
-require "active_support/core_ext/enumerable"
-
-module ActionView
-  # = Action View Errors
-  class ActionViewError < StandardError #:nodoc:
-  end
-
-  class EncodingError < StandardError #:nodoc:
-  end
-
-  class MissingRequestError < StandardError #:nodoc:
-  end
-
-  class WrongEncodingError < EncodingError #:nodoc:
-    def initialize(string, encoding)
-      @string, @encoding = string, encoding
-    end
-
-    def message
-      @string.force_encoding(Encoding::ASCII_8BIT)
-      "Your template was not saved as valid #{@encoding}. Please " \
-      "either specify #{@encoding} as the encoding for your template " \
-      "in your text editor, or mark the template with its " \
-      "encoding by inserting the following as the first line " \
-      "of the template:\n\n# encoding: <name of correct encoding>.\n\n" \
-      "The source of your template was:\n\n#{@string}"
-    end
-  end
-
-  class MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
-
-    def initialize(paths, path, prefixes, partial, details, *)
-      @path = path
-      prefixes = Array(prefixes)
-      template_type = if partial
-        "partial"
-      elsif path =~ /layouts/i
-        'layout'
-      else
-        'template'
-      end
-
-      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
-
-      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
-      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
-      super out
-    end
-  end
-
-  class Template
-    # The Template::Error exception is raised when the compilation or rendering of the template
-    # fails. This exception then gathers a bunch of intimate details and uses it to report a
-    # precise exception message.
-    class Error < ActionViewError #:nodoc:
-      SOURCE_CODE_RADIUS = 3
-
-      attr_reader :original_exception, :backtrace
-
-      def initialize(template, original_exception)
-        super(original_exception.message)
-        @template, @original_exception = template, original_exception
-        @sub_templates = nil
-        @backtrace = original_exception.backtrace
-      end
-
-      def file_name
-        @template.identifier
-      end
-
-      def sub_template_message
-        if @sub_templates
-          "Trace of template inclusion: " +
-          @sub_templates.collect { |template| template.inspect }.join(", ")
-        else
-          ""
-        end
-      end
-
-      def source_extract(indentation = 0, output = :console)
-        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 = end_on_line.to_s.size + indentation
-        return unless source_code = source_code[start_on_line..end_on_line]
-
-        formatted_code_for(source_code, start_on_line, indent, output)
-      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 || backtrace.find { |line| line =~ regexp }
-          end
-      end
-
-      def annoted_source_code
-        source_extract(4)
-      end
-
-      private
-
-        def source_location
-          if line_number
-            "on line ##{line_number} of "
-          else
-            'in '
-          end + file_name
-        end
-
-        def formatted_code_for(source_code, line_counter, indent, output)
-          start_value = (output == :html) ? {} : ""
-          source_code.inject(start_value) do |result, line|
-            line_counter += 1
-            if output == :html
-              result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
-            else
-              result << "%#{indent}s: %s\n" % [line_counter, line]
-            end
-          end
-        end
-    end
-  end
-
-  TemplateError = Template::Error
-end

data/lib/action_view/template/handlers/builder.rb

@@ -1,26 +0,0 @@
-module ActionView
-  module Template::Handlers
-    class Builder
-      # Default format used by Builder.
-      class_attribute :default_format
-      self.default_format = :xml
-
-      def call(template)
-        require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
-          "self.output_buffer = xml.target!;" +
-          template.source +
-          ";xml.target!;"
-      end
-
-      protected
-
-      def require_engine
-        @required ||= begin
-          require "builder"
-          true
-        end
-      end
-    end
-  end
-end

data/lib/action_view/template/handlers/erb.rb

@@ -1,146 +0,0 @@
-require 'action_dispatch/http/mime_type'
-require 'erubis'
-
-module ActionView
-  class Template
-    module Handlers
-      class Erubis < ::Erubis::Eruby
-        def add_preamble(src)
-          @newline_pending = 0
-          src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-        end
-
-        def add_text(src, text)
-          return if text.empty?
-
-          if text == "\n"
-            @newline_pending += 1
-          else
-            src << "@output_buffer.safe_append='"
-            src << "\n" * @newline_pending if @newline_pending > 0
-            src << escape_text(text)
-            src << "';"
-
-            @newline_pending = 0
-          end
-        end
-
-        # Erubis toggles <%= and <%== behavior when escaping is enabled.
-        # We override to always treat <%== as escaped.
-        def add_expr(src, code, indicator)
-          case indicator
-          when '=='
-            add_expr_escaped(src, code)
-          else
-            super
-          end
-        end
-
-        BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
-        def add_expr_literal(src, code)
-          flush_newline_if_pending(src)
-          if code =~ BLOCK_EXPR
-            src << '@output_buffer.append= ' << code
-          else
-            src << '@output_buffer.append=(' << code << ');'
-          end
-        end
-
-        def add_expr_escaped(src, code)
-          flush_newline_if_pending(src)
-          if code =~ BLOCK_EXPR
-            src << "@output_buffer.safe_append= " << code
-          else
-            src << "@output_buffer.safe_append=(" << code << ");"
-          end
-        end
-
-        def add_stmt(src, code)
-          flush_newline_if_pending(src)
-          super
-        end
-
-        def add_postamble(src)
-          flush_newline_if_pending(src)
-          src << '@output_buffer.to_s'
-        end
-
-        def flush_newline_if_pending(src)
-          if @newline_pending > 0
-            src << "@output_buffer.safe_append='#{"\n" * @newline_pending}';"
-            @newline_pending = 0
-          end
-        end
-      end
-
-      class ERB
-        # Specify trim mode for the ERB compiler. Defaults to '-'.
-        # See ERB documentation for suitable values.
-        class_attribute :erb_trim_mode
-        self.erb_trim_mode = '-'
-
-        # Default implementation used.
-        class_attribute :erb_implementation
-        self.erb_implementation = Erubis
-
-        # Do not escape templates of these mime types.
-        class_attribute :escape_whitelist
-        self.escape_whitelist = ["text/plain"]
-
-        ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
-
-        def self.call(template)
-          new.call(template)
-        end
-
-        def supports_streaming?
-          true
-        end
-
-        def handles_encoding?
-          true
-        end
-
-        def call(template)
-          # First, convert to BINARY, so in case the encoding is
-          # wrong, we can still find an encoding tag
-          # (<%# encoding %>) inside the String using a regular
-          # expression
-          template_source = template.source.dup.force_encoding(Encoding::ASCII_8BIT)
-
-          erb = template_source.gsub(ENCODING_TAG, '')
-          encoding = $2
-
-          erb.force_encoding valid_encoding(template.source.dup, encoding)
-
-          # Always make sure we return a String in the default_internal
-          erb.encode!
-
-          self.class.erb_implementation.new(
-            erb,
-            :escape => (self.class.escape_whitelist.include? template.type),
-            :trim => (self.class.erb_trim_mode == "-")
-          ).src
-        end
-
-      private
-
-        def valid_encoding(string, encoding)
-          # If a magic encoding comment was found, tag the
-          # String with this encoding. This is for a case
-          # where the original String was assumed to be,
-          # for instance, UTF-8, but a magic comment
-          # proved otherwise
-          string.force_encoding(encoding) if encoding
-
-          # If the String is valid, return the encoding we found
-          return string.encoding if string.valid_encoding?
-
-          # Otherwise, raise an exception
-          raise WrongEncodingError.new(string, string.encoding)
-        end
-      end
-    end
-  end
-end

data/lib/action_view/template/handlers/raw.rb

@@ -1,11 +0,0 @@
-module ActionView
-  module Template::Handlers
-    class Raw
-      def call(template)
-        escaped = template.source.gsub(':', '\:')
-
-        '%q:' + escaped + ':;'
-      end
-    end
-  end
-end

data/lib/action_view/template/handlers.rb

@@ -1,53 +0,0 @@
-module ActionView #:nodoc:
-  # = Action View Template Handlers
-  class Template
-    module Handlers #:nodoc:
-      autoload :ERB, 'action_view/template/handlers/erb'
-      autoload :Builder, 'action_view/template/handlers/builder'
-      autoload :Raw, 'action_view/template/handlers/raw'
-
-      def self.extended(base)
-        base.register_default_template_handler :erb, ERB.new
-        base.register_template_handler :builder, Builder.new
-        base.register_template_handler :raw, Raw.new
-        base.register_template_handler :ruby, :source.to_proc
-      end
-
-      @@template_handlers = {}
-      @@default_template_handlers = nil
-
-      def self.extensions
-        @@template_extensions ||= @@template_handlers.keys
-      end
-
-      # Register an object that knows how to handle template files with the given
-      # extensions. This can be used to implement new template types.
-      # The handler must respond to `:call`, which will be passed the template
-      # and should return the rendered template as a String.
-      def register_template_handler(*extensions, handler)
-        raise(ArgumentError, "Extension is required") if extensions.empty?
-        extensions.each do |extension|
-          @@template_handlers[extension.to_sym] = handler
-        end
-        @@template_extensions = nil
-      end
-
-      def template_handler_extensions
-        @@template_handlers.keys.map {|key| key.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_for_extension(extension)
-        registered_template_handler(extension) || @@default_template_handlers
-      end
-    end
-  end
-end