rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/io.rb

@@ -22,43 +22,43 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, 'Text'
-        rule %r(//.*?\n), 'Comment.Single'
-        rule %r(#.*?\n), 'Comment.Single'
-        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, 'Comment.Multiline'
-        rule %r(/[+]), 'Comment.Multiline', :nested_comment
+        rule /\s+/m, Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(#.*?\n), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
 
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
+        rule /"(\\\\|\\"|[^"])*"/, Str
 
-        rule %r(:?:=), 'Keyword'
-        rule /[()]/, 'Punctuation'
+        rule %r(:?:=), Keyword
+        rule /[()]/, Punctuation
 
-        rule %r([-=;,*+><!/|^.%&\[\]{}]), 'Operator'
+        rule %r([-=;,*+><!/|^.%&\[\]{}]), Operator
 
-        rule /[A-Z]\w*/, 'Name.Class'
+        rule /[A-Z]\w*/, Name::Class
 
         rule /[a-z_]\w*/ do |m|
           name = m[0]
 
           if self.class.constants.include? name
-            token 'Keyword.Constant'
+            token Keyword::Constant
           elsif self.class.builtins.include? name
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name'
+            token Name
           end
         end
 
-        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, 'Literal.Number.Float'
-        rule /\d+/, 'Literal.Number.Integer'
+        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
+        rule /\d+/, Num::Integer
 
-        rule /@@?/, 'Keyword'
+        rule /@@?/, Keyword
       end
 
       state :nested_comment do
-        rule %r([^/+]+)m, 'Comment.Multiline'
-        rule %r(/[+]), 'Comment.Multiline', :nested_comment
-        rule %r([+]/), 'Comment.Multiline', :pop!
+        rule %r([^/+]+)m, Comment::Multiline
+        rule %r(/[+]), Comment::Multiline, :nested_comment
+        rule %r([+]/), Comment::Multiline, :pop!
       end
     end
   end

data/lib/rouge/lexers/java.rb

@@ -29,45 +29,45 @@ module Rouge
         )mx do |m|
           # TODO: do this better, this shouldn't need a delegation
           delegate Java, m[1]
-          token 'Name.Function', m[2]
-          token 'Text', m[3]
-          token 'Punctuation', m[4]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Punctuation, m[4]
         end
 
-        rule /\s+/, 'Text'
-        rule %r(//.*?$), 'Comment.Single'
-        rule %r(/\*.*?\*/)m, 'Comment.Multiline'
-        rule /@#{id}/, 'Name.Decorator'
-        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
-        rule /(?:#{declarations.join('|')})\b/, 'Keyword.Declaration'
-        rule /(?:#{types.join('|')})/, 'Keyword.Type'
-        rule /package\b/, 'Keyword.Namespace'
-        rule /(?:true|false|null)\b/, 'Keyword.Constant'
-        rule /(?:class|interface)\b/, 'Keyword.Declaration', :class
-        rule /import\b/, 'Keyword.Namespace', :import
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
-        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, 'Literal.String.Char'
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule /@#{id}/, Name::Decorator
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule /(?:#{types.join('|')})/, Keyword::Type
+        rule /package\b/, Keyword::Namespace
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /(?:class|interface)\b/, Keyword::Declaration, :class
+        rule /import\b/, Keyword::Namespace, :import
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, Str::Char
         rule /(\.)(#{id})/ do
-          group 'Operator'
-          group 'Name.Attribute'
+          group Operator
+          group Name::Attribute
         end
-        rule /#{id}:/, 'Name.Label'
-        rule /\$?#{id}/, 'Name'
-        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, 'Operator'
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, 'Literal.Number.Float'
-        rule /0x[0-9a-f]+/, 'Literal.Number.Hex'
-        rule /[0-9]+L?/, 'Literal.Number.Integer'
-        # rule /\n/, 'Text'
+        rule /#{id}:/, Name::Label
+        rule /\$?#{id}/, Name
+        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule /0x[0-9a-f]+/, Num::Hex
+        rule /[0-9]+L?/, Num::Integer
+        # rule /\n/, Text
       end
 
       state :class do
-        rule /\s+/m, 'Text'
-        rule id, 'Name.Class', :pop!
+        rule /\s+/m, Text
+        rule id, Name::Class, :pop!
       end
 
       state :import do
-        rule /\s+/m, 'Text'
-        rule /[a-z0-9_.]+\*?/i, 'Name.Namespace', :pop!
+        rule /\s+/m, Text
+        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/javascript.rb

@@ -16,10 +16,10 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, 'Text'
-        rule /<!--/, 'Comment' # really...?
-        rule %r(//.*?\n), 'Comment.Single'
-        rule %r(/\*.*?\*/), 'Comment.Multiline'
+        rule /\s+/, Text
+        rule /<!--/, Comment # really...?
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
       end
 
       state :slash_starts_regex do
@@ -33,17 +33,17 @@ module Rouge
           )+
           / # closing slash
           (?:[gim]+\b|\B) # flags
-        )x, 'Literal.String.Regex', :pop!
+        )x, Str::Regex, :pop!
 
         # if it's not matched by the above r.e., it's not
         # a valid expression, so we use :bad_regex to eat until the
         # end of the line.
-        rule %r(/), 'Literal.String.Regex', :bad_regex
-        rule //, 'Text', :pop!
+        rule %r(/), Str::Regex, :bad_regex
+        rule //, Text, :pop!
       end
 
       state :bad_regex do
-        rule /[^\n]+/, 'Error', :pop!
+        rule /[^\n]+/, Error, :pop!
       end
 
       def self.keywords
@@ -84,79 +84,78 @@ module Rouge
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule /\A\s*#!.*?\n/m, 'Comment.Preproc'
-        rule %r((?<=\n)(?=\s|/|<!--)), 'Text', :slash_starts_regex
+        rule /\A\s*#!.*?\n/m, Comment::Preproc
+        rule %r((?<=\n)(?=\s|/|<!--)), Text, :slash_starts_regex
         mixin :comments_and_whitespace
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
-          'Operator', :slash_starts_regex
-        rule %r([-<>+*%&|\^/!=]=?), 'Operator', :slash_starts_regex
-        rule /[(\[;,]/, 'Punctuation', :slash_starts_regex
-        rule /[)\].]/, 'Punctuation'
+          Operator, :slash_starts_regex
+        rule %r([-<>+*%&|\^/!=]=?), Operator, :slash_starts_regex
+        rule /[(\[;,]/, Punctuation, :slash_starts_regex
+        rule /[)\].]/, Punctuation
 
         rule /[?]/ do
-          token 'Punctuation'
+          token Punctuation
           push :ternary
           push :slash_starts_regex
         end
 
-        rule /[{](?=\s*(#{id}|"[^\n]*?")\s*:)/, 'Punctuation', :object
+        rule /[{](?=\s*(#{id}|"[^\n]*?")\s*:)/m, Punctuation, :object
 
         rule /[{]/ do
-          token 'Punctuation'
+          token Punctuation
           push :block
           push :slash_starts_regex
         end
 
         rule id do |m|
           if self.class.keywords.include? m[0]
-            token 'Keyword'
+            token Keyword
             push :slash_starts_regex
           elsif self.class.declarations.include? m[0]
-            token 'Keyword.Declaration'
+            token Keyword::Declaration
             push :slash_starts_regex
           elsif self.class.reserved.include? m[0]
-            token 'Keyword.Reserved'
+            token Keyword::Reserved
           elsif self.class.constants.include? m[0]
-            token 'Keyword.Constant'
+            token Keyword::Constant
           elsif self.class.builtins.include? m[0]
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name.Other'
+            token Name::Other
           end
         end
 
-        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, 'Literal.Number.Float'
-        rule /0x[0-9a-fA-F]+/, 'Literal.Number.Hex'
-        rule /[0-9]+/, 'Literal.Number.Integer'
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String.Double'
-        rule /'(\\\\|\\'|[^'])*'/, 'Literal.String.Single'
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule /0x[0-9a-fA-F]+/, Num::Hex
+        rule /[0-9]+/, Num::Integer
+        rule /"(\\\\|\\"|[^"])*"/, Str::Double
+        rule /'(\\\\|\\'|[^'])*'/, Str::Single
       end
 
       # braced parts that aren't object literals
       state :block do
         rule /(#{id})(\s*)(:)/ do
-          group 'Name.Label'; group 'Text'
-          group 'Punctuation'
+          groups Name::Label, Text, Punctuation
         end
 
-        rule /[}]/, 'Punctuation', :pop!
+        rule /[}]/, Punctuation, :pop!
         mixin :root
       end
 
       # object literals
       state :object do
-        rule /[}]/, 'Punctuation', :pop!
+        rule /[}]/, Punctuation, :pop!
         rule /(#{id})(\s*)(:)/ do
-          group 'Name.Attribute'; group 'Text'
-          group 'Punctuation'
+          groups Name::Attribute, Text, Punctuation
         end
+        rule /:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/, 'Punctuation', :pop!
+        rule /:/, Punctuation, :pop!
         mixin :root
       end
     end
@@ -177,43 +176,41 @@ module Rouge
       state :root do
         mixin :whitespace
         # special case for empty objects
-        rule /(\{)(\s*)(\})/ do
-          group 'Punctuation'
-          group 'Text.Whitespace'
-          group 'Punctuation'
+        rule /(\{)(\s*)(\})/m do
+          groups Punctuation, Text::Whitespace, Punctuation
         end
-        rule /true|false/, 'Keyword.Constant'
-        rule /{/,  'Punctuation', :object_key
-        rule /\[/, 'Punctuation', :array
-        rule /-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, 'Literal.Number.Float'
-        rule /-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, 'Literal.Number.Integer'
+        rule /(?:true|false)\b/, Keyword::Constant
+        rule /{/,  Punctuation, :object_key
+        rule /\[/, Punctuation, :array
+        rule /-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule /-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
         mixin :has_string
       end
 
       state :whitespace do
-        rule /\s+/m, 'Text.Whitespace'
+        rule /\s+/m, Text::Whitespace
       end
 
       state :has_string do
-        rule /"(\\.|[^"])*"/, 'Literal.String.Double'
+        rule /"(\\.|[^"])*"/, Str::Double
       end
 
       state :object_key do
         mixin :whitespace
-        rule /:/, 'Punctuation', :object_val
-        rule /}/, 'Error', :pop!
         mixin :has_string
+        rule /:/, Punctuation, :object_val
+        rule /}/, Error, :pop!
       end
 
       state :object_val do
-        rule /,/, 'Punctuation', :pop!
-        rule(/}/) { token 'Punctuation'; pop!; pop! }
+        rule /,/, Punctuation, :pop!
+        rule(/}/) { token Punctuation; pop!(2) }
         mixin :root
       end
 
       state :array do
-        rule /\]/, 'Punctuation', :pop!
-        rule /,/, 'Punctuation'
+        rule /\]/, Punctuation, :pop!
+        rule /,/, Punctuation
         mixin :root
       end
     end

data/lib/rouge/lexers/literate_haskell.rb

@@ -16,18 +16,18 @@ module Rouge
       # TODO: support TeX versions as well.
       # TODO: enforce a blank line before and after code
       state :root do
-        rule /\s*?\n(?=>)/, 'Text', :code
-        rule /.*?\n/, 'Text'
-        rule /.+\z/, 'Text'
+        rule /\s*?\n(?=>)/, Text, :code
+        rule /.*?\n/, Text
+        rule /.+\z/, Text
       end
 
       state :code do
         rule /(>)( .*?\n)/ do |m|
-          token 'Name.Label', m[1]
+          token Name::Label, m[1]
           delegate haskell, m[2]
         end
 
-        rule /\s*\n(?=\s*[^>])/, 'Text', :pop!
+        rule /\s*\n(?=\s*[^>])/, Text, :pop!
       end
     end
   end

data/lib/rouge/lexers/llvm.rb

@@ -15,21 +15,21 @@ module Rouge
       identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
 
       state :basic do
-        rule /;.*?$/, 'Comment.Single'
-        rule /\s+/, 'Text'
+        rule /;.*?$/, Comment::Single
+        rule /\s+/, Text
 
-        rule /#{identifier}\s*:/, 'Literal.Name.Label'
+        rule /#{identifier}\s*:/, Name::Label
 
-        rule /@(#{identifier}|\d+)/, 'Name.Variable.Global'
-        rule /(%|!)#{identifier}/, 'Name.Variable'
-        rule /(%|!)\d+/, 'Name.Variable.Anonymous'
+        rule /@(#{identifier}|\d+)/, Name::Variable::Global
+        rule /(%|!)#{identifier}/, Name::Variable
+        rule /(%|!)\d+/, Name::Variable
 
-        rule /c?#{string}/, 'Literal.String'
+        rule /c?#{string}/, Str
 
-        rule /0[xX][a-fA-F0-9]+/, 'Literal.Number'
-        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, 'Literal.Number'
+        rule /0[xX][a-fA-F0-9]+/, Num
+        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
 
-        rule /[=<>{}\[\]()*.,!]|x/, 'Punctuation'
+        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
       end
 
       builtin_types = %w(
@@ -37,8 +37,8 @@ module Rouge
       )
 
       state :types do
-        rule /i[1-9]\d*/, 'Keyword.Type'
-        rule /#{builtin_types.join('|')}/, 'Keyword.Type'
+        rule /i[1-9]\d*/, Keyword::Type
+        rule /#{builtin_types.join('|')}/, Keyword::Type
       end
 
       builtin_keywords = %w(
@@ -67,8 +67,8 @@ module Rouge
       )
 
       state :keywords do
-        rule /#{builtin_instructions.join('|')}/, 'Keyword'
-        rule /#{builtin_keywords.join('|')}/, 'Keyword'
+        rule /#{builtin_instructions.join('|')}/, Keyword
+        rule /#{builtin_keywords.join('|')}/, Keyword
       end
 
       state :root do

data/lib/rouge/lexers/lua.rb

@@ -35,60 +35,60 @@ module Rouge
       
       state :root do
         # lua allows a file to start with a shebang
-        rule %r(#!(.*?)$), 'Comment.Preproc'
-        rule //, 'Text', :base
+        rule %r(#!(.*?)$), Comment::Preproc
+        rule //, Text, :base
       end
                   
       state :base do
-        rule %r(--\[(=*)\[.*?\]\1\])ms, 'Comment.Multiline'
-        rule %r(--.*$), 'Comment.Single'
+        rule %r(--\[(=*)\[.*?\]\1\])ms, Comment::Multiline
+        rule %r(--.*$), Comment::Single
         
-        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), 'Literal.Number.Float'
-        rule %r((?i)\d+e[+-]?\d+), 'Literal.Number.Float'
-        rule %r((?i)0x[0-9a-f]*), 'Literal.Number.Hex'
-        rule %r(\d+), 'Literal.Number.Integer'
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
         
-        rule %r(\n), 'Text'
-        rule %r([^\S\n]), 'Text'
+        rule %r(\n), Text
+        rule %r([^\S\n]), Text
         # multiline strings
-        rule %r(\[(=*)\[.*?\]\1\])ms, 'Literal.String'
+        rule %r(\[(=*)\[.*?\]\1\])ms, Str
         
-        rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), 'Operator'
-        rule %r([\[\]\{\}\(\)\.,:;]), 'Punctuation'
-        rule %r((and|or|not)\b), 'Operator.Word'
+        rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
         
-        rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), 'Keyword'
-        rule %r((local)\b), 'Keyword.Declaration'
-        rule %r((true|false|nil)\b), 'Keyword.Constant'
+        rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), Keyword
+        rule %r((local)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
         
-        rule %r((function)\b), 'Keyword', :function_name
+        rule %r((function)\b), Keyword, :function_name
         
         rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
           name = m[0]
           if self.builtins.include?(name)
-            token 'Name.Builtin'
+            token Name::Builtin
           elsif name =~ /\./
             a, b = name.split('.', 2)
-            token 'Name', a
-            token 'Punctuation', '.'
-            token 'Name', b
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
           else
-            token 'Name'
+            token Name
           end
         end
         
-        rule %r('), 'Literal.String.Single', :escape_sqs
-        rule %r("), 'Literal.String.Double', :escape_dqs
+        rule %r('), Str::Single, :escape_sqs
+        rule %r("), Str::Double, :escape_dqs
       end
       
       state :function_name do
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
         rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
-          group 'Name.Class'; group 'Punctuation'; group 'Name.Function'
+          group Name::Class; group Punctuation; group Name::Function
           pop!
         end
         # inline function
-        rule %r(\(), 'Punctuation', :pop!
+        rule %r(\(), Punctuation, :pop!
       end
       
       state :escape_sqs do
@@ -102,24 +102,24 @@ module Rouge
       end
       
       state :string_escape do
-        rule %r(\\([abfnrtv\\"']|\d{1,3})), 'Literal.String.Escape'
+        rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
       end
       
       state :sqs do
-        rule %r('), 'Literal.String', :pop!
+        rule %r('), Str, :pop!
         mixin :string
       end
       
       state :dqs do
-        rule %r("), 'Literal.String', :pop!
+        rule %r("), Str, :pop!
         mixin :string
       end
       
       # Lua is 8-bit clean, every character is valid in a string
       state :string do
-        rule /./, 'Literal.String'
+        rule /./, Str
       end
       
     end
   end
-end
+end