rouge 3.4.1 → 3.6.0

data/lib/rouge/lexers/kotlin.rb

@@ -68,7 +68,7 @@ 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
@@ -85,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

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

data/lib/rouge/lexers/liquid.rb

@@ -10,67 +10,67 @@ module Rouge
       filenames '*.liquid'
 
       state :root do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)/ do
+        rule %r/(\{%)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :tag_or_block
         end
 
-        rule /(\{\{)(\s*)/ do
+        rule %r/(\{\{)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :output
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :tag_or_block do
         # builtin logic blocks
-        rule /(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+        rule %r/(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
 
-        rule /(when)(\s+)/ do
+        rule %r/(when)(\s+)/ do
           groups Keyword::Reserved, Text::Whitespace
           push :when
         end
 
-        rule /(else)(\s*)(%\})/ do
+        rule %r/(else)(\s*)(%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
         # other builtin blocks
-        rule /(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
+        rule %r/(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(comment)(\s*)(%\})/ do
+        rule %r/(comment)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :comment
         end
 
-        rule /(raw)(\s*)(%\})/ do
+        rule %r/(raw)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :raw
         end
 
-        rule /assign/, Name::Tag, :assign
-        rule /include/, Name::Tag, :include
+        rule %r/assign/, Name::Tag, :assign
+        rule %r/include/, Name::Tag, :include
 
         # end of block
-        rule /(end(case|unless|if))(\s*)(%\})/ do
-          groups Keyword::Reserved, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:case|unless|if))(\s*)(%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(end([^\s%]+))(\s*)(%\})/ do
-          groups Name::Tag, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:[^\s%]+))(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
           pop!
         end
 
         # builtin tags
-        rule /(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
+        rule %r/(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
           token Name::Tag, m[1]
           token Text::Whitespace, m[2]
 
@@ -88,8 +88,31 @@ module Rouge
           push :variable_tag_markup
         end
 
+        # iteration
+        rule %r/
+          (for)(\s+)
+          ([\w-]+)(\s+)
+          (in)(\s+)
+          (
+            (?: [^\s,\|'"] | (?:"[^"]*"|'[^']*') )+
+          )(\s*)
+        /x do |m|
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Keyword::Reserved, Text::Whitespace
+
+          token_class = case m[7]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Variable
+                        end
+          token token_class, m[7]
+          token Text::Whitespace, m[8]
+          push :tag_markup
+        end
+
         # other tags or blocks
-        rule /([^\s%]+)(\s*)/ do
+        rule %r/([^\s%]+)(\s*)/ do
           groups Name::Tag, Text::Whitespace
           push :tag_markup
         end
@@ -99,8 +122,8 @@ module Rouge
         mixin :whitespace
         mixin :generic
 
-        rule /\}\}/, Punctuation, :pop!
-        rule /\|/, Punctuation, :filters
+        rule %r/\}\}/, Punctuation, :pop!
+        rule %r/\|/, Punctuation, :filters
       end
 
       state :filters do
@@ -108,14 +131,14 @@ module Rouge
 
         rule(/\}\}/) { token Punctuation; reset_stack }
 
-        rule /([^\s\|:]+)(:?)(\s*)/ do
+        rule %r/([^\s\|:]+)(:?)(\s*)/ do
           groups Name::Function, Punctuation, Text::Whitespace
           push :filter_markup
         end
       end
 
       state :filter_markup do
-        rule /\|/, Punctuation, :pop!
+        rule %r/\|/, Punctuation, :pop!
 
         mixin :end_of_tag
         mixin :end_of_block
@@ -126,13 +149,13 @@ module Rouge
         mixin :end_of_block
         mixin :whitespace
 
-        rule /([=!><]=?)/, Operator
+        rule %r/([=!><]=?)/, Operator
 
-        rule /\b((!)|(not\b))/ do
-          groups nil, Operator, Operator::Word
+        rule %r/\b(?:(!)|(not\b))/ do
+          groups Operator, Operator::Word
         end
 
