halorgium-actionpack 3.0.pre

data/lib/action_view/template/resolver.rb

@@ -0,0 +1,165 @@
+require "pathname"
+require "active_support/core_ext/class"
+require "action_view/template/template"
+
+module ActionView
+  # Abstract superclass
+  class Resolver
+
+    class_inheritable_accessor(:registered_details)
+    self.registered_details = {}
+
+    def self.register_detail(name, options = {})
+      registered_details[name] = lambda do |val|
+        val ||= yield
+        val |= [nil] unless options[:allow_nil] == false
+        val
+      end
+    end
+
+    register_detail(:locale)  { [I18n.locale] }
+    register_detail(:formats) { Mime::SET.symbols }
+    register_detail(:handlers, :allow_nil => false) do
+      TemplateHandlers.extensions
+    end
+
+    def initialize(options = {})
+      @cache  = options[:cache]
+      @cached = {}
+    end
+
+    # Normalizes the arguments and passes it on to find_template
+    def find(*args)
+      find_all(*args).first
+    end
+
+    def find_all(name, details = {}, prefix = nil, partial = nil)
+      details = normalize_details(details)
+      name, prefix = normalize_name(name, prefix)
+
+      cached([name, details, prefix, partial]) do
+        find_templates(name, details, prefix, partial)
+      end
+    end
+
+  private
+
+    # This is what child classes implement. No defaults are needed
+    # because Resolver guarantees that the arguments are present and
+    # normalized.
+    def find_templates(name, details, prefix, partial)
+      raise NotImplementedError
+    end
+
+    def normalize_details(details)
+      details = details.dup
+      # TODO: Refactor this concern out of the resolver
+      details.delete(:formats) if details[:formats] == [:"*/*"]
+      registered_details.each do |k, v|
+        details[k] = v.call(details[k])
+      end
+      details
+    end
+
+    # Support legacy foo.erb names even though we now ignore .erb
+    # as well as incorrectly putting part of the path in the template
+    # name instead of the prefix.
+    def normalize_name(name, prefix)
+      handlers = TemplateHandlers.extensions.join('|')
+      name = name.to_s.gsub(/\.(?:#{handlers})$/, '')
+
+      parts = name.split('/')
+      return parts.pop, [prefix, *parts].compact.join("/")
+    end
+
+    def cached(key)
+      return yield unless @cache
+      return @cached[key] if @cached.key?(key)
+      @cached[key] = yield
+    end
+  end
+
+  class PathResolver < Resolver
+
+    EXTENSION_ORDER = [:locale, :formats, :handlers]
+
+    def to_s
+      @path.to_s
+    end
+    alias to_path to_s
+
+    def find_templates(name, details, prefix, partial)
+      path = build_path(name, details, prefix, partial)
+      query(path, EXTENSION_ORDER.map { |ext| details[ext] })
+    end
+
+  private
+
+    def build_path(name, details, prefix, partial)
+      path = ""
+      path << "#{prefix}/" unless prefix.empty?
+      path << (partial ? "_#{name}" : name)
+      path
+    end
+
+    def query(path, exts)
+      query = "#{@path}/#{path}"
+      exts.each do |ext|
+        query << '{' << ext.map {|e| e && ".#{e}" }.join(',') << '}'
+      end
+
+      Dir[query].map do |path|
+        next if File.directory?(path)
+        source = File.read(path)
+        identifier = Pathname.new(path).expand_path.to_s
+
+        Template.new(source, identifier, *path_to_details(path))
+      end.compact
+    end
+
+    # # TODO: fix me
+    # # :api: plugin
+    def path_to_details(path)
+      # [:erb, :format => :html, :locale => :en, :partial => true/false]
+      if m = path.match(%r'(?:^|/)(_)?[\w-]+((?:\.[\w-]+)*)\.(\w+)$')
+        partial = m[1] == '_'
+        details = (m[2]||"").split('.').reject { |e| e.empty? }
+        handler = Template.handler_class_for_extension(m[3])
+
+        format  = Mime[details.last] && details.pop.to_sym
+        locale  = details.last && details.pop.to_sym
+
+        return handler, :format => format, :locale => locale, :partial => partial
+      end
+    end
+  end
+
+  class FileSystemResolver < PathResolver
+    def initialize(path, options = {})
+      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
+      super(options)
+      @path = Pathname.new(path).expand_path
+    end
+  end
+
+  # OMG HAX
+  # TODO: remove hax
+  class FileSystemResolverWithFallback < Resolver
+    def initialize(path, options = {})
+      super(options)
+      @paths = [FileSystemResolver.new(path, options), FileSystemResolver.new("", options), FileSystemResolver.new("/", options)]
+    end
+
+    def find_templates(*args)
+      @paths.each do |p|
+        template = p.find_templates(*args)
+        return template unless template.empty?
+      end
+      []
+    end
+
+    def to_s
+      @paths.first.to_s
+    end
+  end
+end

data/lib/action_view/template/template.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# This is so that templates compiled in this file are UTF-8
+
+require 'set'
+require "action_view/template/resolver"
+
+module ActionView
+  class Template
+    extend TemplateHandlers
+    attr_reader :source, :identifier, :handler, :mime_type, :formats, :details
+
+    def initialize(source, identifier, handler, details)
+      @source     = source
+      @identifier = identifier
+      @handler    = handler
+      @details    = details
+      @method_names = {}
+
+      format = details.delete(:format) || begin
+        # TODO: Clean this up
+        handler.respond_to?(:default_format) ? handler.default_format.to_sym.to_s : "html"
+      end
+      @mime_type = Mime::Type.lookup_by_extension(format.to_s)
+      @formats = [format.to_sym]
+      @formats << :html if format == :js
+      @details[:formats] = Array.wrap(format.to_sym)
+    end
+
+    def render(view, locals, &block)
+      ActiveSupport::Notifications.instrument(:render_template, :identifier => identifier) do
+        method_name = compile(locals, view)
+        view.send(method_name, locals, &block)
+      end
+    rescue Exception => e
+      if e.is_a?(TemplateError)
+        e.sub_template_of(self)
+        raise e
+      else
+        raise TemplateError.new(self, view.assigns, e)
+      end
+    end
+
+    # TODO: Figure out how to abstract this
+    def variable_name
+      @variable_name ||= identifier[%r'_?(\w+)(\.\w+)*$', 1].to_sym
+    end
+
+    # TODO: Figure out how to abstract this
+    def counter_name
+      @counter_name ||= "#{variable_name}_counter".to_sym
+    end
+
+    # TODO: kill hax
+    def partial?
+      @details[:partial]
+    end
+
+    def inspect
+      if defined?(Rails.root)
+        identifier.sub("#{Rails.root}/", '')
+      else
+        identifier
+      end
+    end
+
+    private
+      def compile(locals, view)
+        method_name = build_method_name(locals)
+
+        return method_name if view.respond_to?(method_name)
+
+        locals_code = locals.keys.map! { |key| "#{key} = local_assigns[:#{key}];" }.join
+
+        code = @handler.call(self)
+        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 #{method_name}(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::CompiledTemplates.module_eval(source, identifier, line)
+          method_name
+        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::TemplateError.new(self, {}, e)
+        end
+      end
+
+      class LocalsKey
+        @hash_keys = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = {} } }
+
+        def self.get(*locals)
+          @hash_keys[*locals] ||= new(klass, format, locale)
+        end
+
+        attr_accessor :hash
+        def initialize(klass, format, locale)
+          @hash = locals.hash
+        end
+
+        alias_method :eql?, :equal?
+      end
+
+      def build_method_name(locals)
+        # TODO: is locals.keys.hash reliably the same?
+        @method_names[locals.keys.hash] ||=
+          "_render_template_#{@identifier.hash}_#{__id__}_#{locals.keys.hash}".gsub('-', "_")
+      end
+  end
+end

