primary_connect_proto 0.1.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/coderay-1.1.3/lib/coderay/scanners/java_script.rb

@@ -1,236 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Scanner for JavaScript.
-  # 
-  # Aliases: +ecmascript+, +ecma_script+, +javascript+
-  class JavaScript < Scanner
-    
-    register_for :java_script
-    file_extension 'js'
-    
-    # The actual JavaScript keywords.
-    KEYWORDS = %w[
-      break case catch continue default delete do else
-      finally for function if in instanceof new
-      return switch throw try typeof var void while with
-    ]  # :nodoc:
-    PREDEFINED_CONSTANTS = %w[
-      false null true undefined NaN Infinity
-    ]  # :nodoc:
-    
-    MAGIC_VARIABLES = %w[ this arguments ]  # :nodoc: arguments was introduced in JavaScript 1.4
-    
-    KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
-      case delete in instanceof new return throw typeof with
-    ]  # :nodoc:
-    
-    # Reserved for future use.
-    RESERVED_WORDS = %w[
-      abstract boolean byte char class debugger double enum export extends
-      final float goto implements import int interface long native package
-      private protected public short static super synchronized throws transient
-      volatile
-    ]  # :nodoc:
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_CONSTANTS, :predefined_constant).
-      add(MAGIC_VARIABLES, :local_variable).
-      add(KEYWORDS, :keyword)  # :nodoc:
-    
-    ESCAPE = / [bfnrtv\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:
-    REGEXP_ESCAPE = / [bBdDsSwW] /x  # :nodoc:
-    STRING_CONTENT_PATTERN = {
-      "'" => /[^\\']+/,
-      '"' => /[^\\"]+/,
-      '/' => /[^\\\/]+/,
-    }  # :nodoc:
-    KEY_CHECK_PATTERN = {
-      "'" => / (?> [^\\']* (?: \\. [^\\']* )* ) ' \s* : /mx,
-      '"' => / (?> [^\\"]* (?: \\. [^\\"]* )* ) " \s* : /mx,
-    }  # :nodoc:
-    
-  protected
-    
-    def setup
-      @state = :initial
-    end
-    
-    def scan_tokens encoder, options
-      
-      state, string_delimiter = options[:state] || @state
-      if string_delimiter
-        encoder.begin_group state
-      end
-      
-      value_expected = true
-      key_expected = false
-      function_expected = false
-      
-      until eos?
-        
-        case state
-          
-        when :initial
-          
-          if match = scan(/ \s+ | \\\n /x)
-            value_expected = true if !value_expected && match.index(?\n)
-            encoder.text_token match, :space
-            
-          elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .*() ) !mx)
-            value_expected = true
-            encoder.text_token match, :comment
-            state = :open_multi_line_comment if self[1]
-            
-          elsif check(/\.?\d/)
-            key_expected = value_expected = false
-            if match = scan(/0[xX][0-9A-Fa-f]+/)
-              encoder.text_token match, :hex
-            elsif match = scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              encoder.text_token match, :octal
-            elsif match = scan(/\d+[fF]|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-              encoder.text_token match, :float
-            elsif match = scan(/\d+/)
-              encoder.text_token match, :integer
-            end
-            
-          elsif value_expected && match = scan(/<([[:alpha:]]\w*) (?: [^\/>]*\/> | .*?<\/\1>)/xim)
-            # TODO: scan over nested tags
-            xml_scanner.tokenize match, :tokens => encoder
-            value_expected = false
-            
-          elsif match = scan(/ [-+*=<>?:;,!&^|(\[{~%]+ | \.(?!\d) /x)
-            value_expected = true
-            last_operator = match[-1]
-            key_expected = (last_operator == ?{) || (last_operator == ?,)
-            function_expected = false
-            encoder.text_token match, :operator
-            
-          elsif match = scan(/ [)\]}]+ /x)
-            function_expected = key_expected = value_expected = false
-            encoder.text_token match, :operator
-            
-          elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
-            kind = IDENT_KIND[match]
-            value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
-            # TODO: labels
-            if kind == :ident
-              if match.index(?$)  # $ allowed inside an identifier
-                kind = :predefined
-              elsif function_expected
-                kind = :function
-              elsif check(/\s*[=:]\s*function\b/)
-                kind = :function
-              elsif key_expected && check(/\s*:/)
-                kind = :key
-              end
-            end
-            function_expected = (kind == :keyword) && (match == 'function')
-            key_expected = false
-            encoder.text_token match, kind
-            
-          elsif match = scan(/["']/)
-            if key_expected && check(KEY_CHECK_PATTERN[match])
-              state = :key
-            else
-              state = :string
-            end
-            encoder.begin_group state
-            string_delimiter = match
-            encoder.text_token match, :delimiter
-            
-          elsif value_expected && (match = scan(/\//))
-            encoder.begin_group :regexp
-            state = :regexp
-            string_delimiter = '/'
-            encoder.text_token match, :delimiter
-            
-          elsif match = scan(/ \/ /x)
-            value_expected = true
-            key_expected = false
-            encoder.text_token match, :operator
-            
-          else
-            encoder.text_token getch, :error
-            
-          end
-          
-        when :string, :regexp, :key
-          if match = scan(STRING_CONTENT_PATTERN[string_delimiter])
-            encoder.text_token match, :content
-          elsif match = scan(/["'\/]/)
-            encoder.text_token match, :delimiter
-            if state == :regexp
-              modifiers = scan(/[gim]+/)
-              encoder.text_token modifiers, :modifier if modifiers && !modifiers.empty?
-            end
-            encoder.end_group state
-            string_delimiter = nil
-            key_expected = value_expected = false
-            state = :initial
-          elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
-              encoder.text_token match, :content
-            else
-              encoder.text_token match, :char
-            end
-          elsif state == :regexp && match = scan(/ \\ (?: #{ESCAPE} | #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            encoder.text_token match, :char
-          elsif match = scan(/\\./m)
-            encoder.text_token match, :content
-          elsif match = scan(/ \\ | $ /x)
-            encoder.end_group state
-            encoder.text_token match, :error unless match.empty?
-            string_delimiter = nil
-            key_expected = value_expected = false
-            state = :initial
-          else
-            raise_inspect "else case #{string_delimiter} reached; %p not handled." % peek(1), encoder
-          end
-          
-        when :open_multi_line_comment
-          if match = scan(%r! .*? \*/ !mx)
-            state = :initial
-          else
-            match = scan(%r! .+ !mx)
-          end
-          value_expected = true
-          encoder.text_token match, :comment if match
-          
-        else
-          #:nocov:
-          raise_inspect 'Unknown state: %p' % [state], encoder
-          #:nocov:
-          
-        end
-        
-      end
-      
-      if options[:keep_state]
-        @state = state, string_delimiter
-      end
-      
-      if [:string, :regexp].include? state
-        encoder.end_group state
-      end
-      
-      encoder
-    end
-    
-  protected
-    
-    def reset_instance
-      super
-      @xml_scanner.reset if defined? @xml_scanner
-    end
-    
-    def xml_scanner
-      @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => false
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.6.0/gems/coderay-1.1.3/lib/coderay/scanners/json.rb

@@ -1,98 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Scanner for JSON (JavaScript Object Notation).
-  class JSON < Scanner
-    
-    register_for :json
-    file_extension 'json'
-    
-    KINDS_NOT_LOC = [
-      :float, :char, :content, :delimiter,
-      :error, :integer, :operator, :value,
-    ]  # :nodoc:
-    
-    ESCAPE = / [bfnrt\\"\/] /x  # :nodoc:
-    UNICODE_ESCAPE = / u[a-fA-F0-9]{4} /x  # :nodoc:
-    KEY = / (?> (?: [^\\"]+ | \\. )* ) " \s* : /x
-    
-  protected
-    
-    def setup
-      @state = :initial
-    end
-    
-    # See http://json.org/ for a definition of the JSON lexic/grammar.
-    def scan_tokens encoder, options
-      state = options[:state] || @state
-      
-      if [:string, :key].include? state
-        encoder.begin_group state
-      end
-      
-      until eos?
-        
-        case state
-        
-        when :initial
-          if match = scan(/ \s+ /x)
-            encoder.text_token match, :space
-          elsif match = scan(/"/)
-            state = check(/#{KEY}/o) ? :key : :string
-            encoder.begin_group state
-            encoder.text_token match, :delimiter
-          elsif match = scan(/ [:,\[{\]}] /x)
-            encoder.text_token match, :operator
-          elsif match = scan(/ true | false | null /x)
-            encoder.text_token match, :value
-          elsif match = scan(/ -? (?: 0 | [1-9]\d* ) /x)
-            if scan(/ \.\d+ (?:[eE][-+]?\d+)? | [eE][-+]? \d+ /x)
-              match << matched
-              encoder.text_token match, :float
-            else
-              encoder.text_token match, :integer
-            end
-          else
-            encoder.text_token getch, :error
-          end
-          
-        when :string, :key
-          if match = scan(/[^\\"]+/)
-            encoder.text_token match, :content
-          elsif match = scan(/"/)
-            encoder.text_token match, :delimiter
-            encoder.end_group state
-            state = :initial
-          elsif match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            encoder.text_token match, :char
-          elsif match = scan(/\\./m)
-            encoder.text_token match, :content
-          elsif match = scan(/ \\ | $ /x)
-            encoder.end_group state
-            encoder.text_token match, :error unless match.empty?
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), encoder
-          end
-          
-        else
-          raise_inspect 'Unknown state: %p' % [state], encoder
-          
-        end
-      end
-      
-      if options[:keep_state]
-        @state = state
-      end
-      
-      if [:string, :key].include? state
-        encoder.end_group state
-      end
-      
-      encoder
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/ruby/2.6.0/gems/coderay-1.1.3/lib/coderay/scanners/lua.rb

@@ -1,280 +0,0 @@
-# encoding: utf-8
-
-module CodeRay
-module Scanners
-
-  # Scanner for the Lua[http://lua.org] programming lanuage.
-  #
-  # The language’s complete syntax is defined in
-  # {the Lua manual}[http://www.lua.org/manual/5.2/manual.html],
-  # which is what this scanner tries to conform to.
-  class Lua < Scanner
-    
-    register_for :lua
-    file_extension 'lua'
-    title 'Lua'
-    
-    # Keywords used in Lua.
-    KEYWORDS = %w[and break do else elseif end
-      for function goto if in
-      local not or repeat return
-      then until while
-    ]
-    
-    # Constants set by the Lua core.
-    PREDEFINED_CONSTANTS = %w[false true nil]
-    
-    # The expressions contained in this array are parts of Lua’s `basic'
-    # library. Although it’s not entirely necessary to load that library,
-    # it is highly recommended and one would have to provide own implementations
-    # of some of these expressions if one does not do so. They however aren’t
-    # keywords, neither are they constants, but nearly predefined, so they
-    # get tagged as `predefined' rather than anything else.
-    #
-    # This list excludes values of form `_UPPERCASE' because the Lua manual
-    # requires such identifiers to be reserved by Lua anyway and they are
-    # highlighted directly accordingly, without the need for specific
-    # identifiers to be listed here.
-    PREDEFINED_EXPRESSIONS = %w[
-      assert collectgarbage dofile error getmetatable
-      ipairs load loadfile next pairs pcall print
-      rawequal rawget rawlen rawset select setmetatable
-      tonumber tostring type xpcall
-    ]
-    
-    # Automatic token kind selection for normal words.
-    IDENT_KIND = CodeRay::WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(PREDEFINED_CONSTANTS, :predefined_constant).
-      add(PREDEFINED_EXPRESSIONS, :predefined)
-    
-    protected
-    
-    # Scanner initialization.
-    def setup
-      @state = :initial
-      @brace_depth = 0
-    end
-    
-    # CodeRay entry hook. Starts parsing.
-    def scan_tokens(encoder, options)
-      state = options[:state] || @state
-      brace_depth = @brace_depth
-      num_equals = nil
-      
-      until eos?
-        case state
-        
-        when :initial
-          if match = scan(/\-\-\[\=*\[/)   #--[[ long (possibly multiline) comment ]]
-            num_equals = match.count("=") # Number must match for comment end
-            encoder.begin_group(:comment)
-            encoder.text_token(match, :delimiter)
-            state = :long_comment
-          
-          elsif match = scan(/--.*$/) # --Lua comment
-            encoder.text_token(match, :comment)
-          
-          elsif match = scan(/\[=*\[/)     # [[ long (possibly multiline) string ]]
-            num_equals = match.count("=") # Number must match for string end
-            encoder.begin_group(:string)
-            encoder.text_token(match, :delimiter)
-            state = :long_string
-          
-          elsif match = scan(/::\s*[a-zA-Z_][a-zA-Z0-9_]+\s*::/) # ::goto_label::
-            encoder.text_token(match, :label)
-          
-          elsif match = scan(/_[A-Z]+/) # _UPPERCASE are names reserved for Lua
-            encoder.text_token(match, :predefined)
-          
-          elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/) # Normal letters (or letters followed by digits)
-            kind = IDENT_KIND[match]
-            
-            # Extra highlighting for entities following certain keywords
-            if kind == :keyword and match == "function"
-              state = :function_expected
-            elsif kind == :keyword and match == "goto"
-              state = :goto_label_expected
-            elsif kind == :keyword and match == "local"
-              state = :local_var_expected
-            end
-            
-            encoder.text_token(match, kind)
-          
-          elsif match = scan(/\{/) # Opening table brace {
-            encoder.begin_group(:map)
-            encoder.text_token(match, brace_depth >= 1 ? :inline_delimiter : :delimiter)
-            brace_depth += 1
-            state        = :map
-          
-          elsif match = scan(/\}/) # Closing table brace }
-            if brace_depth == 1
-              brace_depth = 0
-              encoder.text_token(match, :delimiter)
-              encoder.end_group(:map)
-            elsif brace_depth == 0 # Mismatched brace
-              encoder.text_token(match, :error)
-            else
-              brace_depth -= 1
-              encoder.text_token(match, :inline_delimiter)
-              encoder.end_group(:map)
-              state = :map
-            end
-          
-          elsif match = scan(/["']/) # String delimiters " and '
-            encoder.begin_group(:string)
-            encoder.text_token(match, :delimiter)
-            start_delim = match
-            state       = :string
-          
-                            # ↓Prefix                hex number ←|→ decimal number
-          elsif match = scan(/-? (?:0x\h* \. \h+ (?:p[+\-]?\d+)? | \d*\.\d+ (?:e[+\-]?\d+)?)/ix) # hexadecimal constants have no E power, decimal ones no P power
-            encoder.text_token(match, :float)
-          
-                            # ↓Prefix         hex number ←|→ decimal number
-          elsif match = scan(/-? (?:0x\h+ (?:p[+\-]?\d+)? | \d+ (?:e[+\-]?\d+)?)/ix) # hexadecimal constants have no E power, decimal ones no P power
-            encoder.text_token(match, :integer)
-          
-          elsif match = scan(/[\+\-\*\/%^\#=~<>\(\)\[\]:;,] | \.(?!\d)/x) # Operators
-            encoder.text_token(match, :operator)
-          
-          elsif match = scan(/\s+/) # Space
-            encoder.text_token(match, :space)
-          
-          else # Invalid stuff. Note that Lua doesn’t accept multibyte chars outside of strings, hence these are also errors.
-            encoder.text_token(getch, :error)
-          end
-          
-          # It may be that we’re scanning a full-blown subexpression of a table
-          # (tables can contain full expressions in parts).
-          # If this is the case, return to :map scanning state.
-          state = :map if state == :initial && brace_depth >= 1
-        
-        when :function_expected
-          if match = scan(/\(.*?\)/m) # x = function() # "Anonymous" function without explicit name
-            encoder.text_token(match, :operator)
-            state = :initial
-          elsif match = scan(/[a-zA-Z_] (?:[a-zA-Z0-9_\.] (?!\.\d))* [\.\:]/x) # function tbl.subtbl.foo() | function tbl:foo() # Colon only allowed as last separator
-            encoder.text_token(match, :ident)
-          elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/) # function foo()
-            encoder.text_token(match, :function)
-            state = :initial
-          elsif match = scan(/\s+/) # Between the `function' keyword and the ident may be any amount of whitespace
-            encoder.text_token(match, :space)
-          else
-            encoder.text_token(getch, :error)
-            state = :initial
-          end
-        
-        when :goto_label_expected
-          if match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
-            encoder.text_token(match, :label)
-            state = :initial
-          elsif match = scan(/\s+/) # Between the `goto' keyword and the label may be any amount of whitespace
-            encoder.text_token(match, :space)
-          else
-            encoder.text_token(getch, :error)
-          end
-        
-        when :local_var_expected
-          if match = scan(/function/) # local function ...
-            encoder.text_token(match, :keyword)
-            state = :function_expected
-          elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
-            encoder.text_token(match, :local_variable)
-          elsif match = scan(/,/)
-            encoder.text_token(match, :operator)
-          elsif match = scan(/\=/)
-            encoder.text_token(match, :operator)
-            # After encountering the equal sign, arbitrary expressions are
-            # allowed again, so just return to the main state for further
-            # parsing.
-            state = :initial
-          elsif match = scan(/\n/)
-            encoder.text_token(match, :space)
-            state = :initial
-          elsif match = scan(/\s+/)
-            encoder.text_token(match, :space)
-          else
-            encoder.text_token(getch, :error)
-          end
-        
-        when :long_comment
-          if match = scan(/.*?(?=\]={#{num_equals}}\])/m)
-            encoder.text_token(match, :content)
-            
-            delim = scan(/\]={#{num_equals}}\]/)
-            encoder.text_token(delim, :delimiter)
-          else # No terminator found till EOF
-            encoder.text_token(rest, :error)
-            terminate
-          end
-          encoder.end_group(:comment)
-          state = :initial
-        
-        when :long_string
-          if match = scan(/.*?(?=\]={#{num_equals}}\])/m) # Long strings do not interpret any escape sequences
-            encoder.text_token(match, :content)
-            
-            delim = scan(/\]={#{num_equals}}\]/)
-            encoder.text_token(delim, :delimiter)
-          else # No terminator found till EOF
-            encoder.text_token(rest, :error)
-            terminate
-          end
-          encoder.end_group(:string)
-          state = :initial
-        
-        when :string
-          if match = scan(/[^\\#{start_delim}\n]+/) # Everything except \ and the start delimiter character is string content (newlines are only allowed if preceeded by \ or \z)
-            encoder.text_token(match, :content)
-          elsif match = scan(/\\(?:['"abfnrtv\\]|z\s*|x\h\h|\d{1,3}|\n)/m)
-            encoder.text_token(match, :char)
-          elsif match = scan(Regexp.compile(start_delim))
-            encoder.text_token(match, :delimiter)
-            encoder.end_group(:string)
-            state = :initial
-          elsif match = scan(/\n/) # Lua forbids unescaped newlines in normal non-long strings
-            encoder.text_token("\\n\n", :error) # Visually appealing error indicator--otherwise users may wonder whether the highlighter cannot highlight multine strings
-            encoder.end_group(:string)
-            state = :initial
-          else
-            encoder.text_token(getch, :error)
-          end
-        
-        when :map
-          if match = scan(/[,;]/)
-            encoder.text_token(match, :operator)
-          elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]* (?=\s*=)/x)
-            encoder.text_token(match, :key)
-            encoder.text_token(scan(/\s+/), :space) if check(/\s+/)
-            encoder.text_token(scan(/\=/), :operator)
-            state = :initial
-          elsif match = scan(/\s+/m)
-            encoder.text_token(match, :space)
-          else
-            # Note this clause doesn’t advance the scan pointer, it’s a kind of
-            # "retry with other options" (the :initial state then of course
-            # advances the pointer).
-            state = :initial
-          end
-        else
-          raise
-        end
-        
-      end
-      
-      if options[:keep_state]
-        @state = state
-      end
-      
-      encoder.end_group :string if [:string].include? state
-      brace_depth.times { encoder.end_group :map }
-      
-      encoder
-    end
-    
-  end
-  
-end
-end