logstash-output-scalyr 0.1.26.beta → 0.2.2

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/parenthesized_expression.rb

@@ -1,9 +0,0 @@
-module Treetop
-  module Compiler    
-    class ParenthesizedExpression < ParsingExpression
-      def compile(address, builder, parent_expression = nil)
-        elements[2].compile(address, builder, parent_expression)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/parsing_expression.rb

@@ -1,146 +0,0 @@
-module Treetop
-  module Compiler
-    class ParsingExpression < Runtime::SyntaxNode
-      attr_reader :address, :builder, :subexpression_address, :var_symbols, :parent_expression
-    
-      def compile(address, builder, parent_expression)
-        @address = address
-        @builder = builder
-        @parent_expression = parent_expression
-      end
-      
-      def node_class_name
-        parent_expression && parent_expression.node_class_name || 'SyntaxNode'
-      end
-      
-      def declared_module_name
-        parent_expression && parent_expression.node_class_name
-      end
-      
-      def inline_module_name
-        parent_expression && parent_expression.inline_module_name
-      end
-      
-      def decorated?
-        parent_expression && (parent_expression.node_class_name || parent_expression.node_class_name || parent_expression.inline_module_name)
-      end
-      
-      def optional_arg(arg)
-        if arg
-          ", #{arg}"
-        else
-          ''
-        end
-      end
-    
-      def use_vars(*var_symbols)
-        @var_symbols = var_symbols
-        builder << var_initialization
-      end
-    
-      def result_var
-        var(:result)
-      end
-    
-      def accumulator_var
-        var(:accumulator)
-      end
-      
-      def start_index_var
-        var(:start_index)
-      end
-    
-      def subexpression_result_var
-        "r#{subexpression_address}"
-      end
-    
-      def subexpression_success?
-        subexpression_result_var
-      end
-    
-      def obtain_new_subexpression_address
-        @subexpression_address = builder.next_address
-      end
-        
-      def accumulate_subexpression_result
-        builder.accumulate accumulator_var, subexpression_result_var
-      end
-    
-      def assign_result(value_ruby)
-        builder.assign result_var, value_ruby
-      end
-      
-      def extend_result(module_name)
-        builder.extend result_var, module_name
-      end
-
-      def extend_result_with_declared_module
-        extend_result declared_module_name if declared_module_name
-      end
-      
-      def extend_result_with_inline_module
-        extend_result inline_module_name if inline_module_name
-      end
-    
-      def reset_index
-        builder.assign '@index', start_index_var
-      end
-      
-      def epsilon_node
-        "instantiate_node(SyntaxNode,input, index...index)"
-      end
-      
-      def assign_failure(start_index_var)
-        assign_result("nil")
-      end
-      
-      def assign_lazily_instantiated_node
-        assign_result("true")
-      end
-    
-      def var_initialization
-        left, right = [], []
-        var_symbols.each do |symbol|
-          if init_value(symbol)
-            left << var(symbol)
-            right << init_value(symbol)
-          end
-        end
-        if left.empty?
-          ""
-        else
-          left.join(', ') + ' = ' + right.join(', ')
-        end
-      end
-    
-      def var(var_symbol)
-        case var_symbol
-        when :result then "r#{address}"
-        when :accumulator then "s#{address}"
-        when :start_index then "i#{address}"
-        else raise "Unknown var symbol #{var_symbol}."
-        end
-      end
-    
-      def init_value(var_symbol)
-        case var_symbol
-        when :accumulator then '[]'
-        when :start_index then 'index'
-        else nil
-        end
-      end
-      
-      def begin_comment(expression)
-        #builder << "# begin #{on_one_line(expression)}"
-      end
-      
-      def end_comment(expression)
-        #builder << "# end #{on_one_line(expression)}"
-      end
-      
-      def on_one_line(expression)
-        expression.text_value.tr("\n", ' ')
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -1,58 +0,0 @@
-module Treetop
-  module Compiler
-    class ParsingRule < Runtime::SyntaxNode
-
-      def compile(builder)
-        compile_inline_module_declarations(builder)
-        generate_method_definition(builder)
-      end
-      
-      def compile_inline_module_declarations(builder)
-        parsing_expression.inline_modules.each_with_index do |inline_module, i|
-          inline_module.compile(i, builder, self)
-          builder.newline
-        end
-      end
-      
-      def generate_method_definition(builder)
-        builder.reset_addresses
-        expression_address = builder.next_address
-        result_var = "r#{expression_address}"
-        
-        builder.method_declaration(method_name) do
-          builder.assign 'start_index', 'index'
-          generate_cache_lookup(builder)
-          builder.newline
-          parsing_expression.compile(expression_address, builder)
-          builder.newline
-          generate_cache_storage(builder, result_var)
-          builder.newline          
-          builder << result_var
-        end
-      end
-      
-      def generate_cache_lookup(builder)
-        builder.if_ "node_cache[:#{name}].has_key?(index)" do
-          builder.assign 'cached', "node_cache[:#{name}][index]"
-          builder.if_ "cached" do
-            builder << 'cached = SyntaxNode.new(input, index...(index + 1)) if cached == true'
-            builder << '@index = cached.interval.end'
-          end
-          builder << 'return cached'
-        end
-      end
-      
-      def generate_cache_storage(builder, result_var)
-        builder.assign "node_cache[:#{name}][start_index]", result_var
-      end
-      
-      def method_name
-        "_nt_#{name}"
-      end
-      
-      def name
-        nonterminal.text_value
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/predicate.rb

