logstash-input-beats 0.9.2 → 0.9.3

data/vendor/jruby/1.9/gems/coderay-1.1.0/lib/coderay/scanner.rb

@@ -1,355 +0,0 @@
-# encoding: utf-8
-require 'strscan'
-
-module CodeRay
-  
-  autoload :WordList, coderay_path('helpers', 'word_list')
-  
-  # = Scanners
-  #
-  # This module holds the Scanner class and its subclasses.
-  # For example, the Ruby scanner is named CodeRay::Scanners::Ruby
-  # can be found in coderay/scanners/ruby.
-  #
-  # Scanner also provides methods and constants for the register
-  # mechanism and the [] method that returns the Scanner class
-  # belonging to the given lang.
-  #
-  # See PluginHost.
-  module Scanners
-    extend PluginHost
-    plugin_path File.dirname(__FILE__), 'scanners'
-    
-    
-    # = Scanner
-    #
-    # The base class for all Scanners.
-    #
-    # It is a subclass of Ruby's great +StringScanner+, which
-    # makes it easy to access the scanning methods inside.
-    #
-    # It is also +Enumerable+, so you can use it like an Array of
-    # Tokens:
-    #
-    #   require 'coderay'
-    #   
-    #   c_scanner = CodeRay::Scanners[:c].new "if (*p == '{') nest++;"
-    #   
-    #   for text, kind in c_scanner
-    #     puts text if kind == :operator
-    #   end
-    #   
-    #   # prints: (*==)++;
-    #
-    # OK, this is a very simple example :)
-    # You can also use +map+, +any?+, +find+ and even +sort_by+,
-    # if you want.
-    class Scanner < StringScanner
-      
-      extend Plugin
-      plugin_host Scanners
-      
-      # Raised if a Scanner fails while scanning
-      ScanError = Class.new StandardError
-      
-      # The default options for all scanner classes.
-      #
-      # Define @default_options for subclasses.
-      DEFAULT_OPTIONS = { }
-      
-      KINDS_NOT_LOC = [:comment, :doctype, :docstring]
-      
-      attr_accessor :state
-      
-      class << self
-        
-        # Normalizes the given code into a string with UNIX newlines, in the
-        # scanner's internal encoding, with invalid and undefined charachters
-        # replaced by placeholders. Always returns a new object.
-        def normalize code
-          # original = code
-          code = code.to_s unless code.is_a? ::String
-          return code if code.empty?
-          
-          if code.respond_to? :encoding
-            code = encode_with_encoding code, self.encoding
-          else
-            code = to_unix code
-          end
-          # code = code.dup if code.eql? original
-          code
-        end
-        
-        # The typical filename suffix for this scanner's language.
-        def file_extension extension = lang
-          @file_extension ||= extension.to_s
-        end
-        
-        # The encoding used internally by this scanner.
-        def encoding name = 'UTF-8'
-          @encoding ||= defined?(Encoding.find) && Encoding.find(name)
-        end
-        
-        # The lang of this Scanner class, which is equal to its Plugin ID.
-        def lang
-          @plugin_id
-        end
-        
-      protected
-        
-        def encode_with_encoding code, target_encoding
-          if code.encoding == target_encoding
-            if code.valid_encoding?
-              return to_unix(code)
-            else
-              source_encoding = guess_encoding code
-            end
-          else
-            source_encoding = code.encoding
-          end
-          # print "encode_with_encoding from #{source_encoding} to #{target_encoding}"
-          code.encode target_encoding, source_encoding, :universal_newline => true, :undef => :replace, :invalid => :replace
-        end
-        
-        def to_unix code
-          code.index(?\r) ? code.gsub(/\r\n?/, "\n") : code
-        end
-        
-        def guess_encoding s
-          #:nocov:
-          IO.popen("file -b --mime -", "w+") do |file|
-            file.write s[0, 1024]
-            file.close_write
-            begin
-              Encoding.find file.gets[/charset=([-\w]+)/, 1]
-            rescue ArgumentError
-              Encoding::BINARY
-            end
-          end
-          #:nocov:
-        end
-        
-      end
-      
-      # Create a new Scanner.
-      #
-      # * +code+ is the input String and is handled by the superclass
-      #   StringScanner.
-      # * +options+ is a Hash with Symbols as keys.
-      #   It is merged with the default options of the class (you can
-      #   overwrite default options here.)
-      #
-      # Else, a Tokens object is used.
-      def initialize code = '', options = {}
-        if self.class == Scanner
-          raise NotImplementedError, "I am only the basic Scanner class. I can't scan anything. :( Use my subclasses."
-        end
-        
-        @options = self.class::DEFAULT_OPTIONS.merge options
-        
-        super self.class.normalize(code)
-        
-        @tokens = options[:tokens] || Tokens.new
-        @tokens.scanner = self if @tokens.respond_to? :scanner=
-        
-        setup
-      end
-      
-      # Sets back the scanner. Subclasses should redefine the reset_instance
-      # method instead of this one.
-      def reset
-        super
-        reset_instance
-      end
-      
-      # Set a new string to be scanned.
-      def string= code
-        code = self.class.normalize(code)
-        super code
-        reset_instance
-      end
-      
-      # the Plugin ID for this scanner
-      def lang
-        self.class.lang
-      end
-      
-      # the default file extension for this scanner
-      def file_extension
-        self.class.file_extension
-      end
-      
-      # Scan the code and returns all tokens in a Tokens object.
-      def tokenize source = nil, options = {}
-        options = @options.merge(options)
-        
-        set_tokens_from_options options
-        set_string_from_source source
-        
-        begin
-          scan_tokens @tokens, options
-        rescue => e
-          message = "Error in %s#scan_tokens, initial state was: %p" % [self.class, defined?(state) && state]
-          raise_inspect e.message, @tokens, message, 30, e.backtrace
-        end
-        
-        @cached_tokens = @tokens
-        if source.is_a? Array
-          @tokens.split_into_parts(*source.map { |part| part.size })
-        else
-          @tokens
-        end
-      end
-      
-      # Cache the result of tokenize.
-      def tokens
-        @cached_tokens ||= tokenize
-      end
-      
-      # Traverse the tokens.
-      def each &block
-        tokens.each(&block)
-      end
-      include Enumerable
-      
-      # The current line position of the scanner, starting with 1.
-      # See also: #column.
-      #
-      # Beware, this is implemented inefficiently. It should be used
-      # for debugging only.
-      def line pos = self.pos
-        return 1 if pos <= 0
-        binary_string[0...pos].count("\n") + 1
-      end
-      
-      # The current column position of the scanner, starting with 1.
-      # See also: #line.
-      def column pos = self.pos
-        return 1 if pos <= 0
-        pos - (binary_string.rindex(?\n, pos - 1) || -1)
-      end
-      
-      # The string in binary encoding.
-      # 
-      # To be used with #pos, which is the index of the byte the scanner
-      # will scan next.
-      def binary_string
-        @binary_string ||=
-          if string.respond_to?(:bytesize) && string.bytesize != string.size
-            #:nocov:
-            string.dup.force_encoding('binary')
-            #:nocov:
-          else
-            string
-          end
-      end
-      
-    protected
-      
-      # Can be implemented by subclasses to do some initialization
-      # that has to be done once per instance.
-      #
-      # Use reset for initialization that has to be done once per
-      # scan.
-      def setup  # :doc:
-      end
-      
-      def set_string_from_source source
-        case source
-        when Array
-          self.string = self.class.normalize(source.join)
-        when nil
-          reset
-        else
-          self.string = self.class.normalize(source)
-        end
-      end
-      
-      def set_tokens_from_options options
-        @tokens = options[:tokens] || @tokens || Tokens.new
-        @tokens.scanner = self if @tokens.respond_to? :scanner=
-      end
-      
-      # This is the central method, and commonly the only one a
-      # subclass implements.
-      #
-      # Subclasses must implement this method; it must return +tokens+
-      # and must only use Tokens#<< for storing scanned tokens!
-      def scan_tokens tokens, options  # :doc:
-        raise NotImplementedError, "#{self.class}#scan_tokens not implemented."
-      end
-      
-      # Resets the scanner.
-      def reset_instance
-        @tokens.clear if @tokens.respond_to?(:clear) && !@options[:keep_tokens]
-        @cached_tokens = nil
-        @binary_string = nil if defined? @binary_string
-      end
-      
-      SCAN_ERROR_MESSAGE = <<-MESSAGE
-
-
-***ERROR in %s: %s (after %s tokens)
-
-tokens:
-%s
-
-%s
-
-surrounding code:
-%p  ~~  %p
-
-
-***ERROR***
-
-      MESSAGE
-      
-      def raise_inspect_arguments message, tokens, state, ambit
-        return File.basename(caller[0]),
-          message,
-          tokens_size(tokens),
-          tokens_last(tokens, 10).map(&:inspect).join("\n"),
-          scanner_state_info(state),
-          binary_string[pos - ambit, ambit],
-          binary_string[pos, ambit]
-      end
-      
-      SCANNER_STATE_INFO = <<-INFO
-current line: %d  column: %d  pos: %d
-matched: %p  state: %p
-bol?: %p,  eos?: %p
-      INFO
-      
-      def scanner_state_info state
-        SCANNER_STATE_INFO % [
-          line, column, pos,
-          matched, state || 'No state given!',
-          bol?, eos?,
-        ]
-      end
-      
-      # Scanner error with additional status information
-      def raise_inspect message, tokens, state = self.state, ambit = 30, backtrace = caller
-        raise ScanError, SCAN_ERROR_MESSAGE % raise_inspect_arguments(message, tokens, state, ambit), backtrace
-      end
-      
-      def tokens_size tokens
-        tokens.size if tokens.respond_to?(:size)
-      end
-      
-      def tokens_last tokens, n
-        tokens.respond_to?(:last) ? tokens.last(n) : []
-      end
-      
-      # Shorthand for scan_until(/\z/).
-      # This method also avoids a JRuby 1.9 mode bug.
-      def scan_rest
-        rest = self.rest
-        terminate
-        rest
-      end
-      
-    end
-    
-  end
-end

