omg-actionview 8.0.0.alpha1

data/lib/action_view/test_case.rb

@@ -0,0 +1,449 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+require "action_controller"
+require "action_controller/test_case"
+require "action_view"
+
+require "rails-dom-testing"
+
+module ActionView
+  # = Action View Test Case
+  #
+  # Read more about <tt>ActionView::TestCase</tt> in {Testing Rails Applications}[https://guides.rubyonrails.org/testing.html#testing-view-partials]
+  # in the guides.
+  class TestCase < ActiveSupport::TestCase
+    class TestController < ActionController::Base
+      include ActionDispatch::TestProcess
+
+      attr_accessor :request, :response, :params
+
+      class << self
+        # Overrides AbstractController::Base#controller_path
+        attr_accessor :controller_path
+      end
+
+      def controller_path=(path)
+        self.class.controller_path = path
+      end
+
+      def self.controller_name
+        "test"
+      end
+
+      def initialize
+        super
+        self.class.controller_path = ""
+        @request = ActionController::TestRequest.create(self.class)
+        @response = ActionDispatch::TestResponse.new
+
+        @request.env.delete("PATH_INFO")
+        @params = ActionController::Parameters.new
+      end
+    end
+
+    module Behavior
+      extend ActiveSupport::Concern
+
+      include ActionDispatch::Assertions, ActionDispatch::TestProcess
+      include Rails::Dom::Testing::Assertions
+      include ActionController::TemplateAssertions
+      include ActionView::Context
+
+      include ActionDispatch::Routing::PolymorphicRoutes
+
+      include AbstractController::Helpers
+      include ActionView::Helpers
+      include ActionView::RecordIdentifier
+      include ActionView::RoutingUrlFor
+
+      include ActiveSupport::Testing::ConstantLookup
+
+      delegate :lookup_context, to: :controller
+      attr_accessor :controller, :request, :output_buffer, :rendered
+
+      module ClassMethods
+        def inherited(descendant) # :nodoc:
+          super
+
+          descendant_content_class = content_class.dup
+
+          if descendant_content_class.respond_to?(:set_temporary_name)
+            descendant_content_class.set_temporary_name("rendered_content")
+          end
+
+          descendant.content_class = descendant_content_class
+        end
+
+        # Register a callable to parse rendered content for a given template
+        # format.
+        #
+        # Each registered parser will also define a +#rendered.[FORMAT]+ helper
+        # method, where +[FORMAT]+ corresponds to the value of the
+        # +format+ argument.
+        #
+        # By default, ActionView::TestCase defines parsers for:
+        #
+        # * +:html+ - returns an instance of +Nokogiri::XML::Node+
+        # * +:json+ - returns an instance of ActiveSupport::HashWithIndifferentAccess
+        #
+        # These pre-registered parsers also define corresponding helpers:
+        #
+        # * +:html+ - defines +rendered.html+
+        # * +:json+ - defines +rendered.json+
+        #
+        # ==== Parameters
+        #
+        # [+format+]
+        #   The name (as a +Symbol+) of the format used to render the content.
+        #
+        # [+callable+]
+        #   The parser. A callable object that accepts the rendered string as
+        #   its sole argument. Alternatively, the parser can be specified as a
+        #   block.
+        #
+        # ==== Examples
+        #
+        #   test "renders HTML" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render partial: "articles/article", locals: { article: article }
+        #
+        #     assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } }
+        #   end
+        #
+        #   test "renders JSON" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render formats: :json, partial: "articles/article", locals: { article: article }
+        #
+        #     assert_pattern { rendered.json => { title: "Hello, world" } }
+        #   end
+        #
+        # To parse the rendered content into RSS, register a call to +RSS::Parser.parse+:
+        #
+        #   register_parser :rss, -> rendered { RSS::Parser.parse(rendered) }
+        #
+        #   test "renders RSS" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render formats: :rss, partial: article
+        #
+        #     assert_equal "Hello, world", rendered.rss.items.last.title
+        #   end
+        #
+        # To parse the rendered content into a +Capybara::Simple::Node+,
+        # re-register an +:html+ parser with a call to +Capybara.string+:
+        #
+        #   register_parser :html, -> rendered { Capybara.string(rendered) }
+        #
+        #   test "renders HTML" do
+        #     article = Article.create!(title: "Hello, world")
+        #
+        #     render partial: article
+        #
+        #     rendered.html.assert_css "h1", text: "Hello, world"
+        #   end
+        #
+        def register_parser(format, callable = nil, &block)
+          parser = callable || block || :itself.to_proc
+          content_class.redefine_method(format) do
+            parser.call(to_s)
+          end
+        end
+
+        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)
+          determine_constant_from_test_name(name) do |constant|
+            Module === constant && !(Class === constant)
+          end
+        end
+
+        def helper_method(*methods)
+          # Almost a duplicate from ActionController::Helpers
+          methods.flatten.each do |method|
+            _helpers_for_modification.module_eval <<~end_eval, __FILE__, __LINE__ + 1
+              def #{method}(...)                    # def current_user(...)
+                _test_case.send(:'#{method}', ...)  #   _test_case.send(:'current_user', ...)
+              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
+
+      included do
+        class_attribute :content_class, instance_accessor: false, default: RenderedViewContent
+
+        setup :setup_with_controller
+
+        register_parser :html, -> rendered { Rails::Dom::Testing.html_document_fragment.parse(rendered) }
+        register_parser :json, -> rendered { JSON.parse(rendered, object_class: ActiveSupport::HashWithIndifferentAccess) }
+
+        ActiveSupport.run_load_hooks(:action_view_test_case, self)
+
+        helper do
+          def protect_against_forgery?
+            false
+          end
+
+          def _test_case
+            controller._test_case
+          end
+        end
+      end
+
+      def setup_with_controller
+        controller_class = Class.new(ActionView::TestCase::TestController)
+        @controller = controller_class.new
+        @request = @controller.request
+        @view_flow = ActionView::OutputFlow.new
+        @output_buffer = ActionView::OutputBuffer.new
+        @rendered = self.class.content_class.new(+"")
+
+        test_case_instance = self
+        controller_class.define_method(:_test_case) { test_case_instance }
+      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 rendered_views
+        @_rendered_views ||= RenderedViewsCollection.new
+      end
+
+      ##
+      # :method: rendered
+      #
+      # Returns the content rendered by the last +render+ call.
+      #
+      # The returned object behaves like a string but also exposes a number of methods
+      # that allows you to parse the content string in formats registered using
+      # <tt>.register_parser</tt>.
+      #
+      # By default includes the following parsers:
+      #
+      # +.html+
+      #
+      # Parse the <tt>rendered</tt> content String into HTML. By default, this means
+      # a <tt>Nokogiri::XML::Node</tt>.
+      #
+      #   test "renders HTML" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render partial: "articles/article", locals: { article: article }
+      #
+      #     assert_pattern { rendered.html.at("main h1") => { content: "Hello, world" } }
+      #   end
+      #
+      # To parse the rendered content into a <tt>Capybara::Simple::Node</tt>,
+      # re-register an <tt>:html</tt> parser with a call to
+      # <tt>Capybara.string</tt>:
+      #
+      #   register_parser :html, -> rendered { Capybara.string(rendered) }
+      #
+      #   test "renders HTML" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render partial: article
+      #
+      #     rendered.html.assert_css "h1", text: "Hello, world"
+      #   end
+      #
+      # +.json+
+      #
+      # Parse the <tt>rendered</tt> content String into JSON. By default, this means
+      # a <tt>ActiveSupport::HashWithIndifferentAccess</tt>.
+      #
+      #   test "renders JSON" do
+      #     article = Article.create!(title: "Hello, world")
+      #
+      #     render formats: :json, partial: "articles/article", locals: { article: article }
+      #
+      #     assert_pattern { rendered.json => { title: "Hello, world" } }
+      #   end
+
+      def _routes
+        @controller._routes if @controller.respond_to?(:_routes)
+      end
+
+      class RenderedViewContent < String # :nodoc:
+      end
+
+      # Need to experiment if this priority is the best one: rendered => output_buffer
+      class RenderedViewsCollection
+        def initialize
+          @rendered_views ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def add(view, locals)
+          @rendered_views[view] ||= []
+          @rendered_views[view] << locals
+        end
+
+        def locals_for(view)
+          @rendered_views[view]
+        end
+
+        def rendered_views
+          @rendered_views.keys
+        end
+
+        def view_rendered?(view, expected_locals)
+          locals_for(view).any? do |actual_locals|
+            expected_locals.all? { |key, value| value == actual_locals[key] }
+          end
+        end
+      end
+
+    private
+      # Need to experiment if this priority is the best one: rendered => output_buffer
+      def document_root_element
+        Rails::Dom::Testing.html_document.parse(@rendered.blank? ? @output_buffer.to_str : @rendered).root
+      end
+
+      module Locals
+        attr_accessor :rendered_views
+
+        def render(options = {}, local_assigns = {})
+          case options
+          when Hash
+            if block_given?
+              rendered_views.add options[:layout], options[:locals]
+            elsif options.key?(:partial)
+              rendered_views.add options[:partial], options[:locals]
+            end
+          else
+            rendered_views.add 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.include(_helpers)
+          view.extend(Locals)
+          view.rendered_views = rendered_views
+          view.output_buffer = output_buffer
+          view
+        end
+      end
+
+      alias_method :_view, :view
+
+      INTERNAL_IVARS = [
+        :@NAME,
+        :@failures,
+        :@assertions,
+        :@__io__,
+        :@_assertion_wrapped,
+        :@_assertions,
+        :@_result,
+        :@_routes,
+        :@controller,
+        :@_controller,
+        :@_request,
+        :@_config,
+        :@_default_form_builder,
+        :@_layouts,
+        :@_files,
+        :@_rendered_views,
+        :@method_name,
+        :@output_buffer,
+        :@_partials,
+        :@passed,
+        :@rendered,
+        :@request,
+        :@routes,
+        :@tagged_logger,
+        :@_templates,
+        :@options,
+        :@test_passed,
+        :@view,
+        :@view_context_class,
+        :@view_flow,
+        :@_subscribers,
+        :@html_document,
+      ]
+
+      def _user_defined_ivars
+        instance_variables - 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 |ivar|
+          [ivar[1..-1].to_sym, instance_variable_get(ivar)]
+        end]
+      end
+
+      def method_missing(selector, ...)
+        begin
+          routes = @controller.respond_to?(:_routes) && @controller._routes
+        rescue
+          # Don't call routes, if there is an error on _routes call
+        end
+
+        if routes &&
+           (routes.named_routes.route_defined?(selector) ||
+             routes.mounted_helpers.method_defined?(selector))
+          @controller.__send__(selector, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        begin
+          routes = @controller.respond_to?(:_routes) && @controller._routes
+        rescue
+          # Don't call routes, if there is an error on _routes call
+        end
+
+        routes &&
+          (routes.named_routes.route_defined?(name) ||
+           routes.mounted_helpers.method_defined?(name))
+      end
+    end
+
+    include Behavior
+  end
+end

data/lib/action_view/testing/resolvers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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 < FileSystemResolver
+    def initialize(hash = {})
+      super("")
+      @hash = hash
+      @path = ""
+    end
+
+    def data
+      @hash
+    end
+
+    def to_s
+      @hash.keys.join(", ")
+    end
+
+    private
+      def template_glob(glob)
+        @hash.keys.filter_map do |path|
+          "/#{path}" if File.fnmatch(glob, path)
+        end
+      end
+
+      def source_for_template(template)
+        @hash[template.from(1)]
+      end
+  end
+
+  class NullResolver < Resolver
+    def find_templates(name, prefix, partial, details, locals = [])
+      path = TemplatePath.build(name, prefix, partial)
+      handler = ActionView::Template::Handlers::Raw
+      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: nil, variant: nil, locals: locals)]
+    end
+  end
+end

