rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/nim.rb

@@ -112,7 +112,7 @@ module Rouge
              Punctuation)
 
         # Strings
-        rule(/(?:[\w]+)"/,Str, :rdqs)
+        rule(/(?:\w+)"/,Str, :rdqs)
         rule(/"""/,       Str, :tdqs)
         rule(/"/,         Str, :dqs)
 

data/lib/rouge/lexers/nix.rb

@@ -11,34 +11,34 @@ module Rouge
       filenames '*.nix'
 
       state :whitespaces do
-        rule /^\s*\n\s*$/m, Text
-        rule /\s+/, Text
+        rule %r/^\s*\n\s*$/m, Text
+        rule %r/\s+/, Text
       end
 
       state :comment do
-        rule /#.*$/, Comment
-        rule /\/\*/, Comment, :multiline_comment
+        rule %r/#.*$/, Comment
+        rule %r(/\*), Comment, :multiline_comment
       end
 
       state :multiline_comment do
-        rule /\*\//, Comment, :pop!
-        rule /./, Comment
+        rule %r(\*/), Comment, :pop!
+        rule %r/./, Comment
       end
 
       state :number do
-        rule /[0-9]/, Num::Integer
+        rule %r/[0-9]/, Num::Integer
       end
 
       state :null do
-        rule /(null)/, Keyword::Constant
+        rule %r/(null)/, Keyword::Constant
       end
 
       state :boolean do
-        rule /(true|false)/, Keyword::Constant
+        rule %r/(true|false)/, Keyword::Constant
       end
 
       state :binding do
-        rule /[a-zA-Z_][a-zA-Z0-9-]*/, Name::Variable
+        rule %r/[a-zA-Z_][a-zA-Z0-9-]*/, Name::Variable
       end
 
       state :path do
@@ -49,86 +49,86 @@ module Rouge
         tilde = /~#{section}+/.source
         basic = /#{word}(\/#{word})+/.source
         url = /#{prefix}(\/?#{basic})/.source
-        rule /(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
+        rule %r/(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
       end
 
       state :string do
-        rule /"/, Str::Double, :double_quoted_string
-        rule /''/, Str::Double, :indented_string
+        rule %r/"/, Str::Double, :double_quoted_string
+        rule %r/''/, Str::Double, :indented_string
       end
 
       state :string_content do
-        rule /\\./, Str::Escape
-        rule /\$\$/, Str::Escape
-        rule /\${/, Str::Interpol, :string_interpolated_arg
+        rule %r/\\./, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
       end
 
       state :indented_string_content do
-        rule /'''/, Str::Escape
-        rule /''\$/, Str::Escape
-        rule /\$\$/, Str::Escape
-        rule /''\\./, Str::Escape
-        rule /\${/, Str::Interpol, :string_interpolated_arg
+        rule %r/'''/, Str::Escape
+        rule %r/''\$/, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/''\\./, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
       end
 
       state :string_interpolated_arg do
         mixin :expression
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
       end
 
       state :indented_string do
         mixin :indented_string_content
-        rule /''/, Str::Double, :pop!
-        rule /./, Str::Double
+        rule %r/''/, Str::Double, :pop!
+        rule %r/./, Str::Double
       end
 
       state :double_quoted_string do
         mixin :string_content
-        rule /"/, Str::Double, :pop!
-        rule /./, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./, Str::Double
       end
 
       state :operator do
-        rule /(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
+        rule %r/(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
       end
 
       state :assignment do
-        rule /(=)/, Operator
-        rule /(@)/, Operator
+        rule %r/(=)/, Operator
+        rule %r/(@)/, Operator
       end
 
       state :accessor do
-        rule /(\$)/, Punctuation
+        rule %r/(\$)/, Punctuation
       end
 
       state :delimiter do
-        rule /(;|,|:)/, Punctuation
+        rule %r/(;|,|:)/, Punctuation
       end
 
       state :atom_content do
         mixin :expression
-        rule /\)/, Punctuation, :pop!
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :atom do
-        rule /\(/, Punctuation, :atom_content
+        rule %r/\(/, Punctuation, :atom_content
       end
 
       state :list do
-        rule /\[/, Punctuation, :list_content
+        rule %r/\[/, Punctuation, :list_content
       end
 
       state :list_content do
-        rule /\]/, Punctuation, :pop!
+        rule %r/\]/, Punctuation, :pop!
         mixin :expression
       end
 
       state :set do
-        rule /{/, Punctuation, :set_content
+        rule %r/{/, Punctuation, :set_content
       end
 
       state :set_content do
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
         mixin :expression
       end
       
@@ -161,22 +161,22 @@ module Rouge
 
       state :keywords_namespace do
         keywords = %w(with in inherit)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Namespace
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Namespace
       end
 
       state :keywords_declaration do
         keywords = %w(let)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Declaration
       end
 
       state :keywords_conditional do
         keywords = %w(if then else)
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
       end
 
       state :keywords_reserved do
         keywords = %w(rec assert map)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Reserved
       end
 
       state :keywords_builtin do
@@ -192,7 +192,7 @@ module Rouge
           throw
           toString
         )
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Reserved
       end
 
       state :ignore do

data/lib/rouge/lexers/objective_c.rb

@@ -33,21 +33,21 @@ module Rouge
       id = /[a-z$_][a-z0-9$_]*/i
 
       prepend :statements do
-        rule /@"/, Str, :string
-        rule /@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
+        rule %r/@"/, Str, :string
+        rule %r/@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
           Str::Char
-        rule /@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
+        rule %r/@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
           Num::Float
-        rule /@(\d+[.]\d*|[.]\d+|\d+f)f?/i, Num::Float
-        rule /@0x\h+[lL]?/, Num::Hex
-        rule /@0[0-7]+l?/i, Num::Oct
-        rule /@\d+l?/, Num::Integer
-        rule /\bin\b/, Keyword
+        rule %r/@(\d+[.]\d*|[.]\d+|\d+f)f?/i, Num::Float
+        rule %r/@0x\h+[lL]?/, Num::Hex
+        rule %r/@0[0-7]+l?/i, Num::Oct
+        rule %r/@\d+l?/, Num::Integer
+        rule %r/\bin\b/, Keyword
 
-        rule /@(?:interface|implementation)\b/, Keyword, :classname
-        rule /@(?:class|protocol)\b/, Keyword, :forward_classname
+        rule %r/@(?:interface|implementation)\b/, Keyword, :classname
+        rule %r/@(?:class|protocol)\b/, Keyword, :forward_classname
 
-        rule /@([[:alnum:]]+)/ do |m|
+        rule %r/@([[:alnum:]]+)/ do |m|
           if self.class.at_keywords.include? m[1]
             token Keyword
           elsif self.class.at_builtins.include? m[1]
@@ -57,32 +57,32 @@ module Rouge
           end
         end
 
-        rule /[?]/, Punctuation, :ternary
-        rule /\[/,  Punctuation, :message
-        rule /@\[/, Punctuation, :array_literal
-        rule /@\{/, Punctuation, :dictionary_literal
+        rule %r/[?]/, Punctuation, :ternary
+        rule %r/\[/,  Punctuation, :message
+        rule %r/@\[/, Punctuation, :array_literal
+        rule %r/@\{/, Punctuation, :dictionary_literal
       end
 
       state :ternary do
-        rule /:/, Punctuation, :pop!
+        rule %r/:/, Punctuation, :pop!
         mixin :statements
       end
 
       state :message_shared do
-        rule /\]/, Punctuation, :pop!
-        rule /\{/, Punctuation, :pop!
-        rule /;/, Error
+        rule %r/\]/, Punctuation, :pop!
+        rule %r/\{/, Punctuation, :pop!
+        rule %r/;/, Error
 
         mixin :statements
       end
 
       state :message do
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups(Name::Function, Text, Punctuation)
           goto :message_with_args
         end
 
-        rule /(#{id})(\s*)(\])/ do
+        rule %r/(#{id})(\s*)(\])/ do
           groups(Name::Function, Text, Punctuation)
           pop!
         end
@@ -91,8 +91,8 @@ module Rouge
       end
 
       state :message_with_args do
-        rule /\{/, Punctuation, :function
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/\{/, Punctuation, :function
+        rule %r/(#{id})(\s*)(:)/ do
           groups(Name::Function, Text, Punctuation)
           pop!
         end
@@ -101,28 +101,28 @@ module Rouge
       end
 
       state :array_literal do
-        rule /]/, Punctuation, :pop!
-        rule /,/, Punctuation
+        rule %r/]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
         mixin :statements
       end
 
       state :dictionary_literal do
-        rule /}/, Punctuation, :pop!
-        rule /,/, Punctuation
+        rule %r/}/, Punctuation, :pop!
+        rule %r/,/, Punctuation
         mixin :statements
       end
 
       state :classname do
         mixin :whitespace
 
-        rule /(#{id})(\s*)(:)(\s*)(#{id})/ do
+        rule %r/(#{id})(\s*)(:)(\s*)(#{id})/ do
           groups(Name::Class, Text,
                  Punctuation, Text,
                  Name::Class)
           pop!
         end
 
-        rule /(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
+        rule %r/(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
           groups(Name::Class, Text,
                  Punctuation, Text,
                  Name::Label, Text,
@@ -136,12 +136,12 @@ module Rouge
       state :forward_classname do
         mixin :whitespace
 
-        rule /(#{id})(\s*)(,)(\s*)/ do
+        rule %r/(#{id})(\s*)(,)(\s*)/ do
           groups(Name::Class, Text, Punctuation, Text)
           push
         end
 
-        rule /(#{id})(\s*)(;?)/ do
+        rule %r/(#{id})(\s*)(;?)/ do
           groups(Name::Class, Text, Punctuation)
           pop!
         end
@@ -162,26 +162,26 @@ module Rouge
       end
 
       state :method_definition do
-        rule /,/, Punctuation
-        rule /[.][.][.]/, Punctuation
-        rule /([(].*?[)])(#{id})/ do |m|
+        rule %r/,/, Punctuation
+        rule %r/[.][.][.]/, Punctuation
+        rule %r/([(].*?[)])(#{id})/ do |m|
           recurse m[1]; token Name::Variable, m[2]
         end
 
-        rule /(#{id})(\s*)(:)/m do
+        rule %r/(#{id})(\s*)(:)/m do
           groups(Name::Function, Text, Punctuation)
         end
 
-        rule /;/, Punctuation, :pop!
+        rule %r/;/, Punctuation, :pop!
 
-        rule /{/ do
+        rule %r/{/ do
           token Punctuation
           goto :function
         end
 
         mixin :inline_whitespace
         rule %r(//.*?\n), Comment::Single
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
 
         rule(//) { pop! }
       end

data/lib/rouge/lexers/ocaml.rb

@@ -33,12 +33,12 @@ module Rouge
       upper_id = /[A-Z][\w']*/
 
       state :root do
-        rule /\s+/m, Text
-        rule /false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
-        rule /#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
-        rule /`#{id}/, Name::Tag
+        rule %r/\s+/m, Text
+        rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule %r/`#{id}/, Name::Tag
         rule upper_id, Name::Class
-        rule /[(][*](?![)])/, Comment, :comment
+        rule %r/[(][*](?![)])/, Comment, :comment
         rule id do |m|
           match = m[0]
           if self.class.keywords.include? match
@@ -52,49 +52,49 @@ module Rouge
           end
         end
 
-        rule /[(){}\[\];]+/, Punctuation
+        rule %r/[(){}\[\];]+/, Punctuation
         rule operator, Operator
 
-        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
-        rule /0x\h[\h_]*/i, Num::Hex
-        rule /0o[0-7][0-7_]*/i, Num::Oct
-        rule /0b[01][01_]*/i, Num::Bin
-        rule /\d[\d_]*/, Num::Integer
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
 
-        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
-        rule /'[.]'/, Str::Char
-        rule /'/, Keyword
-        rule /"/, Str::Double, :string
-        rule /[~?]#{id}/, Name::Variable
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[.]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{id}/, Name::Variable
       end
 
       state :comment do
-        rule /[^(*)]+/, Comment
+        rule %r/[^(*)]+/, Comment
         rule(/[(][*]/) { token Comment; push }
-        rule /[*][)]/, Comment, :pop!
-        rule /[(*)]/, Comment
+        rule %r/[*][)]/, Comment, :pop!
+        rule %r/[(*)]/, Comment
       end
 
       state :string do
-        rule /[^\\"]+/, Str::Double
+        rule %r/[^\\"]+/, Str::Double
         mixin :escape_sequence
-        rule /\\\n/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :escape_sequence do
-        rule /\\[\\"'ntbr]/, Str::Escape
-        rule /\\\d{3}/, Str::Escape
-        rule /\\x\h{2}/, Str::Escape
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
       end
 
       state :dotted do
-        rule /\s+/m, Text
-        rule /[.]/, Punctuation
-        rule /#{upper_id}(?=\s*[.])/, Name::Namespace
+        rule %r/\s+/m, Text
+        rule %r/[.]/, Punctuation
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace
         rule upper_id, Name::Class, :pop!
         rule id, Name, :pop!
-        rule /[({\[]/, Punctuation, :pop!
+        rule %r/[({\[]/, Punctuation, :pop!
       end
     end
   end