rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/julia.rb

@@ -21,6 +21,8 @@ module Rouge
                             | NaN       | NaN16    | NaN32   | NaN64
                             | stdout    | stderr   | stdin   | devnull
                             | pi        | π        | ℯ       | im
+                            | ARGS      | C_NULL   | ENV     | ENDIAN_BOM
+                            | VERSION   | undef    | (LOAD|DEPOT)_PATH
                             )\b/x
 
       KEYWORDS            = /\b(?:
@@ -30,21 +32,137 @@ module Rouge
                             | const    | local  | global | using  | struct
                             | mutable struct    | abstract type   | finally
                             | begin    | do     | quote  | macro  | for outer
+                            | where
                             )\b/x
 
+      # NOTE: The list of types was generated automatically using the following script:
+      # using Pkg, InteractiveUtils
+      #
+      # allnames = [names(Core); names(Base, imported=true)]
+      #
+      # for stdlib in readdir(Pkg.Types.stdlib_dir())
+      #     mod = Symbol(basename(stdlib))
+      #     @eval begin
+      #         using $mod
+      #         append!(allnames, names($mod))
+      #     end
+      # end
+      #
+      # sort!(unique!(allnames))
+      #
+      # i = 1
+      # for sym in allnames
+      #     global i # needed at the top level, e.g. in the REPL
+      #     isdefined(Main, sym) || continue
+      #     getfield(which(Main, sym), sym) isa Type || continue
+      #     sym === :(=>) && continue # Actually an alias for Pair
+      #     print("| ", sym)
+      #     i % 3 == 0 ? println() : print(" ") # print 3 to a line
+      #     i += 1
+      # end
       TYPES               = /\b(?:
-                              Int         | UInt           | Int8
-                            | UInt8       | Int16          | UInt16
-                            | Int32       | UInt32         | Int64
-                            | UInt64      | Int128         | UInt128
-                            | Float16     | Float32        | Float64
-                            | Bool        | BigInt         | BigFloat
-                            | Complex     | ComplexF16     | ComplexF32
-                            | ComplexF64  | Missing        | Nothing
-                            | Char        | String         | SubString
-                            | Regex       | RegexMatch     | Any
-                            | Type        | DataType       | UnionAll
-                            | (Abstract)?(Array|Vector|Matrix|VecOrMat)
+                              ARPACKException | AbstractArray | AbstractChannel
+                            | AbstractChar | AbstractDict | AbstractDisplay
+                            | AbstractFloat | AbstractIrrational | AbstractLogger
+                            | AbstractMatrix | AbstractREPL | AbstractRNG
+                            | AbstractRange | AbstractSerializer | AbstractSet
+                            | AbstractSparseArray | AbstractSparseMatrix | AbstractSparseVector
+                            | AbstractString | AbstractUnitRange | AbstractVecOrMat
+                            | AbstractVector | AbstractWorkerPool | Adjoint
+                            | Any | ArgumentError | Array
+                            | AssertionError | Base64DecodePipe | Base64EncodePipe
+                            | BasicREPL | Bidiagonal | BigFloat
+                            | BigInt | BitArray | BitMatrix
+                            | BitSet | BitVector | Bool
+                            | BoundsError | BunchKaufman | CachingPool
+                            | CapturedException | CartesianIndex | CartesianIndices
+                            | Cchar | Cdouble | Cfloat
+                            | Channel | Char | Cholesky
+                            | CholeskyPivoted | Cint | Cintmax_t
+                            | Clong | Clonglong | ClusterManager
+                            | Cmd | Colon | Complex
+                            | ComplexF16 | ComplexF32 | ComplexF64
+                            | CompositeException | Condition | ConsoleLogger
+                            | Cptrdiff_t | Cshort | Csize_t
+                            | Cssize_t | Cstring | Cuchar
+                            | Cuint | Cuintmax_t | Culong
+                            | Culonglong | Cushort | Cvoid
+                            | Cwchar_t | Cwstring | DataType
+                            | Date | DateFormat | DatePeriod
+                            | DateTime | Day | DenseArray
+                            | DenseMatrix | DenseVecOrMat | DenseVector
+                            | Diagonal | Dict | DimensionMismatch
+                            | Dims | DivideError | DomainError
+                            | EOFError | Eigen | Enum
+                            | ErrorException | Exception | ExponentialBackOff
+                            | Expr | FDWatcher | Factorization
+                            | FileMonitor | Float16 | Float32
+                            | Float64 | FolderMonitor | Function
+                            | GeneralizedEigen | GeneralizedSVD | GeneralizedSchur
+                            | GenericArray | GenericDict | GenericSet
+                            | GenericString | GitConfig | GitRepo
+                            | GlobalRef | HMAC_CTX | HTML
+                            | Hermitian | Hessenberg | Hour
+                            | IO | IOBuffer | IOContext
+                            | IOStream | IPAddr | IPv4
+                            | IPv6 | IdDict | IndexCartesian
+                            | IndexLinear | IndexStyle | InexactError
+                            | InitError | Int | Int128
+                            | Int16 | Int32 | Int64
+                            | Int8 | Integer | InterruptException
+                            | InvalidStateException | Irrational | KeyError
+                            | LAPACKException | LDLt | LQ
+                            | LU | LinRange | LineEditREPL
+                            | LineNumberNode | LinearIndices | LoadError
+                            | LogLevel | LowerTriangular | MIME
+                            | Matrix | MersenneTwister | Method
+                            | MethodError | Microsecond | Millisecond
+                            | Minute | Missing | MissingException
+                            | Module | Month | NTuple
+                            | NamedTuple | Nanosecond | Nothing
+                            | NullLogger | Number | OrdinalRange
+                            | OutOfMemoryError | OverflowError | PackageMode
+                            | PackageSpec | Pair | PartialQuickSort
+                            | Period | PermutedDimsArray | Pipe
+                            | PollingFileWatcher | PosDefException | ProcessExitedException
+                            | Ptr | QR | QRPivoted
+                            | QuoteNode | RandomDevice | RankDeficientException
+                            | Rational | RawFD | ReadOnlyMemoryError
+                            | Real | ReentrantLock | Ref
+                            | Regex | RegexMatch | RemoteChannel
+                            | RemoteException | RoundingMode | SHA1_CTX
+                            | SHA224_CTX | SHA256_CTX | SHA2_224_CTX
+                            | SHA2_256_CTX | SHA2_384_CTX | SHA2_512_CTX
+                            | SHA384_CTX | SHA3_224_CTX | SHA3_256_CTX
+                            | SHA3_384_CTX | SHA3_512_CTX | SHA512_CTX
+                            | SVD | Schur | Second
+                            | SegmentationFault | Serializer | Set
+                            | SharedArray | SharedMatrix | SharedVector
+                            | Signed | SimpleLogger | SingularException
+                            | Some | SparseMatrixCSC | SparseVector
+                            | StackOverflowError | StepRange | StepRangeLen
+                            | StreamREPL | StridedArray | StridedMatrix
+                            | StridedVecOrMat | StridedVector | String
+                            | StringIndexError | SubArray | SubString
+                            | SubstitutionString | SymTridiagonal | Symbol
+                            | Symmetric | SystemError | TCPSocket
+                            | Task | TestSetException | Text
+                            | TextDisplay | Time | TimePeriod
+                            | TimeType | TimeZone | Timer
+                            | Transpose | Tridiagonal | Tuple
+                            | Type | TypeError | TypeVar
+                            | UDPSocket | UInt | UInt128
+                            | UInt16 | UInt32 | UInt64
+                            | UInt8 | UTC | UUID
+                            | UndefInitializer | UndefKeywordError | UndefRefError
+                            | UndefVarError | UniformScaling | Union
+                            | UnionAll | UnitLowerTriangular | UnitRange
+                            | UnitUpperTriangular | Unsigned | UpgradeLevel
+                            | UpperTriangular | Val | Vararg
+                            | VecElement | VecOrMat | Vector
+                            | VersionNumber | WeakKeyDict | WeakRef
+                            | Week | WorkerConfig | WorkerPool
+                            | Year
                             )\b/x
 
       OPERATORS           = / \+      | =        | -     | \*   | \/
