rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/sed.rb

@@ -17,15 +17,15 @@ module Rouge
 
       class Regex < RegexLexer
         state :root do
-          rule /\\./, Str::Escape
-          rule /\[/, Punctuation, :brackets
-          rule /[$^.*]/, Operator
-          rule /[()]/, Punctuation
-          rule /./, Str::Regex
+          rule %r/\\./, Str::Escape
+          rule %r/\[/, Punctuation, :brackets
+          rule %r/[$^.*]/, Operator
+          rule %r/[()]/, Punctuation
+          rule %r/./, Str::Regex
         end
 
         state :brackets do
-          rule /\^/ do
+          rule %r/\^/ do
             token Punctuation
             goto :brackets_int
           end
@@ -35,17 +35,17 @@ module Rouge
 
         state :brackets_int do
           # ranges
-          rule /.-./, Name::Variable
-          rule /\]/, Punctuation, :pop!
-          rule /./, Str::Regex
+          rule %r/.-./, Name::Variable
+          rule %r/\]/, Punctuation, :pop!
+          rule %r/./, Str::Regex
         end
       end
 
       class Replacement < RegexLexer
         state :root do
-          rule /\\./m, Str::Escape
-          rule /&/, Operator
-          rule /[^\\&]+/m, Text
+          rule %r/\\./m, Str::Escape
+          rule %r/&/, Operator
+          rule %r/[^\\&]+/m, Text
         end
       end
 
@@ -60,7 +60,7 @@ module Rouge
       start { regex.reset!; replacement.reset! }
 
       state :whitespace do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule(/#.*?\n/) { token Comment; reset_stack }
         rule(/\n/) { token Text; reset_stack }
         rule(/;/) { token Punctuation; reset_stack }
@@ -76,7 +76,7 @@ module Rouge
         mixin :whitespace
 
         # subst and transliteration
-        rule /(s)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+        rule %r/(s)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
           token Keyword, m[1]
           token Punctuation, m[2]
           delegate regex, m[3]
@@ -88,7 +88,7 @@ module Rouge
           goto :flags
         end
 
-        rule /(y)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
+        rule %r/(y)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
           token Keyword, m[1]
           token Punctuation, m[2]
           delegate replacement, m[3]
@@ -100,29 +100,29 @@ module Rouge
         end
 
         # commands that take a text segment as an argument
-        rule /([aic])(\s*)/ do
+        rule %r/([aic])(\s*)/ do
           groups Keyword, Text; goto :text
         end
 
-        rule /[pd]/, Keyword
+        rule %r/[pd]/, Keyword
 
         # commands that take a number argument
-        rule /([qQl])(\s+)(\d+)/i do
+        rule %r/([qQl])(\s+)(\d+)/i do
           groups Keyword, Text, Num
           pop!
         end
 
         # no-argument commands
-        rule /[={}dDgGhHlnpPqx]/, Keyword, :pop!
+        rule %r/[={}dDgGhHlnpPqx]/, Keyword, :pop!
 
         # commands that take a filename argument
-        rule /([rRwW])(\s+)(\S+)/ do
+        rule %r/([rRwW])(\s+)(\S+)/ do
           groups Keyword, Text, Name
           pop!
         end
 
         # commands that take a label argument
-        rule /([:btT])(\s+)(\S+)/ do
+        rule %r/([:btT])(\s+)(\S+)/ do
           groups Keyword, Text, Name::Label
           pop!
         end
@@ -133,15 +133,15 @@ module Rouge
 
         ### address ranges ###
         addr_tok = Keyword::Namespace
-        rule /\d+/, addr_tok
-        rule /[$,~+!]/, addr_tok
+        rule %r/\d+/, addr_tok
+        rule %r/[$,~+!]/, addr_tok
 
         rule %r((/)((?:\\.|.)*?)(/)) do |m|
           token addr_tok, m[1]; delegate regex, m[2]; token addr_tok, m[3]
         end
 
         # alternate regex rage delimiters
-        rule %r((\\)(.)(\\.|.)*?(\2)) do |m|
+        rule %r((\\)(.)((?:\\.|.)*?)(\2)) do |m|
           token addr_tok, m[1] + m[2]
           delegate regex, m[3]
           token addr_tok, m[4]
@@ -151,18 +151,18 @@ module Rouge
       end
 
       state :text do
-        rule /[^\\\n]+/, Str
-        rule /\\\n/, Str::Escape
-        rule /\\/, Str
-        rule /\n/, Text, :pop!
+        rule %r/[^\\\n]+/, Str
+        rule %r/\\\n/, Str::Escape
+        rule %r/\\/, Str
+        rule %r/\n/, Text, :pop!
       end
 
       state :flags do
-        rule /[gp]+/, Keyword, :pop!
+        rule %r/[gp]+/, Keyword, :pop!
 
         # writing to a file with the subst command.
         # who'da thunk...?
-        rule /([wW])(\s+)(\S+)/ do
+        rule %r/([wW])(\s+)(\S+)/ do
           token Keyword; token Text; token Name
         end
 

data/lib/rouge/lexers/shell.rb

@@ -10,7 +10,7 @@ module Rouge
       tag 'shell'
       aliases 'bash', 'zsh', 'ksh', 'sh'
       filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
-                '.bashrc', '.zshrc', '.kshrc', '.profile', 'PKGBUILD'
+                '.bashrc', '.zshrc', '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD'
 
       mimetypes 'application/x-sh', 'application/x-shellscript'
 
@@ -44,25 +44,25 @@ module Rouge
       ).join('|')
 
       state :basic do
