zuora_connect_ui 0.8.3 → 0.9.0

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/etanni.rb

@@ -0,0 +1,27 @@
+require 'tilt/template'
+
+module Tilt
+  class EtanniTemplate < Template
+    def prepare
+      separator = data.hash.abs
+      chomp = "<<#{separator}.chomp!"
+      start = "\n_out_ << #{chomp}\n"
+      stop = "\n#{separator}\n"
+      replacement = "#{stop}\\1#{start}"
+
+      temp = data.strip
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, replacement)
+
+      @code = "_out_ = [<<#{separator}.chomp!]\n#{temp}#{stop}_out_.join"
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/haml.rb

@@ -0,0 +1,86 @@
+require 'tilt/template'
+require 'haml'
+
+module Tilt
+  # Haml template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  class HamlTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    # `Gem::Version.correct?` may return false because of Haml::VERSION #=> "3.1.8 (Separated Sally)". After Haml 4, it's always correct.
+    if Gem::Version.correct?(Haml::VERSION) && Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.0.0.beta.2')
+      def prepare
+        options = {}.update(@options).update(filename: eval_file, line: line)
+        if options.include?(:outvar)
+          options[:buffer] = options.delete(:outvar)
+          options[:save_buffer] = true
+        end
+        @engine = ::Haml::TempleEngine.new(options)
+        @engine.compile(data)
+      end
+
+      def evaluate(scope, locals, &block)
+        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
+        super
+      end
+
+      def precompiled_template(locals)
+        @engine.precompiled_with_ambles(
+          [],
+          after_preamble: <<-RUBY
+            __in_erb_template = true
+            _haml_locals = locals
+          RUBY
+        )
+      end
+    else # Following definitions are for Haml <= 4 and deprecated.
+      def prepare
+        options = @options.merge(:filename => eval_file, :line => line)
+        @engine = ::Haml::Engine.new(data, options)
+      end
+
+      def evaluate(scope, locals, &block)
+        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
+
+        if @engine.respond_to?(:precompiled_method_return_value, true)
+          super
+        else
+          @engine.render(scope, locals, &block)
+        end
+      end
+
+      # Precompiled Haml source. Taken from the precompiled_with_ambles
+      # method in Haml::Precompiler:
+      # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
+      def precompiled_template(locals)
+        @engine.precompiled
+      end
+
+      def precompiled_preamble(locals)
+        local_assigns = super
+        @engine.instance_eval do
+          <<-RUBY
+            begin
+              extend Haml::Helpers
+              _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
+              _erbout = _hamlout.buffer
+              __in_erb_template = true
+              _haml_locals = locals
+              #{local_assigns}
+          RUBY
+        end
+      end
+
+      def precompiled_postamble(locals)
+        @engine.instance_eval do
+          <<-RUBY
+              #{precompiled_method_return_value}
+            ensure
+              @haml_buffer = @haml_buffer.upper if haml_buffer
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/kramdown.rb

@@ -0,0 +1,25 @@
+require 'tilt/template'
+require 'kramdown'
+
+module Tilt
+  # Kramdown Markdown implementation. See:
+  # http://kramdown.rubyforge.org/
+  class KramdownTemplate < Template
+    DUMB_QUOTES = [39, 39, 34, 34]
+
+    def prepare
+      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
+      @engine = Kramdown::Document.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/less.rb