@@ -58,109 +176,114 @@ module Rouge
                               | ::    | <:       | ->    | \?   | \.\*
                               | \.\^  | \.\\     | \.\/  | \\   | <
                               | >     | ÷        | >:    | :    | ===
-                              | !==
+                              | !==   | =>
                             /x
 
-      PUNCTUATION         = / [ \[ \] { } \( \) , ; @ ] /x
+      PUNCTUATION         = /[\[\]{}\(\),;]/
 
 
       state :root do
-        rule /\n/, Text
-        rule /[^\S\n]+/, Text
-        rule /#=/, Comment::Multiline, :blockcomment
-        rule /#.*$/, Comment
+        rule %r/\n/, Text
+        rule %r/[^\S\n]+/, Text
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/#.*$/, Comment
         rule OPERATORS, Operator
-        rule /\\\n/, Text
-        rule /\\/, Text
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
 
 
-        # functions
-        rule /(function)((?:\s|\\\s)+)/ do
+        # functions and macros
+        rule %r/(function|macro)((?:\s|\\\s)+)/ do
           groups Keyword, Name::Function
           push :funcname
         end
 
         # types
-        rule /(type|typealias|abstract)((?:\s|\\\s)+)/ do
+        rule %r/((?:mutable )?struct|(?:abstract|primitive) type)((?:\s|\\\s)+)/ do
           groups Keyword, Name::Class
           push :typename
         end
         rule TYPES, Keyword::Type
 
         # keywords