@@ -1,45 +0,0 @@
-module Treetop
-  module Compiler
-    class Predicate < ParsingExpression
-      def compile(address, builder, parent_expression)
-        super
-        begin_comment(parent_expression)
-        use_vars :result, :start_index
-        obtain_new_subexpression_address
-        parent_expression.prefixed_expression.compile(subexpression_address, builder)
-        builder.if__(subexpression_success?) { when_success }
-        builder.else_ { when_failure }
-        end_comment(parent_expression)
-      end
-      
-      def assign_failure
-        super(start_index_var)
-      end
-      
-      def assign_success
-        reset_index
-        assign_result epsilon_node
-      end
-    end
-    
-    class AndPredicate < Predicate
-      def when_success
-        assign_success
-      end
-
-      def when_failure
-        assign_failure
-      end
-    end
-    
-    class NotPredicate < Predicate
-      def when_success
-        assign_failure
-      end
-      
-      def when_failure
-        assign_success
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/predicate_block.rb

@@ -1,16 +0,0 @@
-module Treetop
-  module Compiler
-    class PredicateBlock < ParsingExpression
-      def compile(index, builder, parent_expression = nil)
-        super
-        # REVISIT: This is distinctly dodgey, but since we can only be called from
-        # two contexts, and it works in both those, I'm going with it for now, as
-        # opposed to doing the major refactor of providing a proper way of accessing
-        # the parent's accumulator variable.
-        p = parent
-        p = p.parent while p && !p.respond_to?(:accumulator_var)
-        assign_result "lambda #{text_value}.call(#{p ? p.accumulator_var : ""})"
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/repetition.rb

@@ -1,89 +0,0 @@
-module Treetop
-  module Compiler
-    class Repetition < ParsingExpression
-      def compile(address, builder, parent_expression)
-        super
-        repeated_expression = parent_expression.atomic
-        begin_comment(parent_expression)
-        use_vars :result, :accumulator, :start_index
-
-        builder.loop do
-          obtain_new_subexpression_address
-          repeated_expression.compile(subexpression_address, builder)
-          builder.if__ subexpression_success? do
-            accumulate_subexpression_result
-          end
-          builder.else_ do
-            builder.break
-          end
-          if max && !max.empty?
-            builder.if_ "#{accumulator_var}.size == #{max.text_value}" do
-              builder.break
-            end
-          end
-        end
-      end
-
-      def inline_module_name
-        parent_expression.inline_module_name
-      end
-
-      def assign_and_extend_result
-        assign_result "instantiate_node(#{node_class_name},input, #{start_index_var}...index, #{accumulator_var})"
-        extend_result_with_inline_module
-      end
-    end
-
-
-    class ZeroOrMore < Repetition
-      def compile(address, builder, parent_expression)
-        super
-        assign_and_extend_result
-        end_comment(parent_expression)
-      end
-
-      def max
-        nil
-      end
-    end
-
-    class OneOrMore < Repetition
-      def compile(address, builder, parent_expression)
-        super
-        builder.if__ "#{accumulator_var}.empty?" do
-          reset_index
-          assign_failure start_index_var
-        end
-        builder.else_ do
-          assign_and_extend_result
-        end
-        end_comment(parent_expression)
-      end
-
-      def max
-        nil
-      end
-    end
-
-    class OccurrenceRange < Repetition
-      def compile(address, builder, parent_expression)
-        super
-
-        if min.empty? || min.text_value.to_i == 0
-          assign_and_extend_result
-        else
-          # We got some, but fewer than we wanted. There'll be a failure reported already
-          builder.if__ "#{accumulator_var}.size < #{min.text_value}" do
-            reset_index
-            assign_failure start_index_var
-          end
-          builder.else_ do
-            assign_and_extend_result
-          end
-        end
-        end_comment(parent_expression)
-      end
-    end
-
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/sequence.rb

