actionview 6.0.0

data/lib/action_view/helpers/atom_feed_helper.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ActionView
+  # = Action View Atom Feed Helpers
+  module Helpers #:nodoc:
+    module AtomFeedHelper
+      # Adds easy defaults to writing Atom feeds with the Builder template engine (this does not work on ERB or any other
+      # template languages).
+      #
+      # Full usage example:
+      #
+      #   config/routes.rb:
+      #     Rails.application.routes.draw do
+      #       resources :posts
+      #       root to: "posts#index"
+      #     end
+      #
+      #   app/controllers/posts_controller.rb:
+      #     class PostsController < ApplicationController
+      #       # GET /posts.html
+      #       # GET /posts.atom
+      #       def index
+      #         @posts = Post.all
+      #
+      #         respond_to do |format|
+      #           format.html
+      #           format.atom
+      #         end
+      #       end
+      #     end
+      #
+      #   app/views/posts/index.atom.builder:
+      #     atom_feed do |feed|
+      #       feed.title("My great blog!")
+      #       feed.updated(@posts[0].created_at) if @posts.length > 0
+      #
+      #       @posts.each do |post|
+      #         feed.entry(post) do |entry|
+      #           entry.title(post.title)
+      #           entry.content(post.body, type: 'html')
+      #
+      #           entry.author do |author|
+      #             author.name("DHH")
+      #           end
+      #         end
+      #       end
+      #     end
+      #
+      # The options for atom_feed are:
+      #
+      # * <tt>:language</tt>: Defaults to "en-US".
+      # * <tt>:root_url</tt>: The HTML alternative that this feed is doubling for. Defaults to / on the current host.
+      # * <tt>:url</tt>: The URL for this feed. Defaults to the current URL.
+      # * <tt>:id</tt>: The id for this feed. Defaults to "tag:localhost,2005:/posts", in this case.
+      # * <tt>:schema_date</tt>: The date at which the tag scheme for the feed was first used. A good default is the year you
+      #   created the feed. See http://feedvalidator.org/docs/error/InvalidTAG.html for more information. If not specified,
+      #   2005 is used (as an "I don't care" value).
+      # * <tt>:instruct</tt>: Hash of XML processing instructions in the form {target => {attribute => value, }} or {target => [{attribute => value, }, ]}
+      #
+      # Other namespaces can be added to the root element:
+      #
+      #   app/views/posts/index.atom.builder:
+      #     atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
+      #         'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
+      #       feed.title("My great blog!")
+      #       feed.updated((@posts.first.created_at))
+      #       feed.tag!('openSearch:totalResults', 10)
+      #
+      #       @posts.each do |post|
+      #         feed.entry(post) do |entry|
+      #           entry.title(post.title)
+      #           entry.content(post.body, type: 'html')
+      #           entry.tag!('app:edited', Time.now)
+      #
+      #           entry.author do |author|
+      #             author.name("DHH")
+      #           end
+      #         end
+      #       end
+      #     end
+      #
+      # The Atom spec defines five elements (content rights title subtitle
+      # summary) which may directly contain xhtml content if type: 'xhtml'
+      # is specified as an attribute. If so, this helper will take care of
+      # the enclosing div and xhtml namespace declaration. Example usage:
+      #
+      #    entry.summary type: 'xhtml' do |xhtml|
+      #      xhtml.p pluralize(order.line_items.count, "line item")
+      #      xhtml.p "Shipped to #{order.address}"
+      #      xhtml.p "Paid by #{order.pay_type}"
+      #    end
+      #
+      #
+      # <tt>atom_feed</tt> yields an +AtomFeedBuilder+ instance. Nested elements yield
+      # an +AtomBuilder+ instance.
+      def atom_feed(options = {}, &block)
+        if options[:schema_date]
+          options[:schema_date] = options[:schema_date].strftime("%Y-%m-%d") if options[:schema_date].respond_to?(:strftime)
+        else
+          options[:schema_date] = "2005" # The Atom spec copyright date
+        end
+
+        xml = options.delete(:xml) || eval("xml", block.binding)
+        xml.instruct!
+        if options[:instruct]
+          options[:instruct].each do |target, attrs|
+            if attrs.respond_to?(:keys)
+              xml.instruct!(target, attrs)
+            elsif attrs.respond_to?(:each)
+              attrs.each { |attr_group| xml.instruct!(target, attr_group) }
+            end
+          end
+        end
+
+        feed_opts = { "xml:lang" => options[:language] || "en-US", "xmlns" => "http://www.w3.org/2005/Atom" }
+        feed_opts.merge!(options).reject! { |k, v| !k.to_s.match(/^xml/) }
+
+        xml.feed(feed_opts) do
+          xml.id(options[:id] || "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}")
+          xml.link(rel: "alternate", type: "text/html", href: options[:root_url] || (request.protocol + request.host_with_port))
+          xml.link(rel: "self", type: "application/atom+xml", href: options[:url] || request.url)
+
+          yield AtomFeedBuilder.new(xml, self, options)
+        end
+      end
+
+      class AtomBuilder #:nodoc:
+        XHTML_TAG_NAMES = %w(content rights title subtitle summary).to_set
+
+        def initialize(xml)
+          @xml = xml
+        end
+
+        private
+          # Delegate to xml builder, first wrapping the element in an xhtml
+          # namespaced div element if the method and arguments indicate
+          # that an xhtml_block? is desired.
+          def method_missing(method, *arguments, &block)
+            if xhtml_block?(method, arguments)
+              @xml.__send__(method, *arguments) do
+                @xml.div(xmlns: "http://www.w3.org/1999/xhtml") do |xhtml|
+                  block.call(xhtml)
+                end
+              end
+            else
+              @xml.__send__(method, *arguments, &block)
+            end
+          end
+
+          # True if the method name matches one of the five elements defined
+          # in the Atom spec as potentially containing XHTML content and
+          # if type: 'xhtml' is, in fact, specified.
+          def xhtml_block?(method, arguments)
+            if XHTML_TAG_NAMES.include?(method.to_s)
+              last = arguments.last
+              last.is_a?(Hash) && last[:type].to_s == "xhtml"
+            end
+          end
+      end
+
+      class AtomFeedBuilder < AtomBuilder #:nodoc:
+        def initialize(xml, view, feed_options = {})
+          @xml, @view, @feed_options = xml, view, feed_options
+        end
+
+        # Accepts a Date or Time object and inserts it in the proper format. If +nil+ is passed, current time in UTC is used.
+        def updated(date_or_time = nil)
+          @xml.updated((date_or_time || Time.now.utc).xmlschema)
+        end
+
+        # Creates an entry tag for a specific record and prefills the id using class and id.
+        #
+        # Options:
+        #
+        # * <tt>:published</tt>: Time first published. Defaults to the created_at attribute on the record if one such exists.
+        # * <tt>:updated</tt>: Time of update. Defaults to the updated_at attribute on the record if one such exists.
+        # * <tt>:url</tt>: The URL for this entry or +false+ or +nil+ for not having a link tag. Defaults to the +polymorphic_url+ for the record.
+        # * <tt>:id</tt>: The ID for this entry. Defaults to "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}"
+        # * <tt>:type</tt>: The TYPE for this entry. Defaults to "text/html".
+        def entry(record, options = {})
+          @xml.entry do
+            @xml.id(options[:id] || "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}")
+
+            if options[:published] || (record.respond_to?(:created_at) && record.created_at)
+              @xml.published((options[:published] || record.created_at).xmlschema)
+            end
+
+            if options[:updated] || (record.respond_to?(:updated_at) && record.updated_at)
+              @xml.updated((options[:updated] || record.updated_at).xmlschema)
+            end
+
+            type = options.fetch(:type, "text/html")
+
+            url = options.fetch(:url) { @view.polymorphic_url(record) }
+            @xml.link(rel: "alternate", type: type, href: url) if url
+
+            yield AtomBuilder.new(@xml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_view/helpers/cache_helper.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module ActionView
+  # = Action View Cache Helper
+  module Helpers #:nodoc:
+    module CacheHelper
+      # This helper exposes a method for caching fragments of a view
+      # rather than an entire action or page. This technique is useful
+      # caching pieces like menus, lists of new topics, static HTML
+      # fragments, and so on. This method takes a block that contains
+      # the content you wish to cache.
+      #
+      # The best way to use this is by doing recyclable key-based cache expiration
+      # on top of a cache store like Memcached or Redis that'll automatically
+      # kick out old entries.
+      #
+      # When using this method, you list the cache dependency as the name of the cache, like so:
+      #
+      #   <% cache project do %>
+      #     <b>All the topics on this project</b>
+      #     <%= render project.topics %>
+      #   <% end %>
+      #
+      # This approach will assume that when a new topic is added, you'll touch
+      # the project. The cache key generated from this call will be something like:
+      #
+      #   views/template/action.html.erb:7a1156131a6928cb0026877f8b749ac9/projects/123
+      #         ^template path           ^template tree digest            ^class   ^id
+      #
+      # This cache key is stable, but it's combined with a cache version derived from the project
+      # record. When the project updated_at is touched, the #cache_version changes, even
+      # if the key stays stable. This means that unlike a traditional key-based cache expiration
+      # approach, you won't be generating cache trash, unused keys, simply because the dependent
+      # record is updated.
+      #
+      # If your template cache depends on multiple sources (try to avoid this to keep things simple),
+      # you can name all these dependencies as part of an array:
+      #
+      #   <% cache [ project, current_user ] do %>
+      #     <b>All the topics on this project</b>
+      #     <%= render project.topics %>
+      #   <% end %>
+      #
+      # This will include both records as part of the cache key and updating either of them will
+      # expire the cache.
+      #
+      # ==== \Template digest
+      #
+      # The template digest that's added to the cache key is computed by taking an MD5 of the
+      # contents of the entire template file. This ensures that your caches will automatically
+      # expire when you change the template file.
+      #
+      # Note that the MD5 is taken of the entire template file, not just what's within the
+      # cache do/end call. So it's possible that changing something outside of that call will
+      # still expire the cache.
+      #
+      # Additionally, the digestor will automatically look through your template file for
+      # explicit and implicit dependencies, and include those as part of the digest.
+      #
+      # The digestor can be bypassed by passing skip_digest: true as an option to the cache call:
+      #
+      #   <% cache project, skip_digest: true do %>
+      #     <b>All the topics on this project</b>
+      #     <%= render project.topics %>
+      #   <% end %>
+      #
+      # ==== Implicit dependencies
+      #
+      # Most template dependencies can be derived from calls to render in the template itself.
+      # Here are some examples of render calls that Cache Digests knows how to decode:
+      #
+      #   render partial: "comments/comment", collection: commentable.comments
+      #   render "comments/comments"
+      #   render 'comments/comments'
+      #   render('comments/comments')
+      #
+      #   render "header" translates to render("comments/header")
+      #
+      #   render(@topic)         translates to render("topics/topic")
+      #   render(topics)         translates to render("topics/topic")
+      #   render(message.topics) translates to render("topics/topic")
+      #
+      # It's not possible to derive all render calls like that, though.
+      # Here are a few examples of things that can't be derived:
+      #
+      #   render group_of_attachments
+      #   render @project.documents.where(published: true).order('created_at')
+      #
+      # You will have to rewrite those to the explicit form:
+      #
+      #   render partial: 'attachments/attachment', collection: group_of_attachments
+      #   render partial: 'documents/document', collection: @project.documents.where(published: true).order('created_at')
+      #
+      # === Explicit dependencies
+      #
+      # Sometimes you'll have template dependencies that can't be derived at all. This is typically
+      # the case when you have template rendering that happens in helpers. Here's an example:
+      #
+      #   <%= render_sortable_todolists @project.todolists %>
+      #
+      # You'll need to use a special comment format to call those out:
+      #
+      #   <%# Template Dependency: todolists/todolist %>
+      #   <%= render_sortable_todolists @project.todolists %>
+      #
+      # In some cases, like a single table inheritance setup, you might have
+      # a bunch of explicit dependencies. Instead of writing every template out,
+      # you can use a wildcard to match any template in a directory:
+      #
+      #   <%# Template Dependency: events/* %>
+      #   <%= render_categorizable_events @person.events %>
+      #
+      # This marks every template in the directory as a dependency. To find those
+      # templates, the wildcard path must be absolutely defined from <tt>app/views</tt> or paths
+      # otherwise added with +prepend_view_path+ or +append_view_path+.
+      # This way the wildcard for <tt>app/views/recordings/events</tt> would be <tt>recordings/events/*</tt> etc.
+      #
+      # The pattern used to match explicit dependencies is <tt>/# Template Dependency: (\S+)/</tt>,
+      # so it's important that you type it out just so.
+      # You can only declare one template dependency per line.
+      #
+      # === External dependencies
+      #
+      # If you use a helper method, for example, inside a cached block and
+      # you then update that helper, you'll have to bump the cache as well.
+      # It doesn't really matter how you do it, but the MD5 of the template file
+      # must change. One recommendation is to simply be explicit in a comment, like:
+      #
+      #   <%# Helper Dependency Updated: May 6, 2012 at 6pm %>
+      #   <%= some_helper_method(person) %>
+      #
+      # Now all you have to do is change that timestamp when the helper method changes.
+      #
+      # === Collection Caching
+      #
+      # When rendering a collection of objects that each use the same partial, a <tt>:cached</tt>
+      # option can be passed.
+      #
+      # For collections rendered such:
+      #
+      #   <%= render partial: 'projects/project', collection: @projects, cached: true %>
+      #
+      # The <tt>cached: true</tt> will make Action View's rendering read several templates
+      # from cache at once instead of one call per template.
+      #
+      # Templates in the collection not already cached are written to cache.
+      #
+      # Works great alongside individual template fragment caching.
+      # For instance if the template the collection renders is cached like:
+      #
+      #   # projects/_project.html.erb
+      #   <% cache project do %>
+      #     <%# ... %>
+      #   <% end %>
+      #
+      # Any collection renders will find those cached templates when attempting
+      # to read multiple templates at once.
+      #
+      # If your collection cache depends on multiple sources (try to avoid this to keep things simple),
+      # you can name all these dependencies as part of a block that returns an array:
+      #
+      #   <%= render partial: 'projects/project', collection: @projects, cached: -> project { [ project, current_user ] } %>
+      #
+      # This will include both records as part of the cache key and updating either of them will
+      # expire the cache.
+      def cache(name = {}, options = {}, &block)
+        if controller.respond_to?(:perform_caching) && controller.perform_caching
+          name_options = options.slice(:skip_digest, :virtual_path)
+          safe_concat(fragment_for(cache_fragment_name(name, name_options), options, &block))
+        else
+          yield
+        end
+
+        nil
+      end
+
+      # Cache fragments of a view if +condition+ is true
+      #
+      #   <% cache_if admin?, project do %>
+      #     <b>All the topics on this project</b>
+      #     <%= render project.topics %>
+      #   <% end %>
+      def cache_if(condition, name = {}, options = {}, &block)
+        if condition
+          cache(name, options, &block)
+        else
+          yield
+        end
+
+        nil
+      end
+
+      # Cache fragments of a view unless +condition+ is true
+      #
+      #   <% cache_unless admin?, project do %>
+      #     <b>All the topics on this project</b>
+      #     <%= render project.topics %>
+      #   <% end %>
+      def cache_unless(condition, name = {}, options = {}, &block)
+        cache_if !condition, name, options, &block
+      end
+
+      # This helper returns the name of a cache key for a given fragment cache
+      # call. By supplying <tt>skip_digest: true</tt> to cache, the digestion of cache
+      # fragments can be manually bypassed. This is useful when cache fragments
+      # cannot be manually expired unless you know the exact key which is the
+      # case when using memcached.
+      #
+      # The digest will be generated using +virtual_path:+ if it is provided.
+      #
+      def cache_fragment_name(name = {}, skip_digest: nil, virtual_path: nil, digest_path: nil)
+        if skip_digest
+          name
+        else
+          fragment_name_with_digest(name, virtual_path, digest_path)
+        end
+      end
+
+      def digest_path_from_template(template) # :nodoc:
+        digest = Digestor.digest(name: template.virtual_path, format: template.format, finder: lookup_context, dependencies: view_cache_dependencies)
+
+        if digest.present?
+          "#{template.virtual_path}:#{digest}"
+        else
+          template.virtual_path
+        end
+      end
+
+    private
+
+      def fragment_name_with_digest(name, virtual_path, digest_path)
+        virtual_path ||= @virtual_path
+
+        if virtual_path || digest_path
+          name = controller.url_for(name).split("://").last if name.is_a?(Hash)
+
+          digest_path ||= digest_path_from_template(@current_template)
+
+          [ digest_path, name ]
+        else
+          name
+        end
+      end
+
+      def fragment_for(name = {}, options = nil, &block)
+        if content = read_fragment_for(name, options)
+          @view_renderer.cache_hits[@virtual_path] = :hit if defined?(@view_renderer)
+          content
+        else
+          @view_renderer.cache_hits[@virtual_path] = :miss if defined?(@view_renderer)
+          write_fragment_for(name, options, &block)
+        end
+      end
+
+      def read_fragment_for(name, options)
+        controller.read_fragment(name, options)
+      end
+
+      def write_fragment_for(name, options)
+        pos = output_buffer.length
+        yield
+        output_safe = output_buffer.html_safe?
+        fragment = output_buffer.slice!(pos..-1)
+        if output_safe
+          self.output_buffer = output_buffer.class.new(output_buffer)
+        end
+        controller.write_fragment(name, fragment, options)
+      end
+    end
+  end
+end