logstash-output-scalyr 0.1.3 → 0.1.8

data/vendor/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/erubis.rb

@@ -1,43 +0,0 @@
-require 'tilt/erb'
-require 'erubis'
-
-module Tilt
-  # Erubis template implementation. See:
-  # http://www.kuwata-lab.com/erubis/
-  #
-  # ErubisTemplate supports the following additional options, which are not
-  # passed down to the Erubis engine:
-  #
-  #   :engine_class   allows you to specify a custom engine class to use
-  #                   instead of the default (which is ::Erubis::Eruby).
-  #
-  #   :escape_html    when true, ::Erubis::EscapedEruby will be used as
-  #                   the engine class instead of the default. All content
-  #                   within <%= %> blocks will be automatically html escaped.
-  class ErubisTemplate < ERBTemplate
-    def prepare
-      @outvar = options.delete(:outvar) || self.class.default_output_variable
-      @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
-      engine_class = options.delete(:engine_class)
-      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
-      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
-    end
-
-    def precompiled_preamble(locals)
-      [super, "#{@outvar} = _buf = String.new"].join("\n")
-    end
-
-    def precompiled_postamble(locals)
-      [@outvar, super].join("\n")
-    end
-
-    # Erubis doesn't have ERB's line-off-by-one under 1.9 problem.
-    # Override and adjust back.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset - 1]
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/etanni.rb

@@ -1,27 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/haml.rb

@@ -1,86 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/kramdown.rb

@@ -1,25 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/less.rb

@@ -1,30 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/liquid.rb

@@ -1,44 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/livescript.rb

@@ -1,23 +0,0 @@
-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/bundle/jruby/2.5.0/gems/tilt-2.0.10/lib/tilt/mapping.rb

@@ -1,293 +0,0 @@
-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