rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/sql.rb

@@ -85,52 +85,52 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, 'Text'
-        rule /--.*?\n/, 'Comment.Single'
-        rule %r(/\*), 'Comment.Multiline', :multiline_comments
-        rule /\d+/, 'Literal.Number.Integer'
-        rule /'/, 'Literal.String.Single', :single_string
-        rule /"/, 'Name.Variable', :double_string
-        rule /`/, 'Name.Variable', :backtick
+        rule /\s+/m, Text
+        rule /--.*?\n/, Comment::Single
+        rule %r(/\*), Comment::Multiline, :multiline_comments
+        rule /\d+/, Num::Integer
+        rule /'/, Str::Single, :single_string
+        rule /"/, Name::Variable, :double_string
+        rule /`/, Name::Variable, :backtick
 
         rule /\w[\w\d]*/ do |m|
           if self.class.keywords.include? m[0].upcase
-            token 'Keyword'
+            token Keyword
           else
-            token 'Name'
+            token Name
           end
         end
 
-        rule %r([+*/<>=~!@#%^&|?^-]), 'Operator'
-        rule /[;:()\[\],.]/, 'Punctuation'
+        rule %r([+*/<>=~!@#%^&|?^-]), Operator
+        rule /[;:()\[\],.]/, Punctuation
       end
 
       state :multiline_comments do
-        rule %r(/[*]), 'Comment.Multiline', :multiline_comments
-        rule %r([*]/), 'Comment.Multiline', :pop!
-        rule %r([^/*]+), 'Comment.Multiline'
-        rule %r([/*]), 'Comment.Multiline'
+        rule %r(/[*]), Comment::Multiline, :multiline_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^/*]+), Comment::Multiline
+        rule %r([/*]), Comment::Multiline
       end
 
       state :backtick do
-        rule /\\./, 'Literal.String.Escape'
-        rule /``/, 'Literal.String.Escape'
-        rule /`/, 'Name.Variable', :pop!
-        rule /[^\\`]+/, 'Name.Variable'
+        rule /\\./, Str::Escape
+        rule /``/, Str::Escape
+        rule /`/, Name::Variable, :pop!
+        rule /[^\\`]+/, Name::Variable
       end
 
       state :single_string do
-        rule /\\./, 'Literal.String.Escape'
-        rule /''/, 'Literal.String.Escape'
-        rule /'/, 'Literal.String.Single', :pop!
-        rule /[^\\']+/, 'Literal.String.Single'
+        rule /\\./, Str::Escape
+        rule /''/, Str::Escape
+        rule /'/, Str::Single, :pop!
+        rule /[^\\']+/, Str::Single
       end
 
       state :double_string do
-        rule /\\./, 'Literal.String.Escape'
-        rule /""/, 'Literal.String.Escape'
-        rule /"/, 'Name.Variable', :pop!
-        rule /[^\\"]+/, 'Name.Variable'
+        rule /\\./, Str::Escape
+        rule /""/, Str::Escape
+        rule /"/, Name::Variable, :pop!
+        rule /[^\\"]+/, Name::Variable
       end
     end
   end

data/lib/rouge/lexers/tcl.rb

@@ -41,21 +41,21 @@ module Rouge
       NOT_CHARS = lambda { |list| Regexp.new %/[^#{list.join}]/ }
 
       state :word do
-        rule /\{\*\}/, 'Keyword'
+        rule /\{\*\}/, Keyword
 
         mixin :brace_abort
         mixin :interp
-        rule /\{/, 'Punctuation', :brace
-        rule /\(/, 'Punctuation',   :paren
-        rule /"/,  'Literal.String.Double', :string
-        rule /#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN+['\\\\']]})/, 'Text'
+        rule /\{/, Punctuation, :brace
+        rule /\(/, Punctuation,   :paren
+        rule /"/,  Str::Double, :string
+        rule /#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN+['\\\\']]})/, Text
       end
 
       def self.gen_command_state(name='')
         state(:"command#{name}") do
           mixin :word
 
-          rule /##{NOT_CHARS[END_LINE]}+/, 'Comment.Single'
+          rule /##{NOT_CHARS[END_LINE]}+/, Comment::Single
 
           rule /(?=#{CHARS[END_WORD]})/ do
             push :"params#{name}"
@@ -63,11 +63,11 @@ module Rouge
 
           rule /#{NOT_CHARS[END_WORD]}+/ do |m|
             if KEYWORDS.include? m[0]
-              token 'Keyword'
+              token Keyword
             elsif BUILTINS.include? m[0]
-              token 'Name.Builtin'
+              token Name::Builtin
             else
-              token 'Text'
+              token Text
             end
           end
 
@@ -80,24 +80,24 @@ module Rouge
 
         state :"params_in_#{name}" do
           rule close do
-            token 'Punctuation'
-            pop!; pop!
+            token Punctuation
+            pop! 2
           end
 
           # mismatched delimiters.  Braced strings with mismatched
           # closing delimiters should be okay, since this is standard
           # practice, like {]]]]}
           if opts[:strict]
-            rule CHARS[CLOSE - [close]], 'Error'
+            rule CHARS[CLOSE - [close]], Error
           else
-            rule CHARS[CLOSE - [close]], 'Text'
+            rule CHARS[CLOSE - [close]], Text
           end
 
           mixin :params
         end
 
         state name do
-          rule close, 'Punctuation', :pop!
+          rule close, Punctuation, :pop!
           mixin :"command_in_#{name}"
         end
       end
@@ -116,20 +116,20 @@ module Rouge
           if in_state? :brace
             pop! until state? :brace
             pop!
-            token 'Punctuation'
+            token Punctuation
           else
-            token 'Error'
+            token Error
           end
         end
       end
 
       state :params do
-        rule /;/, 'Punctuation', :pop!
-        rule /\n/, 'Text', :pop!
-        rule /else|elseif|then/, 'Keyword'
+        rule /;/, Punctuation, :pop!
+        rule /\n/, Text, :pop!
+        rule /else|elseif|then/, Keyword
         mixin :word
         mixin :whitespace
-        rule /#{NOT_CHARS[END_WORD]}+/, 'Text'
+        rule /#{NOT_CHARS[END_WORD]}+/, Text
       end
 
       gen_delimiter_states :brace,   /\}/, :strict => false
@@ -143,26 +143,26 @@ module Rouge
 
       state :whitespace do
         # not a multiline regex because we want to capture \n sometimes
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
       end
 
       state :interp do
-        rule /\[/, 'Punctuation', :bracket
-        rule /\$[a-z0-9.:-]+/, 'Name.Variable'
-        rule /\$\{.*?\}/m, 'Name.Variable'
-        rule /\$/, 'Text'
+        rule /\[/, Punctuation, :bracket
+        rule /\$[a-z0-9.:-]+/, Name::Variable
+        rule /\$\{.*?\}/m, Name::Variable
+        rule /\$/, Text
 
         # escape sequences
-        rule /\\[0-7]{3}/, 'Literal.String.Escape'
-        rule /\\x[0-9a-f]{2}/i, 'Literal.String.Escape'
-        rule /\\u[0-9a-f]{4}/i, 'Literal.String.Escape'
-        rule /\\./m, 'Literal.String.Escape'
+        rule /\\[0-7]{3}/, Str::Escape
+        rule /\\x[0-9a-f]{2}/i, Str::Escape
+        rule /\\u[0-9a-f]{4}/i, Str::Escape
+        rule /\\./m, Str::Escape
       end
 
       state :string do
-        rule /"/, 'Literal.String.Double', :pop!
+        rule /"/, Str::Double, :pop!
         mixin :interp
-        rule /[^\\\[\$"{}]+/m, 'Literal.String.Double'
+        rule /[^\\\[\$"{}]+/m, Str::Double
 
         # strings have to keep count of their internal braces, to support
         # for example { "{ }" }.
@@ -170,17 +170,17 @@ module Rouge
           @brace_count ||= 0
           @brace_count += 1
 
-          token 'Literal.String.Double'
+          token Str::Double
         end
 
         rule /}/ do
           if in_state? :brace and @brace_count.to_i == 0
             pop! until state? :brace
             pop!
-            token 'Punctuation'
+            token Punctuation
           else
             @brace_count -= 1
-            token 'Literal.String.Double'
+            token Str::Double
           end
         end
       end

data/lib/rouge/lexers/tex.rb

@@ -18,53 +18,53 @@ module Rouge
       command = /\\([a-z]+|\s+|.)/i
 
       state :general do
-        rule /%.*$/, 'Comment'
-        rule /[{}&_^]/, 'Punctuation'
+        rule /%.*$/, Comment
+        rule /[{}&_^]/, Punctuation
       end
 
       state :root do
-        rule /\\\[/, 'Punctuation', :displaymath
-        rule /\\\(/, 'Punctuation', :inlinemath
-        rule /\$\$/, 'Punctuation', :displaymath
-        rule /\$/, 'Punctuation', :inlinemath
-        rule /\\(begin|end)\{.*?\}/, 'Name.Tag'
+        rule /\\\[/, Punctuation, :displaymath
+        rule /\\\(/, Punctuation, :inlinemath
+        rule /\$\$/, Punctuation, :displaymath
+        rule /\$/, Punctuation, :inlinemath
+        rule /\\(begin|end)\{.*?\}/, Name::Tag
 
         rule /(\\verb)\b(\S)(.*?)(\2)/ do |m|
-          group 'Name.Builtin'
-          group 'Keyword.Pseudo'
-          group 'Literal.String.Other'
-          group 'Keyword.Pseudo'
+          group Name::Builtin
+          group Keyword::Pseudo
+          group Str::Other
+          group Keyword::Pseudo
         end
 
-        rule command, 'Keyword', :command
+        rule command, Keyword, :command
         mixin :general
-        rule /[^\\$%&_^{}]+/, 'Text'
+        rule /[^\\$%&_^{}]+/, Text
       end
 
       state :math do
-        rule command, 'Name.Variable'
+        rule command, Name::Variable
         mixin :general
-        rule /[0-9]+/, 'Literal.Number'
-        rule /[-=!+*\/()\[\]]/, 'Operator'
-        rule /[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, 'Name.Builtin'
+        rule /[0-9]+/, Num
+        rule /[-=!+*\/()\[\]]/, Operator
+        rule /[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
       end
 
       state :inlinemath do
-        rule /\\\)/, 'Punctuation', :pop!
-        rule /\$/, 'Punctuation', :pop!
+        rule /\\\)/, Punctuation, :pop!
+        rule /\$/, Punctuation, :pop!
         mixin :math
       end
 
       state :displaymath do
-        rule /\\\]/, 'Punctuation', :pop!
-        rule /\$\$/, 'Punctuation', :pop!
-        rule /\$/, 'Name.Builtin'
+        rule /\\\]/, Punctuation, :pop!
+        rule /\$\$/, Punctuation, :pop!
+        rule /\$/, Name::Builtin
         mixin :math
       end
 
       state :command do
-        rule /\[.*?\]/, 'Name.Attribute'
-        rule /\*/, 'Keyword'
+        rule /\[.*?\]/, Name::Attribute
+        rule /\*/, Keyword
         rule(//) { pop! }
       end
     end

data/lib/rouge/lexers/toml.rb

@@ -14,55 +14,55 @@ module Rouge
       identifier = /[\w.\S]+/
 
       state :basic do
-        rule /\s+/, 'Text'
-        rule /#.*?$/, 'Comment'
-        rule /(true|false)/, 'Keyword.Constant'
-        rule /(?<!=)\s*\[[\w\d\S]+\]/, 'Name.Namespace'
+        rule /\s+/, Text
+        rule /#.*?$/, Comment
+        rule /(true|false)/, Keyword::Constant
+        rule /(?<!=)\s*\[[\w\d\S]+\]/, Name::Namespace
 
-        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, 'Literal.Date'
+        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
 
-        rule /(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, 'Literal.Number.Float'
-        rule /\d+[eE][+-]?[0-9]+j?/, 'Literal.Number.Float'
-        rule /\-?\d+/, 'Literal.Number.Integer'
+        rule /(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
+        rule /\d+[eE][+-]?[0-9]+j?/, Num::Float
+        rule /\-?\d+/, Num::Integer
       end
 
       state :root do
         mixin :basic
 
         rule /(#{identifier})(\s*)(=)/ do
-          group 'Name.Property'; group 'Text'
-          group 'Punctuation'
+          group Name::Property; group Text
+          group Punctuation
           push :value
         end
 
       end
 
       state :value do
-        rule /\n/, 'Text', :pop!
+        rule /\n/, Text, :pop!
         mixin :content
       end
 
       state :content do
         mixin :basic
-        rule /"/, 'Literal.String', :dq
+        rule /"/, Str, :dq
         mixin :esc_str
-        rule /\,/, 'Punctuation'
-        rule /\[/, 'Punctuation', :array
+        rule /\,/, Punctuation
+        rule /\[/, Punctuation, :array
       end
 
       state :dq do
-        rule /"/, 'Literal.String', :pop!
+        rule /"/, Str, :pop!
         mixin :esc_str
-        rule /[^\\"]+/, 'Literal.String'
+        rule /[^\\"]+/, Str
       end
 
       state :esc_str do
-        rule /\\[0t\tn\n "\\ r]/, 'Literal.String.Escape'
+        rule /\\[0t\tn\n "\\ r]/, Str::Escape
       end
 
       state :array do
         mixin :content
-        rule /\]/, 'Punctuation', :pop!
+        rule /\]/, Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/viml.rb

@@ -16,48 +16,48 @@ module Rouge
 
       state :root do
         rule /^(\s*)(".*?)$/ do
-          group 'Text'; group 'Comment'
+          group Text; group Comment
         end
 
-        rule /^\s*\\/, 'Literal.String.Escape'
+        rule /^\s*\\/, Str::Escape
 
-        rule /[ \t]+/, 'Text'
+        rule /[ \t]+/, Text
 
         # TODO: regexes can have other delimiters
-        rule %r(/(\\\\|\\/|[^\n/])*/), 'Literal.String.Regex'
-        rule %r("(\\\\|\\"|[^\n"])*"), 'Literal.String.Double'
-        rule %r('(\\\\|\\'|[^\n'])*'), 'Literal.String.Single'
+        rule %r(/(\\\\|\\/|[^\n/])*/), Str::Regex
+        rule %r("(\\\\|\\"|[^\n"])*"), Str::Double
+        rule %r('(\\\\|\\'|[^\n'])*'), Str::Single
 
         # if it's not a string, it's a comment.
-        rule /(?<=\s)"[^-:.%#=*].*?$/, 'Comment'
+        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
 
-        rule /-?\d+/, 'Literal.Number'
-        rule /#[0-9a-f]{6}/i, 'Literal.Number.Hex'
-        rule /^:/, 'Punctuation'
-        rule /[():<>+=!\[\]{}\|,~.-]/, 'Punctuation'
+        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/,
-          'Keyword'
+          Keyword
 
-        rule /\b(NONE|bold|italic|underline|dark|light)\b/, 'Name.Builtin'
+        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
 
-        rule /[absg]:\w+\b/, 'Name.Variable'
+        rule /[absg]:\w+\b/, Name::Variable
         rule /\b\w+\b/ do |m|
           name = m[0]
           keywords = self.class.keywords
 
           if mapping_contains?(keywords[:command], name)
-            token 'Keyword'
+            token Keyword
           elsif mapping_contains?(keywords[:option], name)
-            token 'Name.Builtin'
+            token Name::Builtin
           elsif mapping_contains?(keywords[:auto], name)
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Text'
+            token Text
           end
         end
 
         # no errors in VimL!
-        rule /./m, 'Text'
+        rule /./m, Text
       end
 
       def mapping_contains?(mapping, word)