@@ -1,71 +0,0 @@
-module Treetop
-  module Compiler    
-    class Sequence < ParsingExpression
-      def compile(address, builder, parent_expression = nil)
-        super
-        begin_comment(self)
-        use_vars :result, :start_index, :accumulator
-        compile_sequence_elements(sequence_elements)
-        builder.if__ "#{accumulator_var}.last" do
-          assign_result "instantiate_node(#{node_class_name},input, #{start_index_var}...index, #{accumulator_var})"
-          extend_result sequence_element_accessor_module_name if sequence_element_accessor_module_name
-          extend_result_with_inline_module
-        end
-        builder.else_ do
-          reset_index
-          assign_failure start_index_var
-        end
-        end_comment(self)
-      end
-      
-      def node_class_name
-        node_class_declarations.node_class_name || 'SyntaxNode'
-      end
-      
-      def compile_sequence_elements(elements)
-        obtain_new_subexpression_address
-        elements.first.compile(subexpression_address, builder)
-        accumulate_subexpression_result
-        if elements.size > 1
-          builder.if_ subexpression_success? do
-            compile_sequence_elements(elements[1..-1])
-          end
-        end
-      end
-      
-      def sequence_element_accessor_module
-        @sequence_element_accessor_module ||= SequenceElementAccessorModule.new(sequence_elements)
-      end
-      
-      def sequence_element_accessor_module_name
-        sequence_element_accessor_module.module_name
-      end
-    end
-    
-    class SequenceElementAccessorModule
-      include InlineModuleMixin   
-      attr_reader :sequence_elements
-      
-      def initialize(sequence_elements)
-        @sequence_elements = sequence_elements
-      end
-      
-      def compile(idx, builder, rule)
-        super
-        builder.module_declaration(module_name) do
-          elements_by_name = sequence_elements.inject({}){|h,e| (h[e.label_name.to_s] ||= []) << e; h}
-          sequence_elements.each_with_index do |element, index|
-            if element.label_name
-              repetitions = elements_by_name[element.label_name.to_s]
-              label_name = element.label_name + (repetitions.size > 1 ? (repetitions.index(element)+1).to_s : "")
-              builder.method_declaration(label_name) do
-                builder << "elements[#{index}]"
-              end
-              builder.newline unless index == sequence_elements.size - 1
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/terminal.rb

@@ -1,20 +0,0 @@
-module Treetop
-  module Compiler    
-    class Terminal < AtomicExpression
-      def compile(address, builder, parent_expression = nil)
-        super
-        string_length = eval(text_value).length
-        
-        builder.if__ "has_terminal?(#{text_value}, false, index)" do
-          assign_result "instantiate_node(#{node_class_name},input, index...(index + #{string_length}))"
-          extend_result_with_inline_module
-          builder << "@index += #{string_length}"
-        end
-        builder.else_ do
-          builder << "terminal_parse_failure(#{text_value})"
-          assign_result 'nil'
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/transient_prefix.rb

@@ -1,9 +0,0 @@
-module Treetop
-  module Compiler
-    class TransientPrefix < ParsingExpression
-      def compile(address, builder, parent_expression)
-        parent_expression.prefixed_expression.compile(address, builder)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes/treetop_file.rb

@@ -1,9 +0,0 @@
-module Treetop
-  module Compiler
-    class TreetopFile < Runtime::SyntaxNode
-      def compile
-        (elements.map {|elt| elt.compile}).join
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/node_classes.rb

@@ -1,19 +0,0 @@
-require 'treetop/compiler/node_classes/parsing_expression'
-require 'treetop/compiler/node_classes/atomic_expression'
-require 'treetop/compiler/node_classes/inline_module'
-require 'treetop/compiler/node_classes/predicate_block'
-require 'treetop/compiler/node_classes/treetop_file'
-require 'treetop/compiler/node_classes/grammar'
-require 'treetop/compiler/node_classes/declaration_sequence'
-require 'treetop/compiler/node_classes/parsing_rule'
-require 'treetop/compiler/node_classes/parenthesized_expression'
-require 'treetop/compiler/node_classes/nonterminal'
-require 'treetop/compiler/node_classes/terminal'
-require 'treetop/compiler/node_classes/anything_symbol'
-require 'treetop/compiler/node_classes/character_class'
-require 'treetop/compiler/node_classes/sequence'
-require 'treetop/compiler/node_classes/choice'
-require 'treetop/compiler/node_classes/repetition'
-require 'treetop/compiler/node_classes/optional'
-require 'treetop/compiler/node_classes/predicate'
-require 'treetop/compiler/node_classes/transient_prefix'

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler/ruby_builder.rb