-        rule /(contains)/, Operator::Word
+        rule %r/(contains)/, Operator::Word
 
         mixin :generic
         mixin :whitespace
@@ -145,12 +168,12 @@ module Rouge
       end
 
       state :operator do
-        rule /(\s*)((=|!|>|<)=?)(\s*)/ do
-          groups Text::Whitespace, Operator, nil, Text::Whitespace
+        rule %r/(\s*)((?:=|!|>|<)=?)(\s*)/ do
+          groups Text::Whitespace, Operator, Text::Whitespace
           pop!
         end
 
-        rule /(\s*)(\bcontains\b)(\s*)/ do
+        rule %r/(\s*)(\bcontains\b)(\s*)/ do
           groups Text::Whitespace, Operator::Word, Text::Whitespace
           pop!
         end
@@ -169,29 +192,29 @@ module Rouge
         mixin :whitespace
         mixin :string
 
-        rule /([^\s=:]+)(\s*)(=|:)/ do
+        rule %r/([^\s=:]+)(\s*)(=|:)/ do
           groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule /(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
-          groups Punctuation, Text::Whitespace, nil, Text::Whitespace, Punctuation
+        rule %r/(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
+          groups Punctuation, Text::Whitespace, Text, Text::Whitespace, Punctuation
         end
 
         mixin :number
         mixin :keyword
 
-        rule /,/, Punctuation
+        rule %r/,/, Punctuation
       end
 
       state :default_param_markup do
         mixin :param_markup
-        rule /./, Text
+        rule %r/./, Text
       end
 
       state :variable_param_markup do
         mixin :param_markup
         mixin :variable
-        rule /./, Text
+        rule %r/./, Text
       end
 
       state :tag_markup do
@@ -206,27 +229,27 @@ module Rouge
 
       # states for different values types
       state :keyword do
-        rule /\b(false|true)\b/, Keyword::Constant
+        rule %r/\b(false|true)\b/, Keyword::Constant
       end
 
       state :variable do
-        rule /\.(?=\w)/, Punctuation
-        rule /[a-zA-Z_]\w*\??/, Name::Variable
+        rule %r/\.(?=\w)/, Punctuation
+        rule %r/[a-zA-Z_]\w*\??/, Name::Variable
       end
 
       state :string do
-        rule /'[^']*'/, Str::Single
-        rule /"[^"]*"/, Str::Double
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
       end
 
       state :number do
-        rule /\d+\.\d+/, Num::Float
-        rule /\d+/, Num::Integer
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
       end
 
       state :array_index do
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
       end
 
       state :generic do
@@ -238,38 +261,38 @@ module Rouge
       end
 
       state :whitespace do
-        rule /[ \t]+/, Text::Whitespace
+        rule %r/[ \t]+/, Text::Whitespace
       end
 
       state :comment do
-        rule /(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+        rule %r/(\{%)(\s*)(endcomment)(\s*)(%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /./, Comment
+        rule %r/./, Comment
       end
 
       state :raw do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)(endraw)(\s*)(%\})/ do
+        rule %r/(\{%)(\s*)(endraw)(\s*)(%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :assign do
         mixin :whitespace
         mixin :end_of_block
 
-        rule /(\s*)(=)(\s*)/ do
+        rule %r/(\s*)(=)(\s*)/ do
           groups Text::Whitespace, Operator, Text::Whitespace
         end
 
-        rule /\|/, Punctuation, :filters
+        rule %r/\|/, Punctuation, :filters
 
         mixin :generic
       end
@@ -277,7 +300,7 @@ module Rouge
       state :include do
         mixin :whitespace
 
-        rule /([^\.]+)(\.)(html|liquid)/ do
+        rule %r/([^\.]+)(\.)(html|liquid)/ do
           groups Name::Attribute, Punctuation, Name::Attribute
         end