omg-actionview 8.0.0.alpha1

data/lib/action_view/lookup_context.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "active_support/core_ext/module/attribute_accessors"
+require "action_view/template/resolver"
+
+module ActionView
+  # = Action View Lookup Context
+  #
+  # <tt>LookupContext</tt> is the object responsible for holding all information
+  # required for looking up templates, i.e. view paths and details.
+  # <tt>LookupContext</tt> is also responsible for generating a key, given to
+  # view paths, used in the resolver cache lookup. Since this key is generated
+  # only once during the request, it speeds up all cache accesses.
+  class LookupContext # :nodoc:
+    attr_accessor :prefixes
+
+    singleton_class.attr_accessor :registered_details
+    self.registered_details = []
+
+    def self.register_detail(name, &block)
+      registered_details << name
+      Accessors::DEFAULT_PROCS[name] = block
+
+      Accessors.define_method(:"default_#{name}", &block)
+      Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{name}
+          @details[:#{name}] || []
+        end
+
+        def #{name}=(value)
+          value = value.present? ? Array(value) : default_#{name}
+          _set_detail(:#{name}, value) if value != @details[:#{name}]
+        end
+      METHOD
+    end
+
+    # Holds accessors for the registered details.
+    module Accessors # :nodoc:
+      DEFAULT_PROCS = {}
+    end
+
+    register_detail(:locale) do
+      locales = [I18n.locale]
+      locales.concat(I18n.fallbacks[I18n.locale]) if I18n.respond_to? :fallbacks
+      locales << I18n.default_locale
+      locales.uniq!
+      locales
+    end
+    register_detail(:formats) { ActionView::Base.default_formats || [:html, :text, :js, :css,  :xml, :json] }
+    register_detail(:variants) { [] }
+    register_detail(:handlers) { Template::Handlers.extensions }
+
+    class DetailsKey # :nodoc:
+      alias :eql? :equal?
+
+      @details_keys = Concurrent::Map.new
+      @digest_cache = Concurrent::Map.new
+      @view_context_mutex = Mutex.new
+
+      def self.digest_cache(details)
+        @digest_cache[details_cache_key(details)] ||= Concurrent::Map.new
+      end
+
+      def self.details_cache_key(details)
+        @details_keys.fetch(details) do
+          if formats = details[:formats]
+            unless Template::Types.valid_symbols?(formats)
+              details = details.dup
+              details[:formats] &= Template::Types.symbols
+            end
+          end
+          @details_keys[details] ||= TemplateDetails::Requested.new(**details)
+        end
+      end
+
+      def self.clear
+        ActionView::PathRegistry.all_resolvers.each do |resolver|
+          resolver.clear_cache
+        end
+        @view_context_class = nil
+        @details_keys.clear
+        @digest_cache.clear
+      end
+
+      def self.digest_caches
+        @digest_cache.values
+      end
+
+      def self.view_context_class
+        @view_context_mutex.synchronize do
+          @view_context_class ||= ActionView::Base.with_empty_template_cache
+        end
+      end
+    end
+
+    # Add caching behavior on top of Details.
+    module DetailsCache
+      attr_accessor :cache
+
+      # Calculate the details key. Remove the handlers from calculation to improve performance
+      # since the user cannot modify it explicitly.
+      def details_key # :nodoc:
+        @details_key ||= DetailsKey.details_cache_key(@details) if @cache
+      end
+
+      # Temporary skip passing the details_key forward.
+      def disable_cache
+        old_value, @cache = @cache, false
+        yield
+      ensure
+        @cache = old_value
+      end
+
+    private
+      def _set_detail(key, value) # :doc:
+        @details = @details.dup if @digest_cache || @details_key
+        @digest_cache = nil
+        @details_key = nil
+        @details[key] = value
+      end
+    end
+
+    # Helpers related to template lookup using the lookup context information.
+    module ViewPaths
+      attr_reader :view_paths, :html_fallback_for_js
+
+      def find(name, prefixes = [], partial = false, keys = [], options = {})
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find(name, prefixes, partial, details, details_key, keys)
+      end
+      alias :find_template :find
+
+      def find_all(name, prefixes = [], partial = false, keys = [], options = {})
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find_all(name, prefixes, partial, details, details_key, keys)
+      end
+
+      def exists?(name, prefixes = [], partial = false, keys = [], **options)
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.exists?(name, prefixes, partial, details, details_key, keys)
+      end
+      alias :template_exists? :exists?
+
+      def any?(name, prefixes = [], partial = false)
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for_any
+        @view_paths.exists?(name, prefixes, partial, details, details_key, [])
+      end
+      alias :any_templates? :any?
+
+      def append_view_paths(paths)
+        @view_paths = build_view_paths(@view_paths.to_a + paths)
+      end
+
+      def prepend_view_paths(paths)
+        @view_paths = build_view_paths(paths + @view_paths.to_a)
+      end
+
+    private
+      # Whenever setting view paths, makes a copy so that we can manipulate them in
+      # instance objects as we wish.
+      def build_view_paths(paths)
+        if ActionView::PathSet === paths
+          paths
+        else
+          ActionView::PathSet.new(Array(paths))
+        end
+      end
+
+      # Compute details hash and key according to user options (e.g. passed from #render).
+      def detail_args_for(options) # :doc:
+        return @details, details_key if options.empty? # most common path.
+        user_details = @details.merge(options)
+
+        if @cache
+          details_key = DetailsKey.details_cache_key(user_details)
+        else
+          details_key = nil
+        end
+
+        [user_details, details_key]
+      end
+
+      def detail_args_for_any
+        @detail_args_for_any ||= begin
+          details = {}
+
+          LookupContext.registered_details.each do |k|
+            if k == :variants
+              details[k] = :any
+            else
+              details[k] = Accessors::DEFAULT_PROCS[k].call
+            end
+          end
+
+          if @cache
+            [details, DetailsKey.details_cache_key(details)]
+          else
+            [details, nil]
+          end
+        end
+      end
+
+      # Fix when prefix is specified as part of the template name
+      def normalize_name(name, prefixes)
+        name = name.to_s
+        idx = name.rindex("/")
+        return name, prefixes.presence || [""] unless idx
+
+        path_prefix = name[0, idx]
+        path_prefix = path_prefix.from(1) if path_prefix.start_with?("/")
+        name = name.from(idx + 1)
+
+        if !prefixes || prefixes.empty?
+          prefixes = [path_prefix]
+        else
+          prefixes = prefixes.map { |p| "#{p}/#{path_prefix}" }
+        end
+
+        return name, prefixes
+      end
+    end
+
+    include Accessors
+    include DetailsCache
+    include ViewPaths
+
+    def initialize(view_paths, details = {}, prefixes = [])
+      @details_key = nil
+      @digest_cache = nil
+      @cache = true
+      @prefixes = prefixes
+
+      @details = initialize_details({}, details)
+      @view_paths = build_view_paths(view_paths)
+    end
+
+    def digest_cache
+      @digest_cache ||= DetailsKey.digest_cache(@details)
+    end
+
+    def with_prepended_formats(formats)
+      details = @details.dup
+      details[:formats] = formats
+
+      self.class.new(@view_paths, details, @prefixes)
+    end
+
+    def initialize_details(target, details)
+      LookupContext.registered_details.each do |k|
+        target[k] = details[k] || Accessors::DEFAULT_PROCS[k].call
+      end
+      target
+    end
+    private :initialize_details
+
+    # Override formats= to expand ["*/*"] values and automatically
+    # add :html as fallback to :js.
+    def formats=(values)
+      if values
+        values = values.dup
+        values.concat(default_formats) if values.delete "*/*"
+        values.uniq!
+
+        unless Template::Types.valid_symbols?(values)
+          invalid_values = values - Template::Types.symbols
+          raise ArgumentError, "Invalid formats: #{invalid_values.map(&:inspect).join(", ")}"
+        end
+
+        if (values.length == 1) && (values[0] == :js)
+          values << :html
+          @html_fallback_for_js = true
+        end
+      end
+      super(values)
+    end
+
+    # Override locale to return a symbol instead of array.
+    def locale
+      @details[:locale].first
+    end
+
+    # Overload locale= to also set the I18n.locale. If the current I18n.config object responds
+    # to original_config, it means that it has a copy of the original I18n configuration and it's
+    # acting as proxy, which we need to skip.
+    def locale=(value)
+      if value
+        config = I18n.config.respond_to?(:original_config) ? I18n.config.original_config : I18n.config
+        config.locale = value
+      end
+
+      super(default_locale)
+    end
+  end
+end

data/lib/action_view/model_naming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActionView
+  module ModelNaming # :nodoc:
+    # Converts the given object to an Active Model compliant one.
+    def convert_to_model(object)
+      object.respond_to?(:to_model) ? object.to_model : object
+    end
+
+    def model_name_from_record_or_class(record_or_class)
+      convert_to_model(record_or_class).model_name
+    end
+  end
+end

data/lib/action_view/path_registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  module PathRegistry # :nodoc:
+    @view_paths_by_class = {}
+    @file_system_resolvers = {}
+    @file_system_resolver_mutex = Mutex.new
+    @file_system_resolver_hooks = []
+
+    class << self
+      attr_reader :file_system_resolver_hooks
+    end
+
+    def self.get_view_paths(klass)
+      @view_paths_by_class[klass] || get_view_paths(klass.superclass)
+    end
+
+    def self.set_view_paths(klass, paths)
+      @view_paths_by_class[klass] = paths
+    end
+
+    def self.cast_file_system_resolvers(paths)
+      paths = Array(paths)
+
+      @file_system_resolver_mutex.synchronize do
+        built_resolver = false
+        paths = paths.map do |path|
+          case path
+          when String, Pathname
+            path = File.expand_path(path)
+            @file_system_resolvers[path] ||=
+              begin
+                built_resolver = true
+                FileSystemResolver.new(path)
+              end
+          else
+            path
+          end
+        end
+
+        file_system_resolver_hooks.each(&:call) if built_resolver
+      end
+
+      paths
+    end
+
+    def self.all_resolvers
+      resolvers = [all_file_system_resolvers]
+      resolvers.concat @view_paths_by_class.values.map(&:to_a)
+      resolvers.flatten.uniq
+    end
+
+    def self.all_file_system_resolvers
+      @file_system_resolvers.values
+    end
+  end
+end

data/lib/action_view/path_set.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  # = Action View PathSet
+  #
+  # This class is used to store and access paths in Action View. A number of
+  # operations are defined so that you can search among the paths in this
+  # set and also perform operations on other +PathSet+ objects.
+  #
+  # A +LookupContext+ will use a +PathSet+ to store the paths in its context.
+  class PathSet # :nodoc:
+    include Enumerable
+
+    attr_reader :paths
+
+    delegate :[], :include?, :size, :each, to: :paths
+
+    def initialize(paths = [])
+      @paths = typecast(paths).freeze
+    end
+
+    def initialize_copy(other)
+      @paths = other.paths.dup.freeze
+      self
+    end
+
+    def to_ary
+      paths.dup
+    end
+
+    def compact
+      PathSet.new paths.compact
+    end
+
+    def +(other)
+      array = Array === other ? other : other.paths
+      PathSet.new(paths + array)
+    end
+
+    def find(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).first ||
+        raise(MissingTemplate.new(self, path, prefixes, partial, details, details_key, locals))
+    end
+
+    def find_all(path, prefixes, partial, details, details_key, locals)
+      search_combinations(prefixes) do |resolver, prefix|
+        templates = resolver.find_all(path, prefix, partial, details, details_key, locals)
+        return templates unless templates.empty?
+      end
+      []
+    end
+
+    def exists?(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).any?
+    end
+
+    private
+      def search_combinations(prefixes)
+        prefixes = Array(prefixes)
+        prefixes.each do |prefix|
+          paths.each do |resolver|
+            yield resolver, prefix
+          end
+        end
+      end
+
+      def typecast(paths)
+        paths.map do |path|
+          case path
+          when Pathname, String
+            # This path should only be reached by "direct" users of
+            # ActionView::Base (not using the ViewPaths or Renderer modules).
+            # We can't cache/de-dup the file system resolver in this case as we
+            # don't know which compiled_method_container we'll be rendering to.
+            FileSystemResolver.new(path)
+          when Resolver
+            path
+          else
+            raise TypeError, "#{path.inspect} is not a valid path: must be a String, Pathname, or Resolver"
+          end
+        end
+      end
+  end
+end

data/lib/action_view/railtie.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "action_view"
+require "rails"
+
+module ActionView
+  # = Action View Railtie
+  class Railtie < Rails::Engine # :nodoc:
+    config.action_view = ActiveSupport::OrderedOptions.new
+    config.action_view.embed_authenticity_token_in_remote_forms = nil
+    config.action_view.debug_missing_translation = true
+    config.action_view.default_enforce_utf8 = nil
+    config.action_view.image_loading = nil
+    config.action_view.image_decoding = nil
+    config.action_view.apply_stylesheet_media_default = true
+    config.action_view.prepend_content_exfiltration_prevention = false
+
+    config.eager_load_namespaces << ActionView
+
+    config.after_initialize do |app|
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
+        app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+    end
+
+    config.after_initialize do |app|
+      form_with_generates_remote_forms = app.config.action_view.delete(:form_with_generates_remote_forms)
+      ActionView::Helpers::FormHelper.form_with_generates_remote_forms = form_with_generates_remote_forms
+    end
+
+    config.after_initialize do |app|
+      form_with_generates_ids = app.config.action_view.delete(:form_with_generates_ids)
+      unless form_with_generates_ids.nil?
+        ActionView::Helpers::FormHelper.form_with_generates_ids = form_with_generates_ids
+      end
+    end
+
+    config.after_initialize do |app|
+      default_enforce_utf8 = app.config.action_view.delete(:default_enforce_utf8)
+      unless default_enforce_utf8.nil?
+        ActionView::Helpers::FormTagHelper.default_enforce_utf8 = default_enforce_utf8
+      end
+    end
+
+    config.after_initialize do |app|
+      prepend_content_exfiltration_prevention = app.config.action_view.delete(:prepend_content_exfiltration_prevention)
+      ActionView::Helpers::ContentExfiltrationPreventionHelper.prepend_content_exfiltration_prevention = prepend_content_exfiltration_prevention
+    end
+
+    config.after_initialize do |app|
+      if klass = app.config.action_view.delete(:sanitizer_vendor)
+        ActionView::Helpers::SanitizeHelper.sanitizer_vendor = klass
+      end
+    end
+
+    config.after_initialize do |app|
+      button_to_generates_button_tag = app.config.action_view.delete(:button_to_generates_button_tag)
+      unless button_to_generates_button_tag.nil?
+        ActionView::Helpers::UrlHelper.button_to_generates_button_tag = button_to_generates_button_tag
+      end
+    end
+
+    config.after_initialize do |app|
+      frozen_string_literal = app.config.action_view.delete(:frozen_string_literal)
+      ActionView::Template.frozen_string_literal = frozen_string_literal
+    end
+
+    config.after_initialize do |app|
+      ActionView::Helpers::AssetTagHelper.image_loading = app.config.action_view.delete(:image_loading)
+      ActionView::Helpers::AssetTagHelper.image_decoding = app.config.action_view.delete(:image_decoding)
+      ActionView::Helpers::AssetTagHelper.preload_links_header = app.config.action_view.delete(:preload_links_header)
+      ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default = app.config.action_view.delete(:apply_stylesheet_media_default)
+    end
+
+    config.after_initialize do |app|
+      ActiveSupport.on_load(:action_view) do
+        app.config.action_view.each do |k, v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    initializer "action_view.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_view] = ActionView.deprecator
+    end
+
+    initializer "action_view.logger" do
+      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
+    end
+
+    initializer "action_view.caching" do |app|
+      ActiveSupport.on_load(:action_view) do
+        if app.config.action_view.cache_template_loading.nil?
+          ActionView::Resolver.caching = !app.config.reloading_enabled?
+        end
+      end
+    end
+
+    initializer "action_view.setup_action_pack" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        ActionView::RoutingUrlFor.include(ActionDispatch::Routing::UrlFor)
+      end
+    end
+
+    initializer "action_view.collection_caching", after: "action_controller.set_configs" do |app|
+      PartialRenderer.collection_cache = app.config.action_controller.cache_store
+    end
+
+    config.after_initialize do |app|
+      enable_caching = if app.config.action_view.cache_template_loading.nil?
+        !app.config.reloading_enabled?
+      else
+        app.config.action_view.cache_template_loading
+      end
+
+      unless enable_caching
+        view_reloader = ActionView::CacheExpiry::ViewReloader.new(watcher: app.config.file_watcher)
+
+        app.reloaders << view_reloader
+        app.reloader.to_run do
+          require_unload_lock!
+          view_reloader.execute
+        end
+      end
+    end
+
+    rake_tasks do |app|
+      unless app.config.api_only
+        load "action_view/tasks/cache_digests.rake"
+      end
+    end
+  end
+end

data/lib/action_view/record_identifier.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "action_view/model_naming"
+
+module ActionView
+  # = Action View \Record \Identifier
+  #
+  # RecordIdentifier encapsulates methods used by various ActionView helpers
+  # to associate records with DOM elements.
+  #
+  # Consider for example the following code that form of post:
+  #
+  #   <%= form_for(post) do |f| %>
+  #     <%= f.text_field :body %>
+  #   <% end %>
+  #
+  # When +post+ is a new, unsaved ActiveRecord::Base instance, the resulting HTML
+  # is:
+  #
+  #    <form class="new_post" id="new_post" action="/posts" accept-charset="UTF-8" method="post">
+  #      <input type="text" name="post[body]" id="post_body" />
+  #    </form>
+  #
+  # When +post+ is a persisted ActiveRecord::Base instance, the resulting HTML
+  # is:
+  #
+  #   <form class="edit_post" id="edit_post_42" action="/posts/42" accept-charset="UTF-8" method="post">
+  #     <input type="text" value="What a wonderful world!" name="post[body]" id="post_body" />
+  #   </form>
+  #
+  # In both cases, the +id+ and +class+ of the wrapping DOM element are
+  # automatically generated, following naming conventions encapsulated by the
+  # RecordIdentifier methods #dom_id and #dom_class:
+  #
+  #   dom_id(Post)             # => "new_post"
+  #   dom_class(Post)          # => "post"
+  #   dom_id(Post.new)         # => "new_post"
+  #   dom_class(Post.new)      # => "post"
+  #   dom_id(Post.find 42)     # => "post_42"
+  #   dom_class(Post.find 42)  # => "post"
+  #
+  # Note that these methods do not strictly require +Post+ to be a subclass of
+  # ActiveRecord::Base.
+  # Any +Post+ class will work as long as its instances respond to +to_key+
+  # and +model_name+, given that +model_name+ responds to +param_key+.
+  # For instance:
+  #
+  #   class Post
+  #     attr_accessor :to_key
+  #
+  #     def model_name
+  #       OpenStruct.new param_key: 'post'
+  #     end
+  #
+  #     def self.find(id)
+  #       new.tap { |post| post.to_key = [id] }
+  #     end
+  #   end
+  module RecordIdentifier
+    extend self
+    extend ModelNaming
+
+    include ModelNaming
+
+    JOIN = "_"
+    NEW = "new"
+
+    # The DOM class convention is to use the singular form of an object or class.
+    #
+    #   dom_class(post)   # => "post"
+    #   dom_class(Person) # => "person"
+    #
+    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_class:
+    #
+    #   dom_class(post, :edit)   # => "edit_post"
+    #   dom_class(Person, :edit) # => "edit_person"
+    def dom_class(record_or_class, prefix = nil)
+      singular = model_name_from_record_or_class(record_or_class).param_key
+      prefix ? "#{prefix}#{JOIN}#{singular}" : singular
+    end
+
+    # The DOM id convention is to use the singular form of an object or class with the id following an underscore.
+    # If no id is found, prefix with "new_" instead.
+    #
+    #   dom_id(Post.find(45)) # => "post_45"
+    #   dom_id(Post)          # => "new_post"
+    #
+    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_id:
+    #
+    #   dom_id(Post.find(45), :edit) # => "edit_post_45"
+    #   dom_id(Post, :custom)        # => "custom_post"
+    def dom_id(record_or_class, prefix = nil)
+      raise ArgumentError, "dom_id must be passed a record_or_class as the first argument, you passed #{record_or_class.inspect}" unless record_or_class
+
+      record_id = record_key_for_dom_id(record_or_class) unless record_or_class.is_a?(Class)
+      if record_id
+        "#{dom_class(record_or_class, prefix)}#{JOIN}#{record_id}"
+      else
+        dom_class(record_or_class, prefix || NEW)
+      end
+    end
+
+  private
+    # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
+    # This can be overwritten to customize the default generated string representation if desired.
+    # If you need to read back a key from a dom_id in order to query for the underlying database record,
+    # you should write a helper like 'person_record_from_dom_id' that will extract the key either based
+    # on the default implementation (which just joins all key attributes with '_') or on your own
+    # overwritten version of the method. By default, this implementation passes the key string through a
+    # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
+    # make sure yourself that your dom ids are valid, in case you override this method.
+    def record_key_for_dom_id(record) # :doc:
+      key = convert_to_model(record).to_key
+      key && key.all? ? key.join(JOIN) : nil
+    end
+  end
+end