rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/haskell.rb

@@ -23,160 +23,159 @@ module Rouge
       )
 
       state :basic do
-        rule /\s+/m, 'Text'
-        rule /{-#/, 'Comment.Preproc', :comment_preproc
-        rule /{-/, 'Comment.Multiline', :comment
-        rule /^--\s+\|.*?$/, 'Comment.Doc'
+        rule /\s+/m, Text
+        rule /{-#/, Comment::Preproc, :comment_preproc
+        rule /{-/, Comment::Multiline, :comment
+        rule /^--\s+\|.*?$/, Comment::Doc
         # this is complicated in order to support custom symbols
         # like -->
-        rule /--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, 'Comment.Single'
+        rule /--(?![!#\$\%&*+.\/<=>?@\^\|_~]).*?$/, Comment::Single
       end
 
       # nested commenting
       state :comment do
-        rule /-}/, 'Comment.Multiline', :pop!
-        rule /{-/, 'Comment.Multiline', :comment
-        rule /[^-{}]+/, 'Comment.Multiline'
-        rule /[-{}]/, 'Comment.Multiline'
+        rule /-}/, Comment::Multiline, :pop!
+        rule /{-/, Comment::Multiline, :comment
+        rule /[^-{}]+/, Comment::Multiline
+        rule /[-{}]/, Comment::Multiline
       end
 
       state :comment_preproc do
-        rule /-}/, 'Comment.Preproc', :pop!
-        rule /{-/, 'Comment.Preproc', :comment
-        rule /[^-{}]+/, 'Comment.Preproc'
-        rule /[-{}]/, 'Comment.Preproc'
+        rule /-}/, Comment::Preproc, :pop!
+        rule /{-/, Comment::Preproc, :comment
+        rule /[^-{}]+/, Comment::Preproc
+        rule /[-{}]/, Comment::Preproc
       end
 
       state :root do
         mixin :basic
 
-        rule /\bimport\b/, 'Keyword.Reserved', :import
-        rule /\bmodule\b/, 'Keyword.Reserved', :module
-        rule /\berror\b/, 'Name.Exception'
-        rule /\b(?:#{reserved.join('|')})\b/, 'Keyword.Reserved'
+        rule /\bimport\b/, Keyword::Reserved, :import
+        rule /\bmodule\b/, Keyword::Reserved, :module
+        rule /\berror\b/, Name::Exception
+        rule /\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
         # not sure why, but ^ doesn't work here
-        # rule /^[_a-z][\w']*/, 'Name.Function'
-        rule /[_a-z][\w']*/, 'Name'
-        rule /[A-Z][\w']*/, 'Keyword.Type'
+        # rule /^[_a-z][\w']*/, Name::Function
+        rule /[_a-z][\w']*/, Name
+        rule /[A-Z][\w']*/, Keyword::Type
 
         # lambda operator
-        rule %r(\\(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), 'Name.Function'
+        rule %r(\\(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Name::Function
         # special operators
-        rule %r((<-|::|->|=>|=)(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), 'Operator'
+        rule %r((<-|::|->|=>|=)(?![:!#\$\%&*+.\\/<=>?@^\|~-]+)), Operator
         # constructor/type operators
-        rule %r(:[:!#\$\%&*+.\\/<=>?@^\|~-]*), 'Operator'
+        rule %r(:[:!#\$\%&*+.\\/<=>?@^\|~-]*), Operator
         # other operators
-        rule %r([:!#\$\%&*+.\\/<=>?@^\|~-]+), 'Operator'
+        rule %r([:!#\$\%&*+.\\/<=>?@^\|~-]+), Operator
 
-        rule /\d+e[+-]?\d+/i, 'Literal.Number.Float'
-        rule /\d+\.\d+(e[+-]?\d+)?/i, 'Literal.Number.Float'
-        rule /0o[0-7]+/i, 'Literal.Number.Oct'
-        rule /0x[\da-f]+/i, 'Literal.Number.Hex'
-        rule /\d+/, 'Literal.Number.Integer'
+        rule /\d+e[+-]?\d+/i, Num::Float
+        rule /\d+\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule /0o[0-7]+/i, Num::Oct
+        rule /0x[\da-f]+/i, Num::Hex
+        rule /\d+/, Num::Integer
 
-        rule /'/, 'Literal.String.Char', :character
-        rule /"/, 'Literal.String', :string
+        rule /'/, Str::Char, :character
+        rule /"/, Str, :string
 
-        rule /\[\s*\]/, 'Keyword.Type'
-        rule /\(\s*\)/, 'Name.Builtin'
-        rule /[\[\](),;`{}]/, 'Punctuation'
+        rule /\[\s*\]/, Keyword::Type
+        rule /\(\s*\)/, Name::Builtin
+        rule /[\[\](),;`{}]/, Punctuation
       end
 
       state :import do
-        rule /\s+/, 'Text'
-        rule /"/, 'Literal.String', :string
-        rule /\bqualified\b/, 'Keyword'
+        rule /\s+/, Text
+        rule /"/, Str, :string
+        rule /\bqualified\b/, Keyword
         # import X as Y
         rule /([A-Z][\w.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)/ do
-          group 'Name.Namespace' # X
-          group 'Text'
-          group 'Keyword' # as
-          group 'Text'
-          group 'Name' # Y
+          group Name::Namespace # X
+          group Text
+          group Keyword # as
+          group Text
+          group Name # Y
           pop!
         end
 
         # import X hiding (functions)
         rule /([A-Z][\w.]*)(\s+)(hiding)(\s+)(\()/ do
-          group 'Name.Namespace' # X
-          group 'Text'
-          group 'Keyword' # hiding
-          group 'Text'
-          group 'Punctuation' # (
+          group Name::Namespace # X
+          group Text
+          group Keyword # hiding
+          group Text
+          group Punctuation # (
           pop!
           push :funclist
         end
 
         # import X (functions)
         rule /([A-Z][\w.]*)(\s+)(\()/ do
-          group 'Name.Namespace' # X
-          group 'Text'
-          group 'Punctuation' # (
+          group Name::Namespace # X
+          group Text
+          group Punctuation # (
           pop!
           push :funclist
         end
 
-        rule /[\w.]+/, 'Name.Namespace', :pop!
+        rule /[\w.]+/, Name::Namespace, :pop!
       end
 
       state :module do
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
         # module Foo (functions)
         rule /([A-Z][\w.]*)(\s+)(\()/ do
-          group 'Name.Namespace'
-          group 'Text'
-          group 'Punctuation'
+          group Name::Namespace
+          group Text
+          group Punctuation
           push :funclist
         end
 
-        rule /\bwhere\b/, 'Keyword.Reserved', :pop!
+        rule /\bwhere\b/, Keyword::Reserved, :pop!
 
-        rule /[A-Z][a-zA-Z0-9_.]*/, 'Name.Namespace', :pop!
+        rule /[A-Z][a-zA-Z0-9_.]*/, Name::Namespace, :pop!
       end
 
       state :funclist do
         mixin :basic
-        rule /[A-Z]\w*/, 'Keyword.Type'
-        rule /(_[\w\']+|[a-z][\w\']*)/, 'Name.Function'
-        rule /,/, 'Punctuation'
-        rule /[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, 'Operator'
-        rule /\(/, 'Punctuation', :funclist
-        rule /\)/, 'Punctuation', :pop!
+        rule /[A-Z]\w*/, Keyword::Type
+        rule /(_[\w\']+|[a-z][\w\']*)/, Name::Function
+        rule /,/, Punctuation
+        rule /[:!#\$\%&*+.\\\/<=>?@^\|~-]+/, Operator
+        rule /\(/, Punctuation, :funclist
+        rule /\)/, Punctuation, :pop!
       end
 
       state :character do
         rule /\\/ do
-          token 'Literal.String.Escape'
+          token Str::Escape
           push :character_end
           push :escape
         end
 
         rule /./ do
-          token 'Literal.String.Char'
-          pop!
-          push :character_end
+          token Str::Char
+          goto :character_end
         end
       end
 
       state :character_end do
-        rule /'/, 'Literal.String.Char', :pop!
-        rule /./, 'Error', :pop!
+        rule /'/, Str::Char, :pop!
+        rule /./, Error, :pop!
       end
 
       state :string do
-        rule /"/, 'Literal.String', :pop!
-        rule /\\/, 'Literal.String.Escape', :escape
-        rule /[^\\"]+/, 'Literal.String'
+        rule /"/, Str, :pop!
+        rule /\\/, Str::Escape, :escape
+        rule /[^\\"]+/, Str
       end
 
       state :escape do
-        rule /[abfnrtv"'&\\]/, 'Literal.String.Escape', :pop!
-        rule /\^[\]\[A-Z@\^_]/, 'Literal.String.Escape', :pop!
-        rule /#{ascii.join('|')}/, 'Literal.String.Escape', :pop!
-        rule /o[0-7]+/i, 'Literal.String.Escape', :pop!
-        rule /x[\da-f]/i, 'Literal.String.Escape', :pop!
-        rule /\d+/, 'Literal.String.Escape', :pop!
-        rule /\s+\\/, 'Literal.String.Escape', :pop!
+        rule /[abfnrtv"'&\\]/, Str::Escape, :pop!
+        rule /\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
+        rule /#{ascii.join('|')}/, Str::Escape, :pop!
+        rule /o[0-7]+/i, Str::Escape, :pop!
+        rule /x[\da-f]/i, Str::Escape, :pop!
+        rule /\d+/, Str::Escape, :pop!
+        rule /\s+\\/, Str::Escape, :pop!
       end
     end
   end

data/lib/rouge/lexers/html.rb

@@ -12,76 +12,76 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/m, 'Text'
-        rule /&\S*?;/, 'Name.Entity'
-        rule /<!DOCTYPE .*?>/i, 'Comment.Preproc'
-        rule /<!\[CDATA\[.*?\]\]>/m, 'Comment.Preproc'
-        rule /<!--/, 'Comment', :comment
-        rule /<\?.*?\?>/m, 'Comment.Preproc' # php? really?
+        rule /[^<&]+/m, Text
+        rule /&\S*?;/, Name::Entity
+        rule /<!DOCTYPE .*?>/i, Comment::Preproc
+        rule /<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
+        rule /<!--/, Comment, :comment
+        rule /<\?.*?\?>/m, Comment::Preproc # php? really?
 
         rule /<\s*script\s*/m do
-          token 'Name.Tag'
+          token Name::Tag
           push :script_content
           push :tag
         end
 
         rule /<\s*style\s*/m do
-          token 'Name.Tag'
+          token Name::Tag
           push :style_content
           push :tag
         end
 
-        rule %r(<\s*[a-zA-Z0-9:]+), 'Name.Tag', :tag # opening tags
-        rule %r(<\s*/\s*[a-zA-Z0-9:]+\s*>), 'Name.Tag' # closing tags
+        rule %r(<\s*[a-zA-Z0-9:]+), Name::Tag, :tag # opening tags
+        rule %r(<\s*/\s*[a-zA-Z0-9:]+\s*>), Name::Tag # closing tags
       end
 
       state :comment do
-        rule /[^-]+/, 'Comment'
-        rule /-->/, 'Comment', :pop!
-        rule /-/, 'Comment'
+        rule /[^-]+/, Comment
+        rule /-->/, Comment, :pop!
+        rule /-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, 'Text'
-        rule /[a-zA-Z0-9_:-]+\s*=/m, 'Name.Attribute', :attr
-        rule /[a-zA-Z0-9_:-]+/, 'Name.Attribute'
-        rule %r(/?\s*>)m, 'Name.Tag', :pop!
+        rule /\s+/m, Text
+        rule /[a-zA-Z0-9_:-]+\s*=/m, Name::Attribute, :attr
+        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r(/?\s*>)m, Name::Tag, :pop!
       end
 
       state :attr do
         # TODO: are backslash escapes valid here?
         rule /"/ do
-          token 'Literal.String'
-          pop!; push :dq
+          token Str
+          goto :dq
         end
 
         rule /'/ do
-          token 'Literal.String'
-          pop!; push :sq
+          token Str
+          goto :sq
         end
 
-        rule /[^\s>]+/, 'Literal.String', :pop!
+        rule /[^\s>]+/, Str, :pop!
       end
 
       state :dq do
-        rule /"/, 'Literal.String', :pop!
-        rule /[^"]+/, 'Literal.String'
+        rule /"/, Str, :pop!
+        rule /[^"]+/, Str
       end
 
       state :sq do
-        rule /'/, 'Literal.String', :pop!
-        rule /[^']+/, 'Literal.String'
+        rule /'/, Str, :pop!
+        rule /[^']+/, Str
       end
 
       state :script_content do
-        rule %r(<\s*/\s*script\s*>)m, 'Name.Tag', :pop!
+        rule %r(<\s*/\s*script\s*>)m, Name::Tag, :pop!
         rule %r(.*?(?=<\s*/\s*script\s*>))m do
           delegate Javascript
         end
       end
 
       state :style_content do
-        rule %r(<\s*/\s*style\s*>)m, 'Name.Tag', :pop!
+        rule %r(<\s*/\s*style\s*>)m, Name::Tag, :pop!
         rule %r(.*(?=<\s*/\s*style\s*>))m do
           delegate CSS
         end

data/lib/rouge/lexers/http.rb

@@ -17,10 +17,10 @@ module Rouge
           ([^ ]+)([ ]+)                     # path
           (HTTPS?)(/)(1[.][01])(\r?\n|$)  # http version
         )ox do
-          group 'Name.Function'; group 'Text'
-          group 'Name.Namespace'; group 'Text'
-          group 'Keyword'; group 'Operator'
-          group 'Literal.Number'; group 'Text'
+          group Name::Function; group Text
+          group Name::Namespace; group Text
+          group Keyword; group Operator
+          group Num; group Text
           push :headers
         end
 
@@ -30,10 +30,10 @@ module Rouge
           (\d{3})([ ]+)               # status
           ([^\r\n]+)(\r?\n|$)       # status message
         )x do
-          group 'Keyword'; group 'Operator'
-          group 'Literal.Number'; group 'Text'
-          group 'Literal.Number'; group 'Text'
-          group 'Name.Exception'; group 'Text'
+          group Keyword; group Operator
+          group Num; group Text
+          group Num; group Text
+          group Name::Exception; group Text
           push :headers
         end
       end
@@ -46,16 +46,16 @@ module Rouge
             @content_type = value.split(';')[0].downcase
           end
 
-          group 'Name.Attribute'; group 'Text'
-          group 'Punctuation'; group 'Text'
-          group 'Literal.String'; group 'Text'
+          group Name::Attribute; group Text
+          group Punctuation; group Text
+          group Str; group Text
         end
 
         rule /([^\r\n]+)(\r?\n|$)/ do
-          group 'Literal.String'; group 'Text'
+          group Str; group Text
         end
 
-        rule /\r?\n/, 'Text', :content
+        rule /\r?\n/, Text, :content
       end
 
       state :content do

data/lib/rouge/lexers/ini.rb

@@ -15,40 +15,40 @@ module Rouge
       identifier = /[\w.]+/
 
       state :basic do
-        rule /[;#].*?\n/, 'Comment'
-        rule /\s+/, 'Text'
-        rule /\\\n/, 'Literal.String.Escape'
+        rule /[;#].*?\n/, Comment
+        rule /\s+/, Text
+        rule /\\\n/, Str::Escape
       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
 
-        rule /\[.*?\]/, 'Name.Namespace'
+        rule /\[.*?\]/, Name::Namespace
       end
 
       state :value do
-        rule /\n/, 'Text', :pop!
+        rule /\n/, Text, :pop!
         mixin :basic
-        rule /"/, 'Literal.String', :dq
-        rule /'.*?'/, 'Literal.String'
+        rule /"/, Str, :dq
+        rule /'.*?'/, Str
         mixin :esc_str
-        rule /[^\\\n]+/, 'Literal.String'
+        rule /[^\\\n]+/, Str
       end
 
       state :dq do
-        rule /"/, 'Literal.String', :pop!
+        rule /"/, Str, :pop!
         mixin :esc_str
-        rule /[^\\"]+/m, 'Literal.String'
+        rule /[^\\"]+/m, Str
       end
 
       state :esc_str do
-        rule /\\./m, 'Literal.String.Escape'
+        rule /\\./m, Str::Escape
       end
     end
   end