actionview 4.1.0.beta1

data/lib/action_view/buffers.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/string/output_safety'
+
+module ActionView
+  class OutputBuffer < ActiveSupport::SafeBuffer #:nodoc:
+    def initialize(*)
+      super
+      encode!
+    end
+
+    def <<(value)
+      return self if value.nil?
+      super(value.to_s)
+    end
+    alias :append= :<<
+
+    def safe_concat(value)
+      return self if value.nil?
+      super(value.to_s)
+    end
+    alias :safe_append= :safe_concat
+  end
+
+  class StreamingBuffer #:nodoc:
+    def initialize(block)
+      @block = block
+    end
+
+    def <<(value)
+      value = value.to_s
+      value = ERB::Util.h(value) unless value.html_safe?
+      @block.call(value)
+    end
+    alias :concat  :<<
+    alias :append= :<<
+
+    def safe_concat(value)
+      @block.call(value.to_s)
+    end
+    alias :safe_append= :safe_concat
+
+    def html_safe?
+      true
+    end
+
+    def html_safe
+      self
+    end
+  end
+end

data/lib/action_view/context.rb

@@ -0,0 +1,36 @@
+module ActionView
+  module CompiledTemplates #:nodoc:
+    # holds compiled template code
+  end
+
+  # = Action View Context
+  #
+  # Action View contexts are supplied to Action Controller to render a template.
+  # The default Action View context is ActionView::Base.
+  #
+  # In order to work with ActionController, a Context must just include this module.
+  # The initialization of the variables used by the context (@output_buffer, @view_flow,
+  # and @virtual_path) is responsibility of the object that includes this module
+  # (although you can call _prepare_context defined below).
+  module Context
+    include CompiledTemplates
+    attr_accessor :output_buffer, :view_flow
+
+    # Prepares the context by setting the appropriate instance variables.
+    # :api: plugin
+    def _prepare_context
+      @view_flow     = OutputFlow.new
+      @output_buffer = nil
+      @virtual_path  = nil
+    end
+
+    # Encapsulates the interaction with the view flow so it
+    # returns the correct buffer on +yield+. This is usually
+    # overwritten by helpers to add more behavior.
+    # :api: plugin
+    def _layout_for(name=nil)
+      name ||= :layout
+      view_flow.get(name).html_safe
+    end
+  end
+end

data/lib/action_view/dependency_tracker.rb

