rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/gherkin.rb

@@ -36,15 +36,15 @@ module Rouge
       rest_of_line = /.*?(?=[#\n])/
 
       state :basic do
-        rule %r(#.*$), 'Comment'
-        rule /[ \r\t]+/, 'Text'
+        rule %r(#.*$), Comment
+        rule /[ \r\t]+/, Text
       end
 
       state :root do
         mixin :basic
-        rule %r(\n), 'Text'
-        rule %r(""".*?""")m, 'Literal.String'
-        rule %r(@[^\s@]+), 'Name.Tag'
+        rule %r(\n), Text
+        rule %r(""".*?""")m, Str
+        rule %r(@[^\s@]+), Name::Tag
         mixin :has_table
         mixin :has_examples
       end
@@ -55,23 +55,23 @@ module Rouge
 
           keyword = m[1]
           if self.class.keywords[:element].include? keyword
-            group 'Keyword.Namespace'; push :description
+            group Keyword::Namespace; push :description
           elsif self.class.keywords[:feature].include? keyword
-            group 'Keyword.Declaration'; push :feature_description
+            group Keyword::Declaration; push :feature_description
           elsif self.class.keywords[:examples].include? keyword
-            group 'Name.Namespace'; push :example_description
+            group Name::Namespace; push :example_description
           else
-            group 'Error'
+            group Error
           end
 
-          group 'Punctuation'
+          group Punctuation
         end
       end
 
       state :has_examples do
         mixin :has_scenarios
-        rule Gherkin.step_regex, 'Name.Function' do
-          token 'Name.Function'
+        rule Gherkin.step_regex, Name::Function do
+          token Name::Function
           reset_stack; push :step
         end
       end
@@ -81,10 +81,10 @@ module Rouge
       end
 
       state :table_header do
-        rule /[^|\s]+/, 'Name.Variable'
+        rule /[^|\s]+/, Name::Variable
         rule /\n/ do
-          token 'Text'
-          pop!; push :table
+          token Text
+          goto :table
         end
         mixin :table
       end
@@ -92,37 +92,37 @@ module Rouge
       state :table do
         rule(/^(?=\s*[^\s|])/) { reset_stack }
         mixin :basic
-        rule /[|]/, 'Punctuation'
-        rule /[^|\s]+/, 'Name'
+        rule /[|]/, Punctuation
+        rule /[^|\s]+/, Name
       end
 
       state :description do
         mixin :basic
         mixin :has_examples
-        rule /\n/, 'Text'
-        rule rest_of_line, 'Text'
+        rule /\n/, Text
+        rule rest_of_line, Text
       end
 
       state :feature_description do
         mixin :basic
         mixin :has_scenarios
-        rule /\n/, 'Text'
-        rule rest_of_line, 'Text'
+        rule /\n/, Text
+        rule rest_of_line, Text
       end
 
       state :example_description do
         mixin :basic
         mixin :has_table
-        rule /\n/, 'Text'
-        rule rest_of_line, 'Text'
+        rule /\n/, Text
+        rule rest_of_line, Text
       end
 
       state :step do
         mixin :basic
-        rule /<.*?>/, 'Name.Variable'
-        rule /".*?"/, 'Literal.String'
-        rule /\S+/, 'Text'
-        rule rest_of_line, 'Text', :pop!
+        rule /<.*?>/, Name::Variable
+        rule /".*?"/, Str
+        rule /\S+/, Text
+        rule rest_of_line, Text, :pop!
       end
     end
   end

data/lib/rouge/lexers/go.rb

@@ -137,38 +137,38 @@ module Rouge
                                )\b/x
 
       state :simple_tokens do
-        rule(COMMENT,               "Comment")
-        rule(KEYWORD,               "Keyword")
-        rule(PREDECLARED_TYPES,     "Keyword.Type")
-        rule(PREDECLARED_FUNCTIONS, "Name.Builtin")
-        rule(PREDECLARED_CONSTANTS, "Name.Constant")
-        rule(IMAGINARY_LIT,         "Literal.Number")
-        rule(FLOAT_LIT,             "Literal.Number")
-        rule(INT_LIT,               "Literal.Number")
-        rule(CHAR_LIT,              "Literal.String.Char")
-        rule(OPERATOR,              "Operator")
-        rule(SEPARATOR,             "Punctuation")
-        rule(IDENTIFIER,            "Name")
-        rule(WHITE_SPACE,           "Other")
+        rule(COMMENT,               Comment)
+        rule(KEYWORD,               Keyword)
+        rule(PREDECLARED_TYPES,     Keyword::Type)
+        rule(PREDECLARED_FUNCTIONS, Name::Builtin)
+        rule(PREDECLARED_CONSTANTS, Name::Constant)
+        rule(IMAGINARY_LIT,         Num)
+        rule(FLOAT_LIT,             Num)
+        rule(INT_LIT,               Num)
+        rule(CHAR_LIT,              Str::Char)
+        rule(OPERATOR,              Operator)
+        rule(SEPARATOR,             Punctuation)
+        rule(IDENTIFIER,            Name)
+        rule(WHITE_SPACE,           Other)
       end
 
       state :root do
         mixin :simple_tokens
 
-        rule(/`/,             "Literal.String", :raw_string)
-        rule(/"/,             "Literal.String", :interpreted_string)
+        rule(/`/,             Str, :raw_string)
+        rule(/"/,             Str, :interpreted_string)
       end
 
       state :interpreted_string do
-        rule(ESCAPE_SEQUENCE, "Literal.String.Escape")
-        rule(/\\./,           "Error")
-        rule(/"/,             "Literal.String", :pop!)
-        rule(/./,             "Literal.String")
+        rule(ESCAPE_SEQUENCE, Str::Escape)
+        rule(/\\./,           Error)
+        rule(/"/,             Str, :pop!)
+        rule(/[^"\\]+/,       Str)
       end
 
       state :raw_string do
-        rule(/`/,             "Literal.String", :pop!)
-        rule(/./m,            "Literal.String")
+        rule(/`/,             Str, :pop!)
+        rule(/[^`]+/m,        Str)
       end
     end
   end

data/lib/rouge/lexers/groovy.rb

@@ -40,62 +40,62 @@ module Rouge
           (\s*) (\() # signature start
         )x do |m|
           delegate self.clone, m[1]
-          token 'Name.Function', m[2]
-          token 'Text', m[3]
-          token 'Operator', m[4]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Operator, m[4]
         end
 
         # whitespace
-        rule /[^\S\n]+/, 'Text'
-        rule %r(//.*?\n), 'Comment.Single'
-        rule %r(/[*].*?[*]/), 'Comment.Multiline'
-        rule /@\w[\w\d.]*/, 'Name.Decorator'
-        rule /(class|interface)\b/,  'Keyword.Declaration', :class
-        rule /package\b/, 'Keyword.Namespace', :import
-        rule /import\b/, 'Keyword.Namespace', :import
+        rule /[^\S\n]+/, Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        rule /@\w[\w\d.]*/, Name::Decorator
+        rule /(class|interface)\b/,  Keyword::Declaration, :class
+        rule /package\b/, Keyword::Namespace, :import
+        rule /import\b/, Keyword::Namespace, :import
 
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String.Double'
-        rule /'(\\\\|\\'|[^'])*'/, 'Literal.String.Single'
-        rule %r(\$/((?!/\$).)*/\$), 'Literal.String'
-        rule %r(/(\\\\|\\"|[^/])*/), 'Literal.String'
-        rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, 'Literal.String.Char'
+        rule /"(\\\\|\\"|[^"])*"/, Str::Double
+        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r(\$/((?!/\$).)*/\$), Str
+        rule %r(/(\\\\|\\"|[^/])*/), Str
+        rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
         rule /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
-          group 'Operator'
-          group 'Name.Attribute'
+          group Operator
+          group Name::Attribute
         end
 
-        rule /[a-zA-Z_][a-zA-Z0-9_]*:/, 'Name.Label'
+        rule /[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label
         rule /[a-zA-Z_\$][a-zA-Z0-9_]*/ do |m|
           if self.class.keywords.include? m[0]
-            token 'Keyword'
+            token Keyword
           elsif self.class.declarations.include? m[0]
-            token 'Keyword.Declaration'
+            token Keyword::Declaration
           elsif self.class.types.include? m[0]
-            token 'Keyword.Type'
+            token Keyword::Type
           elsif self.class.constants.include? m[0]
-            token 'Keyword.Constant'
+            token Keyword::Constant
           else
-            token 'Name'
+            token Name
           end
         end
 
-        rule %r([~^*!%&\[\](){}<>\|+=:;,./?-]), 'Operator'
+        rule %r([~^*!%&\[\](){}<>\|+=:;,./?-]), Operator
 
         # numbers
-        rule /\d+\.\d+([eE]\d+)?[fd]?/, 'Literal.Number.Float'
-        rule /0x[0-9a-f]+/, 'Literal.Number.Hex'
-        rule /[0-9]+L?/, 'Literal.Number.Integer'
-        rule /\n/, 'Text'
+        rule /\d+\.\d+([eE]\d+)?[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+/, 'Text'
-        rule /\w[\w\d]*/, 'Name.Class', :pop!
+        rule /\s+/, Text
+        rule /\w[\w\d]*/, Name::Class, :pop!
       end
 
       state :import do
-        rule /\s+/, 'Text'
-        rule /[\w\d.]+[*]?/, 'Name.Namespace', :pop!
+        rule /\s+/, Text
+        rule /[\w\d.]+[*]?/, Name::Namespace, :pop!
       end
     end
   end

data/lib/rouge/lexers/haml.rb

@@ -71,42 +71,42 @@ module Rouge
       comma_dot = /,\s*\n|#{dot}/
 
       state :root do
-        rule /\s*\n/, 'Text'
-        rule(/\s*/) { |m| token 'Text'; indentation(m[0]) }
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
       end
 
       state :content do
         mixin :css
-        rule(/%#{identifier}/) { token 'Name.Tag'; pop!; push :tag }
-        rule /!!!#{dot}*\n/, 'Name.Namespace', :pop!
+        rule(/%#{identifier}/) { token Name::Tag; goto :tag }
+        rule /!!!#{dot}*\n/, Name::Namespace, :pop!
         rule %r(
           (/) (\[#{dot}*?\]) (#{dot}*\n)
         )x do
-          group 'Comment'; group 'Comment.Special'; group 'Comment'
+          group Comment; group Comment::Special; group Comment
           pop!
         end
 
         rule %r(/#{dot}*\n) do
-          token 'Comment'
+          token Comment
           pop!
           starts_block :html_comment_block
         end
 
         rule /-##{dot}*\n/ do
-          token 'Comment'
+          token Comment
           pop!
           starts_block :haml_comment_block
         end
 
         rule /-/ do
-          token 'Punctuation'
+          token Punctuation
           reset_stack
           push :ruby_line
         end
 
         # filters
         rule /:(#{dot}*)\n/ do |m|
-          token 'Name.Decorator'
+          token Name::Decorator
           pop!
           starts_block :filter_block
 
@@ -122,19 +122,19 @@ module Rouge
       end
 
       state :css do
-        rule(/\.#{identifier}/) { token 'Name.Class'; pop!; push :tag }
-        rule(/##{identifier}/) { token 'Name.Function'; pop!; push :tag }
+        rule(/\.#{identifier}/) { token Name::Class; goto :tag }
+        rule(/##{identifier}/) { token Name::Function; goto :tag }
       end
 
       state :tag do
         mixin :css
         rule(/\{#{comma_dot}*?\}/) { delegate ruby }
         rule(/\[#{dot}*?\]/) { delegate ruby }
-        rule /\(/, 'Punctuation', :html_attributes
-        rule /\s*\n/, 'Text', :pop!
+        rule /\(/, Punctuation, :html_attributes
+        rule /\s*\n/, Text, :pop!
 
         # whitespace chompers
-        rule /[<>]{1,2}(?=[ \t=])/, 'Punctuation'
+        rule /[<>]{1,2}(?=[ \t=])/, Punctuation
 
         mixin :eval_or_plain
       end
@@ -142,13 +142,13 @@ module Rouge
       state :plain do
         rule(/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/) { delegate html }
         mixin :interpolation
-        rule(/\n/) { token 'Text'; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
       end
 
       state :eval_or_plain do
-        rule /[&!]?==/, 'Punctuation', :plain
+        rule /[&!]?==/, Punctuation, :plain
         rule /[&!]?[=!]/ do
-          token 'Punctuation'
+          token Punctuation
           reset_stack
           push :ruby_line
         end
@@ -157,35 +157,35 @@ module Rouge
       end
 
       state :ruby_line do
-        rule /\n/, 'Text', :pop!
+        rule /\n/, Text, :pop!
         rule(/,[ \t]*\n/) { delegate ruby }
-        rule /[ ]\|[ \t]*\n/, 'Literal.String.Escape'
+        rule /[ ]\|[ \t]*\n/, Str::Escape
         rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
       end
 
       state :html_attributes do
-        rule /\s+/, 'Text'
-        rule /#{identifier}\s*=/, 'Name.Attribute', :html_attribute_value
-        rule identifier, 'Name.Attribute'
-        rule /\)/, 'Text', :pop!
+        rule /\s+/, Text
+        rule /#{identifier}\s*=/, Name::Attribute, :html_attribute_value
+        rule identifier, Name::Attribute
+        rule /\)/, Text, :pop!
       end
 
       state :html_attribute_value do
-        rule /\s+/, 'Text'
-        rule ruby_var, 'Name.Variable', :pop!
-        rule /@#{ruby_var}/, 'Name.Variable.Instance', :pop!
-        rule /\$#{ruby_var}/, 'Name.Variable.Global', :pop!
-        rule /'(\\\\|\\'|[^'\n])*'/, 'Literal.String', :pop!
-        rule /"(\\\\|\\"|[^"\n])*"/, 'Literal.String', :pop!
+        rule /\s+/, Text
+        rule ruby_var, Name::Variable, :pop!
+        rule /@#{ruby_var}/, Name::Variable::Instance, :pop!
+        rule /\$#{ruby_var}/, Name::Variable::Global, :pop!
+        rule /'(\\\\|\\'|[^'\n])*'/, Str, :pop!
+        rule /"(\\\\|\\"|[^"\n])*"/, Str, :pop!
       end
 
       state :html_comment_block do
-        rule /#{dot}+/, 'Comment'
+        rule /#{dot}+/, Comment
         mixin :indented_block
       end
 
       state :haml_comment_block do
-        rule /#{dot}+/, 'Comment.Preproc'
+        rule /#{dot}+/, Comment::Preproc
         mixin :indented_block
       end
 
@@ -194,7 +194,7 @@ module Rouge
           if @filter_lexer
             delegate @filter_lexer
           else
-            token 'Name.Decorator'
+            token Name::Decorator
           end
         end
 
@@ -204,14 +204,14 @@ module Rouge
 
       state :interpolation do
         rule /(#\{)(#{dot}*?)(\})/ do |m|
-          token 'Literal.String.Interpol', m[1]
+          token Str::Interpol, m[1]
           delegate ruby, m[2]
-          token 'Literal.String.Interpol', m[3]
+          token Str::Interpol, m[3]
         end
       end
 
       state :indented_block do
-        rule(/\n/) { token 'Text'; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
       end
     end
   end

data/lib/rouge/lexers/handlebars.rb

@@ -14,11 +14,11 @@ module Rouge
         rule(/\\{+/) { delegate parent }
 
         # block comments
-        rule /{{!--/, 'Comment', :comment
-        rule /{{!.*?}}/, 'Comment'
+        rule /{{!--/, Comment, :comment
+        rule /{{!.*?}}/, Comment
 
         rule /{{{?/ do
-          token 'Keyword'
+          token Keyword
           push :stache
           push :open_sym
         end
@@ -31,44 +31,44 @@ module Rouge
       end
 
       state :comment do
-        rule(/{{/) { token 'Comment'; push }
-        rule(/}}/) { token 'Comment'; pop! }
-        rule(/[^{}]+/m) { token 'Comment' }
-        rule(/[{}]/) { token 'Comment' }
+        rule(/{{/) { token Comment; push }
+        rule(/}}/) { token Comment; pop! }
+        rule(/[^{}]+/m) { token Comment }
+        rule(/[{}]/) { token Comment }
       end
 
       state :stache do
-        rule /}}}?/, 'Keyword', :pop!
-        rule /\s+/m, 'Text'
-        rule /[=]/, 'Operator'
-        rule /[\[\]]/, 'Punctuation'
-        rule /[.](?=[}\s])/, 'Name.Variable'
-        rule /[.][.]/, 'Name.Variable'
-        rule %r([/.]), 'Punctuation'
-        rule /"(\\.|.)*?"/, 'Literal.String.Double'
-        rule /'(\\.|.)*?'/, 'Literal.String.Single'
-        rule /\d+(?=}\s)/, 'Literal.Number'
-        rule /(true|false)(?=[}\s])/, 'Keyword.Constant'
-        rule /else(?=[}\s])/, 'Keyword'
-        rule /this(?=[}\s])/, 'Name.Builtin.Pseudo'
-        rule /@#{id}/, 'Name.Attribute'
-        rule id, 'Name.Variable'
+        rule /}}}?/, Keyword, :pop!
+        rule /\s+/m, Text
+        rule /[=]/, Operator
+        rule /[\[\]]/, Punctuation
+        rule /[.](?=[}\s])/, Name::Variable
+        rule /[.][.]/, Name::Variable
+        rule %r([/.]), Punctuation
+        rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+        rule /\d+(?=}\s)/, Num
+        rule /(true|false)(?=[}\s])/, Keyword::Constant
+        rule /else(?=[}\s])/, Keyword
+        rule /this(?=[}\s])/, Name::Builtin::Pseudo
+        rule /@#{id}/, Name::Attribute
+        rule id, Name::Variable
       end
 
       state :open_sym do
         rule %r([#/]) do
-          token 'Keyword'
-          pop!; push :block_name
+          token Keyword
+          goto :block_name
         end
 
-        rule /[>^&]/, 'Keyword'
+        rule /[>^&]/, Keyword
 
         rule(//) { pop! }
       end
 
       state :block_name do
-        rule /if(?=[}\s])/, 'Keyword'
-        rule id, 'Name.Namespace', :pop!
+        rule /if(?=[}\s])/, Keyword
+        rule id, Name::Namespace, :pop!
         rule(//) { pop! }
       end
     end