rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/diff.rb

@@ -16,17 +16,17 @@ module Rouge
       end
 
       state :header do
-        rule /^diff .*?\n(?=---|\+\+\+)/m, 'Generic.Heading'
-        rule /^--- .*?\n/, 'Generic.Deleted'
-        rule /^\+\+\+ .*?\n/, 'Generic.Inserted'
+        rule /^diff .*?\n(?=---|\+\+\+)/m, Generic::Heading
+        rule /^--- .*?\n/, Generic::Deleted
+        rule /^\+\+\+ .*?\n/, Generic::Inserted
       end
 
       state :diff do
-        rule /@@ -\d+,\d+ \+\d+,\d+ @@.*?\n/, 'Generic.Heading'
-        rule /^\+.*?\n/, 'Generic.Inserted'
-        rule /^-.*?\n/,  'Generic.Deleted'
-        rule /^ .*?\n/,  'Text'
-        rule /^.*?\n/,   'Error'
+        rule /@@ -\d+,\d+ \+\d+,\d+ @@.*?\n/, Generic::Heading
+        rule /^\+.*?\n/, Generic::Inserted
+        rule /^-.*?\n/,  Generic::Deleted
+        rule /^ .*?\n/,  Text
+        rule /^.*?\n/,   Error
       end
 
       state :root do

data/lib/rouge/lexers/elixir.rb

@@ -19,40 +19,40 @@ module Rouge
       ]
 
       state :root do
-        rule /\s+/m, 'Text'
-        rule /#.*$/, 'Comment.Single'
+        rule /\s+/m, Text
+        rule /#.*$/, Comment::Single
         rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
              defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
              defexception|exit|raise|throw|unless|after|rescue|catch|else)\b(?![?!])|
-             (?<!\.)\b(do|\-\>)\b}x, 'Keyword'
-        rule /\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, 'Keyword.Namespace'
-        rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, 'Operator.Word'
+             (?<!\.)\b(do|\-\>)\b}x, Keyword
+        rule /\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
         rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
              <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s\t])\?|
              (?<=[\s\t])!+|&&|\|\||\^|\*|\+|\-|/|
-             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.}x, 'Operator'
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.}x, Operator
         rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
              <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
-             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, 'Literal.String.Symbol'
-        rule /:"/, 'Literal.String.Symbol', :interpoling_symbol
-        rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, 'Name.Constant'
-        rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, 'Name.Builtin.Pseudo'
-        rule /[a-zA-Z_!][\w_]*[!\?]?/, 'Name'
-        rule %r{::|[(){};,/\|:\\\[\]]}, 'Punctuation'
-        rule /@[a-zA-Z_]\w*|&\d/, 'Name.Variable'
+             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
+        rule /:"/, Str::Symbol, :interpoling_symbol
+        rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule /[a-zA-Z_!][\w_]*[!\?]?/, Name
+        rule %r{::|[(){};,/\|:\\\[\]]}, Punctuation
+        rule /@[a-zA-Z_]\w*|&\d/, Name::Variable
         rule %r{\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])
