rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/turtle.rb

@@ -7,57 +7,54 @@ module Rouge
       title "Turtle/TriG"
       desc "Terse RDF Triple Language, TriG"
       tag 'turtle'
-      filenames *%w(*.ttl *.trig)
-      mimetypes *%w(
-        text/turtle
-        application/trig
-      )
+      filenames '*.ttl', '*.trig'
+      mimetypes 'text/turtle', 'application/trig'
 
       state :root do
-        rule /@base\b/, Keyword::Declaration
-        rule /@prefix\b/, Keyword::Declaration
-        rule /true\b/, Keyword::Constant
-        rule /false\b/, Keyword::Constant
+        rule %r/@base\b/, Keyword::Declaration
+        rule %r/@prefix\b/, Keyword::Declaration
+        rule %r/true\b/, Keyword::Constant
+        rule %r/false\b/, Keyword::Constant
 
-        rule /""".*?"""/m, Literal::String
-        rule /"([^"\\]|\\.)*"/, Literal::String
-        rule /'''.*?'''/m, Literal::String
-        rule /'([^'\\]|\\.)*'/, Literal::String
+        rule %r/""".*?"""/m, Literal::String
+        rule %r/"([^"\\]|\\.)*"/, Literal::String
+        rule %r/'''.*?'''/m, Literal::String
+        rule %r/'([^'\\]|\\.)*'/, Literal::String
 
-        rule /#.*$/, Comment::Single
+        rule %r/#.*$/, Comment::Single
 
-        rule /@[^\s,.; ]+/, Name::Attribute
+        rule %r/@[^\s,.;]+/, Name::Attribute
 
