actionview 4.1.13 → 6.1.3.1

data/lib/action_view/test_case.rb

@@ -1,7 +1,11 @@
-require 'active_support/core_ext/module/remove_method'
-require 'action_controller'
-require 'action_controller/test_case'
-require 'action_view'
+# 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
@@ -12,21 +16,22 @@ module ActionView
       attr_accessor :request, :response, :params
 
       class << self
-        attr_writer :controller_path
+        # Overrides AbstractController::Base#controller_path
+        attr_accessor :controller_path
       end
 
       def controller_path=(path)
-        self.class.controller_path=(path)
+        self.class.controller_path = path
       end
 
       def initialize
         super
         self.class.controller_path = ""
-        @request = ActionController::TestRequest.new
-        @response = ActionController::TestResponse.new
+        @request = ActionController::TestRequest.create(self.class)
+        @response = ActionDispatch::TestResponse.new
 
-        @request.env.delete('PATH_INFO')
-        @params = {}
+        @request.env.delete("PATH_INFO")
+        @params = ActionController::Parameters.new
       end
     end
 
@@ -34,6 +39,7 @@ module ActionView
       extend ActiveSupport::Concern
 
       include ActionDispatch::Assertions, ActionDispatch::TestProcess
+      include Rails::Dom::Testing::Assertions
       include ActionController::TemplateAssertions
       include ActionView::Context
 
@@ -46,7 +52,7 @@ module ActionView
 
       include ActiveSupport::Testing::ConstantLookup
 
-      delegate :lookup_context, :to => :controller
+      delegate :lookup_context, to: :controller
       attr_accessor :controller, :output_buffer, :rendered
 
       module ClassMethods
@@ -68,10 +74,11 @@ module ActionView
         def helper_method(*methods)
           # Almost a duplicate from ActionController::Helpers
           methods.flatten.each do |method|
-            _helpers.module_eval <<-end_eval
+            _helpers_for_modification.module_eval <<-end_eval, __FILE__, __LINE__ + 1
               def #{method}(*args, &block)                    # def current_user(*args, &block)
-                _test_case.send(%(#{method}), *args, &block)  #   _test_case.send(%(current_user), *args, &block)
+                _test_case.send(:'#{method}', *args, &block)  #   _test_case.send(:'current_user', *args, &block)
               end                                             # end
+              ruby2_keywords(:'#{method}') if respond_to?(:ruby2_keywords, true)
             end_eval
           end
         end
@@ -88,22 +95,24 @@ module ActionView
         end
 
       private
-
         def include_helper_modules!
           helper(helper_class) if helper_class
           include _helpers
         end
-
       end
 
       def setup_with_controller
-        @controller = ActionView::TestCase::TestController.new
+        controller_class = Class.new(ActionView::TestCase::TestController)
+        @controller = controller_class.new
         @request = @controller.request
-        @output_buffer = ActiveSupport::SafeBuffer.new
-        @rendered = ''
+        @view_flow = ActionView::OutputFlow.new
+        # empty string ensures buffer has UTF-8 encoding as
+        # new without arguments returns ASCII-8BIT encoded buffer like String#new
+        @output_buffer = ActiveSupport::SafeBuffer.new ""
+        @rendered = +""
 
-        make_test_case_available_to_view!
-        say_no_to_protect_against_forgery!
+        test_case_instance = self
+        controller_class.define_method(:_test_case) { test_case_instance }
       end
 
       def config
@@ -120,6 +129,11 @@ module ActionView
         @_rendered_views ||= RenderedViewsCollection.new
       end
 
+      def _routes
+        @controller._routes if @controller.respond_to?(:_routes)
+      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] = [] }
@@ -140,43 +154,32 @@ module ActionView
 
         def view_rendered?(view, expected_locals)
           locals_for(view).any? do |actual_locals|
-            expected_locals.all? {|key, value| value == actual_locals[key] }
+            expected_locals.all? { |key, value| value == actual_locals[key] }
           end
         end
       end
 
       included do
         setup :setup_with_controller
-      end
-
-    private
+        ActiveSupport.run_load_hooks(:action_view_test_case, self)
 