-             (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, 'Literal.Number'
-        rule %r{%r\/.*\/}, 'Literal.String.Regex'
+             (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, Num
+        rule %r{%r\/.*\/}, Str::Regex
 
         mixin :strings
       end
 
       state :strings do
-        rule /(%[A-Ba-z])?"""(?:.|\n)*?"""/, 'Literal.String.Doc'
-        rule /'''(?:.|\n)*?'''/, 'Literal.String.Doc'
-        rule /"/, 'Literal.String.Doc', :dqs
-        rule /'.*?'/, 'Literal.String.Single'
-        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, 'Literal.String.Other'
+        rule /(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule /'''(?:.|\n)*?'''/, Str::Doc
+        rule /"/, Str::Doc, :dqs
+        rule /'.*?'/, Str::Single
+        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
 
         BRACES.each do |_, _, name|
           mixin :"braces_#{name}"
@@ -61,43 +61,43 @@ module Rouge
 
       BRACES.each do |lbrace, rbrace, name|
         state :"braces_#{name}" do
-          rule /%[a-z]#{lbrace}/, 'Literal.String.Double', :"braces_#{name}_intp"
-          rule /%[A-Z]#{lbrace}/, 'Literal.String.Double', :"braces_#{name}_no_intp"
+          rule /%[a-z]#{lbrace}/, Str::Double, :"braces_#{name}_intp"
+          rule /%[A-Z]#{lbrace}/, Str::Double, :"braces_#{name}_no_intp"
         end
 
         state :"braces_#{name}_intp" do
-          rule /#{rbrace}[a-z]*/, 'Literal.String.Double', :pop!
+          rule /#{rbrace}[a-z]*/, Str::Double, :pop!
           mixin :enddoublestr
         end
 
         state :"braces_#{name}_no_intp" do
-          rule /.*#{rbrace}[a-z]*/, 'Literal.String.Double', :pop!
+          rule /.*#{rbrace}[a-z]*/, Str::Double, :pop!
         end
       end
 
       state :dqs do
-        rule /"/, 'Literal.String.Double', :pop!
+        rule /"/, Str::Double, :pop!
         mixin :enddoublestr
       end
 
       state :interpoling do
-        rule /#\{/, 'Literal.String.Interpol', :interpoling_string
+        rule /#\{/, Str::Interpol, :interpoling_string
       end
 
       state :interpoling_string do
-        rule /\}/, 'Literal.String.Interpol', :pop!
+        rule /\}/, Str::Interpol, :pop!
         mixin :root
       end
 
       state :interpoling_symbol do
-        rule /"/, 'Literal.String.Symbol', :pop!
+        rule /"/, Str::Symbol, :pop!
         mixin :interpoling
-        rule /[^#"]+/, 'Literal.String.Symbol'
+        rule /[^#"]+/, Str::Symbol
       end
 
       state :enddoublestr do
         mixin :interpoling
-        rule /[^#"]+/, 'Literal.String.Double'
+        rule /[^#"]+/, Str::Double
       end
     end
   end

data/lib/rouge/lexers/erb.rb

@@ -27,9 +27,9 @@ module Rouge
       close = /%%>|-%>|%>/
 
       state :root do
-        rule /<%#/, 'Comment', :comment
+        rule /<%#/, Comment, :comment
 
-        rule open, 'Comment.Preproc', :ruby
+        rule open, Comment::Preproc, :ruby
 
         rule /.+?(?=#{open})|.+/m do
           delegate parent
@@ -37,12 +37,12 @@ module Rouge
       end
 
       state :comment do
-        rule close, 'Comment', :pop!
-        rule /.+(?=#{close})|.+/m, 'Comment'
+        rule close, Comment, :pop!
+        rule /.+(?=#{close})|.+/m, Comment
       end
 
       state :ruby do
-        rule close, 'Comment.Preproc', :pop!
+        rule close, Comment::Preproc, :pop!
 
         rule /.+?(?=#{close})|.+/m do
           delegate @ruby_lexer

data/lib/rouge/lexers/erlang.rb

@@ -64,60 +64,60 @@ module Rouge
       base_re = %r{(?:[2-9]|[12][0-9]|3[0-6])}
 
       state :root do
-        rule(/\s+/, "Text")
-        rule(/%.*\n/, "Comment")
-        rule(%r{(#{keywords.join('|')})\b}, "Keyword")
-        rule(%r{(#{builtins.join('|')})\b}, "Name.Builtin")
-        rule(%r{(#{word_operators.join('|')})\b}, "Operator.Word")
-        rule(/^-/, "Punctuation", :directive)
-        rule(operators, "Operator")
-        rule(/"/, "Literal.String", :string)
-        rule(/<</, "Name.Label")
-        rule(/>>/, "Name.Label")
+        rule(/\s+/, Text)
+        rule(/%.*\n/, Comment)
+        rule(%r{(#{keywords.join('|')})\b}, Keyword)
+        rule(%r{(#{builtins.join('|')})\b}, Name::Builtin)
+        rule(%r{(#{word_operators.join('|')})\b}, Operator::Word)
+        rule(/^-/, Punctuation, :directive)
+        rule(operators, Operator)
+        rule(/"/, Str, :string)
+        rule(/<</, Name::Label)
+        rule(/>>/, Name::Label)
         rule %r{(#{atom_re})(:)} do
-          group "Name.Namespace"
-          group "Punctuation"
+          group Name::Namespace
+          group Punctuation
         end
         rule %r{(?:^|(?<=:))(#{atom_re})(\s*)(\()} do
-          group "Name.Function"
-          group "Text"
-          group "Punctuation"
+          group Name::Function
+          group Text
+          group Punctuation
         end
-        rule(%r{[+-]?#{base_re}#[0-9a-zA-Z]+}, "Literal.Number.Integer")
-        rule(/[+-]?\d+/, "Literal.Number.Integer")
-        rule(/[+-]?\d+.\d+/, "Literal.Number.Float")
-        rule(%r{[\]\[:_@\".{}()|;,]}, "Punctuation")
-        rule(variable_re, "Name.Variable")
-        rule(atom_re, "Name")
-        rule(%r{\?#{macro_re}}, "Name.Constant")
-        rule(%r{\$(?:#{escape_re}|\\[ %]|[^\\])}, "Literal.String.Char")
-        rule(%r{##{atom_re}(:?\.#{atom_re})?}, "Name.Label")
+        rule(%r{[+-]?#{base_re}#[0-9a-zA-Z]+}, Num::Integer)
+        rule(/[+-]?\d+/, Num::Integer)
+        rule(/[+-]?\d+.\d+/, Num::Float)
+        rule(%r{[\]\[:_@\".{}()|;,]}, Punctuation)
+        rule(variable_re, Name::Variable)
+        rule(atom_re, Name)
+        rule(%r{\?#{macro_re}}, Name::Constant)
+        rule(%r{\$(?:#{escape_re}|\\[ %]|[^\\])}, Str::Char)
+        rule(%r{##{atom_re}(:?\.#{atom_re})?}, Name::Label)
       end
 
       state :string do
-        rule(escape_re, "Literal.String.Escape")
-        rule(/"/, "Literal.String", :pop!)
-        rule(%r{~[0-9.*]*[~#+bBcdefginpPswWxX]}, "Literal.String.Interpol")
-        rule(%r{[^"\\~]+}, "Literal.String")
-        rule(/~/, "Literal.String")
+        rule(escape_re, Str::Escape)
+        rule(/"/, Str, :pop!)
+        rule(%r{~[0-9.*]*[~#+bBcdefginpPswWxX]}, Str::Interpol)
+        rule(%r{[^"\\~]+}, Str)
+        rule(/~/, Str)
       end
 
       state :directive do
         rule %r{(define)(\s*)(\()(#{macro_re})} do
-          group "Name.Entity"
-          group "Text"
-          group "Punctuation"
-          group "Name.Constant"
+          group Name::Entity
+          group Text
+          group Punctuation
+          group Name::Constant
           pop!
         end
         rule %r{(record)(\s*)(\()(#{macro_re})} do
-          group "Name.Entity"
-          group "Text"
-          group "Punctuation"
-          group "Name.Label"
+          group Name::Entity
+          group Text
+          group Punctuation
+          group Name::Label
           pop!
         end
-        rule(atom_re, "Name.Entity", :pop!)
+        rule(atom_re, Name::Entity, :pop!)
       end
     end
   end

data/lib/rouge/lexers/factor.rb

@@ -163,135 +163,135 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, 'Text'
+        rule /\s+/m, Text
 
         rule /(:|::|MACRO:|MEMO:|GENERIC:|HELP:)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'
-          group 'Name.Function'
+          group Keyword; group Text
+          group Name::Function
         end
 
         rule /(M:|HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'
-          group 'Name.Class'; group 'Text'
-          group 'Name.Function'
+          group Keyword; group Text
+          group Name::Class; group Text
+          group Name::Function
         end
 
-        rule /\((?=\s)/, 'Name.Function', :stack_effect
-        rule /;(?=\s)/, 'Keyword'
+        rule /\((?=\s)/, Name::Function, :stack_effect
+        rule /;(?=\s)/, Keyword
 
         rule /(USING:)((?:\s|\\\s)+)/m do
-          group 'Keyword.Namespace'; group 'Text'
+          group Keyword::Namespace; group Text
           push :import
         end
 
         rule /(IN:|USE:|UNUSE:|QUALIFIED:|QUALIFIED-WITH:)(\s+)(\S+)/m do
-          group 'Keyword.Namespace'; group 'Text'; group 'Name.Namespace'
+          group Keyword::Namespace; group Text; group Name::Namespace
         end
 
         rule /(FROM:|EXCLUDE:)(\s+)(\S+)(\s+)(=>)/m do
-          group 'Keyword.Namespace'; group 'Text'
-          group 'Name.Namespace'; group 'Text'
-          group 'Punctuation'
+          group Keyword::Namespace; group Text
+          group Name::Namespace; group Text
+          group Punctuation
         end
 
-        rule /(?:ALIAS|DEFER|FORGET|POSTPONE):/, 'Keyword.Namespace'
+        rule /(?:ALIAS|DEFER|FORGET|POSTPONE):/, Keyword::Namespace
 
         rule /(TUPLE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'
-          group 'Name.Class'; group 'Text'
-          group 'Punctuation'; group 'Text'
-          group 'Name.Class'
+          group Keyword; group Text
+          group Name::Class; group Text
+          group Punctuation; group Text
+          group Name::Class
           push :slots
         end
 
         rule /(TUPLE:)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'; group 'Name.Class'
+          group Keyword; group Text; group Name::Class
           push :slots
         end
 
         rule /(UNION:|INTERSECTION:)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'; group 'Name.Class'
+          group Keyword; group Text; group Name::Class
         end
 
         rule /(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'
-          group 'Name.Class'; group 'Text'
-          group 'Punctuation'; group 'Text'
-          group 'Name.Class'
+          group Keyword; group Text
+          group Name::Class; group Text
+          group Punctuation; group Text
+          group Name::Class
         end
 
         rule /(C:)(\s+)(\S+)(\s+)(\S+)/m do
-          group 'Keyword'; group 'Text'
-          group 'Name.Function'; group 'Text'
-          group 'Name.Class'
+          group Keyword; group Text
+          group Name::Function; group Text
+          group Name::Class
         end
 
         rule %r(
           (INSTANCE|SLOT|MIXIN|SINGLETONS?|CONSTANT|SYMBOLS?|ERROR|SYNTAX
            |ALIEN|TYPEDEF|FUNCTION|STRUCT):
-        )x, 'Keyword'
+        )x, Keyword
 
-        rule /(?:<PRIVATE|PRIVATE>)/, 'Keyword.Namespace'
+        rule /(?:<PRIVATE|PRIVATE>)/, Keyword::Namespace
 
         rule /(MAIN:)(\s+)(\S+)/ do
-          group 'Keyword.Namespace'; group 'Text'; group 'Name.Function'
+          group Keyword::Namespace; group Text; group Name::Function
         end
 
         # strings
-        rule /"""\s+.*?\s+"""/, 'Literal.String'
-        rule /"(\\.|[^\\])*?"/, 'Literal.String'
-        rule /(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, 'Literal.String.Char'
+        rule /"""\s+.*?\s+"""/, Str
+        rule /"(\\.|[^\\])*?"/, Str
+        rule /(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
 
         # comments
-        rule /!\s+.*$/, 'Comment'
-        rule /#!\s+.*$/, 'Comment'
+        rule /!\s+.*$/, Comment
+        rule /#!\s+.*$/, Comment
 
         # booleans
-        rule /[tf](?=\s)/, 'Name.Constant'
+        rule /[tf](?=\s)/, Name::Constant
 
         # numbers
-        rule /-?\d+\.\d+(?=\s)/, 'Literal.Number.Float'
-        rule /-?\d+(?=\s)/, 'Literal.Number.Integer'
+        rule /-?\d+\.\d+(?=\s)/, Num::Float
+        rule /-?\d+(?=\s)/, Num::Integer
 
-        rule /HEX:\s+[a-fA-F\d]+(?=\s)/m, 'Literal.Number.Hex'
-        rule /BIN:\s+[01]+(?=\s)/, 'Literal.Number.Bin'
-        rule /OCT:\s+[0-7]+(?=\s)/, 'Literal.Number.Oct'
+        rule /HEX:\s+[a-fA-F\d]+(?=\s)/m, Num::Hex
+        rule /BIN:\s+[01]+(?=\s)/, Num::Bin
+        rule /OCT:\s+[0-7]+(?=\s)/, Num::Oct
 
-        rule %r([-+/*=<>^](?=\s)), 'Operator'
+        rule %r([-+/*=<>^](?=\s)), Operator
 
         rule /(?:deprecated|final|foldable|flushable|inline|recursive)(?=\s)/,
-          'Keyword'
+          Keyword
 
         rule /\S+/ do |m|
           name = m[0]
 
           if self.class.builtins.values.any? { |b| b.include? name }
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name'
+            token Name
           end
         end
       end
 
       state :stack_effect do
-        rule /\s+/, 'Text'
-        rule /\(/, 'Name.Function', :stack_effect
-        rule /\)/, 'Name.Function', :pop!
+        rule /\s+/, Text
+        rule /\(/, Name::Function, :stack_effect
+        rule /\)/, Name::Function, :pop!
 
-        rule /--/, 'Name.Function'
-        rule /\S+/, 'Name.Variable'
+        rule /--/, Name::Function
+        rule /\S+/, Name::Variable
       end
 
       state :slots do
-        rule /\s+/, 'Text'
-        rule /;(?=\s)/, 'Keyword', :pop!
-        rule /\S+/, 'Name.Variable'
+        rule /\s+/, Text
+        rule /;(?=\s)/, Keyword, :pop!
+        rule /\S+/, Name::Variable
       end
 
       state :import do
-        rule /;(?=\s)/, 'Keyword', :pop!
-        rule /\s+/, 'Text'
-        rule /\S+/, 'Name.Namespace'
+        rule /;(?=\s)/, Keyword, :pop!
+        rule /\s+/, Text
+        rule /\S+/, Name::Namespace
       end
     end
   end