-        rule /[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
-        rule /[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
-        rule /[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule %r/[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
 
-        rule /[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
+        rule %r/[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
 
-        rule /[+-]?[0-9]+/, Literal::Number::Integer
+        rule %r/[+-]?[0-9]+/, Literal::Number::Integer
 
-        rule /\./, Punctuation
-        rule /,/, Punctuation
-        rule /;/, Punctuation
-        rule /\(/, Punctuation
-        rule /\)/, Punctuation
-        rule /\{/, Punctuation
-        rule /\}/, Punctuation
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
-        rule /\^\^/, Punctuation
+        rule %r/\./, Punctuation
+        rule %r/,/, Punctuation
+        rule %r/;/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/\)/, Punctuation
+        rule %r/\{/, Punctuation
+        rule %r/\}/, Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
+        rule %r/\^\^/, Punctuation
 
-        rule /<[^>]*>/, Name::Label
+        rule %r/<[^>]*>/, Name::Label
 
-        rule /base\b/i, Keyword::Declaration
-        rule /prefix\b/i, Keyword::Declaration
-        rule /GRAPH\b/, Keyword
-        rule /a\b/, Keyword
+        rule %r/base\b/i, Keyword::Declaration
+        rule %r/prefix\b/i, Keyword::Declaration
+        rule %r/GRAPH\b/, Keyword
+        rule %r/a\b/, Keyword
 
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
 
-        rule /[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
-        rule /[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
+        rule %r/[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
       end
     end
   end

data/lib/rouge/lexers/vala.rb

@@ -24,12 +24,12 @@ module Rouge
       )
 
       keywords_type = %w(
-        bool char double float int int8 int16 int32 int64 long short size_t 
+        bool char double float int int8 int16 int32 int64 long short size_t
         ssize_t string unichar uint uint8 uint16 uint32 uint64 ulong ushort
       )
 
       state :whitespace do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
       end
@@ -37,30 +37,30 @@ module Rouge
       state :root do
         mixin :whitespace
 
-        rule /^\s*\[.*?\]/, Name::Attribute
+        rule %r/^\s*\[.*?\]/, Name::Attribute
 
-        rule /(<\[)\s*(#{id}:)?/, Keyword
-        rule /\]>/, Keyword
+        rule %r/(<\[)\s*(#{id}:)?/, Keyword
+        rule %r/\]>/, Keyword
 
-        rule /[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
-        rule /@"(\\.|.)*?"/, Str
-        rule /"(\\.|.)*?["\n]/, Str
-        rule /'(\\.|.)'/, Str::Char
-        rule /0x[0-9a-f]+[lu]?/i, Num
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/@"(\\.|.)*?"/, Str
+        rule %r/"(\\.|.)*?["\n]/, Str
+        rule %r/'(\\.|.)'/, Str::Char
+        rule %r/0x[0-9a-f]+[lu]?/i, Num
         rule %r(
           [0-9]
           ([.][0-9]*)? # decimal
           (e[+-][0-9]+)? # exponent
           [fldu]? # type
         )ix, Num
-        rule /\b(#{keywords.join('|')})\b/, Keyword
-        rule /\b(#{keywords_type.join('|')})\b/, Keyword::Type
-        rule /class|struct/, Keyword, :class
-        rule /namespace|using/, Keyword, :namespace
-        rule /#{id}(?=\s*[(])/, Name::Function
+        rule %r/\b(#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/class|struct/, Keyword, :class
+        rule %r/namespace|using/, Keyword, :namespace
+        rule %r/#{id}(?=\s*[(])/, Name::Function
         rule id, Name
 
-        rule /#.*/, Comment::Preproc
+        rule %r/#.*/, Comment::Preproc
       end
 
       state :class do
@@ -70,8 +70,8 @@ module Rouge
 
       state :namespace do
         mixin :whitespace
-        rule /(?=[(])/, Text, :pop!
-        rule /(#{id}|[.])+/, Name::Namespace, :pop!
+        rule %r/(?=[(])/, Text, :pop!
+        rule %r/(#{id}|[.])+/, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/vb.rb

@@ -54,16 +54,16 @@ module Rouge
       upper_id = /[A-Z]\w*/
 
       state :whitespace do
-        rule /\s+/, Text
-        rule /\n/, Text, :bol
-        rule /rem\b.*?$/i, Comment::Single
+        rule %r/\s+/, Text
+        rule %r/\n/, Text, :bol
+        rule %r/rem\b.*?$/i, Comment::Single
         rule %r(%\{.*?%\})m, Comment::Multiline
-        rule /'.*$/, Comment::Single
+        rule %r/'.*$/, Comment::Single
       end
 
       state :bol do
-        rule /\s+/, Text
-        rule /<.*?>/, Name::Attribute
+        rule %r/\s+/, Text
+        rule %r/<.*?>/, Name::Attribute
         rule(//) { :pop! }
       end
 
@@ -80,15 +80,15 @@ module Rouge
           | [#]End \s+ Region
           | [#]ExternalChecksum
         )x, Comment::Preproc
-        rule /[.]/, Punctuation, :dotted
-        rule /[(){}!#,:]/, Punctuation
-        rule /Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
+        rule %r/[.]/, Punctuation, :dotted
+        rule %r/[(){}!#,:]/, Punctuation
+        rule %r/Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
           Keyword::Declaration
-        rule /End\b/, Keyword, :end
-        rule /(Dim|Const)\b/, Keyword, :dim
-        rule /(Function|Sub|Property)\b/, Keyword, :funcname
-        rule /(Class|Structure|Enum)\b/, Keyword, :classname
-        rule /(Module|Namespace|Imports)\b/, Keyword, :namespace
+        rule %r/End\b/, Keyword, :end
+        rule %r/(Dim|Const)\b/, Keyword, :dim
+        rule %r/(Function|Sub|Property)\b/, Keyword, :funcname
+        rule %r/(Class|Structure|Enum)\b/, Keyword, :classname
+        rule %r/(Module|Namespace|Imports)\b/, Keyword, :namespace
 
         rule upper_id do |m|
           match = m[0]
@@ -110,16 +110,16 @@ module Rouge
           Operator
         )
 
-        rule /"/, Str, :string
-        rule /#{id}[%&@!#\$]?/, Name
-        rule /#.*?#/, Literal::Date
+        rule %r/"/, Str, :string
+        rule %r/#{id}[%&@!#\$]?/, Name
+        rule %r/#.*?#/, Literal::Date
 
-        rule /(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
-        rule /\d+([SILDFR]|US|UI|UL)?/, Num::Integer
-        rule /&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
-        rule /&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule %r/(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
+        rule %r/\d+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule %r/&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule %r/&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
 
-        rule /_\n/, Keyword
+        rule %r/_\n/, Keyword
       end
 
       state :dotted do
@@ -128,9 +128,9 @@ module Rouge
       end
 
       state :string do
-        rule /""/, Str::Escape
-        rule /"C?/, Str, :pop!
-        rule /[^"]+/, Str
+        rule %r/""/, Str::Escape
+        rule %r/"C?/, Str, :pop!
+        rule %r/[^"]+/, Str
       end
 
       state :dim do
@@ -151,12 +151,12 @@ module Rouge
 
       state :namespace do
         mixin :whitespace
-        rule /#{id}([.]#{id})*/, Name::Namespace, :pop!
+        rule %r/#{id}([.]#{id})*/, Name::Namespace, :pop!
       end
 
       state :end do
         mixin :whitespace
-        rule /(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
+        rule %r/(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
           Keyword, :pop!
         rule(//) { pop! }
       end

data/lib/rouge/lexers/verilog.rb

@@ -10,8 +10,6 @@ module Rouge
       filenames '*.v', '*.sv', '*.svh'
       mimetypes 'text/x-verilog', 'text/x-systemverilog'
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       def self.keywords
@@ -82,7 +80,7 @@ module Rouge
 
       state :expr_bol do
         mixin :inline_whitespace
-        rule /`define/, Comment::Preproc, :macro
+        rule %r/`define/, Comment::Preproc, :macro
 
         rule(//) { pop! }
       end
@@ -90,47 +88,47 @@ module Rouge
       # :expr_bol is the same as :bol but without labels, since
       # labels can only appear at the beginning of a statement.
       state :bol do
-        rule /#{id}:(?!:)/, Name::Label
+        rule %r/#{id}:(?!:)/, Name::Label
         mixin :expr_bol
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
-        rule /\\\n/, Text # line continuation
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
       end
 
       state :whitespace do
-        rule /\n+/m, Text, :bol
+        rule %r/\n+/m, Text, :bol
         rule %r(//(\\.|.)*?\n), Comment::Single, :bol
         mixin :inline_whitespace
       end
 
       state :expr_whitespace do
-        rule /\n+/m, Text, :expr_bol
+        rule %r/\n+/m, Text, :expr_bol
         mixin :whitespace
       end
 
       state :string do
-        rule /"/, Str, :pop!
-        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\\n/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
       end
 
       state :statement do
         mixin :whitespace
-        rule /L?"/, Str, :string
-        rule /([0-9_]+\.[0-9_]*|[0-9_]*\.[0-9_]+)(e[+-]?[0-9_]+)?/i, Num::Float
-        rule /[0-9_]+e[+-]?[0-9_]+/i, Num::Float
-        rule /[0-9]*'h[0-9a-fA-F_?]+/, Num::Hex
-        rule /[0-9]*'b?[01xz_?]+/, Num::Bin
-        rule /[0-9]*'d[0-9_?]+/, Num::Integer
-        rule /[0-9_]+[lu]*/i, Num::Integer
-        rule %r([~!%^&*+-=\|?:<>/@{}]), Operator
-        rule /[()\[\],.$\#]/, Punctuation
-        rule /`(\w+)/, Comment::Preproc
+        rule %r/L?"/, Str, :string
+        rule %r/([0-9_]+\.[0-9_]*|[0-9_]*\.[0-9_]+)(e[+-]?[0-9_]+)?/i, Num::Float
+        rule %r/[0-9_]+e[+-]?[0-9_]+/i, Num::Float
+        rule %r/[0-9]*'h[0-9a-fA-F_?]+/, Num::Hex
+        rule %r/[0-9]*'b?[01xz_?]+/, Num::Bin
+        rule %r/[0-9]*'d[0-9_?]+/, Num::Integer
+        rule %r/[0-9_]+[lu]*/i, Num::Integer
+        rule %r([-~!%^&*+=\|?:<>/@{}]), Operator
+        rule %r/[()\[\],.$\#;]/, Punctuation
+        rule %r/`(\w+)/, Comment::Preproc
 
         rule id do |m|
           name = m[0]
@@ -153,11 +151,11 @@ module Rouge
       end
 
       state :macro do
-        rule /\n/, Comment::Preproc, :pop!
+        rule %r/\n/, Comment::Preproc, :pop!
         mixin :inline_whitespace
-        rule /;/, Punctuation
-        rule /\=/, Operator
-        rule /(\w+)/, Text
+        rule %r/;/, Punctuation
+        rule %r/\=/, Operator
+        rule %r/(\w+)/, Text
       end
 
     end

data/lib/rouge/lexers/vhdl.rb

@@ -41,30 +41,30 @@ module Rouge
       id = /[a-zA-Z][a-zA-Z0-9_]*/
 
       state :whitespace do
-        rule /\s+/, Text
-        rule /\n/, Text
+        rule %r/\s+/, Text
+        rule %r/\n/, Text
         # Find Comments (VHDL doesn't support multiline comments)
-        rule /--.*$/, Comment::Single
+        rule %r/--.*$/, Comment::Single
       end
 
       state :statements do
 
         # Find Numbers
-        rule /-?\d+/i, Num::Integer
-        rule /-?\d+[.]\d+/i, Num::Float
+        rule %r/-?\d+/i, Num::Integer
+        rule %r/-?\d+[.]\d+/i, Num::Float
 
         # Find Strings
-        rule /[box]?"[^"]*"/i, Str::Single
-        rule /'[^']?'/i, Str::Char
+        rule %r/[box]?"[^"]*"/i, Str::Single
+        rule %r/'[^']?'/i, Str::Char
 
         # Find Attributes
-        rule /'#{id}/i, Name::Attribute
-        
+        rule %r/'#{id}/i, Name::Attribute
+
         # Punctuations
-        rule /[(),:;]/, Punctuation
+        rule %r/[(),:;]/, Punctuation
 
         # Boolean and NULL
-        rule /(?:true|false|null)\b/i, Name::Builtin
+        rule %r/(?:true|false|null)\b/i, Name::Builtin
 
         rule id do |m|
           match = m[0].downcase   #convert to lower case

data/lib/rouge/lexers/viml.rb

@@ -14,18 +14,18 @@ module Rouge
       mimetypes 'text/x-vim'
 
       def self.keywords
-        load Pathname.new(__FILE__).dirname.join('viml/keywords.rb')
+        load File.join(__dir__, 'viml/keywords.rb')
         self.keywords
       end
 
       state :root do
-        rule /^(\s*)(".*?)$/ do
+        rule %r/^(\s*)(".*?)$/ do
           groups Text, Comment
         end
 
-        rule /^\s*\\/, Str::Escape
+        rule %r/^\s*\\/, Str::Escape
 
-        rule /[ \t]+/, Text
+        rule %r/[ \t]+/, Text
 
         # TODO: regexes can have other delimiters
         rule %r(/(\\\\|\\/|[^\n/])*/), Str::Regex
@@ -33,19 +33,19 @@ module Rouge
         rule %r('(\\\\|\\'|[^\n'])*'), Str::Single
 
         # if it's not a string, it's a comment.
-        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
+        rule %r/(?<=\s)"[^-:.%#=*].*?$/, Comment
 
-        rule /-?\d+/, Num
-        rule /#[0-9a-f]{6}/i, Num::Hex
-        rule /^:/, Punctuation
-        rule /[():<>+=!\[\]{}\|,~.-]/, Punctuation
-        rule /\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
+        rule %r/-?\d+/, Num
+        rule %r/#[0-9a-f]{6}/i, Num::Hex
+        rule %r/^:/, Punctuation
+        rule %r/[():<>+=!\[\]{}\|,~.-]/, Punctuation
+        rule %r/\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
           Keyword
 
-        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
+        rule %r/\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
 
-        rule /[absg]:\w+\b/, Name::Variable
-        rule /\b\w+\b/ do |m|
+        rule %r/[absg]:\w+\b/, Name::Variable
+        rule %r/\b\w+\b/ do |m|
           name = m[0]
           keywords = self.class.keywords
 
@@ -61,7 +61,7 @@ module Rouge
         end
 
         # no errors in VimL!
-        rule /./m, Text
+        rule %r/./m, Text
       end
 
       def mapping_contains?(mapping, word)