jets 1.9.7 → 1.9.8

data/vendor/rails/actionview/lib/action_view/template/error.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/enumerable"
-
-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 MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
-
-    def initialize(paths, path, prefixes, partial, details, *)
-      @path = path
-      prefixes = Array(prefixes)
-      template_type = if partial
-        "partial"
-      elsif /layouts/i.match?(path)
-        "layout"
-      else
-        "template"
-      end
-
-      if partial && path.present?
-        path = path.sub(%r{([^/]+)$}, "_\\1")
-      end
-      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
-
-      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
-      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
-      super out
-    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
-
-      def initialize(template)
-        super($!.message)
-        set_backtrace($!.backtrace)
-        @cause = $!
-        @template, @sub_templates = template, nil
-      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, output = :console)
-        return unless num = line_number
-        num = num.to_i
-
-        source_code = @template.source.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, output)
-      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 annoted_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, output)
-          start_value = (output == :html) ? {} : []
-          source_code.inject(start_value) do |result, line|
-            line_counter += 1
-            if output == :html
-              result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
-            else
-              result << "%#{indent}s: %s" % [line_counter, line]
-            end
-          end
-        end
-    end
-  end
-
-  TemplateError = Template::Error
-end

data/vendor/rails/actionview/lib/action_view/template/handlers.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView #:nodoc:
-  # = Action View Template Handlers
-  class Template #:nodoc:
-    module Handlers #:nodoc:
-      autoload :Raw, "action_view/template/handlers/raw"
-      autoload :ERB, "action_view/template/handlers/erb"
-      autoload :Html, "action_view/template/handlers/html"
-      autoload :Builder, "action_view/template/handlers/builder"
-
-      def self.extended(base)
-        base.register_default_template_handler :raw, Raw.new
-        base.register_template_handler :erb, ERB.new
-        base.register_template_handler :html, Html.new
-        base.register_template_handler :builder, Builder.new
-        base.register_template_handler :ruby, :source.to_proc
-      end
-
-      @@template_handlers = {}
-      @@default_template_handlers = nil
-
-      def self.extensions
-        @@template_extensions ||= @@template_handlers.keys
-      end
-
-      # Register an object that knows how to handle template files with the given
-      # extensions. This can be used to implement new template types.
-      # The handler must respond to +:call+, which will be passed the template
-      # and should return the rendered template as a String.
-      def register_template_handler(*extensions, handler)
-        raise(ArgumentError, "Extension is required") if extensions.empty?
-        extensions.each do |extension|
-          @@template_handlers[extension.to_sym] = handler
-        end
-        @@template_extensions = nil
-      end
-
-      # Opposite to register_template_handler.
-      def unregister_template_handler(*extensions)
-        extensions.each do |extension|
-          handler = @@template_handlers.delete extension.to_sym
-          @@default_template_handlers = nil if @@default_template_handlers == handler
-        end
-        @@template_extensions = nil
-      end
-
-      def template_handler_extensions
-        @@template_handlers.keys.map(&:to_s).sort
-      end
-
-      def registered_template_handler(extension)
-        extension && @@template_handlers[extension.to_sym]
-      end
-
-      def register_default_template_handler(extension, klass)
-        register_template_handler(extension, klass)
-        @@default_template_handlers = klass
-      end
-
-      def handler_for_extension(extension)
-        registered_template_handler(extension) || @@default_template_handlers
-      end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/handlers/builder.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Template::Handlers
-    class Builder
-      class_attribute :default_format, default: :xml
-
-      def call(template)
-        require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
-          "self.output_buffer = xml.target!;" +
-          template.source +
-          ";xml.target!;"
-      end
-
-      private
-        def require_engine # :doc:
-          @required ||= begin
-            require "builder"
-            true
-          end
-        end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/handlers/erb.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-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_whitelist, default: ["text/plain"]
-
-        ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
-
-        def self.call(template)
-          new.call(template)
-        end
-
-        def supports_streaming?
-          true
-        end
-
-        def handles_encoding?
-          true
-        end
-
-        def call(template)
-          # 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 = template.source.dup.force_encoding(Encoding::ASCII_8BIT)
-
-          erb = template_source.gsub(ENCODING_TAG, "")
-          encoding = $2
-
-          erb.force_encoding valid_encoding(template.source.dup, encoding)
-
-          # Always make sure we return a String in the default_internal
-          erb.encode!
-
-          self.class.erb_implementation.new(
-            erb,
-            escape: (self.class.escape_whitelist.include? template.type),
-            trim: (self.class.erb_trim_mode == "-")
-          ).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
-      end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/handlers/erb/erubi.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "erubi"
-
-module ActionView
-  class Template
-    module Handlers
-      class ERB
-        class Erubi < ::Erubi::Engine
-          # :nodoc: all
-          def initialize(input, properties = {})
-            @newline_pending = 0
-
-            # Dup properties so that we don't modify argument
-            properties = Hash[properties]
-            properties[:preamble]   = "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-            properties[:postamble]  = "@output_buffer.to_s"
-            properties[:bufvar]     = "@output_buffer"
-            properties[:escapefunc] = ""
-
-            super
-          end
-
-          def evaluate(action_view_erb_handler_context)
-            pr = eval("proc { #{@src} }", binding, @filename || "(erubi)")
-            action_view_erb_handler_context.instance_eval(&pr)
-          end
-
-        private
-          def add_text(text)
-            return if text.empty?
-
-            if text == "\n"
-              @newline_pending += 1
-            else
-              src << "@output_buffer.safe_append='"
-              src << "\n" * @newline_pending if @newline_pending > 0
-              src << text.gsub(/['\\]/, '\\\\\&')
-              src << "'.freeze;"
-
-              @newline_pending = 0
-            end
-          end
-
-          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
-          def add_expression(indicator, code)
-            flush_newline_if_pending(src)
-
-            if (indicator == "==") || @escape
-              src << "@output_buffer.safe_expr_append="
-            else
-              src << "@output_buffer.append="
-            end
-
-            if BLOCK_EXPR.match?(code)
-              src << " " << code
-            else
-              src << "(" << code << ");"
-            end
-          end
-
-          def add_code(code)
-            flush_newline_if_pending(src)
-            super
-          end
-
-          def add_postamble(_)
-            flush_newline_if_pending(src)
-            super
-          end
-
-          def flush_newline_if_pending(src)
-            if @newline_pending > 0
-              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
-              @newline_pending = 0
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/handlers/html.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Template::Handlers
-    class Html < Raw
-      def call(template)
-        "ActionView::OutputBuffer.new #{super}"
-      end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/handlers/raw.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Template::Handlers
-    class Raw
-      def call(template)
-        "#{template.source.inspect}.html_safe;"
-      end
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/template/html.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView #:nodoc:
-  # = Action View HTML Template
-  class Template #:nodoc:
-    class HTML #:nodoc:
-      attr_accessor :type
-
-      def initialize(string, type = nil)
-        @string = string.to_s
-        @type   = Types[type] || type if type
-        @type ||= Types[:html]
-      end
-
-      def identifier
-        "html template"
-      end
-
-      alias_method :inspect, :identifier
-
-      def to_str
-        ERB::Util.h(@string)
-      end
-
-      def render(*args)
-        to_str
-      end
-
-      def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
-      end
-    end
-  end
-end