actionpack 3.2.19 → 4.2.11.3

data/lib/action_view/template.rb

@@ -1,337 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'thread'
-
-module ActionView
-  # = Action View Template
-  class Template
-    extend ActiveSupport::Autoload
-
-    # === Encodings in ActionView::Template
-    #
-    # ActionView::Template is one of a few sources of potential
-    # encoding issues in Rails. This is because the source for
-    # templates are usually read from disk, and Ruby (like most
-    # encoding-aware programming languages) assumes that the
-    # String retrieved through File IO is encoded in the
-    # <tt>default_external</tt> encoding. In Rails, the default
-    # <tt>default_external</tt> encoding is UTF-8.
-    #
-    # As a result, if a user saves their template as ISO-8859-1
-    # (for instance, using a non-Unicode-aware text editor),
-    # and uses characters outside of the ASCII range, their
-    # users will see diamonds with question marks in them in
-    # the browser.
-    #
-    # For the rest of this documentation, when we say "UTF-8",
-    # we mean "UTF-8 or whatever the default_internal encoding
-    # is set to". By default, it will be UTF-8.
-    #
-    # To mitigate this problem, we use a few strategies:
-    # 1. If the source is not valid UTF-8, we raise an exception
-    #    when the template is compiled to alert the user
-    #    to the problem.
-    # 2. The user can specify the encoding using Ruby-style
-    #    encoding comments in any template engine. If such
-    #    a comment is supplied, Rails will apply that encoding
-    #    to the resulting compiled source returned by the
-    #    template handler.
-    # 3. In all cases, we transcode the resulting String to
-    #    the UTF-8.
-    #
-    # This means that other parts of Rails can always assume
-    # that templates are encoded in UTF-8, even if the original
-    # source of the template was not UTF-8.
-    #
-    # From a user's perspective, the easiest thing to do is
-    # to save your templates as UTF-8. If you do this, you
-    # do not need to do anything else for things to "just work".
-    #
-    # === Instructions for template handlers
-    #
-    # The easiest thing for you to do is to simply ignore
-    # encodings. Rails will hand you the template source
-    # as the default_internal (generally UTF-8), raising
-    # an exception for the user before sending the template
-    # to you if it could not determine the original encoding.
-    #
-    # For the greatest simplicity, you can support only
-    # UTF-8 as the <tt>default_internal</tt>. This means
-    # that from the perspective of your handler, the
-    # entire pipeline is just UTF-8.
-    #
-    # === Advanced: Handlers with alternate metadata sources
-    #
-    # If you want to provide an alternate mechanism for
-    # specifying encodings (like ERB does via <%# encoding: ... %>),
-    # you may indicate that you will handle encodings yourself
-    # by implementing <tt>self.handles_encoding?</tt>
-    # on your handler.
-    #
-    # If you do, Rails will not try to encode the String
-    # into the default_internal, passing you the unaltered
-    # bytes tagged with the assumed encoding (from
-    # default_external).
-    #
-    # In this case, make sure you return a String from
-    # your handler encoded in the default_internal. Since
-    # you are handling out-of-band metadata, you are
-    # also responsible for alerting the user to any
-    # problems with converting the user's data to
-    # the <tt>default_internal</tt>.
-    #
-    # To do so, simply raise the raise +WrongEncodingError+
-    # as follows:
-    #
-    #     raise WrongEncodingError.new(
-    #       problematic_string,
-    #       expected_encoding
-    #     )
-
-    eager_autoload do
-      autoload :Error
-      autoload :Handlers
-      autoload :Text
-    end
-
-    extend Template::Handlers
-
-    attr_accessor :locals, :formats, :virtual_path
-
-    attr_reader :source, :identifier, :handler, :original_encoding, :updated_at
-
-    # This finalizer is needed (and exactly with a proc inside another proc)
-    # otherwise templates leak in development.
-    Finalizer = proc do |method_name, mod|
-      proc do
-        mod.module_eval do
-          remove_possible_method method_name
-        end
-      end
-    end
-
-    def initialize(source, identifier, handler, details)
-      format = details[:format] || (handler.default_format if handler.respond_to?(:default_format))
-
-      @source            = source
-      @identifier        = identifier
-      @handler           = handler
-      @compiled          = false
-      @original_encoding = nil
-      @locals            = details[:locals] || []
-      @virtual_path      = details[:virtual_path]
-      @updated_at        = details[:updated_at] || Time.now
-      @formats = Array.wrap(format).map { |f| f.is_a?(Mime::Type) ? f.ref : f }
-      @compile_mutex     = Mutex.new
-    end
-
-    # Returns if the underlying handler supports streaming. If so,
-    # a streaming buffer *may* be passed when it start rendering.
-    def supports_streaming?
-      handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
-    end
-
-    # Render a template. If the template was not compiled yet, it is done
-    # exactly before rendering.
-    #
-    # This method is instrumented as "!render_template.action_view". Notice that
-    # we use a bang in this instrumentation because you don't want to
-    # consume this in production. This is only slow if it's being listened to.
-    def render(view, locals, buffer=nil, &block)
-      ActiveSupport::Notifications.instrument("!render_template.action_view", :virtual_path => @virtual_path) do
-        compile!(view)
-        view.send(method_name, locals, buffer, &block)
-      end
-    rescue Exception => e
-      handle_render_error(view, e)
-    end
-
-    def mime_type
-      @mime_type ||= Mime::Type.lookup_by_extension(@formats.first.to_s) if @formats.first
-    end
-
-    # Receives a view object and return a template similar to self by using @virtual_path.
-    #
-    # This method is useful if you have a template object but it does not contain its source
-    # anymore since it was already compiled. In such cases, all you need to do is to call
-    # refresh passing in the view object.
-    #
-    # Notice this method raises an error if the template to be refreshed does not have a
-    # virtual path set (true just for inline templates).
-    def refresh(view)
-      raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
-      lookup  = view.lookup_context
-      pieces  = @virtual_path.split("/")
-      name    = pieces.pop
-      partial = !!name.sub!(/^_/, "")
-      lookup.disable_cache do
-        lookup.find_template(name, [ pieces.join('/') ], partial, @locals)
-      end
-    end
-
-    def inspect
-      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", '') : identifier
-    end
-
-    # This method is responsible for properly setting the encoding of the
-    # source. Until this point, we assume that the source is BINARY data.
-    # If no additional information is supplied, we assume the encoding is
-    # the same as <tt>Encoding.default_external</tt>.
-    #
-    # The user can also specify the encoding via a comment on the first
-    # line of the template (# encoding: NAME-OF-ENCODING). This will work
-    # with any template engine, as we process out the encoding comment
-    # before passing the source on to the template engine, leaving a
-    # blank line in its stead.
-    def encode!
-      return unless source.encoding_aware? && source.encoding == Encoding::BINARY
-
-      # Look for # encoding: *. If we find one, we'll encode the
-      # String in that encoding, otherwise, we'll use the
-      # default external encoding.
-      if source.sub!(/\A#{ENCODING_FLAG}/, '')
-        encoding = magic_encoding = $1
-      else
-        encoding = Encoding.default_external
-      end
-
-      # Tag the source with the default external encoding
-      # or the encoding specified in the file
-      source.force_encoding(encoding)
-
-      # If the user didn't specify an encoding, and the handler
-      # handles encodings, we simply pass the String as is to
-      # the handler (with the default_external tag)
-      if !magic_encoding && @handler.respond_to?(:handles_encoding?) && @handler.handles_encoding?
-        source
-      # Otherwise, if the String is valid in the encoding,
-      # encode immediately to default_internal. This means
-      # that if a handler doesn't handle encodings, it will
-      # always get Strings in the default_internal
-      elsif source.valid_encoding?
-        source.encode!
-      # Otherwise, since the String is invalid in the encoding
-      # specified, raise an exception
-      else
-        raise WrongEncodingError.new(source, encoding)
-      end
-    end
-
-    protected
-
-      # Compile a template. This method ensures a template is compiled
-      # just once and removes the source after it is compiled.
-      def compile!(view) #:nodoc:
-        return if @compiled
-
-        # Templates can be used concurrently in threaded environments
-        # so compilation and any instance variable modification must
-        # be synchronized
-        @compile_mutex.synchronize do
-          # Any thread holding this lock will be compiling the template needed
-          # by the threads waiting. So re-check the @compiled flag to avoid
-          # re-compilation
-          return if @compiled
-
-          if view.is_a?(ActionView::CompiledTemplates)
-            mod = ActionView::CompiledTemplates
-          else
-            mod = view.singleton_class
-          end
-
-          compile(view, mod)
-
-          # Just discard the source if we have a virtual path. This
-          # means we can get the template back.
-          @source = nil if @virtual_path
-          @compiled = true
-        end
-      end
-
-      # Among other things, this method is responsible for properly setting
-      # the encoding of the compiled template.
-      #
-      # If the template engine handles encodings, we send the encoded
-      # String to the engine without further processing. This allows
-      # the template engine to support additional mechanisms for
-      # specifying the encoding. For instance, ERB supports <%# encoding: %>
-      #
-      # Otherwise, after we figure out the correct encoding, we then
-      # encode the source into <tt>Encoding.default_internal</tt>.
-      # In general, this means that templates will be UTF-8 inside of Rails,
-      # regardless of the original source encoding.
-      def compile(view, mod) #:nodoc:
-        encode!
-        method_name = self.method_name
-        code = @handler.call(self)
-
-        # Make sure that the resulting String to be evalled is in the
-        # encoding of the code
-        source = <<-end_src
-          def #{method_name}(local_assigns, output_buffer)
-            _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
-          ensure
-            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
-          end
-        end_src
-
-        if source.encoding_aware?
-          # Make sure the source is in the encoding of the returned code
-          source.force_encoding(code.encoding)
-
-          # In case we get back a String from a handler that is not in
-          # BINARY or the default_internal, encode it to the default_internal
-          source.encode!
-
-          # Now, validate that the source we got back from the template
-          # handler is valid in the default_internal. This is for handlers
-          # that handle encoding but screw up
-          unless source.valid_encoding?
-            raise WrongEncodingError.new(@source, Encoding.default_internal)
-          end
-        end
-
-        begin
-          mod.module_eval(source, identifier, 0)
-          ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
-        rescue Exception => e # errors from template code
-          if logger = (view && view.logger)
-            logger.debug "ERROR: compiling #{method_name} RAISED #{e}"
-            logger.debug "Function body: #{source}"
-            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-          end
-
-          raise ActionView::Template::Error.new(self, {}, e)
-        end
-      end
-
-      def handle_render_error(view, e) #:nodoc:
-        if e.is_a?(Template::Error)
-          e.sub_template_of(self)
-          raise e
-        else
-          assigns  = view.respond_to?(:assigns) ? view.assigns : {}
-          template = self
-          unless template.source
-            template = refresh(view)
-            template.encode!
-          end
-          raise Template::Error.new(template, assigns, e)
-        end
-      end
-
-      def locals_code #:nodoc:
-        @locals.map { |key| "#{key} = local_assigns[:#{key}];" }.join
-      end
-
-      def method_name #:nodoc:
-        @method_name ||= "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}".gsub('-', "_")
-      end
-
-      def identifier_method_name #:nodoc:
-        inspect.gsub(/[^a-z_]/, '_')
-      end
-  end
-end

data/lib/action_view/test_case.rb

@@ -1,245 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/remove_method'
-require 'action_controller'
-require 'action_controller/test_case'
-require 'action_view'
-
-module ActionView
-  # = Action View Test Case
-  class TestCase < ActiveSupport::TestCase
-    class TestController < ActionController::Base
-      include ActionDispatch::TestProcess
-
-      attr_accessor :request, :response, :params
-
-      class << self
-        attr_writer :controller_path
-      end
-
-      def controller_path=(path)
-        self.class.controller_path=(path)
-      end
-
-      def initialize
-        super
-        self.class.controller_path = ""
-        @request = ActionController::TestRequest.new
-        @response = ActionController::TestResponse.new
-
-        @request.env.delete('PATH_INFO')
-        @params = {}
-      end
-    end
-
-    module Behavior
-      extend ActiveSupport::Concern
-
-      include ActionDispatch::Assertions, ActionDispatch::TestProcess
-      include ActionController::TemplateAssertions
-      include ActionView::Context
-
-      include ActionDispatch::Routing::PolymorphicRoutes
-      include ActionController::RecordIdentifier
-
-      include AbstractController::Helpers
-      include ActionView::Helpers
-
-      delegate :lookup_context, :to => :controller
-      attr_accessor :controller, :output_buffer, :rendered
-
-      module ClassMethods
-        def tests(helper_class)
-          case helper_class
-          when String, Symbol
-            self.helper_class = "#{helper_class.to_s.underscore}_helper".camelize.safe_constantize
-          when Module
-            self.helper_class = helper_class
-          end
-        end
-
-        def determine_default_helper_class(name)
-          mod = name.sub(/Test$/, '').constantize
-          mod.is_a?(Class) ? nil : mod
-        rescue NameError
-          nil
-        end
-
-        def helper_method(*methods)
-          # Almost a duplicate from ActionController::Helpers
-          methods.flatten.each do |method|
-            _helpers.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
-
-        attr_writer :helper_class
-
-        def helper_class
-          @helper_class ||= determine_default_helper_class(name)
-        end
-
-        def new(*)
-          include_helper_modules!
-          super
-        end
-
-      private
-
-        def include_helper_modules!
-          helper(helper_class) if helper_class
-          include _helpers
-        end
-
-      end
-
-      def setup_with_controller
-        @controller = ActionView::TestCase::TestController.new
-        @request = @controller.request
-        @output_buffer = ActiveSupport::SafeBuffer.new
-        @rendered = ''
-
-        make_test_case_available_to_view!
-        say_no_to_protect_against_forgery!
-      end
-
-      def config
-        @controller.config if @controller.respond_to?(:config)
-      end
-
-      def render(options = {}, local_assigns = {}, &block)
-        view.assign(view_assigns)
-        @rendered << output = view.render(options, local_assigns, &block)
-        output
-      end
-
-      def locals
-        @locals ||= {}
-      end
-
-      included do
-        setup :setup_with_controller
-      end
-
-    private
-
-      # Support the selector assertions
-      #
-      # Need to experiment if this priority is the best one: rendered => output_buffer
-      def response_from_page
-        HTML::Document.new(@rendered.blank? ? @output_buffer : @rendered).root
-      end
-
-      def say_no_to_protect_against_forgery!
-        _helpers.module_eval do
-          remove_possible_method :protect_against_forgery?
-          def protect_against_forgery?
-            false
-          end
-        end
-      end
-
-      def make_test_case_available_to_view!
-        test_case_instance = self
-        _helpers.module_eval do
-          unless private_method_defined?(:_test_case)
-            define_method(:_test_case) { test_case_instance }
-            private :_test_case
-          end
-        end
-      end
-
-      module Locals
-        attr_accessor :locals
-
-        def render(options = {}, local_assigns = {})
-          case options
-          when Hash
-            if block_given?
-              locals[options[:layout]] = options[:locals]
-            elsif options.key?(:partial)
-              locals[options[:partial]] = options[:locals]
-            end
-          else
-            locals[options] = local_assigns
-          end
-
-          super
-        end
-      end
-
-      # The instance of ActionView::Base that is used by +render+.
-      def view
-        @view ||= begin
-          view = @controller.view_context
-          view.singleton_class.send :include, _helpers
-          view.extend(Locals)
-          view.locals = self.locals
-          view.output_buffer = self.output_buffer
-          view
-        end
-      end
-
-      alias_method :_view, :view
-
-      INTERNAL_IVARS = %w{
-        @__name__
-        @__io__
-        @_assertion_wrapped
-        @_assertions
-        @_result
-        @_routes
-        @controller
-        @layouts
-        @locals
-        @method_name
-        @output_buffer
-        @partials
-        @passed
-        @rendered
-        @request
-        @routes
-        @templates
-        @options
-        @test_passed
-        @view
-        @view_context_class
-      }
-
-      def _user_defined_ivars
-        instance_variables.map(&:to_s) - INTERNAL_IVARS
-      end
-
-      # Returns a Hash of instance variables and their values, as defined by
-      # the user in the test case, which are then assigned to the view being
-      # rendered. This is generally intended for internal use and extension
-      # frameworks.
-      def view_assigns
-        Hash[_user_defined_ivars.map do |var|
-          [var[1, var.length].to_sym, instance_variable_get(var)]
-        end]
-      end
-
-      def _routes
-        @controller._routes if @controller.respond_to?(:_routes)
-      end
-
-      def method_missing(selector, *args)
-        if @controller.respond_to?(:_routes) &&
-          ( @controller._routes.named_routes.helpers.include?(selector) ||
-            @controller._routes.mounted_helpers.method_defined?(selector) )
-          @controller.__send__(selector, *args)
-        else
-          super
-        end
-      end
-
-    end
-
-    include Behavior
-
-  end
-end

data/lib/action_view/testing/resolvers.rb

@@ -1,50 +0,0 @@
-require 'action_view/template/resolver'
-
-module ActionView #:nodoc:
-  # Use FixtureResolver in your tests to simulate the presence of files on the
-  # file system. This is used internally by Rails' own test suite, and is
-  # useful for testing extensions that have no way of knowing what the file
-  # system will look like at runtime.
-  class FixtureResolver < PathResolver
-    attr_reader :hash
-
-    def initialize(hash = {}, pattern=nil)
-      super(pattern)
-      @hash = hash
-    end
-
-    def to_s
-      @hash.keys.join(', ')
-    end
-
-  private
-
-    def query(path, exts, formats)
-      query = ""
-      EXTENSIONS.each do |ext|
-        query << '(' << exts[ext].map {|e| e && Regexp.escape(".#{e}") }.join('|') << '|)'
-      end
-      query = /^(#{Regexp.escape(path)})#{query}$/
-
-      templates = []
-      @hash.each do |_path, array|
-        source, updated_at = array
-        next unless _path =~ query
-        handler, format = extract_handler_and_format(_path, formats)
-        templates << Template.new(source, _path, handler,
-          :virtual_path => path.virtual, :format => format, :updated_at => updated_at)
-      end
-
-      templates.sort_by {|t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
-    end
-  end
-
-  class NullResolver < PathResolver
-    def query(path, exts, formats)
-      handler, format = extract_handler_and_format(path, formats)
-      [ActionView::Template.new("Template generated by Null Resolver", path, handler, :virtual_path => path, :format => format)]
-    end
-  end
-
-end
-