katalyst-govuk-formbuilder 1.9.2 → 1.9.3

data/vendor/bundle/ruby/3.3.0/gems/actionview-7.1.3.4/lib/action_view/render_parser.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/ripper_ast_parser"
-
-module ActionView
-  class RenderParser # :nodoc:
-    def initialize(name, code)
-      @name = name
-      @code = code
-      @parser = RipperASTParser
-    end
-
-    def render_calls
-      render_nodes = @parser.parse_render_nodes(@code)
-
-      render_nodes.map do |method, nodes|
-        nodes.map { |n| send(:parse_render, n) }
-      end.flatten.compact
-    end
-
-    private
-      def directory
-        File.dirname(@name)
-      end
-
-      def resolve_path_directory(path)
-        if path.include?("/")
-          path
-        else
-          "#{directory}/#{path}"
-        end
-      end
-
-      # Convert
-      #   render("foo", ...)
-      # into either
-      #   render(template: "foo", ...)
-      # or
-      #   render(partial: "foo", ...)
-      def normalize_args(string, options_hash)
-        if options_hash
-          { partial: string, locals: options_hash }
-        else
-          { partial: string }
-        end
-      end
-
-      def parse_render(node)
-        node = node.argument_nodes
-
-        if (node.length == 1 || node.length == 2) && !node[0].hash?
-          if node.length == 1
-            options = normalize_args(node[0], nil)
-          elsif node.length == 2
-            options = normalize_args(node[0], node[1])
-          end
-
-          return nil unless options
-
-          parse_render_from_options(options)
-        elsif node.length == 1 && node[0].hash?
-          options = parse_hash_to_symbols(node[0])
-
-          return nil unless options
-
-          parse_render_from_options(options)
-        else
-          nil
-        end
-      end
-
-      def parse_hash(node)
-        node.hash? && node.to_hash
-      end
-
-      def parse_hash_to_symbols(node)
-        hash = parse_hash(node)
-
-        return unless hash
-
-        hash.transform_keys do |key_node|
-          key = parse_sym(key_node)
-
-          return unless key
-
-          key
-        end
-      end
-
-      ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
-
-      RENDER_TYPE_KEYS =
-        [:partial, :template, :layout]
-
-      def parse_render_from_options(options_hash)
-        renders = []
-        keys = options_hash.keys
-
-        if (keys & RENDER_TYPE_KEYS).size < 1
-          # Must have at least one of render keys
-          return nil
-        end
-
-        if (keys - ALL_KNOWN_KEYS).any?
-          # de-opt in case of unknown option
-          return nil
-        end
-
-        render_type = (keys & RENDER_TYPE_KEYS)[0]
-
-        node = options_hash[render_type]
-
-        if node.string?
-          template = resolve_path_directory(node.to_string)
-        else
-          if node.variable_reference?
-            dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
-          elsif node.vcall?
-            dependency = node.variable_name
-          elsif node.call?
-            dependency = node.call_method_name
-          else
-            return
-          end
-
-          object_template = true
-          template = "#{dependency.pluralize}/#{dependency.singularize}"
-        end
-
-        return unless template
-
-        if spacer_template = render_template_with_spacer?(options_hash)
-          virtual_path = partial_to_virtual_path(:partial, spacer_template)
-          renders << virtual_path
-        end
-
-        if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
-          return nil if options_hash.key?(:object) && options_hash.key?(:collection)
-          return nil unless options_hash.key?(:partial)
-        end
-
-        virtual_path = partial_to_virtual_path(render_type, template)
-        renders << virtual_path
-
-        # Support for rendering multiple templates (i.e. a partial with a layout)
-        if layout_template = render_template_with_layout?(render_type, options_hash)
-          virtual_path = partial_to_virtual_path(:layout, layout_template)
-
-          renders << virtual_path
-        end
-
-        renders
-      end
-
-      def parse_str(node)
-        node.string? && node.to_string
-      end
-
-      def parse_sym(node)
-        node.symbol? && node.to_symbol
-      end
-
-      private
-        def render_template_with_layout?(render_type, options_hash)
-          if render_type != :layout && options_hash.key?(:layout)
-            parse_str(options_hash[:layout])
-          end
-        end
-
-        def render_template_with_spacer?(options_hash)
-          if options_hash.key?(:spacer_template)
-            parse_str(options_hash[:spacer_template])
-          end
-        end
-
-        def partial_to_virtual_path(render_type, partial_path)
-          if render_type == :partial || render_type == :layout
-            partial_path.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
-          else
-            partial_path
-          end
-        end
-
-        def layout_to_virtual_path(layout_path)
-          "layouts/#{layout_path}"
-        end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/actionview-7.1.3.4/lib/action_view/renderer/abstract_renderer.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-module ActionView
-  # This class defines the interface for a renderer. Each class that
-  # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
-  # render a specific type of object.
-  #
-  # The base +Renderer+ class uses its +render+ method to delegate to the
-  # renderers. These currently consist of
-  #
-  #   PartialRenderer - Used for rendering partials
-  #   TemplateRenderer - Used for rendering other types of templates
-  #   StreamingTemplateRenderer - Used for streaming
-  #
-  # Whenever the +render+ method is called on the base +Renderer+ class, a new
-  # renderer object of the correct type is created, and the +render+ method on
-  # that new object is called in turn. This abstracts the set up and rendering
-  # into a separate classes for partials and templates.
-  class AbstractRenderer # :nodoc:
-    delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
-
-    def initialize(lookup_context)
-      @lookup_context = lookup_context
-    end
-
-    def render
-      raise NotImplementedError
-    end
-
-    module ObjectRendering # :nodoc:
-      PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
-        h.compute_if_absent(k) { Concurrent::Map.new }
-      end
-
-      def initialize(lookup_context, options)
-        super
-        @context_prefix = lookup_context.prefixes.first
-      end
-
-      private
-        def local_variable(path)
-          if as = @options[:as]
-            raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
-            as.to_sym
-          else
-            base = path.end_with?("/") ? "" : File.basename(path)
-            raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
-            $1.to_sym
-          end
-        end
-
-        IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \
-                                   "make sure your partial name starts with underscore."
-
-        OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
-                                   "make sure it starts with lowercase letter, " \
-                                   "and is followed by any combination of letters, numbers and underscores."
-
-        def raise_invalid_identifier(path)
-          raise ArgumentError, IDENTIFIER_ERROR_MESSAGE % path
-        end
-
-        def raise_invalid_option_as(as)
-          raise ArgumentError, OPTION_AS_ERROR_MESSAGE % as
-        end
-
-        # Obtains the path to where the object's partial is located. If the object
-        # responds to +to_partial_path+, then +to_partial_path+ will be called and
-        # will provide the path. If the object does not respond to +to_partial_path+,
-        # then an +ArgumentError+ is raised.
-        #
-        # If +prefix_partial_path_with_controller_namespace+ is true, then this
-        # method will prefix the partial paths with a namespace.
-        def partial_path(object, view)
-          object = object.to_model if object.respond_to?(:to_model)
-
-          path = if object.respond_to?(:to_partial_path)
-            object.to_partial_path
-          else
-            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
-          end
-
-          if view.prefix_partial_path_with_controller_namespace
-            PREFIXED_PARTIAL_NAMES[@context_prefix][path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
-          else
-            path
-          end
-        end
-
-        def merge_prefix_into_object_path(prefix, object_path)
-          if prefix.include?(?/) && object_path.include?(?/)
-            prefixes = []
-            prefix_array = File.dirname(prefix).split("/")
-            object_path_array = object_path.split("/")[0..-3] # skip model dir & partial
-
-            prefix_array.each_with_index do |dir, index|
-              break if dir == object_path_array[index]
-              prefixes << dir
-            end
-
-            (prefixes << object_path).join("/")
-          else
-            object_path
-          end
-        end
-    end
-
-    class RenderedCollection # :nodoc:
-      def self.empty(format)
-        EmptyCollection.new format
-      end
-
-      attr_reader :rendered_templates
-
-      def initialize(rendered_templates, spacer)
-        @rendered_templates = rendered_templates
-        @spacer = spacer
-      end
-
-      def body
-        @rendered_templates.map(&:body).join(@spacer.body).html_safe
-      end
-
-      def format
-        rendered_templates.first.format
-      end
-
-      class EmptyCollection
-        attr_reader :format
-
-        def initialize(format)
-          @format = format
-        end
-
-        def body; nil; end
-      end
-    end
-
-    class RenderedTemplate # :nodoc:
-      attr_reader :body, :template
-
-      def initialize(body, template)
-        @body = body
-        @template = template
-      end
-
-      def format
-        template.format
-      end
-
-      EMPTY_SPACER = Struct.new(:body).new
-    end
-
-    private
-      NO_DETAILS = {}.freeze
-
-      def extract_details(options) # :doc:
-        details = nil
-        LookupContext.registered_details.each do |key|
-          value = options[key]
-
-          if value
-            (details ||= {})[key] = Array(value)
-          end
-        end
-        details || NO_DETAILS
-      end
-
-      def prepend_formats(formats) # :doc:
-        formats = Array(formats)
-        return if formats.empty? || @lookup_context.html_fallback_for_js
-
-        @lookup_context.formats = formats | @lookup_context.formats
-      end
-
-      def build_rendered_template(content, template)
-        RenderedTemplate.new content, template
-      end
-
-      def build_rendered_collection(templates, spacer)
-        RenderedCollection.new templates, spacer
-      end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/actionview-7.1.3.4/lib/action_view/renderer/collection_renderer.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/renderer/partial_renderer"
-
-module ActionView
-  class PartialIteration
-    # The number of iterations that will be done by the partial.
-    attr_reader :size
-
-    # The current iteration of the partial.
-    attr_reader :index
-
-    def initialize(size)
-      @size  = size
-      @index = 0
-    end
-
-    # Check if this is the first iteration of the partial.
-    def first?
-      index == 0
-    end
-
-    # Check if this is the last iteration of the partial.
-    def last?
-      index == size - 1
-    end
-
-    def iterate! # :nodoc:
-      @index += 1
-    end
-  end
-
-  class CollectionRenderer < PartialRenderer # :nodoc:
-    include ObjectRendering
-
-    class CollectionIterator # :nodoc:
-      include Enumerable
-
-      def initialize(collection)
-        @collection = collection
-      end
-
-      def each(&blk)
-        @collection.each(&blk)
-      end
-
-      def size
-        @collection.size
-      end
-
-      def length
-        @collection.respond_to?(:length) ? @collection.length : size
-      end
-
-      def preload!
-        # no-op
-      end
-    end
-
-    class SameCollectionIterator < CollectionIterator # :nodoc:
-      def initialize(collection, path, variables)
-        super(collection)
-        @path      = path
-        @variables = variables
-      end
-
-      def from_collection(collection)
-        self.class.new(collection, @path, @variables)
-      end
-
-      def each_with_info
-        return enum_for(:each_with_info) unless block_given?
-        variables = [@path] + @variables
-        @collection.each { |o| yield(o, variables) }
-      end
-    end
-
-    class PreloadCollectionIterator < SameCollectionIterator # :nodoc:
-      def initialize(collection, path, variables, relation)
-        super(collection, path, variables)
-        relation.skip_preloading! unless relation.loaded?
-        @relation = relation
-      end
-
-      def from_collection(collection)
-        self.class.new(collection, @path, @variables, @relation)
-      end
-
-      def each_with_info
-        return super unless block_given?
-        preload!
-        super
-      end
-
-      def preload!
-        @relation.preload_associations(@collection)
-      end
-    end
-
-    class MixedCollectionIterator < CollectionIterator # :nodoc:
-      def initialize(collection, paths)
-        super(collection)
-        @paths = paths
-      end
-
-      def each_with_info
-        return enum_for(:each_with_info) unless block_given?
-        @collection.each_with_index { |o, i| yield(o, @paths[i]) }
-      end
-    end
-
-    def render_collection_with_partial(collection, partial, context, block)
-      iter_vars  = retrieve_variable(partial)
-
-      collection = if collection.respond_to?(:preload_associations)
-        PreloadCollectionIterator.new(collection, partial, iter_vars, collection)
-      else
-        SameCollectionIterator.new(collection, partial, iter_vars)
-      end
-
-      template = find_template(partial, @locals.keys + iter_vars)
-
-      layout = if !block && (layout = @options[:layout])
-        find_template(layout.to_s, @locals.keys + iter_vars)
-      end
-
-      render_collection(collection, context, partial, template, layout, block)
-    end
-
-    def render_collection_derive_partial(collection, context, block)
-      paths = collection.map { |o| partial_path(o, context) }
-
-      if paths.uniq.length == 1
-        # Homogeneous
-        render_collection_with_partial(collection, paths.first, context, block)
-      else
-        if @options[:cached]
-          raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering"
-        end
-
-        paths.map! { |path| retrieve_variable(path).unshift(path) }
-        collection = MixedCollectionIterator.new(collection, paths)
-        render_collection(collection, context, nil, nil, nil, block)
-      end
-    end
-
-    private
-      def retrieve_variable(path)
-        variable = local_variable(path)
-        [variable, :"#{variable}_counter", :"#{variable}_iteration"]
-      end
-
-      def render_collection(collection, view, path, template, layout, block)
-        identifier = (template && template.identifier) || path
-        ActiveSupport::Notifications.instrument(
-          "render_collection.action_view",
-          identifier: identifier,
-          layout: layout && layout.virtual_path,
-          count: collection.length
-        ) do |payload|
-          spacer = if @options.key?(:spacer_template)
-            spacer_template = find_template(@options[:spacer_template], @locals.keys)
-            build_rendered_template(spacer_template.render(view, @locals), spacer_template)
-          else
-            RenderedTemplate::EMPTY_SPACER
-          end
-
-          collection_body = if template
-            cache_collection_render(payload, view, template, collection) do |filtered_collection|
-              collection_with_template(view, template, layout, filtered_collection)
-            end
-          else
-            collection_with_template(view, nil, layout, collection)
-          end
-
-          return RenderedCollection.empty(@lookup_context.formats.first) if collection_body.empty?
-
-          build_rendered_collection(collection_body, spacer)
-        end
-      end
-
-      def collection_with_template(view, template, layout, collection)
-        locals = @locals
-        cache = {}
-
-        partial_iteration = PartialIteration.new(collection.size)
-
-        collection.each_with_info.map do |object, (path, as, counter, iteration)|
-          index = partial_iteration.index
-
-          locals[as]        = object
-          locals[counter]   = index
-          locals[iteration] = partial_iteration
-
-          _template = (cache[path] ||= (template || find_template(path, @locals.keys + [as, counter, iteration])))
-
-          content = _template.render(view, locals, implicit_locals: [counter, iteration])
-          content = layout.render(view, locals) { content } if layout
-          partial_iteration.iterate!
-          build_rendered_template(content, _template)
-        end
-      end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/actionview-7.1.3.4/lib/action_view/renderer/object_renderer.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  class ObjectRenderer < PartialRenderer # :nodoc:
-    include ObjectRendering
-
-    def initialize(lookup_context, options)
-      super
-      @object     = nil
-      @local_name = nil
-    end
-
-    def render_object_with_partial(object, partial, context, block)
-      @object     = object
-      @local_name = local_variable(partial)
-      render(partial, context, block)
-    end
-
-    def render_object_derive_partial(object, context, block)
-      path = partial_path(object, context)
-      render_object_with_partial(object, path, context, block)
-    end
-
-    private
-      def template_keys(path)
-        super + [@local_name]
-      end
-
-      def render_partial_template(view, locals, template, layout, block)
-        locals[@local_name || template.variable] = @object
-        super(view, locals, template, layout, block)
-      end
-  end
-end