-      # Support the selector assertions
-      #
-      # Need to experiment if this priority is the best one: rendered => output_buffer
-      def response_from_page
-        HTML::Document.new(@rendered.blank? ? @output_buffer : @rendered).root
-      end
-
-      def say_no_to_protect_against_forgery!
-        _helpers.module_eval do
-          remove_possible_method :protect_against_forgery?
+        helper do
           def protect_against_forgery?
             false
           end
-        end
-      end
 
-      def make_test_case_available_to_view!
-        test_case_instance = self
-        _helpers.module_eval do
-          unless private_method_defined?(:_test_case)
-            define_method(:_test_case) { test_case_instance }
-            private :_test_case
+          def _test_case
+            controller._test_case
           end
         end
       end
 
+    private
+      # Need to experiment if this priority is the best one: rendered => output_buffer
+      def document_root_element
+        Nokogiri::HTML::Document.parse(@rendered.blank? ? @output_buffer : @rendered).root
+      end
+
       module Locals
         attr_accessor :rendered_views
 
@@ -200,10 +203,10 @@ module ActionView
       def view
         @view ||= begin
           view = @controller.view_context
-          view.singleton_class.send :include, _helpers
+          view.singleton_class.include(_helpers)
           view.extend(Locals)
-          view.rendered_views = self.rendered_views
-          view.output_buffer = self.output_buffer
+          view.rendered_views = rendered_views
+          view.output_buffer = output_buffer
           view
         end
       end
@@ -235,7 +238,10 @@ module ActionView
         :@options,
         :@test_passed,
         :@view,
-        :@view_context_class
+        :@view_context_class,
+        :@view_flow,
+        :@_subscribers,
+        :@html_document
       ]
 
       def _user_defined_ivars
@@ -252,19 +258,33 @@ module ActionView
         end]
       end
 
-      def _routes
-        @controller._routes if @controller.respond_to?(:_routes)
-      end
-
       def method_missing(selector, *args)