@@ -0,0 +1,93 @@
+require 'thread_safe'
+
+module ActionView
+  class DependencyTracker
+    @trackers = ThreadSafe::Cache.new
+
+    def self.find_dependencies(name, template)
+      tracker = @trackers[template.handler]
+
+      if tracker.present?
+        tracker.call(name, template)
+      else
+        []
+      end
+    end
+
+    def self.register_tracker(extension, tracker)
+      handler = Template.handler_for_extension(extension)
+      @trackers[handler] = tracker
+    end
+
+    def self.remove_tracker(handler)
+      @trackers.delete(handler)
+    end
+
+    class ERBTracker
+      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
+
+      # Matches:
+      #   render partial: "comments/comment", collection: commentable.comments
+      #   render "comments/comments"
+      #   render 'comments/comments'
+      #   render('comments/comments')
+      #
+      #   render(@topic)         => render("topics/topic")
+      #   render(topics)         => render("topics/topic")
+      #   render(message.topics) => render("topics/topic")
+      RENDER_DEPENDENCY = /
+        render\s*                     # render, followed by optional whitespace
+        \(?                           # start an optional parenthesis for the render call
+        (partial:|:partial\s+=>)?\s*  # naming the partial, used with collection -- 1st capture
+        ([@a-z"'][@\w\/\."']+)        # the template name itself -- 2nd capture
+      /x
+
+      def self.call(name, template)
+        new(name, template).dependencies
+      end
+
+      def initialize(name, template)
+        @name, @template = name, template
+      end
+
+      def dependencies
+        render_dependencies + explicit_dependencies
+      end
+
+      attr_reader :name, :template
+      private :name, :template
+
+      private
+
+        def source
+          template.source
+        end
+
+        def directory
+          name.split("/")[0..-2].join("/")
+        end
+
+        def render_dependencies
+          source.scan(RENDER_DEPENDENCY).
+            collect(&:second).uniq.
+
+            # render(@topic)         => render("topics/topic")
+            # render(topics)         => render("topics/topic")
+            # render(message.topics) => render("topics/topic")
+            collect { |name| name.sub(/\A@?([a-z_]+\.)*([a-z_]+)\z/) { "#{$2.pluralize}/#{$2.singularize}" } }.
+
+            # render("headline") => render("message/headline")
+            collect { |name| name.include?("/") ? name : "#{directory}/#{name}" }.
+
+            # replace quotes from string renders
+            collect { |name| name.gsub(/["']/, "") }
+        end
+
+        def explicit_dependencies
+          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+        end
+    end
+
+    register_tracker :erb, ERBTracker
+  end
+end

data/lib/action_view/digestor.rb

@@ -0,0 +1,116 @@
+require 'thread_safe'
+require 'action_view/dependency_tracker'
+require 'monitor'
+
+module ActionView
+  class Digestor
+    cattr_reader(:cache)
+    @@cache          = ThreadSafe::Cache.new
+    @@digest_monitor = Monitor.new
+
+    class << self
+      def digest(name, format, finder, options = {})
+        details_key = finder.details_key.hash
+        dependencies = Array.wrap(options[:dependencies])
+        cache_key = ([name, details_key, format] + dependencies).join('.')
+
+        # this is a correctly done double-checked locking idiom
+        # (ThreadSafe::Cache's lookups have volatile semantics)
+        @@cache[cache_key] || @@digest_monitor.synchronize do
+          @@cache.fetch(cache_key) do # re-check under lock
+            compute_and_store_digest(cache_key, name, format, finder, options)
+          end
+        end
+      end
+
+      private
+      def compute_and_store_digest(cache_key, name, format, finder, options) # called under @@digest_monitor lock
+        klass = if options[:partial] || name.include?("/_")
+          # Prevent re-entry or else recursive templates will blow the stack.
+          # There is no need to worry about other threads seeing the +false+ value,
+          # as they will then have to wait for this thread to let go of the @@digest_monitor lock.
+          pre_stored = @@cache.put_if_absent(cache_key, false).nil? # put_if_absent returns nil on insertion
+          PartialDigestor
+        else
+          Digestor
+        end
+
+        digest = klass.new(name, format, finder, options).digest
+        # Store the actual digest if config.cache_template_loading is true
+        @@cache[cache_key] = stored_digest = digest if ActionView::Resolver.caching?
+        digest
+      ensure
+        # something went wrong or ActionView::Resolver.caching? is false, make sure not to corrupt the @@cache
+        @@cache.delete_pair(cache_key, false) if pre_stored && !stored_digest 
+      end
+    end
+
+    attr_reader :name, :format, :finder, :options
+
+    def initialize(name, format, finder, options={})
+      @name, @format, @finder, @options = name, format, finder, options
+    end
+
+    def digest
+      Digest::MD5.hexdigest("#{source}-#{dependency_digest}").tap do |digest|
+        logger.try :info, "Cache digest for #{name}.#{format}: #{digest}"
+      end
+    rescue ActionView::MissingTemplate
+      logger.try :error, "Couldn't find template for digesting: #{name}.#{format}"
+      ''
+    end
+
+    def dependencies
+      DependencyTracker.find_dependencies(name, template)
+    rescue ActionView::MissingTemplate
+      [] # File doesn't exist, so no dependencies
+    end
+
+    def nested_dependencies
+      dependencies.collect do |dependency|
+        dependencies = PartialDigestor.new(dependency, format, finder).nested_dependencies
+        dependencies.any? ? { dependency => dependencies } : dependency
+      end
+    end
+
+    private
+
+      def logger
+        ActionView::Base.logger
+      end
+
+      def logical_name
+        name.gsub(%r|/_|, "/")
+      end
+
+      def partial?
+        false
+      end
+
+      def template
+        @template ||= finder.find(logical_name, [], partial?, formats: [ format ])
+      end
+
+      def source
+        template.source
+      end
+
+      def dependency_digest
+        template_digests = dependencies.collect do |template_name|
+          Digestor.digest(template_name, format, finder, partial: true)
+        end
+
+        (template_digests + injected_dependencies).join("-")
+      end
+
+      def injected_dependencies
+        Array.wrap(options[:dependencies])
+      end
+  end
+
+  class PartialDigestor < Digestor # :nodoc:
+    def partial?
+      true
+    end
+  end
+end

data/lib/action_view/flows.rb

@@ -0,0 +1,76 @@
+require 'active_support/core_ext/string/output_safety'
+
+module ActionView
+  class OutputFlow #:nodoc:
+    attr_reader :content
+
+    def initialize
+      @content = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
+    end
+
+    # Called by _layout_for to read stored values.
+    def get(key)
+      @content[key]
+    end
+
+    # Called by each renderer object to set the layout contents.
+    def set(key, value)
+      @content[key] = value
+    end
+
+    # Called by content_for
+    def append(key, value)
+      @content[key] << value
+    end
+    alias_method :append!, :append
+
+  end
+
+  class StreamingFlow < OutputFlow #:nodoc:
+    def initialize(view, fiber)
+      @view    = view
+      @parent  = nil
+      @child   = view.output_buffer
+      @content = view.view_flow.content
+      @fiber   = fiber
+      @root    = Fiber.current.object_id
+    end
+
+    # Try to get stored content. If the content
+    # is not available and we are inside the layout
+    # fiber, we set that we are waiting for the given
+    # key and yield.
+    def get(key)
+      return super if @content.key?(key)
+
+      if inside_fiber?
+        view = @view
+
+        begin
+          @waiting_for = key
+          view.output_buffer, @parent = @child, view.output_buffer
+          Fiber.yield
+        ensure
+          @waiting_for = nil
+          view.output_buffer, @child = @parent, view.output_buffer
+        end
+      end
+
+      super
+    end
+
+    # Appends the contents for the given key. This is called
+    # by provides and resumes back to the fiber if it is
+    # the key it is waiting for.
+    def append!(key, value)
+      super
+      @fiber.resume if @waiting_for == key
+    end
+
+    private
+
+    def inside_fiber?
+      Fiber.current.object_id != @root
+    end
+  end
+end

data/lib/action_view/helpers.rb

@@ -0,0 +1,64 @@
+require 'active_support/benchmarkable'
+
+module ActionView #:nodoc:
+  module Helpers #:nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveModelHelper
+    autoload :AssetTagHelper
+    autoload :AssetUrlHelper
+    autoload :AtomFeedHelper
+    autoload :CacheHelper
+    autoload :CaptureHelper
+    autoload :ControllerHelper
+    autoload :CsrfHelper
+    autoload :DateHelper
+    autoload :DebugHelper
+    autoload :FormHelper
+    autoload :FormOptionsHelper
+    autoload :FormTagHelper
+    autoload :JavaScriptHelper, "action_view/helpers/javascript_helper"
+    autoload :NumberHelper
+    autoload :OutputSafetyHelper
+    autoload :RecordTagHelper
+    autoload :RenderingHelper
+    autoload :SanitizeHelper
+    autoload :TagHelper
+    autoload :TextHelper
+    autoload :TranslationHelper
+    autoload :UrlHelper
+    autoload :Tags
+
+    def self.eager_load!
+      super
+      Tags.eager_load!
+    end
+
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Benchmarkable
+    include ActiveModelHelper
+    include AssetTagHelper
+    include AssetUrlHelper
+    include AtomFeedHelper
+    include CacheHelper
+    include CaptureHelper
+    include ControllerHelper
+    include CsrfHelper
+    include DateHelper
+    include DebugHelper
+    include FormHelper
+    include FormOptionsHelper
+    include FormTagHelper
+    include JavaScriptHelper
+    include NumberHelper
+    include OutputSafetyHelper
+    include RecordTagHelper
+    include RenderingHelper
+    include SanitizeHelper
+    include TagHelper
+    include TextHelper
+    include TranslationHelper
+    include UrlHelper
+  end
+end

data/lib/action_view/helpers/active_model_helper.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/enumerable'
+
+module ActionView
+  # = Active Model Helpers
+  module Helpers
+    module ActiveModelHelper
+    end
+
+    module ActiveModelInstanceTag
+      def object
+        @active_model_object ||= begin
+          object = super
+          object.respond_to?(:to_model) ? object.to_model : object
+        end
+      end
+
+      def content_tag(*)
+        error_wrapping(super)
+      end
+
+      def tag(type, options, *)
+        tag_generate_errors?(options) ? error_wrapping(super) : super
+      end
+
+      def error_wrapping(html_tag)
+        if object_has_errors?
+          Base.field_error_proc.call(html_tag, self)
+        else
+          html_tag
+        end
+      end
+
+      def error_message
+        object.errors[@method_name]
+      end
+
+      private
+
+      def object_has_errors?
+        object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
+      end
+
+      def tag_generate_errors?(options)
+        options['type'] != 'hidden'
+      end
+    end
+  end
+end