@@ -0,0 +1,30 @@
+require 'tilt/template'
+require 'less'
+
+module Tilt
+  # Lessscss template implementation. See:
+  # http://lesscss.org/
+  #
+  # Less templates do not support object scopes, locals, or yield.
+  class LessTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    def prepare
+      if ::Less.const_defined? :Engine
+        @engine = ::Less::Engine.new(data)
+      else
+        parser  = ::Less::Parser.new(options.merge :filename => eval_file, :line => line)
+        @engine = parser.parse(data)
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_css(options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/liquid.rb

@@ -0,0 +1,44 @@
+require 'tilt/template'
+require 'liquid'
+
+module Tilt
+  # Liquid template implementation. See:
+  # http://liquidmarkup.org/
+  #
+  # Liquid is designed to be a *safe* template system and threfore
+  # does not provide direct access to execuatable scopes. In order to
+  # support a +scope+, the +scope+ must be able to represent itself
+  # as a hash by responding to #to_h. If the +scope+ does not respond
+  # to #to_h it will be ignored.
+  #
+  # LiquidTemplate does not support yield blocks.
+  #
+  # It's suggested that your program require 'liquid' at load
+  # time when using this template engine.
+  class LiquidTemplate < Template
+    def prepare
+      @engine = ::Liquid::Template.parse(data, liquid_options)
+    end
+
+    def evaluate(scope, locals, &block)
+      locals = locals.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+      if scope.respond_to?(:to_h)
+        scope  = scope.to_h.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+        locals = scope.merge(locals)
+      end
+      locals['yield'] = block.nil? ? '' : yield
+      locals['content'] = locals['yield']
+      @engine.render(locals)
+    end
+
+    def allows_script?
+      false
+    end
+
+    private
+
+    def liquid_options
+      { line_numbers: true }.merge options
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/livescript.rb

@@ -0,0 +1,23 @@
+require 'tilt/template'
+require 'livescript'
+
+module Tilt
+  # LiveScript template implementation. See:
+  # http://livescript.net/
+  #
+  # LiveScript templates do not support object scopes, locals, or yield.
+  class LiveScriptTemplate < Template
+    self.default_mime_type = 'application/javascript'
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= LiveScript.compile(data, options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/tilt-2.0.10/lib/tilt/mapping.rb

@@ -0,0 +1,293 @@
+require 'monitor'
+
+module Tilt
+  # Tilt::Mapping associates file extensions with template implementations.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register(Tilt::RDocTemplate, 'rdoc')
+  #     mapping['index.rdoc'] # => Tilt::RDocTemplate
+  #     mapping.new('index.rdoc').render
+  #
+  # You can use {#register} to register a template class by file
+  # extension, {#registered?} to see if a file extension is mapped,
+  # {#[]} to lookup template classes, and {#new} to instantiate template
+  # objects.
+  #
+  # Mapping also supports *lazy* template implementations. Note that regularly
+  # registered template implementations *always* have preference over lazily
+  # registered template implementations. You should use {#register} if you
+  # depend on a specific template implementation and {#register_lazy} if there
+  # are multiple alternatives.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register_lazy('RDiscount::Template', 'rdiscount/template', 'md')
+  #     mapping['index.md']
+  #     # => RDiscount::Template
+  #
+  # {#register_lazy} takes a class name, a filename, and a list of file
+  # extensions. When you try to lookup a template name that matches the
+  # file extension, Tilt will automatically try to require the filename and
+  # constantize the class name.
+  #
+  # Unlike {#register}, there can be multiple template implementations
+  # registered lazily to the same file extension. Tilt will attempt to load the
+  # template implementations in order (registered *last* would be tried first),
+  # returning the first which doesn't raise LoadError.
+  #
+  # If all of the registered template implementations fails, Tilt will raise
+  # the exception of the first, since that was the most preferred one.
+  #
+  #     mapping = Tilt::Mapping.new
+  #     mapping.register_lazy('Bluecloth::Template', 'bluecloth/template', 'md')
+  #     mapping.register_lazy('RDiscount::Template', 'rdiscount/template', 'md')
+  #     mapping['index.md']
+  #     # => RDiscount::Template
+  #
+  # In the previous example we say that RDiscount has a *higher priority* than
+  # BlueCloth. Tilt will first try to `require "rdiscount/template"`, falling
+  # back to `require "bluecloth/template"`. If none of these are successful,
+  # the first error will be raised.
+  class Mapping
+    # @private
+    attr_reader :lazy_map, :template_map
+
+    def initialize
+      @template_map = Hash.new
+      @lazy_map = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # @private
+    def initialize_copy(other)
+      @template_map = other.template_map.dup
+      @lazy_map = other.lazy_map.dup
+    end
+
+    # Registers a lazy template implementation by file extension. You
+    # can have multiple lazy template implementations defined on the
+    # same file extension, in which case the template implementation
+    # defined *last* will be attempted loaded *first*.
+    #
+    # @param class_name [String] Class name of a template class.
+    # @param file [String] Filename where the template class is defined.
+    # @param extensions [Array<String>] List of extensions.
+    # @return [void]
+    #
+    # @example
+    #   mapping.register_lazy 'MyEngine::Template', 'my_engine/template',  'mt'
+    #
+    #   defined?(MyEngine::Template) # => false
+    #   mapping['index.mt'] # => MyEngine::Template
+    #   defined?(MyEngine::Template) # => true
+    def register_lazy(class_name, file, *extensions)
+      # Internal API
+      if class_name.is_a?(Symbol)
+        Tilt.autoload class_name, file
+        class_name = "Tilt::#{class_name}"
+      end
+
+      extensions.each do |ext|
+        @lazy_map[ext].unshift([class_name, file])
+      end
+    end
+
+    # Registers a template implementation by file extension. There can only be
+    # one template implementation per file extension, and this method will
+    # override any existing mapping.
+    #
+    # @param template_class
+    # @param extensions [Array<String>] List of extensions.
+    # @return [void]
+    # 
+    # @example
+    #   mapping.register MyEngine::Template, 'mt'
+    #   mapping['index.mt'] # => MyEngine::Template
+    def register(template_class, *extensions)
+      if template_class.respond_to?(:to_str)
+        # Support register(ext, template_class) too
+        extensions, template_class = [template_class], extensions[0]
+      end
+
+      extensions.each do |ext|
+        @template_map[ext.to_s] = template_class
+      end
+    end
+
+    # Checks if a file extension is registered (either eagerly or
+    # lazily) in this mapping.
+    #
+    # @param ext [String] File extension.
+    #
+    # @example
+    #   mapping.registered?('erb')  # => true
+    #   mapping.registered?('nope') # => false
+    def registered?(ext)
+      @template_map.has_key?(ext.downcase) or lazy?(ext)
+    end
+
+    # Instantiates a new template class based on the file.
+    #
+    # @raise [RuntimeError] if there is no template class registered for the
+    #   file name.
+    #
+    # @example
+    #   mapping.new('index.mt') # => instance of MyEngine::Template
+    #
+    # @see Tilt::Template.new
+    def new(file, line=nil, options={}, &block)
+      if template_class = self[file]
+        template_class.new(file, line, options, &block)
+      else
+        fail "No template engine registered for #{File.basename(file)}"
+      end
+    end
+
+    # Looks up a template class based on file name and/or extension.
+    #
+    # @example
+    #   mapping['views/hello.erb'] # => Tilt::ERBTemplate
+    #   mapping['hello.erb']       # => Tilt::ERBTemplate
+    #   mapping['erb']             # => Tilt::ERBTemplate
+    #
+    # @return [template class]
+    def [](file)
+      _, ext = split(file)
+      ext && lookup(ext)
+    end
+
+    alias template_for []
+
+    # Looks up a list of template classes based on file name. If the file name
+    # has multiple extensions, it will return all template classes matching the
+    # extensions from the end.
+    #
+    # @example
+    #   mapping.templates_for('views/index.haml.erb')
+    #   # => [Tilt::ERBTemplate, Tilt::HamlTemplate]
+    #
+    # @return [Array<template class>]
+    def templates_for(file)
+      templates = []
+
+      while true
+        prefix, ext = split(file)
+        break unless ext
+        templates << lookup(ext)
+        file = prefix
+      end
+
+      templates
+    end
+
+    # Finds the extensions the template class has been registered under.
+    # @param [template class] template_class
+    def extensions_for(template_class)
+      res = []
+      template_map.each do |ext, klass|
+        res << ext if template_class == klass
+      end
+      lazy_map.each do |ext, choices|
+        res << ext if choices.any? { |klass, file| template_class.to_s == klass }
+      end
+      res
+    end
+
+    private
+
+    def lazy?(ext)
+      ext = ext.downcase
+      @lazy_map.has_key?(ext) && !@lazy_map[ext].empty?
+    end
+
+    def split(file)
+      pattern = file.to_s.downcase
+      full_pattern = pattern.dup
+
+      until registered?(pattern)
+        return if pattern.empty?
+        pattern = File.basename(pattern)
+        pattern.sub!(/^[^.]*\.?/, '')
+      end
+
+      prefix_size = full_pattern.size - pattern.size
+      [full_pattern[0,prefix_size-1], pattern]
+    end
+
+    def lookup(ext)
+      @template_map[ext] || lazy_load(ext)
+    end
+
+    LOCK = Monitor.new
+
+    def lazy_load(pattern)
+      return unless @lazy_map.has_key?(pattern)
+
+      LOCK.enter
+      entered = true
+
+      choices = @lazy_map[pattern]
+
+      # Check if a template class is already present
+      choices.each do |class_name, file|
+        template_class = constant_defined?(class_name)
+        if template_class
+          register(template_class, pattern)
+          return template_class
+        end
+      end
+
+      first_failure = nil
+
+      # Load in order
+      choices.each do |class_name, file|
+        begin
+          require file
+          # It's safe to eval() here because constant_defined? will
+          # raise NameError on invalid constant names
+          template_class = eval(class_name)
+        rescue LoadError => ex
+          first_failure ||= ex
+        else
+          register(template_class, pattern)
+          return template_class
+        end
+      end
+
+      raise first_failure if first_failure
+    ensure
+      LOCK.exit if entered
+    end
+
+    # This is due to a bug in JRuby (see GH issue jruby/jruby#3585)
+    Tilt.autoload :Dummy, "tilt/dummy"
+    require "tilt/dummy"
+    AUTOLOAD_IS_BROKEN = Tilt.autoload?(:Dummy)
+
+    # The proper behavior (in MRI) for autoload? is to
+    # return `false` when the constant/file has been
+    # explicitly required.
+    #
+    # However, in JRuby it returns `true` even after it's
+    # been required. In that case it turns out that `defined?`
+    # returns `"constant"` if it exists and `nil` when it doesn't.
+    # This is actually a second bug: `defined?` should resolve
+    # autoload (aka. actually try to require the file).
+    #
+    # We use the second bug in order to resolve the first bug.
+
+    def constant_defined?(name)
+      name.split('::').inject(Object) do |scope, n|
+        if scope.autoload?(n)
+          if !AUTOLOAD_IS_BROKEN
+            return false
+          end
+
+          if eval("!defined?(scope::#{n})")
+            return false
+          end
+        end
+        return false if !scope.const_defined?(n)
+        scope.const_get(n)
+      end
+    end
+  end
+end