-        if @controller.respond_to?(:_routes) &&
-          ( @controller._routes.named_routes.helpers.include?(selector) ||
-            @controller._routes.mounted_helpers.method_defined?(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, *args)
         else
           super
         end
       end
+
+      def respond_to_missing?(name, include_private = false)
+        begin
+          routes = defined?(@controller) && @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

data/lib/action_view/testing/resolvers.rb

@@ -1,54 +1,45 @@
-require 'action_view/template/resolver'
+# 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 < PathResolver
-    attr_reader :hash
-
-    def initialize(hash = {}, pattern=nil)
-      super(pattern)
+  class FixtureResolver < OptimizedFileSystemResolver
+    def initialize(hash = {})
+      super("")
       @hash = hash
+      @path = ""
     end
 
-    def to_s
-      @hash.keys.join(', ')
+    def data
+      @hash
     end
 
-  private
+    def to_s
+      @hash.keys.join(", ")
+    end
 
-    def query(path, exts, formats)
-      query = ""
-      EXTENSIONS.each_key do |ext|
-        query << '(' << exts[ext].map {|e| e && Regexp.escape(".#{e}") }.join('|') << '|)'
+    private
+      def find_candidate_template_paths(path)
+        @hash.keys.select do |fixture|
+          fixture.start_with?(path.virtual)
+        end.map do |fixture|
+          "/#{fixture}"
+        end
       end
-      query = /^(#{Regexp.escape(path)})#{query}$/
 
-      templates = []
-      @hash.each do |_path, array|
-        source, updated_at = array
-        next unless _path =~ query
-        handler, format, variant = extract_handler_and_format_and_variant(_path, formats)
-        templates << Template.new(source, _path, handler,
-          :virtual_path => path.virtual,
-          :format => format,
-          :variant => variant,
-          :updated_at => updated_at
-        )
+      def source_for_template(template)
+        @hash[template[1..template.size]]
       end
-
-      templates.sort_by {|t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
-    end
   end
 
   class NullResolver < PathResolver
-    def query(path, exts, formats)
-      handler, format, variant = extract_handler_and_format_and_variant(path, formats)
-      [ActionView::Template.new("Template generated by Null Resolver", path, handler, :virtual_path => path, :format => format, :variant => variant)]
+    def query(path, exts, _, locals, cache:)
+      handler, format, variant = extract_handler_and_format_and_variant(path)
+      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: format, variant: variant, locals: locals)]
     end
   end
-
 end
-

data/lib/action_view/unbound_template.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActionView
+  class UnboundTemplate
+    def initialize(source, identifier, handler, options)
+      @source = source
+      @identifier = identifier
+      @handler = handler
+      @options = options
+
+      @templates = Concurrent::Map.new(initial_capacity: 2)
+    end
+
+    def bind_locals(locals)
+      @templates[locals] ||= build_template(locals)
+    end
+
+    private
+      def build_template(locals)
+        options = @options.merge(locals: locals)
+        Template.new(
+          @source,
+          @identifier,
+          @handler,
+          **options
+        )
+      end
+  end
+end

data/lib/action_view/version.rb

@@ -1,4 +1,6 @@
-require_relative 'gem_version'
+# frozen_string_literal: true
+
+require_relative "gem_version"
 
 module ActionView
   # Returns the version of the currently loaded ActionView as a <tt>Gem::Version</tt>

data/lib/action_view/view_paths.rb

@@ -1,63 +1,33 @@
-require 'action_view/base'
+# frozen_string_literal: true
 
 module ActionView
   module ViewPaths
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_view_paths
-      self._view_paths = ActionView::PathSet.new
-      self._view_paths.freeze
+      ViewPaths.set_view_paths(self, ActionView::PathSet.new.freeze)
     end
 
-    delegate :template_exists?, :view_paths, :formats, :formats=,
-             :locale, :locale=, :to => :lookup_context
+    delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
+             :locale, :locale=, to: :lookup_context
 
     module ClassMethods
-      def parent_prefixes
-        @parent_prefixes ||= begin
-          parent_controller = superclass
-          prefixes = []
-
-          until parent_controller.abstract?
-            prefixes << parent_controller.controller_path
-            parent_controller = parent_controller.superclass
-          end
-
-          prefixes
-        end
+      def _view_paths
+        ViewPaths.get_view_paths(self)
       end
-    end
 
-    # The prefixes used in render "foo" shortcuts.
-    def _prefixes
-      @_prefixes ||= begin
-        parent_prefixes = self.class.parent_prefixes
-        parent_prefixes.dup.unshift(controller_path)
+      def _view_paths=(paths)
+        ViewPaths.set_view_paths(self, paths)
       end
-    end
-
-    # LookupContext is the object responsible to hold all information required to lookup
-    # 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
 
-    def append_view_path(path)
-      lookup_context.view_paths.push(*path)
-    end
+      def _prefixes # :nodoc:
+        @_prefixes ||= begin
+          return local_prefixes if superclass.abstract?
 
-    def prepend_view_path(path)
-      lookup_context.view_paths.unshift(*path)
-    end
+          local_prefixes + superclass._prefixes
+        end
+      end
 
-    module ClassMethods
       # Append a path to the list of view paths for this controller.
       #
       # ==== Parameters
@@ -91,6 +61,66 @@ module ActionView
       def view_paths=(paths)
         self._view_paths = ActionView::PathSet.new(Array(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
+
+    # :stopdoc:
+    @all_view_paths = {}
+
+    def self.get_view_paths(klass)
+      @all_view_paths[klass] || get_view_paths(klass.superclass)
+    end
+
+    def self.set_view_paths(klass, paths)
+      @all_view_paths[klass] = paths
+    end
+
+    def self.all_view_paths
+      @all_view_paths.values.uniq
+    end
+    # :startdoc:
+
+    # The prefixes used in render "foo" shortcuts.
+    def _prefixes # :nodoc:
+      self.class._prefixes
+    end
+
+    # <tt>LookupContext</tt> is the object responsible for holding all
+    # information required for looking up templates, i.e. view paths and
+    # details. Check <tt>ActionView::LookupContext</tt> 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 <tt>LookupContext</tt>.
+    #
+    # ==== 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.view_paths.push(*path)
+    end
+
+    # Prepend a path to the list of view paths for the current <tt>LookupContext</tt>.
+    #
+    # ==== 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.view_paths.unshift(*path)
     end
   end
 end