-        rule /(local|global|const)\b/, Keyword::Declaration
+        rule %r/(local|global|const)\b/, Keyword::Declaration
         rule KEYWORDS, Keyword
 
+        # TODO: end is a builtin when inside of an indexing expression
         rule BUILTINS, Name::Builtin
 
+        # TODO: symbols
+
         # backticks
-        rule /`.*?`/, Literal::String::Backtick
+        rule %r/`.*?`/, Literal::String::Backtick
 
         # chars
-        rule /'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'/, Literal::String::Char
+        rule %r/'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'/, Literal::String::Char
 
         # try to match trailing transpose
-        rule /(?<=[.\w)\]])\'+/, Operator
+        rule %r/(?<=[.\w)\]])\'+/, Operator
 
         # strings
-        rule /(?:[IL])"/, Literal::String, :string
-        rule /[E]?"/, Literal::String, :string
+        # TODO: triple quoted string literals
+        # TODO: Detect string interpolation
+        rule %r/(?:[IL])"/, Literal::String, :string
+        rule %r/[E]?"/, Literal::String, :string
 
         # names
-        rule /@[\w.]+/, Name::Decorator
-        rule /(?:[a-zA-Z_\u00A1-\uffff]|[\u1000-\u10ff])(?:[a-zA-Z_0-9\u00A1-\uffff]|[\u1000-\u10ff])*!*/, Name
+        rule %r/@[\w.]+/, Name::Decorator
+        rule %r/(?:[a-zA-Z_\u00A1-\uffff]|[\u1000-\u10ff])(?:[a-zA-Z_0-9\u00A1-\uffff]|[\u1000-\u10ff])*!*/, Name
 
         rule PUNCTUATION, Other
 
         # numbers
