tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/actionview-8.0.4/lib/action_view/renderer/partial_renderer.rb

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/renderer/partial_renderer/collection_caching"
-
-module ActionView
-  # = Action View Partials
-  #
-  # There's also a convenience method for rendering sub templates within the current controller that depends on a
-  # single object (we call this kind of sub templates for partials). It relies on the fact that partials should
-  # follow the naming convention of being prefixed with an underscore -- as to separate them from regular
-  # templates that could be rendered on their own.
-  #
-  # In a template for Advertiser#account:
-  #
-  #  <%= render partial: "account" %>
-  #
-  # This would render "advertiser/_account.html.erb".
-  #
-  # In another template for Advertiser#buy, we could have:
-  #
-  #   <%= render partial: "account", locals: { account: @buyer } %>
-  #
-  #   <% @advertisements.each do |ad| %>
-  #     <%= render partial: "ad", locals: { ad: ad } %>
-  #   <% end %>
-  #
-  # This would first render <tt>advertiser/_account.html.erb</tt> with <tt>@buyer</tt> passed in as the local variable +account+, then
-  # render <tt>advertiser/_ad.html.erb</tt> and pass the local variable +ad+ to the template for display.
-  #
-  # == The +:as+ and +:object+ options
-  #
-  # By default ActionView::PartialRenderer doesn't have any local variables.
-  # The <tt>:object</tt> option can be used to pass an object to the partial. For instance:
-  #
-  #   <%= render partial: "account", object: @buyer %>
-  #
-  # would provide the <tt>@buyer</tt> object to the partial, available under the local variable +account+ and is
-  # equivalent to:
-  #
-  #   <%= render partial: "account", locals: { account: @buyer } %>
-  #
-  # With the <tt>:as</tt> option we can specify a different name for said local variable. For example, if we
-  # wanted it to be +user+ instead of +account+ we'd do:
-  #
-  #   <%= render partial: "account", object: @buyer, as: 'user' %>
-  #
-  # This is equivalent to
-  #
-  #   <%= render partial: "account", locals: { user: @buyer } %>
-  #
-  # == \Rendering a collection of partials
-  #
-  # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
-  # render a sub template for each of the elements. This pattern has been implemented as a single method that
-  # accepts an array and renders a partial by the same name as the elements contained within. So the three-lined
-  # example in "Using partials" can be rewritten with a single line:
-  #
-  #   <%= render partial: "ad", collection: @advertisements %>
-  #
-  # This will render <tt>advertiser/_ad.html.erb</tt> and pass the local variable +ad+ to the template for display. An
-  # iteration object will automatically be made available to the template with a name of the form
-  # +partial_name_iteration+. The iteration object has knowledge about which index the current object has in
-  # the collection and the total size of the collection. The iteration object also has two convenience methods,
-  # +first?+ and +last?+. In the case of the example above, the template would be fed +ad_iteration+.
-  # For backwards compatibility the +partial_name_counter+ is still present and is mapped to the iteration's
-  # +index+ method.
-  #
-  # The <tt>:as</tt> option may be used when rendering partials.
-  #
-  # You can specify a partial to be rendered between elements via the <tt>:spacer_template</tt> option.
-  # The following example will render <tt>advertiser/_ad_divider.html.erb</tt> between each ad partial:
-  #
-  #   <%= render partial: "ad", collection: @advertisements, spacer_template: "ad_divider" %>
-  #
-  # If the given <tt>:collection</tt> is +nil+ or empty, <tt>render</tt> will return +nil+. This will allow you
-  # to specify a text which will be displayed instead by using this form:
-  #
-  #   <%= render(partial: "ad", collection: @advertisements) || "There's no ad to be displayed" %>
-  #
-  # == \Rendering shared partials
-  #
-  # Two controllers can share a set of partials and render them like this:
-  #
-  #   <%= render partial: "advertisement/ad", locals: { ad: @advertisement } %>
-  #
-  # This will render the partial <tt>advertisement/_ad.html.erb</tt> regardless of which controller this is being called from.
-  #
-  # == \Rendering objects that respond to +to_partial_path+
-  #
-  # Instead of explicitly naming the location of a partial, you can also let PartialRenderer do the work
-  # and pick the proper path by checking +to_partial_path+ method.
-  #
-  #  # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
-  #  # <%= render partial: "accounts/account", locals: { account: @account} %>
-  #  <%= render partial: @account %>
-  #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
-  #  # that's why we can replace:
-  #  # <%= render partial: "posts/post", collection: @posts %>
-  #  <%= render partial: @posts %>
-  #
-  # == \Rendering the default case
-  #
-  # If you're not going to be using any of the options like collections or layouts, you can also use the short-hand
-  # defaults of render to render partials. Examples:
-  #
-  #  # Instead of <%= render partial: "account" %>
-  #  <%= render "account" %>
-  #
-  #  # Instead of <%= render partial: "account", locals: { account: @buyer } %>
-  #  <%= render "account", account: @buyer %>
-  #
-  #  # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
-  #  # <%= render partial: "accounts/account", locals: { account: @account} %>
-  #  <%= render @account %>
-  #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
-  #  # that's why we can replace:
-  #  # <%= render partial: "posts/post", collection: @posts %>
-  #  <%= render @posts %>
-  #
-  # == \Rendering partials with layouts
-  #
-  # Partials can have their own layouts applied to them. These layouts are different than the ones that are
-  # specified globally for the entire action, but they work in a similar fashion. Imagine a list with two types
-  # of users:
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   Here's the administrator:
-  #   <%= render partial: "user", layout: "administrator", locals: { user: administrator } %>
-  #
-  #   Here's the editor:
-  #   <%= render partial: "user", layout: "editor", locals: { user: editor } %>
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   Name: <%= user.name %>
-  #
-  #   <%# app/views/users/_administrator.html.erb %>
-  #   <div id="administrator">
-  #     Budget: $<%= user.budget %>
-  #     <%= yield %>
-  #   </div>
-  #
-  #   <%# app/views/users/_editor.html.erb %>
-  #   <div id="editor">
-  #     Deadline: <%= user.deadline %>
-  #     <%= yield %>
-  #   </div>
-  #
-  # ...this will return:
-  #
-  #   Here's the administrator:
-  #   <div id="administrator">
-  #     Budget: $<%= user.budget %>
-  #     Name: <%= user.name %>
-  #   </div>
-  #
-  #   Here's the editor:
-  #   <div id="editor">
-  #     Deadline: <%= user.deadline %>
-  #     Name: <%= user.name %>
-  #   </div>
-  #
-  # If a collection is given, the layout will be rendered once for each item in
-  # the collection. For example, these two snippets have the same output:
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   Name: <%= user.name %>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <%# This does not use layouts %>
-  #   <ul>
-  #     <% users.each do |user| -%>
-  #       <li>
-  #         <%= render partial: "user", locals: { user: user } %>
-  #       </li>
-  #     <% end -%>
-  #   </ul>
-  #
-  #   <%# app/views/users/_li_layout.html.erb %>
-  #   <li>
-  #     <%= yield %>
-  #   </li>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <ul>
-  #     <%= render partial: "user", layout: "li_layout", collection: users %>
-  #   </ul>
-  #
-  # Given two users whose names are Alice and Bob, these snippets return:
-  #
-  #   <ul>
-  #     <li>
-  #       Name: Alice
-  #     </li>
-  #     <li>
-  #       Name: Bob
-  #     </li>
-  #   </ul>
-  #
-  # The current object being rendered, as well as the object_counter, will be
-  # available as local variables inside the layout template under the same names
-  # as available in the partial.
-  #
-  # You can also apply a layout to a block within any template:
-  #
-  #   <%# app/views/users/_chief.html.erb %>
-  #   <%= render(layout: "administrator", locals: { user: chief }) do %>
-  #     Title: <%= chief.title %>
-  #   <% end %>
-  #
-  # ...this will return:
-  #
-  #   <div id="administrator">
-  #     Budget: $<%= user.budget %>
-  #     Title: <%= chief.name %>
-  #   </div>
-  #
-  # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
-  class PartialRenderer < AbstractRenderer
-    include CollectionCaching
-
-    def initialize(lookup_context, options)
-      super(lookup_context)
-      @options = options
-      @locals  = @options[:locals] || {}
-      @details = extract_details(@options)
-    end
-
-    def render(partial, context, block)
-      template = find_template(partial, template_keys(partial))
-
-      if !block && (layout = @options[:layout])
-        layout = find_template(layout.to_s, template_keys(partial))
-      end
-
-      render_partial_template(context, @locals, template, layout, block)
-    end
-
-    private
-      def template_keys(_)
-        @locals.keys
-      end
-
-      def render_partial_template(view, locals, template, layout, block)
-        ActiveSupport::Notifications.instrument(
-          "render_partial.action_view",
-          identifier: template.identifier,
-          layout: layout && layout.virtual_path,
-          locals: locals
-        ) do |payload|
-          content = template.render(view, locals, add_to_stack: !block) do |*name|
-            view._layout_for(*name, &block)
-          end
-
-          content = layout.render(view, locals) { content } if layout
-          payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
-          build_rendered_template(content, template)
-        end
-      end
-
-      def find_template(path, locals)
-        prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
-        @lookup_context.find_template(path, prefixes, true, locals, @details)
-      end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/actionview-8.0.4/lib/action_view/template/error.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/enumerable"
-require "active_support/syntax_error_proxy"
-
-module ActionView
-  # = Action View Errors
-  class ActionViewError < StandardError # :nodoc:
-  end
-
-  class EncodingError < StandardError # :nodoc:
-  end
-
-  class WrongEncodingError < EncodingError # :nodoc:
-    def initialize(string, encoding)
-      @string, @encoding = string, encoding
-    end
-
-    def message
-      @string.force_encoding(Encoding::ASCII_8BIT)
-      "Your template was not saved as valid #{@encoding}. Please " \
-      "either specify #{@encoding} as the encoding for your template " \
-      "in your text editor, or mark the template with its " \
-      "encoding by inserting the following as the first line " \
-      "of the template:\n\n# encoding: <name of correct encoding>.\n\n" \
-      "The source of your template was:\n\n#{@string}"
-    end
-  end
-
-  class StrictLocalsError < ArgumentError # :nodoc:
-    def initialize(argument_error, template)
-      message = argument_error.message.
-                  gsub("unknown keyword:", "unknown local:").
-                  gsub("missing keyword:", "missing local:").
-                  gsub("no keywords accepted", "no locals accepted").
-                  concat(" for #{template.short_identifier}")
-      super(message)
-    end
-  end
-
-  class MissingTemplate < ActionViewError # :nodoc:
-    attr_reader :path, :paths, :prefixes, :partial
-
-    def initialize(paths, path, prefixes, partial, details, *)
-      if partial && path.present?
-        path = path.sub(%r{([^/]+)$}, "_\\1")
-      end
-
-      @path = path
-      @paths = paths
-      @prefixes = Array(prefixes)
-      @partial = partial
-      template_type = if partial
-        "partial"
-      elsif /layouts/i.match?(path)
-        "layout"
-      else
-        "template"
-      end
-
-      searched_paths = @prefixes.map { |prefix| [prefix, path].join("/") }
-
-      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}.\n\nSearched in:\n"
-      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
-      super out
-    end
-
-    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::Jaro)
-      include DidYouMean::Correctable
-
-      class Results # :nodoc:
-        Result = Struct.new(:path, :score)
-
-        def initialize(size)
-          @size = size
-          @results = []
-        end
-
-        def to_a
-          @results.map(&:path)
-        end
-
-        def should_record?(score)
-          if @results.size < @size
-            true
-          else
-            score < @results.last.score
-          end
-        end
-
-        def add(path, score)
-          if should_record?(score)
-            @results << Result.new(path, score)
-            @results.sort_by!(&:score)
-            @results.pop if @results.size > @size
-          end
-        end
-      end
-
-      # Apps may have thousands of candidate templates so we attempt to
-      # generate the suggestions as efficiently as possible.
-      # First we split templates into prefixes and basenames, so that those can
-      # be matched separately.
-      def corrections
-        candidates = paths.flat_map(&:all_template_paths).uniq
-
-        if partial
-          candidates.select!(&:partial?)
-        else
-          candidates.reject!(&:partial?)
-        end
-
-        # Group by possible prefixes
-        files_by_dir = candidates.group_by(&:prefix)
-        files_by_dir.transform_values! do |files|
-          files.map do |file|
-            # Remove prefix
-            File.basename(file.to_s)
-          end
-        end
-
-        # No suggestions if there's an exact match, but wrong details
-        if prefixes.any? { |prefix| files_by_dir[prefix]&.include?(path) }
-          return []
-        end
-
-        cached_distance = Hash.new do |h, args|
-          h[args] = -DidYouMean::Jaro.distance(*args)
-        end
-
-        results = Results.new(6)
-
-        files_by_dir.keys.index_with do |dirname|
-          prefixes.map do |prefix|
-            cached_distance[[prefix, dirname]]
-          end.min
-        end.sort_by(&:last).each do |dirname, dirweight|
-          # If our directory's score makes it impossible to find a better match
-          # we can prune this search branch.
-          next unless results.should_record?(dirweight - 1.0)
-
-          files = files_by_dir[dirname]
-
-          files.each do |file|
-            fileweight = cached_distance[[path, file]]
-            score = dirweight + fileweight
-
-            results.add(File.join(dirname, file), score)
-          end
-        end
-
-        if partial
-          results.to_a.map { |res| res.sub(%r{_([^/]+)\z}, "\\1") }
-        else
-          results.to_a
-        end
-      end
-    end
-  end
-
-  class Template
-    # The Template::Error exception is raised when the compilation or rendering of the template
-    # fails. This exception then gathers a bunch of intimate details and uses it to report a
-    # precise exception message.
-    class Error < ActionViewError # :nodoc:
-      SOURCE_CODE_RADIUS = 3
-
-      # Override to prevent #cause resetting during re-raise.
-      attr_reader :cause
-
-      attr_reader :template
-
-      def initialize(template)
-        super($!.message)
-        @cause = $!
-        if @cause.is_a?(SyntaxError)
-          @cause = ActiveSupport::SyntaxErrorProxy.new(@cause)
-        end
-        @template, @sub_templates = template, nil
-      end
-
-      def backtrace
-        @cause.backtrace
-      end
-
-      def backtrace_locations
-        @cause.backtrace_locations
-      end
-
-      def file_name
-        @template.identifier
-      end
-
-      def sub_template_message
-        if @sub_templates
-          "Trace of template inclusion: " +
-          @sub_templates.collect(&:inspect).join(", ")
-        else
-          ""
-        end
-      end
-
-      def source_extract(indentation = 0)
-        return [] unless num = line_number
-        num = num.to_i
-
-        source_code = @template.encode!.split("\n")
-
-        start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
-        end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
-
-        indent = end_on_line.to_s.size + indentation
-        return [] unless source_code = source_code[start_on_line..end_on_line]
-
-        formatted_code_for(source_code, start_on_line, indent)
-      end
-
-      def sub_template_of(template_path)
-        @sub_templates ||= []
-        @sub_templates << template_path
-      end
-
-      def line_number
-        @line_number ||=
-          if file_name
-            regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
-            $1 if message =~ regexp || backtrace.find { |line| line =~ regexp }
-          end
-      end
-
-      def annotated_source_code
-        source_extract(4)
-      end
-
-      private
-        def source_location
-          if line_number
-            "on line ##{line_number} of "
-          else
-            "in "
-          end + file_name
-        end
-
-        def formatted_code_for(source_code, line_counter, indent)
-          indent_template = "%#{indent}s: %s"
-          source_code.map do |line|
-            line_counter += 1
-            indent_template % [line_counter, line]
-          end
-        end
-    end
-  end
-
-  TemplateError = Template::Error
-
-  class SyntaxErrorInTemplate < TemplateError # :nodoc:
-    def initialize(template, offending_code_string)
-      @offending_code_string = offending_code_string
-      super(template)
-    end
-
-    def message
-      <<~MESSAGE
-        Encountered a syntax error while rendering template: check #{@offending_code_string}
-      MESSAGE
-    end
-
-    def annotated_source_code
-      @offending_code_string.split("\n").map.with_index(1) { |line, index|
-        indentation = " " * 4
-        "#{index}:#{indentation}#{line}"
-      }
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/actionview-8.0.4/lib/action_view/template/handlers/erb.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require "strscan"
-require "active_support/core_ext/erb/util"
-
-module ActionView
-  class Template
-    module Handlers
-      class ERB
-        autoload :Erubi, "action_view/template/handlers/erb/erubi"
-
-        # Specify trim mode for the ERB compiler. Defaults to '-'.
-        # See ERB documentation for suitable values.
-        class_attribute :erb_trim_mode, default: "-"
-
-        # Default implementation used.
-        class_attribute :erb_implementation, default: Erubi
-
-        # Do not escape templates of these mime types.
-        class_attribute :escape_ignore_list, default: ["text/plain"]
-
-        # Strip trailing newlines from rendered output
-        class_attribute :strip_trailing_newlines, default: false
-
-        ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
-
-        LocationParsingError = Class.new(StandardError) # :nodoc:
-
-        def self.call(template, source)
-          new.call(template, source)
-        end
-
-        def supports_streaming?
-          true
-        end
-
-        def handles_encoding?
-          true
-        end
-
-        # Translate an error location returned by ErrorHighlight to the correct
-        # source location inside the template.
-        def translate_location(spot, backtrace_location, source)
-          # Tokenize the source line
-          source_lines = source.lines
-          return nil if source_lines.size < backtrace_location.lineno
-          tokens = ::ERB::Util.tokenize(source_lines[backtrace_location.lineno - 1])
-          new_first_column = find_offset(spot[:snippet], tokens, spot[:first_column])
-          lineno_delta = spot[:first_lineno] - backtrace_location.lineno
-          spot[:first_lineno] -= lineno_delta
-          spot[:last_lineno] -= lineno_delta
-
-          column_delta = spot[:first_column] - new_first_column
-          spot[:first_column] -= column_delta
-          spot[:last_column] -= column_delta
-          spot[:script_lines] = source_lines
-
-          spot
-        rescue NotImplementedError, LocationParsingError
-          nil
-        end
-
-        def call(template, source)
-          # First, convert to BINARY, so in case the encoding is
-          # wrong, we can still find an encoding tag
-          # (<%# encoding %>) inside the String using a regular
-          # expression
-          template_source = source.b
-
-          erb = template_source.gsub(ENCODING_TAG, "")
-          encoding = $2
-
-          erb.force_encoding valid_encoding(source.dup, encoding)
-
-          # Always make sure we return a String in the default_internal
-          erb.encode!
-
-          # Strip trailing newlines from the template if enabled
-          erb.chomp! if strip_trailing_newlines
-
-          options = {
-            escape: (self.class.escape_ignore_list.include? template.type),
-            trim: (self.class.erb_trim_mode == "-")
-          }
-
-          if ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
-            options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier} -->';"
-            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
-          end
-
-          self.class.erb_implementation.new(erb, options).src
-        end
-
-      private
-        def valid_encoding(string, encoding)
-          # If a magic encoding comment was found, tag the
-          # String with this encoding. This is for a case
-          # where the original String was assumed to be,
-          # for instance, UTF-8, but a magic comment
-          # proved otherwise
-          string.force_encoding(encoding) if encoding
-
-          # If the String is valid, return the encoding we found
-          return string.encoding if string.valid_encoding?
-
-          # Otherwise, raise an exception
-          raise WrongEncodingError.new(string, string.encoding)
-        end
-
-        # Find which token in the source template spans the byte range that
-        # contains the error_column, then return the offset compared to the
-        # original source template.
-        #
-        # Iterate consecutive pairs of CODE or TEXT tokens, requiring
-        # a match of the first token before matching either token.
-        #
-        # For example, if we want to find tokens A, B, C, we do the following:
-        # 1. Find a match for A: test error_column or advance scanner.
-        # 2. Find a match for B or A:
-        #   a. If B: start over with next token set (B, C).
-        #   b. If A: test error_column or advance scanner.
-        #   c. Otherwise: Advance 1 byte
-        #
-        # Prioritize matching the next token over the current token once
-        # a match for the current token has been found. This is to prevent
-        # the current token from looping past the next token if they both
-        # match (i.e. if the current token is a single space character).
-        def find_offset(compiled, source_tokens, error_column)
-          compiled = StringScanner.new(compiled)
-          offset_source_tokens(source_tokens).each_cons(2) do |(name, str, offset), (_, next_str, _)|
-            matched_str = false
-
-            until compiled.eos?
-              if matched_str && next_str && compiled.match?(next_str)
-                break
-              elsif compiled.match?(str)
-                matched_str = true
-
-                if name == :CODE && compiled.pos <= error_column && compiled.pos + str.bytesize >= error_column
-                  return error_column - compiled.pos + offset
-                end
-
-                compiled.pos += str.bytesize
-              else
-                compiled.pos += 1
-              end
-            end
-          end
-
-          raise LocationParsingError, "Couldn't find code snippet"
-        end
-
-        def offset_source_tokens(source_tokens)
-          source_offset = 0
-          with_offset = source_tokens.filter_map do |(name, str)|
-            result = [name, str, source_offset] if name == :CODE || name == :TEXT
-            source_offset += str.bytesize
-            result
-          end
-          with_offset << [:EOS, nil, source_offset]
-        end
-      end
-    end
-  end
-end