jets 1.9.7 → 1.9.8

data/vendor/rails/actionview/lib/action_view/test_case.rb

@@ -1,300 +0,0 @@
-# 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
-  class TestCase < ActiveSupport::TestCase
-    class TestController < ActionController::Base
-      include ActionDispatch::TestProcess
-
-      attr_accessor :request, :response, :params
-
-      class << self
-        attr_writer :controller_path
-      end
-
-      def controller_path=(path)
-        self.class.controller_path = (path)
-      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, :output_buffer, :rendered
-
-      module ClassMethods
-        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.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)
-              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
-
-      def setup_with_controller
-        @controller = ActionView::TestCase::TestController.new
-        @request = @controller.request
-        @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 = "".dup
-
-        make_test_case_available_to_view!
-        say_no_to_protect_against_forgery!
-      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
-
-      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] = [] }
-        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
-
-      included do
-        setup :setup_with_controller
-        ActiveSupport.run_load_hooks(:action_view_test_case, self)
-      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
-
-      def say_no_to_protect_against_forgery!
-        _helpers.module_eval do
-          silence_redefinition_of_method :protect_against_forgery?
-          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
-          end
-        end
-      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,
-        :@_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, *args)
-        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 = @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/vendor/rails/actionview/lib/action_view/testing/resolvers.rb

@@ -1,54 +0,0 @@
-# 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)
-      @hash = hash
-    end
-
-    def to_s
-      @hash.keys.join(", ")
-    end
-
-    private
-
-      def query(path, exts, _, _)
-        query = "".dup
-        EXTENSIONS.each_key do |ext|
-          query << "(" << exts[ext].map { |e| e && Regexp.escape(".#{e}") }.join("|") << "|)"
-        end
-        query = /^(#{Regexp.escape(path)})#{query}$/
-
-        templates = []
-        @hash.each do |_path, array|
-          source, updated_at = array
-          next unless query.match?(_path)
-          handler, format, variant = extract_handler_and_format_and_variant(_path)
-          templates << Template.new(source, _path, handler,
-            virtual_path: path.virtual,
-            format: format,
-            variant: variant,
-            updated_at: updated_at
-          )
-        end
-
-        templates.sort_by { |t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
-      end
-  end
-
-  class NullResolver < PathResolver
-    def query(path, exts, _, _)
-      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)]
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/version.rb

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

data/vendor/rails/actionview/lib/action_view/view_paths.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module ViewPaths
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_view_paths, default: ActionView::PathSet.new.freeze
-    end
-
-    delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
-             :locale, :locale=, to: :lookup_context
-
-    module ClassMethods
-      def _prefixes # :nodoc:
-        @_prefixes ||= begin
-          return local_prefixes if superclass.abstract?
-
-          local_prefixes + superclass._prefixes
-        end
-      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
-
-    # <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
-
-    module ClassMethods
-      # 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 + Array(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 = ActionView::PathSet.new(Array(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 = ActionView::PathSet.new(Array(paths))
-      end
-    end
-  end
-end