rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/make.rb

@@ -29,54 +29,54 @@ module Rouge
       start { @shell.reset! }
 
       state :root do
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
 
-        rule /#.*?\n/, 'Comment'
+        rule /#.*?\n/, Comment
 
         rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
-          group 'Keyword'; group 'Text'
+          group Keyword; group Text
           push :export
         end
 
-        rule /export\s+/, 'Keyword'
+        rule /export\s+/, Keyword
 
         # assignment
         rule /([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
-          token 'Name.Variable', m[1]
-          token 'Text', m[2]
-          token 'Operator', m[3]
+          token Name::Variable, m[1]
+          token Text, m[2]
+          token Operator, m[3]
           push :shell_line
         end
 
-        rule /"(\\\\|\\.|[^"\\])*"/, 'Literal.String.Double'
-        rule /'(\\\\|\\.|[^'\\])*'/, 'Literal.String.Single'
+        rule /"(\\\\|\\.|[^"\\])*"/, Str::Double
+        rule /'(\\\\|\\.|[^'\\])*'/, Str::Single
         rule /([^\n:]+)(:+)([ \t]*)/ do
-          group 'Name.Label'; group 'Operator'; group 'Text'
+          group Name::Label; group Operator; group Text
           push :block_header
         end
       end
 
       state :export do
-        rule /[\w\${}-]/, 'Name.Variable'
-        rule /\n/, 'Text', :pop!
-        rule /\s+/, 'Text'
+        rule /[\w\${}-]/, Name::Variable
+        rule /\n/, Text, :pop!
+        rule /\s+/, Text
       end
 
       state :block_header do