data/lib/action_view/unbound_template.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActionView
+  class UnboundTemplate
+    attr_reader :virtual_path, :details
+    delegate :locale, :format, :variant, :handler, to: :@details
+
+    def initialize(source, identifier, details:, virtual_path:)
+      @source = source
+      @identifier = identifier
+      @details = details
+      @virtual_path = virtual_path
+
+      @templates = Concurrent::Map.new(initial_capacity: 2)
+      @write_lock = Mutex.new
+    end
+
+    def bind_locals(locals)
+      unless template = @templates[locals]
+        @write_lock.synchronize do
+          normalized_locals = normalize_locals(locals)
+
+          # We need ||=, both to dedup on the normalized locals and to check
+          # while holding the lock.
+          template = (@templates[normalized_locals] ||= build_template(normalized_locals))
+
+          if template.strict_locals?
+            # Under strict locals, we only need one template.
+            # This replaces the @templates Concurrent::Map with a hash which
+            # returns this template for every key.
+            @templates = Hash.new(template).freeze
+          else
+            # This may have already been assigned, but we've already de-dup'd so
+            # reassignment is fine.
+            @templates[locals.dup] = template
+          end
+        end
+      end
+      template
+    end
+
+    def built_templates # :nodoc:
+      @templates.values
+    end
+
+    private
+      def build_template(locals)
+        Template.new(
+          @source,
+          @identifier,
+          details.handler_class,
+
+          format: details.format_or_default,
+          variant: variant&.to_s,
+          virtual_path: @virtual_path,
+
+          locals: locals.map(&:to_s)
+        )
+      end
+
+      def normalize_locals(locals)
+        locals.map(&:to_sym).sort!.freeze
+      end
+  end
+end

