rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/php.rb

@@ -58,103 +58,102 @@ module Rouge
       end
 
       state :root do
-        rule /<\?(php|=)?/, 'Comment.Preproc', :php
+        rule /<\?(php|=)?/, Comment::Preproc, :php
         rule(/.*?(?=<\?)|.*/m) { delegate parent }
       end
 
       state :php do
-        rule /\?>/, 'Comment.Preproc', :pop!
+        rule /\?>/, Comment::Preproc, :pop!
         # heredocs
-        rule /<<<('?)([a-z_]\w*)\1\n.*?\n\2;?\n/im, 'Literal.String.Heredoc'
-        rule /\s+/, 'Text'
-        rule /#.*?\n/, 'Comment.Single'
-        rule %r(//.*?\n), 'Comment.Single'
+        rule /<<<('?)([a-z_]\w*)\1\n.*?\n\2;?\n/im, Str::Heredoc
+        rule /\s+/, Text
+        rule /#.*?\n/, Comment::Single
+        rule %r(//.*?\n), Comment::Single
         # empty comment, otherwise seen as the start of a docstring
         rule %r(/\*\*/)
-        rule %r(/\*\*.*?\*/)m, 'Literal.String.Doc'
-        rule %r(/\*.*?\*/)m, 'Comment.Multiline'
+        rule %r(/\*\*.*?\*/)m, Str::Doc
+        rule %r(/\*.*?\*/)m, Comment::Multiline
         rule /(->|::)(\s*)([a-zA-Z_][a-zA-Z0-9_]*)/ do
-          group 'Operator'; group 'Text'; group 'Name.Attribute'
+          group Operator; group Text; group Name::Attribute
         end
 
-        rule /[~!%^&*+=\|:.<>\/?@-]+/, 'Operator'
-        rule /[\[\]{}();,]+/, 'Punctuation'
-        rule /class\b/, 'Keyword', :classname
+        rule /[~!%^&*+=\|:.<>\/?@-]+/, Operator
+        rule /[\[\]{}();,]+/, Punctuation
+        rule /class\b/, Keyword, :classname
         # anonymous functions
         rule /(function)(\s*)(?=\()/ do
-          group 'Keyword'; group 'Text'
+          group Keyword; group Text
         end
 
         # named functions
         rule /(function)(\s+)(&?)(\s*)/ do
-          group 'Keyword'; group 'Text'; group 'Operator'; group 'Text'
+          group Keyword; group Text; group Operator; group Text
           push :funcname
         end
 
         rule /(const)(\s+)([a-zA-Z_]\w*)/i do
-          group 'Keyword'; group 'Text'; group 'Name.Constant'
+          group Keyword; group Text; group Name::Constant
         end
 
-        rule /(true|false|null)\b/, 'Keyword.Constant'
-        rule /\$\{\$+[a-z_]\w*\}/i, 'Name.Variable'
-        rule /\$+[a-z_]\w*/i, 'Name.Variable'
+        rule /(true|false|null)\b/, Keyword::Constant
+        rule /\$\{\$+[a-z_]\w*\}/i, Name::Variable
+        rule /\$+[a-z_]\w*/i, Name::Variable
 
         # may be intercepted for builtin highlighting
         rule /[\\a-z_][\\\w]*/i do |m|
           name = m[0]
 
           if self.class.keywords.include? name
-            token 'Keyword'
+            token Keyword
           elsif self.builtins.include? name
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name.Other'
+            token Name::Other
           end
         end
 
-        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, 'Literal.Number.Float'
-        rule /\d+e[+-]?\d+/i, 'Literal.Number.Float'
-        rule /0[0-7]+/, 'Literal.Number.Oct'
-        rule /0x[a-f0-9]+/i, 'Literal.Number.Hex'
-        rule /\d+/, 'Literal.Number.Integer'
-        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, 'Literal.String.Single'
-        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, 'Literal.String.Backtick'
-        rule /"/, 'Literal.String.Double', :string
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
+        rule /\d+e[+-]?\d+/i, Num::Float
+        rule /0[0-7]+/, Num::Oct
+        rule /0x[a-f0-9]+/i, Num::Hex
+        rule /\d+/, Num::Integer
+        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
+        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
+        rule /"/, Str::Double, :string
       end
 
       state :classname do
-        rule /\s+/, 'Text'
-        rule /[a-z_][\\\w]*/i, 'Name.Class', :pop!
+        rule /\s+/, Text
+        rule /[a-z_][\\\w]*/i, Name::Class, :pop!
       end
 
       state :funcname do
-        rule /[a-z_]\w*/i, 'Name.Function', :pop!
+        rule /[a-z_]\w*/i, Name::Function, :pop!
       end
 
       state :string do
-        rule /"/, 'Literal.String.Double', :pop!
-        rule /[^\\{$"]+/, 'Literal.String.Double'
+        rule /"/, Str::Double, :pop!
+        rule /[^\\{$"]+/, Str::Double
         rule /\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
-          'Literal.String.Escape'
-        rule /\$[a-zA-Z_][a-zA-Z0-9_]*(\[\S+\]|->[a-zA-Z_][a-zA-Z0-9_]*)?/, 'Name.Variable'
+          Str::Escape
+        rule /\$[a-zA-Z_][a-zA-Z0-9_]*(\[\S+\]|->[a-zA-Z_][a-zA-Z0-9_]*)?/, Name::Variable
 
-        lsi = 'Literal.String.Interpol'
-        rule /\{\$\{/, lsi, :interp_double
-        rule /\{(?=\$)/, lsi, :interp_single
+        rule /\{\$\{/, Str::Interpol, :interp_double
+        rule /\{(?=\$)/, Str::Interpol, :interp_single
         rule /(\{)(\S+)(\})/ do
-          group lsi; group 'Name.Variable'; group lsi
+          group Str::Interpol; group Name::Variable; group Str::Interpol
         end
 
-        rule /[${\\]+/, 'Literal.String.Double'
+        rule /[${\\]+/, Str::Double
       end
 
       state :interp_double do
-        rule /\}\}/, 'Literal.String.Interpol', :pop!
+        rule /\}\}/, Str::Interpol, :pop!
         mixin :php
       end
 
       state :interp_single do
-        rule /\}/, 'Literal.String.Interpol', :pop!
+        rule /\}/, Str::Interpol, :pop!
         mixin :php
       end
     end

data/lib/rouge/lexers/{text.rb → plain_text.rb}

@@ -1,9 +1,10 @@
 module Rouge
   module Lexers
-    class Text < Lexer
+    class PlainText < Lexer
       desc "A boring lexer that doesn't highlight anything"
 
-      tag 'text'
+      tag 'plaintext'
+      aliases 'text'
       filenames '*.txt'
       mimetypes 'text/plain'
 

data/lib/rouge/lexers/prolog.rb

@@ -13,35 +13,35 @@ module Rouge
       end
 
       state :basic do
-        rule /\s+/, 'Text'
-        rule /^#.*/, 'Comment.Single'
-        rule /\/\*/, 'Comment.Multiline', :nested_comment
+        rule /\s+/, Text
+        rule /^#.*/, Comment::Single
+        rule /\/\*/, Comment::Multiline, :nested_comment
 
-        rule /[\[\](){}|.,;!]/, 'Punctuation'
-        rule /:-|-->/, 'Punctuation'
+        rule /[\[\](){}|.,;!]/, Punctuation
+        rule /:-|-->/, Punctuation
 
-        rule /"[^"]*"/, 'Literal.String.Double'
+        rule /"[^"]*"/, Str::Double
 
-        rule /\d+\.\d+/, 'Literal.Number.Float'
-        rule /\d+/, 'Literal.Number'
+        rule /\d+\.\d+/, Num::Float
+        rule /\d+/, Num
       end
 
       state :atoms do
-        rule /[[:lower:]]([_[:lower:][:digit:]])*/, 'Literal.String.Symbol'
-        rule /'[^']*'/, 'Literal.String.Symbol'
+        rule /[[:lower:]]([_[:lower:][:digit:]])*/, Str::Symbol
+        rule /'[^']*'/, Str::Symbol
       end
 
       state :operators do
         rule /(<|>|=<|>=|==|=:=|=|\/|\/\/|\*|\+|-)(?=\s|[a-zA-Z0-9\[])/,
-          'Operator'
-        rule /is/, 'Operator'
-        rule /(mod|div|not)/, 'Operator'
-        rule /[#&*+-.\/:<=>?@^~]+/, 'Operator'
+          Operator
+        rule /is/, Operator
+        rule /(mod|div|not)/, Operator
+        rule /[#&*+-.\/:<=>?@^~]+/, Operator
       end
 
       state :variables do
-        rule /[A-Z]+\w*/, 'Name.Variable'
-        rule /_[[:word:]]*/, 'Name.Variable'
+        rule /[A-Z]+\w*/, Name::Variable
+        rule /_[[:word:]]*/, Name::Variable
       end
 
       state :root do
@@ -52,9 +52,9 @@ module Rouge
       end
 
       state :nested_comment do
-        rule /\/\*/, 'Comment.Multiline', :push
-        rule /\s*\*[^*\/]+/, 'Comment.Multiline'
-        rule /\*\//, 'Comment.Multiline', :pop!
+        rule /\/\*/, Comment::Multiline, :push
+        rule /\s*\*[^*\/]+/, Comment::Multiline
+        rule /\*\//, Comment::Multiline, :pop!
       end
     end
   end

data/lib/rouge/lexers/puppet.rb

@@ -35,91 +35,91 @@ module Rouge
       qualname = /(::)?(#{id}::)*\w+/
 
       state :whitespace do
-        rule /\s+/m, 'Text'
-        rule /#.*?\n/, 'Comment'
+        rule /\s+/m, Text
+        rule /#.*?\n/, Comment
       end
 
       state :root do
         mixin :whitespace
 
-        rule /[$]#{qualname}/, 'Name.Variable'
+        rule /[$]#{qualname}/, Name::Variable
         rule /(#{id})(?=\s*[=+]>)/m do |m|
           if self.class.metaparameters.include? m[0]
-            token 'Keyword.Pseudo'
+            token Keyword::Pseudo
           else
-            token 'Name.Property'
+            token Name::Property
           end
         end
 
-        rule /(#{qualname})(?=\s*[(])/m, 'Name.Function'
-        rule cap_id, 'Name.Class'
+        rule /(#{qualname})(?=\s*[(])/m, Name::Function
+        rule cap_id, Name::Class
 
-        rule /[+=|~-]>|<[|~-]/, 'Punctuation'
-        rule /[:}();\[\]]/, 'Punctuation'
+        rule /[+=|~-]>|<[|~-]/, Punctuation
+        rule /[:}();\[\]]/, Punctuation
 
         # HACK for case statements and selectors
-        rule /{/, 'Punctuation', :regex_allowed
-        rule /,/, 'Punctuation', :regex_allowed
+        rule /{/, Punctuation, :regex_allowed
+        rule /,/, Punctuation, :regex_allowed
 
-        rule /(in|and|or)\b/, 'Operator.Word'
-        rule /[=!<>]=/, 'Operator'
-        rule /[=!]~/, 'Operator', :regex_allowed
-        rule %r([<>!+*/-]), 'Operator'
+        rule /(in|and|or)\b/, Operator::Word
+        rule /[=!<>]=/, Operator
+        rule /[=!]~/, Operator, :regex_allowed
+        rule %r([<>!+*/-]), Operator
 
         rule /(class|include)(\s*)(#{qualname})/ do
-          group 'Keyword'; group 'Text'
-          group 'Name.Class'
+          group Keyword; group Text
+          group Name::Class
         end
 
-        rule /node\b/, 'Keyword', :regex_allowed
+        rule /node\b/, Keyword, :regex_allowed
 
-        rule /'(\\[\\']|[^'])*'/m, 'Literal.String.Single'
-        rule /"/, 'Literal.String.Double', :dquotes
+        rule /'(\\[\\']|[^'])*'/m, Str::Single
+        rule /"/, Str::Double, :dquotes
 
-        rule /\d+([.]\d+)?(e[+-]\d+)?/, 'Literal.Number'
+        rule /\d+([.]\d+)?(e[+-]\d+)?/, Num
 
         # a valid regex.  TODO: regexes are only allowed
         # in certain places in puppet.
         rule qualname do |m|
           if self.class.keywords.include? m[0]
-            token 'Keyword'
+            token Keyword
           elsif self.class.constants.include? m[0]
-            token 'Keyword.Constant'
+            token Keyword::Constant
           else
-            token 'Name'
+            token Name
           end
         end
       end
 
       state :regex_allowed do
         mixin :whitespace
-        rule %r(/), 'Literal.String.Regex', :regex
+        rule %r(/), Str::Regex, :regex
 
         rule(//) { pop! }
       end
 
       state :regex do
-        rule %r(/), 'Literal.String.Regex', :pop!
-        rule /\\./, 'Literal.String.Escape'
-        rule /[(){}]/, 'Literal.String.Interpol'
-        rule /\[/, 'Literal.String.Interpol', :regex_class
-        rule /./, 'Literal.String.Regex'
+        rule %r(/), Str::Regex, :pop!
+        rule /\\./, Str::Escape
+        rule /[(){}]/, Str::Interpol
+        rule /\[/, Str::Interpol, :regex_class
+        rule /./, Str::Regex
       end
 
       state :regex_class do
-        rule /\]/, 'Literal.String.Interpol', :pop!
-        rule /(?<!\[)-(?=\])/, 'Literal.String.Regex'
-        rule /-/, 'Literal.String.Interpol'
-        rule /\\./, 'Literal.String.Escape'
-        rule /[^\\\]-]+/, 'Literal.String.Regex'
+        rule /\]/, Str::Interpol, :pop!
+        rule /(?<!\[)-(?=\])/, Str::Regex
+        rule /-/, Str::Interpol
+        rule /\\./, Str::Escape
+        rule /[^\\\]-]+/, Str::Regex
       end
 
       state :dquotes do
-        rule /"/, 'Literal.String.Double', :pop!
-        rule /[^$\\"]+/m, 'Literal.String.Double'
-        rule /\\./m, 'Literal.String.Escape'
-        rule /[$]#{qualname}/, 'Name.Variable'
-        rule /[$][{]#{qualname}[}]/, 'Name.Variable'
+        rule /"/, Str::Double, :pop!
+        rule /[^$\\"]+/m, Str::Double
+        rule /\\./m, Str::Escape
+        rule /[$]#{qualname}/, Name::Variable
+        rule /[$][{]#{qualname}[}]/, Name::Variable
       end
     end
   end

data/lib/rouge/lexers/python.rb

@@ -50,116 +50,116 @@ module Rouge
       identifier =        /[a-z_][a-z0-9_]*/i
       dotted_identifier = /[a-z_.][a-z0-9_.]*/i
       state :root do
-        rule /\n+/m, 'Text'
+        rule /\n+/m, Text
         rule /^(:)(\s*)([ru]{,2}""".*?""")/mi do
-          group 'Punctuation'
-          group 'Text'
-          group 'Literal.String.Doc'
+          group Punctuation
+          group Text
+          group Str::Doc
         end
 
-        rule /[^\S\n]+/, 'Text'
-        rule /#.*$/, 'Comment'
-        rule /[\[\]{}:(),;]/, 'Punctuation'
-        rule /\\\n/, 'Text'
-        rule /\\/, 'Text'
+        rule /[^\S\n]+/, Text
+        rule /#.*$/, Comment
+        rule /[\[\]{}:(),;]/, Punctuation
+        rule /\\\n/, Text
+        rule /\\/, Text
 
-        rule /(in|is|and|or|not)\b/, 'Operator.Word'
-        rule /!=|==|<<|>>|[-~+\/*%=<>&^|.]/, 'Operator'
+        rule /(in|is|and|or|not)\b/, Operator::Word
+        rule /!=|==|<<|>>|[-~+\/*%=<>&^|.]/, Operator
 
-        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /(?:#{keywords.join('|')})\b/, Keyword
 
         rule /(def)((?:\s|\\\s)+)/ do
-          group 'Keyword' # def
-          group 'Text' # whitespae
+          group Keyword # def
+          group Text # whitespae
           push :funcname
         end
 
         rule /(class)((?:\s|\\\s)+)/ do
-          group 'Keyword'
-          group 'Text'
+          group Keyword
+          group Text
           push :classname
         end
 
         rule /(from)((?:\s|\\\s)+)/ do
-          group 'Keyword.Namespace'
-          group 'Text'
+          group Keyword::Namespace
+          group Text
           push :fromimport
         end
 
         rule /(import)((?:\s|\\\s)+)/ do
-          group 'Keyword.Namespace'
-          group 'Text'
+          group Keyword::Namespace
+          group Text
           push :import
         end
 
         # using negative lookbehind so we don't match property names
-        rule /(?<!\.)(?:#{builtins.join('|')})/, 'Name.Builtin'
-        rule /(?<!\.)(?:#{builtins_pseudo.join('|')})/, 'Name.Builtin.Pseudo'
+        rule /(?<!\.)(?:#{builtins.join('|')})/, Name::Builtin
+        rule /(?<!\.)(?:#{builtins_pseudo.join('|')})/, Name::Builtin::Pseudo
 
         # TODO: not in python 3
-        rule /`.*?`/, 'Literal.String.Backtick'
-        rule /(?:r|ur|ru)"""/i, 'Literal.String', :tdqs
-        rule /(?:r|ur|ru)'''/i, 'Literal.String', :tsqs
-        rule /(?:r|ur|ru)"/i,   'Literal.String', :dqs
-        rule /(?:r|ur|ru)'/i,   'Literal.String', :sqs
-        rule /u?"""/i,          'Literal.String', :escape_tdqs
-        rule /u?'''/i,          'Literal.String', :escape_tsqs
-        rule /u?"/i,            'Literal.String', :escape_dqs
-        rule /u?'/i,            'Literal.String', :escape_sqs
-
-        rule /@#{dotted_identifier}/i, 'Name.Decorator'
-        rule identifier, 'Name'
-
-        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, 'Literal.Number.Float'
-        rule /\d+e[+-]?[0-9]+/i, 'Literal.Number.Float'
-        rule /0[0-7]+/, 'Literal.Number.Oct'
-        rule /0x[a-f0-9]+/i, 'Literal.Number.Hex'
-        rule /\d+L/, 'Literal.Number.Integer.Long'
-        rule /\d+/, 'Literal.Number.Integer'
+        rule /`.*?`/, Str::Backtick
+        rule /(?:r|ur|ru)"""/i, Str, :tdqs
+        rule /(?:r|ur|ru)'''/i, Str, :tsqs
+        rule /(?:r|ur|ru)"/i,   Str, :dqs
+        rule /(?:r|ur|ru)'/i,   Str, :sqs
+        rule /u?"""/i,          Str, :escape_tdqs
+        rule /u?'''/i,          Str, :escape_tsqs
+        rule /u?"/i,            Str, :escape_dqs
+        rule /u?'/i,            Str, :escape_sqs
+
+        rule /@#{dotted_identifier}/i, Name::Decorator
+        rule identifier, Name
+
+        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule /\d+e[+-]?[0-9]+/i, Num::Float
+        rule /0[0-7]+/, Num::Oct
+        rule /0x[a-f0-9]+/i, Num::Hex
+        rule /\d+L/, Num::Integer::Long
+        rule /\d+/, Num::Integer
       end
 
       state :funcname do
-        rule identifier, 'Name.Function', :pop!
+        rule identifier, Name::Function, :pop!
       end
 
       state :classname do
-        rule identifier, 'Name.Class', :pop!
+        rule identifier, Name::Class, :pop!
       end
 
       state :import do
         # non-line-terminating whitespace
-        rule /(?:[ \t]|\\\n)+/, 'Text'
+        rule /(?:[ \t]|\\\n)+/, Text
 
-        rule /as\b/, 'Keyword.Namespace'
-        rule /,/, 'Operator'
-        rule dotted_identifier, 'Name.Namespace'
+        rule /as\b/, Keyword::Namespace
+        rule /,/, Operator
+        rule dotted_identifier, Name::Namespace
         rule(//) { pop! } # anything else -> go back
       end
 
       state :fromimport do
         # non-line-terminating whitespace
-        rule /(?:[ \t]|\\\n)+/, 'Text'
+        rule /(?:[ \t]|\\\n)+/, Text
 
-        rule /import\b/, 'Keyword.Namespace', :pop!
-        rule dotted_identifier, 'Name.Namespace'
+        rule /import\b/, Keyword::Namespace, :pop!
+        rule dotted_identifier, Name::Namespace
       end
 
       state :strings do
-        rule /%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, 'Literal.String.Interpol'
+        rule /%(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str::Interpol
       end
 
       state :strings_double do
-        rule /[^\\"%\n]+/, 'Literal.String'
+        rule /[^\\"%\n]+/, Str
         mixin :strings
       end
 
       state :strings_single do
-        rule /[^\\'%\n]+/, 'Literal.String'
+        rule /[^\\'%\n]+/, Str
         mixin :strings
       end
 
       state :nl do
-        rule /\n/, 'Literal.String'
+        rule /\n/, Str
       end
 
       state :escape do
@@ -172,31 +172,31 @@ module Rouge
           | x[a-fA-F0-9]{2}
           | [0-7]{1,3}
           )
-        )x, 'Literal.String.Escape'
+        )x, Str::Escape
       end
 
       state :dqs do
-        rule /"/, 'Literal.String', :pop!
-        rule /\\\\|\\"|\\\n/, 'Literal.String.Escape'
+        rule /"/, Str, :pop!
+        rule /\\\\|\\"|\\\n/, Str::Escape
         mixin :strings_double
       end
 
       state :sqs do
-        rule /'/, 'Literal.String', :pop!
-        rule /\\\\|\\'|\\\n/, 'Literal.String.Escape'
+        rule /'/, Str, :pop!
+        rule /\\\\|\\'|\\\n/, Str::Escape
         mixin :strings_single
       end
 
       state :tdqs do
-        rule /"""/, 'Literal.String', :pop!
-        rule /"/, 'Literal.String'
+        rule /"""/, Str, :pop!
+        rule /"/, Str
         mixin :strings_double
         mixin :nl
       end
 
       state :tsqs do
-        rule /'''/, 'Literal.String', :pop!
-        rule /'/, 'Literal.String'
+        rule /'''/, Str, :pop!
+        rule /'/, Str
         mixin :strings_single
         mixin :nl
       end