data/vendor/jruby/1.9/gems/coderay-1.1.0/lib/coderay/scanners/_map.rb

@@ -1,24 +0,0 @@
-module CodeRay
-module Scanners
-  
-  map \
-    :'c++'       => :cpp,
-    :cplusplus   => :cpp,
-    :ecmascript  => :java_script,
-    :ecma_script => :java_script,
-    :rhtml       => :erb,
-    :eruby       => :erb,
-    :irb         => :ruby,
-    :javascript  => :java_script,
-    :js          => :java_script,
-    :pascal      => :delphi,
-    :patch       => :diff,
-    :plain       => :text,
-    :plaintext   => :text,
-    :xhtml       => :html,
-    :yml         => :yaml
-  
-  default :text
-  
-end
-end

data/vendor/jruby/1.9/gems/coderay-1.1.0/lib/coderay/scanners/c.rb

@@ -1,189 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Scanner for C.
-  class C < Scanner
-
-    register_for :c
-    file_extension 'c'
-    
-    KEYWORDS = [
-      'asm', 'break', 'case', 'continue', 'default', 'do',
-      'else', 'enum', 'for', 'goto', 'if', 'return',
-      'sizeof', 'struct', 'switch', 'typedef', 'union', 'while',
-      'restrict',  # added in C99
-    ]  # :nodoc:
-
-    PREDEFINED_TYPES = [
-      'int', 'long', 'short', 'char',
-      'signed', 'unsigned', 'float', 'double',
-      'bool', 'complex',  # added in C99
-    ]  # :nodoc:
-
-    PREDEFINED_CONSTANTS = [
-      'EOF', 'NULL',
-      'true', 'false',  # added in C99
-    ]  # :nodoc:
-    DIRECTIVES = [
-      'auto', 'extern', 'register', 'static', 'void',
-      'const', 'volatile',  # added in C89
-      'inline',  # added in C99
-    ]  # :nodoc:
-
-    IDENT_KIND = WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(PREDEFINED_TYPES, :predefined_type).
-      add(DIRECTIVES, :directive).
-      add(PREDEFINED_CONSTANTS, :predefined_constant)  # :nodoc:
-
-    ESCAPE = / [rbfntv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x  # :nodoc:
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x  # :nodoc:
-    
-  protected
-    
-    def scan_tokens encoder, options
-
-      state = :initial
-      label_expected = true
-      case_expected = false
-      label_expected_before_preproc_line = nil
-      in_preproc_line = false
-
-      until eos?
-
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            if in_preproc_line && match != "\\\n" && match.index(?\n)
-              in_preproc_line = false
-              label_expected = label_expected_before_preproc_line
-            end
-            encoder.text_token match, :space
-
-          elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            encoder.text_token match, :comment
-
-          elsif match = scan(/ [-+*=<>?:;,!&^|()\[\]{}~%]+ | \/=? | \.(?!\d) /x)
-            label_expected = match =~ /[;\{\}]/
-            if case_expected
-              label_expected = true if match == ':'
-              case_expected = false
-            end
-            encoder.text_token match, :operator
-
-          elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = IDENT_KIND[match]
-            if kind == :ident && label_expected && !in_preproc_line && scan(/:(?!:)/)
-              kind = :label
-              match << matched
-            else
-              label_expected = false
-              if kind == :keyword
-                case match
-                when 'case', 'default'
-                  case_expected = true
-                end
-              end
-            end
-            encoder.text_token match, kind
-
-          elsif match = scan(/L?"/)
-            encoder.begin_group :string
-            if match[0] == ?L
-              encoder.text_token 'L', :modifier
-              match = '"'
-            end
-            encoder.text_token match, :delimiter
-            state = :string
-
-          elsif match = scan(/ \# \s* if \s* 0 /x)
-            match << scan_until(/ ^\# (?:elif|else|endif) .*? $ | \z /xm) unless eos?
-            encoder.text_token match, :comment
-
-          elsif match = scan(/#[ \t]*(\w*)/)
-            encoder.text_token match, :preprocessor
-            in_preproc_line = true
-            label_expected_before_preproc_line = label_expected
-            state = :include_expected if self[1] == 'include'
-
-          elsif match = scan(/ L?' (?: [^\'\n\\] | \\ #{ESCAPE} )? '? /ox)
-            label_expected = false
-            encoder.text_token match, :char
-
-          elsif match = scan(/\$/)
-            encoder.text_token match, :ident
-          
-          elsif match = scan(/0[xX][0-9A-Fa-f]+/)
-            label_expected = false
-            encoder.text_token match, :hex
-
-          elsif match = scan(/(?:0[0-7]+)(?![89.eEfF])/)
-            label_expected = false
-            encoder.text_token match, :octal
-
-          elsif match = scan(/(?:\d+)(?![.eEfF])L?L?/)
-            label_expected = false
-            encoder.text_token match, :integer
-
-          elsif match = scan(/\d[fF]?|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-            label_expected = false
-            encoder.text_token match, :float
-
-          else
-            encoder.text_token getch, :error
-
-          end
-
-        when :string
-          if match = scan(/[^\\\n"]+/)
-            encoder.text_token match, :content
-          elsif match = scan(/"/)
-            encoder.text_token match, :delimiter
-            encoder.end_group :string
-            state = :initial
-            label_expected = false
-          elsif match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            encoder.text_token match, :char
-          elsif match = scan(/ \\ | $ /x)
-            encoder.end_group :string
-            encoder.text_token match, :error unless match.empty?
-            state = :initial
-            label_expected = false
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), encoder
-          end
-
-        when :include_expected
-          if match = scan(/<[^>\n]+>?|"[^"\n\\]*(?:\\.[^"\n\\]*)*"?/)
-            encoder.text_token match, :include
-            state = :initial
-
-          elsif match = scan(/\s+/)
-            encoder.text_token match, :space
-            state = :initial if match.index ?\n
-
-          else
-            state = :initial
-
-          end
-
-        else
-          raise_inspect 'Unknown state', encoder
-
-        end
-
-      end
-
-      if state == :string
-        encoder.end_group :string
-      end
-
-      encoder
-    end
-
-  end
-
-end
-end