@@ -1,115 +0,0 @@
-require 'treetop/ruby_extensions/string'
-
-module Treetop
-  module Compiler
-    class RubyBuilder
-      
-      attr_reader :level, :address_space, :ruby
-      
-      def initialize
-        @level = 0
-        @address_space = LexicalAddressSpace.new
-        @ruby = ""
-      end
-      
-      def <<(ruby_line)              
-        return if ruby_line.blank?
-        ruby << ruby_line.tabto(level) << "\n"
-      end
-
-      def newline
-        ruby << "\n"
-      end
-      
-      def indented(depth = 2)
-        self.in(depth)
-        yield
-        self.out(depth)
-      end
-            
-      def class_declaration(name, &block)
-        self << "class #{name}"
-        indented(&block)
-        self << "end"
-      end
-      
-      def module_declaration(name, &block)
-        self << "module #{name}"
-        indented(&block)
-        self << "end"
-      end
-      
-      def method_declaration(name, &block)
-        self << "def #{name}"
-        indented(&block)
-        self << "end"
-      end
-      
-      def assign(left, right)
-        if left.instance_of? Array
-          self << "#{left.join(', ')} = #{right.join(', ')}"
-        else
-          self << "#{left} = #{right}"
-        end
-      end
-      
-      def extend(var, module_name)
-        self << "#{var}.extend(#{module_name})"
-      end
-      
-      def accumulate(left, right)
-        self << "#{left} << #{right}"
-      end
-      
-      def if__(condition, &block)
-        self << "if #{condition}"
-        indented(&block)
-      end
-      
-      def if_(condition, &block)
-        if__(condition, &block)
-        self << 'end'
-      end
-      
-      def else_(&block)
-        self << 'else'
-        indented(&block)
-        self << 'end'
-      end
-      
-      def loop(&block)
-        self << 'loop do'
-        indented(&block)
-        self << 'end'
-      end
-      
-      def break
-        self << 'break'
-      end
-      
-      def in(depth = 2)
-        @level += depth
-        self
-      end
-      
-      def out(depth = 2)
-        @level -= depth
-        self
-      end
-      
-      def next_address
-        address_space.next_address
-      end
-      
-      def reset_addresses
-        address_space.reset_addresses
-      end
-      
-      private
-      
-      def indent
-        " " * level
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/compiler.rb

@@ -1,7 +0,0 @@
-require 'treetop/ruby_extensions'
-
-require 'treetop/compiler/lexical_address_space'
-require 'treetop/compiler/ruby_builder'
-require 'treetop/compiler/node_classes'
-require 'treetop/compiler/metagrammar' unless defined?($exclude_metagrammar)
-require 'treetop/compiler/grammar_compiler'

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/polyglot.rb

@@ -1,9 +0,0 @@
-module Treetop
-  module Polyglot
-    VALID_GRAMMAR_EXT = ['treetop', 'tt']
-    VALID_GRAMMAR_EXT_REGEXP = /\.(#{VALID_GRAMMAR_EXT.join('|')})\Z/o
-  end
-end
-
-require 'polyglot'
-Polyglot.register(Treetop::Polyglot::VALID_GRAMMAR_EXT, Treetop)

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/ruby_extensions/string.rb

@@ -1,40 +0,0 @@
-class String
-  def column_of(index)
-    return 1 if index == 0
-    newline_index = rindex("\n", index - 1)
-    if newline_index
-      index - newline_index
-    else
-      index + 1
-    end
-  end
-  
-  def line_of(index)
-    self[0...index].count("\n") + 1
-  end
-
-  unless method_defined?(:blank?)
-    def blank?
-      self == ""
-    end
-  end
-
-  # The following methods are lifted from Facets 2.0.2
-  def tabto(n)
-    if self =~ /^( *)\S/
-      # Inlined due to collision with ActiveSupport 4.0: indent(n - $1.length)
-      m = n - $1.length
-      if m >= 0
-        gsub(/^/, ' ' * m)
-      else
-        gsub(/^ {0,#{-m}}/, "")
-      end
-    else
-      self
-    end
-  end
-
-  def treetop_camelize
-    to_s.gsub(/\/(.?)/){ "::" + $1.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/treetop-1.4.15/lib/treetop/ruby_extensions.rb

@@ -1 +0,0 @@
-require 'treetop/ruby_extensions/string'