rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/groovy.rb

@@ -10,8 +10,6 @@ module Rouge
       filenames '*.groovy', 'Jenkinsfile'
       mimetypes 'text/x-groovy'
 
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
-
       def self.detect?(text)
         return true if text.shebang?(/groovy/)
       end
@@ -43,8 +41,8 @@ module Rouge
 
       state :root do
         rule %r(^
-          (\s*(?:\w[\w\d.\[\]]*\s+)+?) # return arguments
-          (\w[\w\d]*) # method name
+          (\s*(?:\w[\w.\[\]]*\s+)+?) # return arguments
+          (\w\w*) # method name
           (\s*) (\() # signature start
         )x do |m|
           delegate self.clone, m[1]
@@ -54,29 +52,29 @@ module Rouge
         end
 
         # whitespace
-        rule /[^\S\n]+/, Text
+        rule %r/[^\S\n]+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
-        rule /@\w[\w\d.]*/, Name::Decorator
-        rule /(class|interface|trait)\b/,  Keyword::Declaration, :class
-        rule /package\b/, Keyword::Namespace, :import
-        rule /import\b/, Keyword::Namespace, :import
+        rule %r/@\w[\w.]*/, Name::Decorator
+        rule %r/(class|interface|trait)\b/,  Keyword::Declaration, :class
+        rule %r/package\b/, Keyword::Namespace, :import
+        rule %r/import\b/, Keyword::Namespace, :import
 
         # TODO: highlight backslash escapes
-        rule /""".*?"""/m, Str::Double
-        rule /'''.*?'''/m, Str::Single
+        rule %r/""".*?"""/m, Str::Double
+        rule %r/'''.*?'''/m, Str::Single
 
-        rule /"(\\.|\\\n|.)*?"/, Str::Double
-        rule /'(\\.|\\\n|.)*?'/, Str::Single
+        rule %r/"(\\.|\\\n|.)*?"/, Str::Double
+        rule %r/'(\\.|\\\n|.)*?'/, Str::Single
         rule %r(\$/(\$.|.)*?/\$)m, Str
         rule %r(/(\\.|\\\n|.)*?/), Str
-        rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
-        rule /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
+        rule %r/'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
+        rule %r/(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
           groups Operator, Name::Attribute
         end
 
-        rule /[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label
-        rule /[a-zA-Z_\$][a-zA-Z0-9_]*/ do |m|
+        rule %r/[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label
+        rule %r/[a-zA-Z_\$][a-zA-Z0-9_]*/ do |m|
           if self.class.keywords.include? m[0]
             token Keyword
           elsif self.class.declarations.include? m[0]
@@ -93,20 +91,20 @@ module Rouge
         rule %r([~^*!%&\[\](){}<>\|+=:;,./?-]), Operator
 
         # numbers
-        rule /\d+\.\d+([eE]\d+)?[fd]?/, Num::Float
-        rule /0x[0-9a-f]+/, Num::Hex
-        rule /[0-9]+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/\d+\.\d+([eE]\d+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-f]+/, Num::Hex
+        rule %r/[0-9]+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /\s+/, Text
-        rule /\w[\w\d]*/, Name::Class, :pop!
+        rule %r/\s+/, Text
+        rule %r/\w\w*/, Name::Class, :pop!
       end
 
       state :import do
-        rule /\s+/, Text
-        rule /[\w\d.]+[*]?/, Name::Namespace, :pop!
+        rule %r/\s+/, Text
+        rule %r/[\w.]+[*]?/, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/hack.rb

@@ -33,7 +33,7 @@ module Rouge
       end
 
       prepend :template do
-        rule /<\?hh(\s*\/\/\s*(strict|decl|partial))?$/, Comment::Preproc, :php
+        rule %r/<\?hh(\s*\/\/\s*(strict|decl|partial))?$/, Comment::Preproc, :php
       end
 
       prepend :php do

data/lib/rouge/lexers/haml.rb

@@ -66,19 +66,15 @@ module Rouge
       # To accomodate this, use this custom faux dot instead.
       dot = /[ ]\|\n(?=.*[ ]\|)|./
 
-      # In certain places, a comma at the end of the line
-      # allows line wrapping as well.
-      comma_dot = /,\s*\n|#{dot}/
-
       state :root do
-        rule /\s*\n/, Text
+        rule %r/\s*\n/, Text
         rule(/\s*/) { |m| token Text; indentation(m[0]) }
       end
 
       state :content do
         mixin :css
         rule(/%#{identifier}/) { token Name::Tag; goto :tag }
-        rule /!!!#{dot}*\n/, Name::Namespace, :pop!
+        rule %r/!!!#{dot}*\n/, Name::Namespace, :pop!
         rule %r(
           (/) (\[#{dot}*?\]) (#{dot}*\n)
         )x do
@@ -92,20 +88,20 @@ module Rouge
           starts_block :html_comment_block
         end
 
-        rule /-##{dot}*\n/ do
+        rule %r/-##{dot}*\n/ do
           token Comment
           pop!
           starts_block :haml_comment_block
         end
 
-        rule /-/ do
+        rule %r/-/ do
           token Punctuation
           reset_stack
           ruby! :ruby_line
         end
 
         # filters
-        rule /:(#{dot}*)\n/ do |m|
+        rule %r/:(#{dot}*)\n/ do |m|
           token Name::Decorator
           pop!
           starts_block :filter_block
@@ -131,11 +127,11 @@ module Rouge
         rule(/[{]/) { token Punctuation; ruby! :ruby_tag }
         rule(/\[#{dot}*?\]/) { delegate ruby }
 
-        rule /\(/, Punctuation, :html_attributes
-        rule /\s*\n/, Text, :pop!
+        rule %r/\(/, Punctuation, :html_attributes
+        rule %r/\s*\n/, Text, :pop!
 
         # whitespace chompers
-        rule /[<>]{1,2}(?=[ \t=])/, Punctuation
+        rule %r/[<>]{1,2}(?=[ \t=])/, Punctuation
 
         mixin :eval_or_plain
       end
@@ -147,8 +143,8 @@ module Rouge
       end
 
       state :eval_or_plain do
-        rule /[&!]?==/, Punctuation, :plain
-        rule /[&!]?[=!]/ do
+        rule %r/[&!]?==/, Punctuation, :plain
+        rule %r/[&!]?[=!]/ do
           token Punctuation
           reset_stack
           ruby! :ruby_line
@@ -158,9 +154,9 @@ module Rouge
       end
 
       state :ruby_line do
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
         rule(/,[ \t]*\n/) { delegate ruby }
-        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule %r/[ ]\|[ \t]*\n/, Str::Escape
         rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
       end
 
@@ -169,33 +165,33 @@ module Rouge
       end
 
       state :html_attributes do
-        rule /\s+/, Text
-        rule /#{identifier}\s*=/, Name::Attribute, :html_attribute_value
+        rule %r/\s+/, Text
+        rule %r/#{identifier}\s*=/, Name::Attribute, :html_attribute_value
         rule identifier, Name::Attribute
-        rule /\)/, Text, :pop!
+        rule %r/\)/, Text, :pop!
       end
 
       state :html_attribute_value do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule ruby_var, Name::Variable, :pop!
-        rule /@#{ruby_var}/, Name::Variable::Instance, :pop!
-        rule /\$#{ruby_var}/, Name::Variable::Global, :pop!
-        rule /'(\\\\|\\'|[^'\n])*'/, Str, :pop!
-        rule /"(\\\\|\\"|[^"\n])*"/, Str, :pop!
+        rule %r/@#{ruby_var}/, Name::Variable::Instance, :pop!
+        rule %r/\$#{ruby_var}/, Name::Variable::Global, :pop!
+        rule %r/'(\\\\|\\'|[^'\n])*'/, Str, :pop!
+        rule %r/"(\\\\|\\"|[^"\n])*"/, Str, :pop!
       end
 
       state :html_comment_block do
-        rule /#{dot}+/, Comment
+        rule %r/#{dot}+/, Comment
         mixin :indented_block
       end
 
       state :haml_comment_block do
-        rule /#{dot}+/, Comment::Preproc
+        rule %r/#{dot}+/, Comment::Preproc
         mixin :indented_block
       end
 
       state :filter_block do
-        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
           if @filter_lexer
             delegate @filter_lexer
           else
@@ -208,11 +204,11 @@ module Rouge
       end
 
       state :interpolation do
-        rule /#[{]/, Str::Interpol, :ruby
+        rule %r/#[{]/, Str::Interpol, :ruby
       end
 
       state :ruby do
-        rule /[}]/, Str::Interpol, :pop!
+        rule %r/[}]/, Str::Interpol, :pop!
         mixin :ruby_inner
       end
 

data/lib/rouge/lexers/handlebars.rb

@@ -18,10 +18,10 @@ module Rouge
         rule(/\\{+/) { delegate parent }
 
         # block comments
-        rule /{{!--/, Comment, :comment
-        rule /{{!.*?}}/, Comment
+        rule %r/{{!--/, Comment, :comment
+        rule %r/{{!.*?}}/, Comment
 
-        rule /{{{?/ do
+        rule %r/{{{?/ do
           token Keyword
           push :stache
           push :open_sym
@@ -42,20 +42,20 @@ module Rouge
       end
 
       state :stache do
-        rule /}}}?/, Keyword, :pop!
-        rule /\s+/m, Text
-        rule /[=]/, Operator
-        rule /[\[\]]/, Punctuation
-        rule /[.](?=[}\s])/, Name::Variable
-        rule /[.][.]/, Name::Variable
+        rule %r/}}}?/, Keyword, :pop!
+        rule %r/\s+/m, Text
+        rule %r/[=]/, Operator
+        rule %r/[\[\]]/, Punctuation
+        rule %r/[.](?=[}\s])/, Name::Variable
+        rule %r/[.][.]/, Name::Variable
         rule %r([/.]), Punctuation
-        rule /"(\\.|.)*?"/, Str::Double
-        rule /'(\\.|.)*?'/, Str::Single
-        rule /\d+(?=}\s)/, Num
-        rule /(true|false)(?=[}\s])/, Keyword::Constant
-        rule /else(?=[}\s])/, Keyword
-        rule /this(?=[}\s])/, Name::Builtin::Pseudo
-        rule /@#{id}/, Name::Attribute
+        rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
+        rule %r/\d+(?=}\s)/, Num
+        rule %r/(true|false)(?=[}\s])/, Keyword::Constant
+        rule %r/else(?=[}\s])/, Keyword
+        rule %r/this(?=[}\s])/, Name::Builtin::Pseudo
+        rule %r/@#{id}/, Name::Attribute
         rule id, Name::Variable
       end
 
@@ -65,13 +65,13 @@ module Rouge
           goto :block_name
         end
 
-        rule /[>^&]/, Keyword
+        rule %r/[>^&]/, Keyword
 
         rule(//) { pop! }
       end
 
       state :block_name do
-        rule /if(?=[}\s])/, Keyword
+        rule %r/if(?=[}\s])/, Keyword
         rule id, Name::Namespace, :pop!
         rule(//) { pop! }
       end

data/lib/rouge/lexers/haskell.rb

@@ -9,7 +9,7 @@ module Rouge
 
       tag 'haskell'
       aliases 'hs'
-      filenames '*.hs'
+      filenames '*.hs', '*.hs-boot'
       mimetypes 'text/x-haskell'
 
       def self.detect?(text)
@@ -27,40 +27,41 @@ module Rouge
       )
 
       state :basic do
-        rule /\s+/m, Text
-        rule /{-#/, Comment::Preproc, :comment_preproc
-        rule /{-/, Comment::Multiline, :comment
-        rule /^--\s+\|.*?$/, Comment::Doc
+        rule %r/\s+/m, Text
+        rule %r/{-#/, Comment::Preproc, :comment_preproc
+        rule %r/{-/, Comment::Multiline, :comment
+        rule %r/^--\s+\|.*?$/, Comment::Doc
         # this is complicated in order to support custom symbols
         # like -->
-        rule /--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, Comment::Single
+        rule %r/--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, Comment::Single
       end
 
       # nested commenting
       state :comment do
-        rule /-}/, Comment::Multiline, :pop!
-        rule /{-/, Comment::Multiline, :comment
-        rule /[^-{}]+/, Comment::Multiline
-        rule /[-{}]/, Comment::Multiline
+        rule %r/-}/, Comment::Multiline, :pop!
+        rule %r/{-/, Comment::Multiline, :comment
+        rule %r/[^-{}]+/, Comment::Multiline
+        rule %r/[-{}]/, Comment::Multiline
       end
 
       state :comment_preproc do
-        rule /-}/, Comment::Preproc, :pop!
-        rule /{-/, Comment::Preproc, :comment
-        rule /[^-{}]+/, Comment::Preproc
-        rule /[-{}]/, Comment::Preproc
+        rule %r/-}/, Comment::Preproc, :pop!
+        rule %r/{-/, Comment::Preproc, :comment
+        rule %r/[^-{}]+/, Comment::Preproc
+        rule %r/[-{}]/, Comment::Preproc
       end
 
       state :root do
         mixin :basic
 
-        rule /\bimport\b/, Keyword::Reserved, :import
-        rule /\bmodule\b/, Keyword::Reserved, :module
-        rule /\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
+        rule %r/\bimport\b/, Keyword::Reserved, :import
+        rule %r/\bmodule\b/, Keyword::Reserved, :module
+        rule %r/\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
         # not sure why, but ^ doesn't work here
-        # rule /^[_a-z][\w']*/, Name::Function
-        rule /[_a-z][\w']*/, Name
-        rule /[A-Z][\w']*/, Keyword::Type
+        # rule %r/^[_a-z][\w']*/, Name::Function
+        rule %r/[_a-z][\w']*/, Name
+        rule %r/[A-Z][\w']*/, Keyword::Type
+        rule %r/'[A-Z]\w+'?/, Keyword::Type  # promoted data constructor
 
         # lambda operator
         rule %r(\\(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Name::Function
@@ -71,35 +72,35 @@ module Rouge
         # other operators
         rule %r([:!#\$\%&*+.\\/<=>?@^\|~-]+), Operator
 
-        rule /\d+e[+-]?\d+/i, Num::Float
-        rule /\d+\.\d+(e[+-]?\d+)?/i, Num::Float
-        rule /0o[0-7]+/i, Num::Oct
-        rule /0x[\da-f]+/i, Num::Hex
-        rule /\d+/, Num::Integer
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/0o[0-7]+/i, Num::Oct
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
 
-        rule /'/, Str::Char, :character
-        rule /"/, Str, :string
+        rule %r/'/, Str::Char, :character
+        rule %r/"/, Str, :string
 
-        rule /\[\s*\]/, Keyword::Type
-        rule /\(\s*\)/, Name::Builtin
+        rule %r/\[\s*\]/, Keyword::Type
+        rule %r/\(\s*\)/, Name::Builtin
 
         # Quasiquotations
-        rule /(\[)([_a-z][\w']*)(\|)/ do |m|
+        rule %r/(\[)([_a-z][\w']*)(\|)/ do |m|
           token Operator, m[1]
           token Name, m[2]
           token Operator, m[3]
           push :quasiquotation
         end
 
-        rule /[\[\](),;`{}]/, Punctuation
+        rule %r/[\[\](),;`{}]/, Punctuation
       end
 
       state :import do
-        rule /\s+/, Text
-        rule /"/, Str, :string
-        rule /\bqualified\b/, Keyword
+        rule %r/\s+/, Text
+        rule %r/"/, Str, :string
+        rule %r/\bqualified\b/, Keyword
         # import X as Y
-        rule /([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)/ do
+        rule %r/([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)/ do
           groups(
             Name::Namespace, # X
             Text, Keyword, # as
@@ -109,7 +110,7 @@ module Rouge
         end
 
         # import X hiding (functions)
-        rule /([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
+        rule %r/([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
           groups(
             Name::Namespace, # X
             Text, Keyword, # hiding
@@ -119,7 +120,7 @@ module Rouge
         end
 
         # import X (functions)
-        rule /([A-Z][\w.]*)(\s+)(\()/ do
+        rule %r/([A-Z][\w.]*)(\s+)(\()/ do
           groups(
             Name::Namespace, # X
             Text,
@@ -128,70 +129,70 @@ module Rouge
           goto :funclist
         end
 
-        rule /[\w.]+/, Name::Namespace, :pop!
+        rule %r/[\w.]+/, Name::Namespace, :pop!
       end
 
       state :module do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         # module Foo (functions)
-        rule /([A-Z][\w.]*)(\s+)(\()/ do
+        rule %r/([A-Z][\w.]*)(\s+)(\()/ do
           groups Name::Namespace, Text, Punctuation
           push :funclist
         end
 
-        rule /\bwhere\b/, Keyword::Reserved, :pop!
+        rule %r/\bwhere\b/, Keyword::Reserved, :pop!
 
-        rule /[A-Z][a-zA-Z0-9_.]*/, Name::Namespace, :pop!
+        rule %r/[A-Z][a-zA-Z0-9_.]*/, Name::Namespace, :pop!
       end
 
       state :funclist do
         mixin :basic
-        rule /[A-Z]\w*/, Keyword::Type
-        rule /(_[\w\']+|[a-z][\w\']*)/, Name::Function
-        rule /,/, Punctuation
-        rule /[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, Operator
-        rule /\(/, Punctuation, :funclist
-        rule /\)/, Punctuation, :pop!
+        rule %r/[A-Z]\w*/, Keyword::Type
+        rule %r/(_[\w\']+|[a-z][\w\']*)/, Name::Function
+        rule %r/,/, Punctuation
+        rule %r/[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, Operator
+        rule %r/\(/, Punctuation, :funclist
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :character do
-        rule /\\/ do
+        rule %r/\\/ do
           token Str::Escape
           goto :character_end
           push :escape
         end
 
-        rule /./ do
+        rule %r/./ do
           token Str::Char
           goto :character_end
         end
       end
 
       state :character_end do
-        rule /'/, Str::Char, :pop!
-        rule /./, Error, :pop!
+        rule %r/'/, Str::Char, :pop!
+        rule %r/./, Error, :pop!
       end
 
       state :quasiquotation do
-        rule /\|\]/, Operator, :pop!
-        rule /[^\|]+/m, Text
-        rule /\|/, Text
+        rule %r/\|\]/, Operator, :pop!
+        rule %r/[^\|]+/m, Text
+        rule %r/\|/, Text
       end
 
       state :string do
-        rule /"/, Str, :pop!
-        rule /\\/, Str::Escape, :escape
-        rule /[^\\"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\\/, Str::Escape, :escape
+        rule %r/[^\\"]+/, Str
       end
 
       state :escape do
-        rule /[abfnrtv"'&\\]/, Str::Escape, :pop!
-        rule /\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
-        rule /#{ascii.join('|')}/, Str::Escape, :pop!
-        rule /o[0-7]+/i, Str::Escape, :pop!
-        rule /x[\da-f]+/i, Str::Escape, :pop!
-        rule /\d+/, Str::Escape, :pop!
-        rule /\s+\\/, Str::Escape, :pop!
+        rule %r/[abfnrtv"'&\\]/, Str::Escape, :pop!
+        rule %r/\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
+        rule %r/#{ascii.join('|')}/, Str::Escape, :pop!
+        rule %r/o[0-7]+/i, Str::Escape, :pop!
+        rule %r/x[\da-f]+/i, Str::Escape, :pop!
+        rule %r/\d+/, Str::Escape, :pop!
+        rule %r/\s+\\/, Str::Escape, :pop!
       end
     end
   end