data/lib/action_view/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActionView
+  # Returns the currently loaded version of Action View as a +Gem::Version+.
+  def self.version
+    gem_version
+  end
+end

data/lib/action_view/view_paths.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActionView
+  module ViewPaths
+    extend ActiveSupport::Concern
+
+    included do
+      ActionView::PathRegistry.set_view_paths(self, ActionView::PathSet.new.freeze)
+    end
+
+    delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
+             :locale, :locale=, to: :lookup_context
+
+    module ClassMethods
+      def _view_paths
+        ActionView::PathRegistry.get_view_paths(self)
+      end
+
+      def _view_paths=(paths)
+        ActionView::PathRegistry.set_view_paths(self, paths)
+      end
+
+      def _prefixes # :nodoc:
+        @_prefixes ||= begin
+          return local_prefixes if superclass.abstract?
+
+          local_prefixes + superclass._prefixes
+        end
+      end
+
+      def _build_view_paths(paths) # :nodoc:
+        return paths if ActionView::PathSet === paths
+
+        paths = ActionView::PathRegistry.cast_file_system_resolvers(paths)
+        ActionView::PathSet.new(paths)
+      end
+
+      # Append a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def append_view_path(path)
+        self._view_paths = view_paths + _build_view_paths(path)
+      end
+
+      # Prepend a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def prepend_view_path(path)
+        self._view_paths = _build_view_paths(path) + view_paths
+      end
+
+      # A list of all of the default view paths for this controller.
+      def view_paths
+        _view_paths
+      end
+
+      # Set the view paths.
+      #
+      # ==== Parameters
+      # * <tt>paths</tt> - If a PathSet is provided, use that;
+      #   otherwise, process the parameter into a PathSet.
+      def view_paths=(paths)
+        self._view_paths = _build_view_paths(paths)
+      end
+
+      private
+        # Override this method in your controller if you want to change paths prefixes for finding views.
+        # Prefixes defined here will still be added to parents' <tt>._prefixes</tt>.
+        def local_prefixes
+          [controller_path]
+        end
+    end
+
+    # The prefixes used in render "foo" shortcuts.
+    def _prefixes # :nodoc:
+      self.class._prefixes
+    end
+
+    # LookupContext is the object responsible for holding all
+    # information required for looking up templates, i.e. view paths and
+    # details. Check ActionView::LookupContext for more information.
+    def lookup_context
+      @_lookup_context ||=
+        ActionView::LookupContext.new(self.class._view_paths, details_for_lookup, _prefixes)
+    end
+
+    def details_for_lookup
+      {}
+    end
+
+    # Append a path to the list of view paths for the current LookupContext.
+    #
+    # ==== Parameters
+    # * <tt>path</tt> - If a String is provided, it gets converted into
+    #   the default view path. You may also provide a custom view path
+    #   (see ActionView::PathSet for more information)
+    def append_view_path(path)
+      lookup_context.append_view_paths(self.class._build_view_paths(path))
+    end
+
+    # Prepend a path to the list of view paths for the current LookupContext.
+    #
+    # ==== Parameters
+    # * <tt>path</tt> - If a String is provided, it gets converted into
+    #   the default view path. You may also provide a custom view path
+    #   (see ActionView::PathSet for more information)
+    def prepend_view_path(path)
+      lookup_context.prepend_view_paths(self.class._build_view_paths(path))
+    end
+  end
+end