-        rule /#.*$/, Comment
+        rule %r/#.*$/, Comment
 
-        rule /\b(#{KEYWORDS})\s*\b/, Keyword
-        rule /\bcase\b/, Keyword, :case
+        rule %r/\b(#{KEYWORDS})\s*\b/, Keyword
+        rule %r/\bcase\b/, Keyword, :case
 
-        rule /\b(#{BUILTINS})\s*\b(?!(\.|-))/, Name::Builtin
-        rule /[.](?=\s)/, Name::Builtin
+        rule %r/\b(#{BUILTINS})\s*\b(?!(\.|-))/, Name::Builtin
+        rule %r/[.](?=\s)/, Name::Builtin
 
-        rule /(\b\w+)(=)/ do |m|
+        rule %r/(\b\w+)(=)/ do
           groups Name::Variable, Operator
         end
 
-        rule /[\[\]{}()!=>]/, Operator
-        rule /&&|\|\|/, Operator
+        rule %r/[\[\]{}()!=>]/, Operator
+        rule %r/&&|\|\|/, Operator
 
         # here-string
-        rule /<<</, Operator
+        rule %r/<<</, Operator
 
-        rule /(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+        rule %r/(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
           groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
           @heredocstr = Regexp.escape(m[5])
           push :heredoc
@@ -70,14 +70,14 @@ module Rouge
       end
 
       state :heredoc do
-        rule /\n/, Str::Heredoc, :heredoc_nl
-        rule /[^$\n]+/, Str::Heredoc
+        rule %r/\n/, Str::Heredoc, :heredoc_nl
+        rule %r/[^$\n\\]+/, Str::Heredoc
         mixin :interp
-        rule /[$]/, Str::Heredoc
+        rule %r/[$]/, Str::Heredoc
       end
 
       state :heredoc_nl do
-        rule /\s*(\w+)\s*\n/ do |m|
+        rule %r/\s*(\w+)\s*\n/ do |m|
           if m[1] == @heredocstr
             token Name::Constant
             pop! 2
@@ -93,92 +93,101 @@ module Rouge
       state :double_quotes do
         # NB: "abc$" is literally the string abc$.
         # Here we prevent :interp from interpreting $" as a variable.
-        rule /(?:\$#?)?"/, Str::Double, :pop!
+        rule %r/(?:\$#?)?"/, Str::Double, :pop!
         mixin :interp
-        rule /[^"`\\$]+/, Str::Double
+        rule %r/[^"`\\$]+/, Str::Double
       end
 
       state :ansi_string do
-        rule /\\./, Str::Escape
-        rule /[^\\']+/, Str::Single
+        rule %r/\\./, Str::Escape
+        rule %r/[^\\']+/, Str::Single
         mixin :single_quotes
       end
 
       state :single_quotes do
-        rule /'/, Str::Single, :pop!
-        rule /[^']+/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
       end
 
       state :data do
-        rule /\s+/, Text
-        rule /\\./, Str::Escape
-        rule /\$?"/, Str::Double, :double_quotes
-        rule /\$'/, Str::Single, :ansi_string
+        rule %r/\s+/, Text
+        rule %r/\\./, Str::Escape
+        rule %r/\$?"/, Str::Double, :double_quotes
+        rule %r/\$'/, Str::Single, :ansi_string
 
         # single quotes are much easier than double quotes - we can
         # literally just scan until the next single quote.
         # POSIX: Enclosing characters in single-quotes ( '' )
         # shall preserve the literal value of each character within the
         # single-quotes. A single-quote cannot occur within single-quotes.
-        rule /'/, Str::Single, :single_quotes
+        rule %r/'/, Str::Single, :single_quotes
 
-        rule /\*/, Keyword
+        rule %r/\*/, Keyword
 
-        rule /;/, Punctuation
+        rule %r/;/, Punctuation
 
-        rule /--?[\w-]+/, Name::Tag
-        rule /[^=\*\s{}()$"'`;\\<]+/, Text
-        rule /\d+(?= |\Z)/, Num
-        rule /</, Text
+        rule %r/--?[\w-]+/, Name::Tag
+        rule %r/[^=\*\s{}()$"'`;\\<]+/, Text
+        rule %r/\d+(?= |\Z)/, Num
+        rule %r/</, Text
         mixin :interp
       end
 
       state :curly do
-        rule /}/, Keyword, :pop!
-        rule /:-/, Keyword
-        rule /[a-zA-Z0-9_]+/, Name::Variable
-        rule /[^}:"`'$]+/, Punctuation
+        rule %r/}/, Keyword, :pop!
+        rule %r/:-/, Keyword
+        rule %r/[a-zA-Z0-9_]+/, Name::Variable
+        rule %r/[^}:"`'$]+/, Punctuation
         mixin :root
       end
 
-      state :paren do
-        rule /\)/, Keyword, :pop!
+      # the state inside $(...)
+      state :paren_interp do
+        rule %r/\)/, Str::Interpol, :pop!
+        rule %r/\(/, Operator, :paren_inner
+        mixin :root
+      end
+
+      # used to balance parentheses inside interpolation
+      state :paren_inner do
+        rule %r/\(/, Operator, :push
+        rule %r/\)/, Operator, :pop!
         mixin :root
       end
 
       state :math do
-        rule /\)\)/, Keyword, :pop!
+        rule %r/\)\)/, Keyword, :pop!
         rule %r([-+*/%^|&!]|\*\*|\|\|), Operator
-        rule /\d+(#\w+)?/, Num
+        rule %r/\d+(#\w+)?/, Num
         mixin :root
       end
 
       state :case do
-        rule /\besac\b/, Keyword, :pop!
-        rule /\|/, Punctuation
-        rule /\)/, Punctuation, :case_stanza
+        rule %r/\besac\b/, Keyword, :pop!
+        rule %r/\|/, Punctuation
+        rule %r/\)/, Punctuation, :case_stanza
         mixin :root
       end
 
       state :case_stanza do
-        rule /;;/, Punctuation, :pop!
+        rule %r/;;/, Punctuation, :pop!
         mixin :root
       end
 
       state :backticks do
-        rule /`/, Str::Backtick, :pop!
+        rule %r/`/, Str::Backtick, :pop!
         mixin :root
       end
 
       state :interp do
-        rule /\\$/, Str::Escape # line continuation
-        rule /\\./, Str::Escape
-        rule /\$\(\(/, Keyword, :math
-        rule /\$\(/, Keyword, :paren
-        rule /\${#?/, Keyword, :curly
-        rule /`/, Str::Backtick, :backticks
-        rule /\$#?(\w+|.)/, Name::Variable
-        rule /\$[*@]/, Name::Variable
+        rule %r/\\$/, Str::Escape # line continuation
+        rule %r/\\./, Str::Escape
+        rule %r/\$\(\(/, Keyword, :math
+        rule %r/\$\(/, Str::Interpol, :paren_interp
+        rule %r/\${#?/, Keyword, :curly
+        rule %r/`/, Str::Backtick, :backticks
+        rule %r/\$#?(\w+|.)/, Name::Variable
+        rule %r/\$[*@]/, Name::Variable
       end
 
       state :root do

data/lib/rouge/lexers/sieve.rb

@@ -57,23 +57,23 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(#.*?\n), Comment::Single
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
       end
 
       state :string do
-        rule /\\./, Str::Escape
-        rule /"/, Str::Double, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/"/, Str::Double, :pop!
         # Variables Extension (rfc5229)
-        rule /\${(?:[0-9][.0-9]*|[a-zA-Z_][.a-zA-Z0-9_]*)}/, Str::Interpol
-        rule /./, Str::Double
+        rule %r/\${(?:[0-9][.0-9]*|[a-zA-Z_][.a-zA-Z0-9_]*)}/, Str::Interpol
+        rule %r/./, Str::Double
       end
 
       state :root do
         mixin :comments_and_whitespace
 
-        rule /[\[\](),;{}]/, Punctuation
+        rule %r/[\[\](),;{}]/, Punctuation
 
         rule id do |m|
           if self.class.controls.include? m[0]
@@ -89,8 +89,8 @@ module Rouge
           end
         end
 
-        rule /"/, Str::Double, :string
-        rule /[0-9]+[KMG]/, Num::Integer
+        rule %r/"/, Str::Double, :string
+        rule %r/[0-9]+[KMG]/, Num::Integer
       end
     end
   end

data/lib/rouge/lexers/slim.rb

@@ -45,22 +45,22 @@ module Rouge
       start { ruby.reset!; html.reset! }
 
       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 /\/#{dot}*/, Comment, :indented_block
+        rule %r/\/#{dot}*/, Comment, :indented_block
 
-        rule /(doctype)(\s+)(.*)/ do
+        rule %r/(doctype)(\s+)(.*)/ do
           groups Name::Namespace, Text::Whitespace, Text
           pop!
         end
 
         # filters, shamelessly ripped from HAML
-        rule /(\w*):\s*\n/ do |m|
+        rule %r/(\w*):\s*\n/ do |m|
           token Name::Decorator
           pop!
           starts_block :filter_block
@@ -81,29 +81,29 @@ module Rouge
           goto :plain_block
         end
 
-        rule /-|==|=/, Punctuation, :ruby_line
+        rule %r/-|==|=/, Punctuation, :ruby_line
 
         # Dynamic tags
-        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+        rule %r/(\*)(#{ruby_chars}+\(.*?\))/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
           push :tag
         end
 
-        rule /(\*)(#{ruby_chars}+)/ do |m|
+        rule %r/(\*)(#{ruby_chars}+)/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
           push :tag
         end
 
-        #rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        #rule %r/<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
         rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
           delegate html, m[1]
           pop!
         end
 
         # Ordinary slim tags
-        rule /\w+/, Name::Tag, :tag
+        rule %r/\w+/, Name::Tag, :tag
 
       end
 
@@ -113,24 +113,24 @@ module Rouge
         mixin :interpolation
 
         # Whitespace control
-        rule /[<>]/, Punctuation
+        rule %r/[<>]/, Punctuation
 
         # Trim whitespace
-        rule /\s+?/, Text::Whitespace
+        rule %r/\s+?/, Text::Whitespace
 
         # Splats, these two might be mergable?
-        rule /(\*)(#{ruby_chars}+)/ do |m|
+        rule %r/(\*)(#{ruby_chars}+)/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
         end
 
-        rule /(\*)(\{#{dot}+?\})/ do |m|
+        rule %r/(\*)(\{#{dot}+?\})/ do |m|
           token Punctuation, m[1]
           delegate ruby, m[2]
         end
 
         # Attributes
-        rule /([\w\-]+)(\s*)(\=)/ do |m|
+        rule %r/([\w\-]+)(\s*)(\=)/ do |m|
           token Name::Attribute, m[1]
           token Text::Whitespace, m[2]
           token Punctuation, m[3]
@@ -138,7 +138,7 @@ module Rouge
         end
 
         # Ruby value
-        rule /(\=)(#{dot}+)/ do |m|
+        rule %r/(\=)(#{dot}+)/ do |m|
           token Punctuation, m[1]
           #token Keyword::Constant, m[2]
           delegate ruby, m[2]
@@ -147,9 +147,9 @@ module Rouge
         # HTML Entities
         rule(/&\S*?;/, Name::Entity)
 
-        rule /#{dot}+?/, Text
+        rule %r/#{dot}+?/, Text
 
-        rule /\s*\n/, Text::Whitespace, :pop!
+        rule %r/\s*\n/, Text::Whitespace, :pop!
       end
 
       state :css do
@@ -165,20 +165,20 @@ module Rouge
         rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
         rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
 
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
       end
 
       state :ruby_line do
         # Need at top
         mixin :indented_block
 
-        rule(/,\s*\n/) { delegate ruby }
-        rule /[ ]\|[ \t]*\n/, Str::Escape
-        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+        rule(/[,\\]\s*\n/) { delegate ruby }
+        rule %r/[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=([,\\]$| \|)?[ \t]*$)/) { delegate ruby }
       end
 
       state :filter_block do
-        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
           if @filter_lexer
             delegate @filter_lexer
           else
@@ -200,18 +200,18 @@ module Rouge
         # HTML Entities
         rule(/&\S*?;/, Name::Entity)
 
-        #rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
-        rule /#{dot}+?/, Text
+        #rule %r/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule %r/#{dot}+?/, Text
 
         mixin :indented_block
       end
 
       state :interpolation do
-        rule /#[{]/, Str::Interpol, :ruby_interp
+        rule %r/#[{]/, Str::Interpol, :ruby_interp
       end
 
       state :ruby_interp do
-        rule /[}]/, Str::Interpol, :pop!
+        rule %r/[}]/, Str::Interpol, :pop!
         mixin :ruby_interp_inner
       end