-        rule /(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
-        rule /(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
-        rule /\d+(_\d+)+[eEf][+-]?[0-9]+/, Literal::Number::Float
-        rule /\d+[eEf][+-]?[0-9]+/, Literal::Number::Float
-        rule /0b[01]+(_[01]+)+/, Literal::Number::Bin
-        rule /0b[01]+/, Literal::Number::Bin
-        rule /0o[0-7]+(_[0-7]+)+/, Literal::Number::Oct
-        rule /0o[0-7]+/, Literal::Number::Oct
-        rule /0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+/, Literal::Number::Hex
-        rule /0x[a-fA-F0-9]+/, Literal::Number::Hex
-        rule /\d+(_\d+)+/, Literal::Number::Integer
-        rule /\d+/, Literal::Number::Integer
+        rule %r/(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/\d+(_\d+)+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/\d+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/0b[01]+(_[01]+)+/, Literal::Number::Bin
+        rule %r/0b[01]+/, Literal::Number::Bin
+        rule %r/0o[0-7]+(_[0-7]+)+/, Literal::Number::Oct
+        rule %r/0o[0-7]+/, Literal::Number::Oct
+        rule %r/0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+/, Literal::Number::Hex
+        rule %r/0x[a-fA-F0-9]+/, Literal::Number::Hex
+        rule %r/\d+(_\d+)+/, Literal::Number::Integer
+        rule %r/\d+/, Literal::Number::Integer
       end
 
 
       state :funcname do
-        rule /[a-zA-Z_]\w*/, Name::Function, :pop!
-        rule /\([^\s\w{]{1,2}\)/, Operator, :pop!
-        rule /[^\s\w{]{1,2}/, Operator, :pop!
+        rule %r/[a-zA-Z_]\w*/, Name::Function, :pop!
+        rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
+        rule %r/[^\s\w{]{1,2}/, Operator, :pop!
       end
 
       state :typename do
-        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule %r/[a-zA-Z_]\w*/, Name::Class, :pop!
       end
 
       state :stringescape do
-        rule /\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})/,
+        rule %r/\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})/,
           Literal::String::Escape
       end
 
       state :blockcomment do
-        rule /[^=#]/, Comment::Multiline
-        rule /#=/, Comment::Multiline, :blockcomment
-        rule /\=#/, Comment::Multiline, :pop!
-        rule /[=#]/, Comment::Multiline
+        rule %r/[^=#]/, Comment::Multiline
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/\=#/, Comment::Multiline, :pop!
+        rule %r/[=#]/, Comment::Multiline
       end
 
       state :string do
         mixin :stringescape
 
-        rule /"/, Literal::String, :pop!
-        rule /\\\\|\\"|\\\n/, Literal::String::Escape  # included here for raw strings
-        rule /\$(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/, Literal::String::Interpol
-        rule /[^\\"$]+/, Literal::String
+        rule %r/"/, Literal::String, :pop!
+        rule %r/\\\\|\\"|\\\n/, Literal::String::Escape  # included here for raw strings
+        rule %r/\$(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/, Literal::String::Interpol
+        rule %r/[^\\"$]+/, Literal::String
         # quotes, dollar signs, and backslashes must be parsed one at a time
-        rule /["\\]/, Literal::String
+        rule %r/["\\]/, Literal::String
         # unhandled string formatting sign
-        rule /\$/, Literal::String
+        rule %r/\$/, Literal::String
       end
     end
   end

data/lib/rouge/lexers/kotlin.rb

@@ -19,9 +19,9 @@ module Rouge
         external false final finally for fun get if import in infix
         inline inner interface internal is lateinit noinline null
         object open operator out override package private protected
-        public reified return sealed set super tailrec this throw
-        true try typealias typeof val var vararg when where while
-        yield
+        public reified return sealed set super suspend tailrec this
+        throw true try typealias typeof val var vararg when where
+        while yield
       )
 
       name = %r'@?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
@@ -68,12 +68,13 @@ module Rouge
           push :property
         end
         rule %r/\bfun\b/, Keyword
-        rule /\b(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(?:#{keywords.join('|')})\b/, Keyword
         rule %r'^\s*\[.*?\]', Name::Attribute
         rule %r'[^\S\n]+', Text
         rule %r'\\\n', Text # line continuation
         rule %r'//.*?$', Comment::Single
-        rule %r'/[*].*?[*]/'m, Comment::Multiline
+        rule %r'/[*].*[*]/', Comment::Multiline # single line block comment
+        rule %r'/[*].*', Comment::Multiline, :comment # multiline block comment
         rule %r'\n', Text
         rule %r'::|!!|\?[:.]', Operator
         rule %r"(\.\.)", Operator
@@ -84,12 +85,12 @@ module Rouge
         rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
         rule %r"'\\.'|'[^\\]'", Str::Char
         rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
-        rule /@#{id}/, Name::Decorator
+        rule %r/@#{id}/, Name::Decorator
         rule id, Name
       end
 
       state :package do
-        rule /\S+/, Name::Namespace, :pop!
+        rule %r/\S+/, Name::Namespace, :pop!
       end
 
       state :class do
@@ -122,6 +123,12 @@ module Rouge
         rule %r'(\s+)', Text
         rule id, Name::Property
       end
+
+      state :comment do
+        rule %r'\s*/[*].*', Comment::Multiline, :comment
+        rule %r'.*[*]/', Comment::Multiline, :pop!
+        rule %r'.*', Comment::Multiline
+      end
     end
   end
 end

data/lib/rouge/lexers/lasso.rb

@@ -39,7 +39,7 @@ module Rouge
       end
 
       # Load Lasso keywords from separate YML file
-      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('lasso/keywords.yml')).tap do |h|
+      @keywords = ::YAML.load_file(File.join(__dir__, 'lasso/keywords.yml')).tap do |h|
         h.each do |k,v|
           h[k] = Set.new v
         end
@@ -48,23 +48,23 @@ module Rouge
       id = /[a-z_][\w.]*/i
 
       state :root do
-        rule /^#![ \S]+lasso9\b/, Comment::Preproc, :lasso
+        rule %r/^#![ \S]+lasso9\b/, Comment::Preproc, :lasso
         rule(/(?=\[|<)/) { push :delimiters }
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
         rule(//) { push :delimiters; push :lassofile }
       end
 
       state :delimiters do
-        rule /\[no_square_brackets\]/, Comment::Preproc, :nosquarebrackets
-        rule /\[noprocess\]/, Comment::Preproc, :noprocess
-        rule /\[/, Comment::Preproc, :squarebrackets
-        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule %r/\[no_square_brackets\]/, Comment::Preproc, :nosquarebrackets
+        rule %r/\[noprocess\]/, Comment::Preproc, :noprocess
+        rule %r/\[/, Comment::Preproc, :squarebrackets
+        rule %r/<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
         rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=)))+/im) { delegate parent }
       end
 
       state :nosquarebrackets do
-        rule /\[noprocess\]/, Comment::Preproc, :noprocess
-        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule %r/\[noprocess\]/, Comment::Preproc, :noprocess
+        rule %r/<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
         rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=))|\[(?!noprocess))+/im) { delegate parent }
       end
 
@@ -74,22 +74,22 @@ module Rouge
       end
 
       state :squarebrackets do
-        rule /\]/, Comment::Preproc, :pop!
+        rule %r/\]/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :anglebrackets do
-        rule /\?>/, Comment::Preproc, :pop!
+        rule %r/\?>/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :lassofile do
-        rule /\]|\?>/, Comment::Preproc, :pop!
+        rule %r/\]|\?>/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :whitespacecomments do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?\n), Comment::Single
         rule %r(/\*\*!.*?\*/)m, Comment::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
@@ -99,43 +99,43 @@ module Rouge
         mixin :whitespacecomments
 
         # literals
-        rule /\d*\.\d+(e[+-]?\d+)?/i, Num::Float
-        rule /0x[\da-f]+/i, Num::Hex
-        rule /\d+/, Num::Integer
-        rule /(infinity|NaN)\b/i, Num
-        rule /'[^'\\]*(\\.[^'\\]*)*'/m, Str::Single
-        rule /"[^"\\]*(\\.[^"\\]*)*"/m, Str::Double
-        rule /`[^`]*`/m, Str::Backtick
+        rule %r/\d*\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+        rule %r/(infinity|NaN)\b/i, Num
+        rule %r/'[^'\\]*(\\.[^'\\]*)*'/m, Str::Single
+        rule %r/"[^"\\]*(\\.[^"\\]*)*"/m, Str::Double
+        rule %r/`[^`]*`/m, Str::Backtick
 
         # names
-        rule /\$#{id}/, Name::Variable
-        rule /#(#{id}|\d+\b)/, Name::Variable::Instance
-        rule /(\.\s*)('#{id}')/ do
+        rule %r/\$#{id}/, Name::Variable
+        rule %r/#(#{id}|\d+\b)/, Name::Variable::Instance
+        rule %r/(\.\s*)('#{id}')/ do
           groups Name::Builtin::Pseudo, Name::Variable::Class
         end
-        rule /(self)(\s*->\s*)('#{id}')/i do
+        rule %r/(self)(\s*->\s*)('#{id}')/i do
           groups Name::Builtin::Pseudo, Operator, Name::Variable::Class
         end
-        rule /(\.\.?\s*)(#{id}(=(?!=))?)/ do
+        rule %r/(\.\.?\s*)(#{id}(=(?!=))?)/ do
           groups Name::Builtin::Pseudo, Name::Other
         end
-        rule /(->\\?\s*|&\s*)(#{id}(=(?!=))?)/ do
+        rule %r/(->\\?\s*|&\s*)(#{id}(=(?!=))?)/ do
           groups Operator, Name::Other
         end
-        rule /(?<!->)(self|inherited|currentcapture|givenblock)\b/i, Name::Builtin::Pseudo
-        rule /-(?!infinity)#{id}/i, Name::Attribute
-        rule /::\s*#{id}/, Name::Label
-        rule /error_((code|msg)_\w+|adderror|columnrestriction|databaseconnectionunavailable|databasetimeout|deleteerror|fieldrestriction|filenotfound|invaliddatabase|invalidpassword|invalidusername|modulenotfound|noerror|nopermission|outofmemory|reqcolumnmissing|reqfieldmissing|requiredcolumnmissing|requiredfieldmissing|updateerror)/i, Name::Exception
+        rule %r/(?<!->)(self|inherited|currentcapture|givenblock)\b/i, Name::Builtin::Pseudo
+        rule %r/-(?!infinity)#{id}/i, Name::Attribute
+        rule %r/::\s*#{id}/, Name::Label
+        rule %r/error_((code|msg)_\w+|adderror|columnrestriction|databaseconnectionunavailable|databasetimeout|deleteerror|fieldrestriction|filenotfound|invaliddatabase|invalidpassword|invalidusername|modulenotfound|noerror|nopermission|outofmemory|reqcolumnmissing|reqfieldmissing|requiredcolumnmissing|requiredfieldmissing|updateerror)/i, Name::Exception
 
         # definitions
-        rule /(define)(\s+)(#{id})(\s*=>\s*)(type|trait|thread)\b/i do
+        rule %r/(define)(\s+)(#{id})(\s*=>\s*)(type|trait|thread)\b/i do
           groups Keyword::Declaration, Text, Name::Class, Operator, Keyword
         end
         rule %r((define)(\s+)(#{id})(\s*->\s*)(#{id}=?|[-+*/%]))i do
           groups Keyword::Declaration, Text, Name::Class, Operator, Name::Function
           push :signature
         end
-        rule /(define)(\s+)(#{id})/i do
+        rule %r/(define)(\s+)(#{id})/i do
           groups Keyword::Declaration, Text, Name::Function
           push :signature
         end
@@ -143,25 +143,25 @@ module Rouge
           groups Keyword, Text, Name::Function
           push :signature
         end
-        rule /(public|protected|private|provide)(\s+)(#{id})/i do
+        rule %r/(public|protected|private|provide)(\s+)(#{id})/i do
           groups Keyword, Text, Name::Function
         end
 
         # keywords
-        rule /(true|false|none|minimal|full|all|void)\b/i, Keyword::Constant
-        rule /(local|var|variable|global|data(?=\s))\b/i, Keyword::Declaration
-        rule /(array|date|decimal|duration|integer|map|pair|string|tag|xml|null|boolean|bytes|keyword|list|locale|queue|set|stack|staticarray)\b/i, Keyword::Type
-        rule /(#{id})(\s+)(in)\b/i do
+        rule %r/(true|false|none|minimal|full|all|void)\b/i, Keyword::Constant
+        rule %r/(local|var|variable|global|data(?=\s))\b/i, Keyword::Declaration
+        rule %r/(array|date|decimal|duration|integer|map|pair|string|tag|xml|null|boolean|bytes|keyword|list|locale|queue|set|stack|staticarray)\b/i, Keyword::Type
+        rule %r/(#{id})(\s+)(in)\b/i do
           groups Name, Text, Keyword
         end
-        rule /(let|into)(\s+)(#{id})/i do
+        rule %r/(let|into)(\s+)(#{id})/i do
           groups Keyword, Text, Name
         end
 
         # other
-        rule /,/, Punctuation, :commamember
-        rule /(and|or|not)\b/i, Operator::Word
-        rule /(#{id})(\s*::\s*#{id})?(\s*=(?!=|>))/ do
+        rule %r/,/, Punctuation, :commamember
+        rule %r/(and|or|not)\b/i, Operator::Word
+        rule %r/(#{id})(\s*::\s*#{id})?(\s*=(?!=|>))/ do
           groups Name, Name::Label, Operator
         end
 
@@ -183,31 +183,31 @@ module Rouge
           end
         end
 
-        rule /(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b/i do
+        rule %r/(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b/i do
           groups Operator, Operator::Word
         end
         rule %r(:=|[-+*/%=<>&|!?\\]+), Operator
-        rule /[{}():;,@^]/, Punctuation
+        rule %r/[{}():;,@^]/, Punctuation
       end
 
       state :signature do
-        rule /\=>/, Operator, :pop!
-        rule /\)/, Punctuation, :pop!
-        rule /[(,]/, Punctuation, :parameter
+        rule %r/\=>/, Operator, :pop!
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/[(,]/, Punctuation, :parameter
         mixin :lasso
       end
 
       state :parameter do
-        rule /\)/, Punctuation, :pop!
-        rule /-?#{id}/, Name::Attribute, :pop!
-        rule /\.\.\./, Name::Builtin::Pseudo
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/-?#{id}/, Name::Attribute, :pop!
+        rule %r/\.\.\./, Name::Builtin::Pseudo
         mixin :lasso
       end
 
       state :commamember do
         rule %r((#{id}=?|[-+*/%])(?=\s*(\(([^()]*\([^()]*\))*[^\)]*\)\s*)?(::[\w.\s]+)?=>)), Name::Function, :signature
         mixin :whitespacecomments
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
     end