data/lib/action_view/template/text.rb

@@ -0,0 +1,38 @@
+module ActionView #:nodoc:
+  class TextTemplate < String #:nodoc:
+    HTML = Mime[:html]
+
+    def initialize(string, content_type = HTML)
+      super(string.to_s)
+      @content_type = Mime[content_type] || content_type
+    end
+
+    def details
+      {:formats => [@content_type.to_sym]}
+    end
+
+    def identifier
+      self
+    end
+
+    def inspect
+      'text template'
+    end
+
+    def render(*args)
+      to_s
+    end
+
+    def mime_type
+      @content_type
+    end
+
+    def formats
+      [mime_type]
+    end
+
+    def partial?
+      false
+    end
+  end
+end

data/lib/action_view/test_case.rb

@@ -0,0 +1,163 @@
+require 'active_support/test_case'
+require 'action_controller/testing/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
+
+    attr_internal :rendered
+  end
+
+  class Template
+    alias_method :render_without_tracking, :render
+    def render(view, locals, &blk)
+      rendered = view.rendered
+      rendered[:partials][self] += 1 if partial?
+      rendered[:template] ||= []
+      rendered[:template] << self
+      render_without_tracking(view, locals, &blk)
+    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 = {}
+      end
+    end
+
+    include ActionDispatch::Assertions
+    include ActionController::TestProcess
+    include ActionView::Context
+
+    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 = ActionView::SafeBuffer.new
+      @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|
+          _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
+
+      private
+        def include_helper_modules!
+          helper(helper_class) if helper_class
+          include _helpers
+        end
+    end
+
+    private
+      def make_test_case_available_to_view!
+        test_case_instance = self
+        _helpers.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.class.send :include, _helpers
+        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