-        rule /[^,\\\n#]+/, 'Name.Function'
-        rule /,/, 'Punctuation'
-        rule /#.*?/, 'Comment'
-        rule /\\\n/, 'Text'
-        rule /\\./, 'Text'
+        rule /[^,\\\n#]+/, Name::Function
+        rule /,/, Punctuation
+        rule /#.*?/, Comment
+        rule /\\\n/, Text
+        rule /\\./, Text
         rule /\n/ do
-          token 'Text'
-          pop!; push :block_body
+          token Text
+          goto :block_body
         end
       end
 
       state :block_body do
         rule /(\t[\t ]*)([@-]?)/ do |m|
-          group 'Text'; group 'Punctuation'
+          group Text; group Punctuation
           push :shell_line
         end
 
@@ -85,11 +85,11 @@ module Rouge
 
       state :shell do
         # macro interpolation
-        rule /\$\(\s*[a-z_]\w*\s*\)/i, 'Name.Variable'
+        rule /\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
         # $(shell ...)
         rule /(\$\()(\s*)(shell)(\s+)/m do
-          group 'Name.Function'; group 'Text'
-          group 'Name.Builtin'; group 'Text'
+          group Name::Function; group Text
+          group Name::Builtin; group Text
           push :shell_expr
         end
 
@@ -101,12 +101,12 @@ module Rouge
 
       state :shell_expr do
         rule(/\(/) { delegate @shell; push }
-        rule /\)/, 'Name.Variable', :pop!
+        rule /\)/, Name::Variable, :pop!
         mixin :shell
       end
 
       state :shell_line do
-        rule /\n/, 'Text', :pop!
+        rule /\n/, Text, :pop!
         mixin :shell
       end
     end

data/lib/rouge/lexers/markdown.rb

@@ -20,44 +20,44 @@ module Rouge
         # YAML frontmatter
         rule(/\A(---\s*\n.*?\n?)^(---\s*$\n?)/m) { delegate YAML }
 
-        rule /\\./, 'Literal.String.Escape'
+        rule /\\./, Str::Escape
 
-        rule /^[\S ]+\n(?:---*)\n/, 'Generic.Heading'
-        rule /^[\S ]+\n(?:===*)\n/, 'Generic.Subheading'
+        rule /^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule /^[\S ]+\n(?:===*)\n/, Generic::Subheading
 
-        rule /^#(?=[^#]).*?$/, 'Generic.Heading'
-        rule /^##*.*?$/, 'Generic.Subheading'
+        rule /^#(?=[^#]).*?$/, Generic::Heading
+        rule /^##*.*?$/, Generic::Subheading
 
         # TODO: syntax highlight the code block, github style
         rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?)(\2)/m do |m|
           sublexer = Lexer.find_fancy(m[3].strip, m[4])
-          sublexer ||= Text.new(:token => 'Literal.String.Backtick')
+          sublexer ||= Text.new(:token => Str::Backtick)
 
-          token 'Text', m[1]
-          token 'Punctuation', m[2]
-          token 'Name.Label', m[3]
+          token Text, m[1]
+          token Punctuation, m[2]
+          token Name::Label, m[3]
           delegate sublexer, m[4]
-          token 'Punctuation', m[5]
+          token Punctuation, m[5]
         end
 
-        rule /\n\n((    |\t).*?\n|\n)+/, 'Literal.String.Backtick'
+        rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick
 
-        rule /(`+)#{edot}*\1/, 'Literal.String.Backtick'
+        rule /(`+)#{edot}*\1/, Str::Backtick
 
         # various uses of * are in order of precedence
 
         # line breaks
-        rule /^(\s*[*]){3,}\s*$/, 'Punctuation'
-        rule /^(\s*[-]){3,}\s*$/, 'Punctuation'
+        rule /^(\s*[*]){3,}\s*$/, Punctuation
+        rule /^(\s*[-]){3,}\s*$/, Punctuation
 
         # bulleted lists
-        rule /^\s*[*+-](?=\s)/, 'Punctuation'
+        rule /^\s*[*+-](?=\s)/, Punctuation
 
         # numbered lists
-        rule /^\s*\d+\./, 'Punctuation'
+        rule /^\s*\d+\./, Punctuation
 
         # blockquotes
-        rule /^\s*>.*?$/, 'Generic.Traceback'
+        rule /^\s*>.*?$/, Generic::Traceback
 
         # link references
         # [foo]: bar "baz"
@@ -66,9 +66,9 @@ module Rouge
           (\[) (#{edot}+?) (\]) # the reference
           (\s*) (:) # colon
         )x do
-          group 'Text'
-          group 'Punctuation'; group 'Literal.String.Symbol'; group 'Punctuation'
-          group 'Text'; group 'Punctuation'
+          group Text
+          group Punctuation; group Str::Symbol; group Punctuation
+          group Text; group Punctuation
 
           push :title
           push :url
@@ -76,82 +76,82 @@ module Rouge
 
         # links and images
         rule /(!?\[)(#{edot}+?)(\])/ do
-          group 'Punctuation'
-          group 'Name.Variable'
-          group 'Punctuation'
+          group Punctuation
+          group Name::Variable
+          group Punctuation
           push :link
         end
 
-        rule /[*][*]#{edot}*?[*][*]/, 'Generic.Strong'
-        rule /__#{edot}*?__/, 'Generic.Strong'
+        rule /[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule /__#{edot}*?__/, Generic::Strong
 
-        rule /[*]#{edot}*?[*]/, 'Generic.Emph'
-        rule /_#{edot}*?_/, 'Generic.Emph'
+        rule /[*]#{edot}*?[*]/, Generic::Emph
+        rule /_#{edot}*?_/, Generic::Emph
 
         # Automatic links
-        rule /<.*?@.+[.].+>/, 'Name.Variable'
-        rule %r[<(https?|mailto|ftp)://#{edot}*?>], 'Name.Variable'
+        rule /<.*?@.+[.].+>/, Name::Variable
+        rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
 
 
-        rule /[^\\`\[*\n&<]+/, 'Text'
+        rule /[^\\`\[*\n&<]+/, Text
 
         # inline html
         rule(/&\S*;/) { delegate html }
         rule(/<#{edot}*?>/) { delegate html }
-        rule /[&<]/, 'Text'
+        rule /[&<]/, Text
 
-        rule /\n/, 'Text'
+        rule /\n/, Text
       end
 
       state :link do
         rule /(\[)(#{edot}*?)(\])/ do
-          group 'Punctuation'
-          group 'Literal.String.Symbol'
-          group 'Punctuation'
+          group Punctuation
+          group Str::Symbol
+          group Punctuation
           pop!
         end
 
         rule /[(]/ do
-          token 'Punctuation'
+          token Punctuation
           push :inline_title
           push :inline_url
         end
 
-        rule /[ \t]+/, 'Text'
+        rule /[ \t]+/, Text
 
         rule(//) { pop! }
       end
 
       state :url do
-        rule /[ \t]+/, 'Text'
+        rule /[ \t]+/, Text
 
         # the url
         rule /(<)(#{edot}*?)(>)/ do
-          group 'Name.Tag'
-          group 'Literal.String.Other'
-          group 'Name.Tag'
+          group Name::Tag
+          group Str::Other
+          group Name::Tag
           pop!
         end
 
-        rule /\S+/, 'Literal.String.Other', :pop!
+        rule /\S+/, Str::Other, :pop!
       end
 
       state :title do
-        rule /"#{edot}*?"/, 'Name.Namespace'
-        rule /'#{edot}*?'/, 'Name.Namespace'
-        rule /[(]#{edot}*?[)]/, 'Name.Namespace'
-        rule /\s*(?=["'()])/, 'Text'
+        rule /"#{edot}*?"/, Name::Namespace
+        rule /'#{edot}*?'/, Name::Namespace
+        rule /[(]#{edot}*?[)]/, Name::Namespace
+        rule /\s*(?=["'()])/, Text
         rule(//) { pop! }
       end
 
       state :inline_title do
-        rule /[)]/, 'Punctuation', :pop!
+        rule /[)]/, Punctuation, :pop!
         mixin :title
       end
 
       state :inline_url do
-        rule /[^<\s)]+/, 'Literal.String.Other', :pop!
-        rule /\s+/m, 'Text'
+        rule /[^<\s)]+/, Str::Other, :pop!
+        rule /\s+/m, Text
         mixin :url
       end
     end

data/lib/rouge/lexers/nginx.rb

@@ -10,59 +10,59 @@ module Rouge
 
       state :root do
         rule /(include)(\s+)([^\s;]+)/ do
-          group 'Keyword'; group 'Text'; group 'Name'
+          group Keyword; group Text; group Name
         end
 
-        rule id, 'Keyword', :statement
+        rule id, Keyword, :statement
 
         mixin :base
       end
 
       state :block do
-        rule /}/, 'Punctuation', :pop!
-        rule id, 'Keyword.Namespace', :statement
+        rule /}/, Punctuation, :pop!
+        rule id, Keyword::Namespace, :statement
         mixin :base
       end
 
       state :statement do
         rule /{/ do
-          token 'Punctuation'; pop!; push :block
+          token Punctuation; pop!; push :block
         end
 
-        rule /;/, 'Punctuation', :pop!
+        rule /;/, Punctuation, :pop!
 
         mixin :base
       end
 
       state :base do
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
 
-        rule /#.*?\n/, 'Comment.Single'
-        rule /(?:on|off)\b/, 'Name.Constant'
-        rule /[$][\w-]+/, 'Name.Variable'
+        rule /#.*?\n/, Comment::Single
+        rule /(?:on|off)\b/, Name::Constant
+        rule /[$][\w-]+/, Name::Variable
 
         # host/port
         rule /([a-z0-9.-]+)(:)([0-9]+)/i do
-          group 'Name.Function'; group 'Punctuation'
-          group 'Literal.Number.Integer'
+          group Name::Function; group Punctuation
+          group Num::Integer
         end
 
         # mimetype
-        rule %r([a-z-]+/[a-z-]+)i, 'Name.Class'
+        rule %r([a-z-]+/[a-z-]+)i, Name::Class
 
-        rule /[0-9]+[kmg]?\b/i, 'Literal.Number.Integer'
+        rule /[0-9]+[kmg]?\b/i, Num::Integer
         rule /(~)(\s*)([^\s{]+)/ do
-          group 'Punctuation'; group 'Text'; group 'Literal.String.Regex'
+          group Punctuation; group Text; group Str::Regex
         end
 
-        rule /[:=~]/, 'Punctuation'
+        rule /[:=~]/, Punctuation
 
         # pathname
-        rule %r(/#{id}?), 'Name'
+        rule %r(/#{id}?), Name
 
-        rule /[^#\s;{}$\\]+/, 'Literal.String' # catchall
+        rule /[^#\s;{}$\\]+/, Str # catchall
 
-        rule /[$;]/, 'Text'
+        rule /[$;]/, Text
       end
     end
   end

data/lib/rouge/lexers/perl.rb

@@ -46,7 +46,7 @@ module Rouge
         utime values vec wait waitpid wantarray warn write
       )
 
-      re_tok = 'Literal.String.Regex'
+      re_tok = Str::Regex
 
       state :balanced_regex do
         rule %r(/(\\\\|\\/|[^/])*/[egimosx]*)m, re_tok, :pop!
@@ -62,19 +62,19 @@ module Rouge
       end
 
       state :root do
-        rule /#.*?$/, 'Comment.Single'
-        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/, 'Comment.Multiline'
-        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /#.*?$/, Comment::Single
+        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/, Comment::Multiline
+        rule /(?:#{keywords.join('|')})\b/, Keyword
 
         rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
-          group 'Keyword'; group 'Text'
-          group 'Name'; group 'Text'
-          group 'Punctuation'; group 'Text'
+          group Keyword; group Text
+          group Name; group Text
+          group Punctuation; group Text
 
           push :format
         end
 
-        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, 'Operator.Word'
+        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
 
         # common delimiters
         rule %r(s/(\\\\|\\/|[^/])*/(\\\\|\\/|[^/])*/[egimosx]*), re_tok
@@ -94,92 +94,91 @@ module Rouge
         rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[gcimosx]*),
           re_tok, :balanced_regex
 
-        rule /\s+/, 'Text'
-        rule /(?:#{builtins.join('|')})\b/, 'Name.Builtin'
+        rule /\s+/, Text
+        rule /(?:#{builtins.join('|')})\b/, Name::Builtin
         rule /((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
-          'Name.Builtin.Pseudo'
+          Name::Builtin::Pseudo
 
-        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m,
-          'Literal.String'
+        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
 
-        rule /__END__\b/, 'Comment.Preproc', :end_part
-        rule /\$\^[ADEFHILMOPSTWX]/, 'Name.Variable.Global'
-        rule /\$[\\"\[\]'&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, 'Name.Variable.Global'
-        rule /[$@%#]+/, 'Name.Variable', :varname
+        rule /__END__\b/, Comment::Preproc, :end_part
+        rule /\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
+        rule /\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
+        rule /[$@%#]+/, Name::Variable, :varname
 
-        rule /0_?[0-7]+(_[0-7]+)*/, 'Literal.Number.Oct'
-        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, 'Literal.Number.Hex'
-        rule /0b[01]+(_[01]+)*/, 'Literal.Number.Bin'
+        rule /0_?[0-7]+(_[0-7]+)*/, Num::Oct
+        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule /0b[01]+(_[01]+)*/, Num::Bin
         rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
-          'Literal.Number.Float'
-        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, 'Literal.Number.Float'
-        rule /\d+(_\d+)*/, 'Literal.Number.Integer'
+          Num::Float
+        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule /\d+(_\d+)*/, Num::Integer
 
-        rule /'(\\\\|\\'|[^'])*'/, 'Literal.String'
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
-        rule /`(\\\\|\\`|[^`])*`/, 'Literal.String.Backtick'
+        rule /'(\\\\|\\'|[^'])*'/, Str
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /`(\\\\|\\`|[^`])*`/, Str::Backtick
         rule /<([^\s>]+)>/, re_tok
-        rule /(q|qq|qw|qr|qx)\{/, 'Literal.String.Other', :cb_string
-        rule /(q|qq|qw|qr|qx)\(/, 'Literal.String.Other', :rb_string
-        rule /(q|qq|qw|qr|qx)\[/, 'Literal.String.Other', :sb_string
-        rule /(q|qq|qw|qr|qx)</, 'Literal.String.Other', :lt_string
-        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, 'Literal.String.Other'
-
-        rule /package\s+/, 'Keyword', :modulename
-        rule /sub\s+/, 'Keyword', :funcname
+        rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule /(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule /(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+
+        rule /package\s+/, Keyword, :modulename
+        rule /sub\s+/, Keyword, :funcname
         rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
-          'Operator'
-        rule /[-+\/*%=<>&^\|!\\~]=?/, 'Operator'
-        rule /[()\[\]:;,<>\/?{}]/, 'Punctuation'
+          Operator
+        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
+        rule /[()\[\]:;,<>\/?{}]/, Punctuation
         rule(/(?=\w)/) { push :name }
       end
 
       state :format do
-        rule /\.\n/, 'Literal.String.Interpol', :pop!
-        rule /.*?\n/, 'Literal.String.Interpol'
+        rule /\.\n/, Str::Interpol, :pop!
+        rule /.*?\n/, Str::Interpol
       end
 
       state :name_common do
-        rule /\w+::/, 'Name.Namespace'
-        rule /[\w:]+/, 'Name.Variable', :pop!
+        rule /\w+::/, Name::Namespace
+        rule /[\w:]+/, Name::Variable, :pop!
       end
 
       state :varname do
-        rule /\s+/, 'Text'
-        rule /\{/, 'Punctuation', :pop! # hash syntax
-        rule /\)|,/, 'Punctuation', :pop! # arg specifier
+        rule /\s+/, Text
+        rule /\{/, Punctuation, :pop! # hash syntax
+        rule /\)|,/, Punctuation, :pop! # arg specifier
         mixin :name_common
       end
 
       state :name do
         mixin :name_common
-        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, 'Name.Constant', :pop!
+        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
         rule(/(?=\W)/) { pop! }
       end
 
       state :modulename do
-        rule /[a-z_]\w*/i, 'Name.Namespace', :pop!
+        rule /[a-z_]\w*/i, Name::Namespace, :pop!
       end
 
       state :funcname do
-        rule /[a-zA-Z_]\w*[!?]?/, 'Name.Function'
-        rule /\s+/, 'Text'
+        rule /[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule /\s+/, Text
 
         # argument declaration
         rule /(\([$@%]*\))(\s*)/ do
-          group 'Punctuation'
-          group 'Text'
+          group Punctuation
+          group Text
         end
 
-        rule /.*?{/, 'Punctuation', :pop!
-        rule /;/, 'Punctuation', :pop!
+        rule /.*?{/, Punctuation, :pop!
+        rule /;/, Punctuation, :pop!
       end
 
       [[:cb, '\{', '\}'],
        [:rb, '\(', '\)'],
        [:sb, '\[', '\]'],
        [:lt, '<',  '>']].each do |name, open, close|
-        tok = 'Literal.String.Other'
+        tok = Str::Other
         state :"#{name}_string" do
           rule /\\[#{open}#{close}\\]/, tok
           rule /\\/, tok
@@ -191,7 +190,7 @@ module Rouge
 
       state :end_part do
         # eat the rest of the stream
-        rule /.+/m, 'Comment.Preproc', :pop!
+        rule /.+/m, Comment::Preproc, :pop!
       end
     end
   end