rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/scheme.rb

@@ -57,47 +57,47 @@ module Rouge
 
       state :root do
         # comments
-        rule /;.*$/, 'Comment.Single'
-        rule /\s+/m, 'Text'
-        rule /-?\d+\.\d+/, 'Literal.Number.Float'
-        rule /-?\d+/, 'Literal.Number.Integer'
+        rule /;.*$/, Comment::Single
+        rule /\s+/m, Text
+        rule /-?\d+\.\d+/, Num::Float
+        rule /-?\d+/, Num::Integer
 
         # Racket infinitites
-        rule /[+-]inf[.][f0]/, 'Literal.Number'
+        rule /[+-]inf[.][f0]/, Num
 
-        rule /#b[01]+/, 'Literal.Number.Binary'
-        rule /#o[0-7]+/, 'Literal.Number.Oct'
-        rule /#d[0-9]+/, 'Literal.Number.Integer'
-        rule /#x[0-9a-f]+/i, 'Literal.Number.Hex'
-        rule /#[ei][\d.]+/, 'Literal.Number.Other'
+        rule /#b[01]+/, Num::Bin
+        rule /#o[0-7]+/, Num::Oct
+        rule /#d[0-9]+/, Num::Integer
+        rule /#x[0-9a-f]+/i, Num::Hex
+        rule /#[ei][\d.]+/, Num::Other
 
-        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
-        rule /'#{id}/i, 'Literal.String.Symbol'
+        rule /"(\\\\|\\"|[^"])*"/, Str
+        rule /'#{id}/i, Str::Symbol
         rule /#\\([()\/'"._!\$%& ?=+-]{1}|[a-z0-9]+)/i,
-          'Literal.String.Char'
-        rule /#t|#f/, 'Name.Constant'
-        rule /(?:'|#|`|,@|,|\.)/, 'Operator'
+          Str::Char
+        rule /#t|#f/, Name::Constant
+        rule /(?:'|#|`|,@|,|\.)/, Operator
 
         rule /(['#])(\s*)(\()/m do
-          group 'Literal.String.Symbol'
-          group 'Text'
-          group 'Punctuation'
+          group Str::Symbol
+          group Text
+          group Punctuation
         end
 
-        rule /\(/, 'Punctuation', :command
-        rule /\)/, 'Punctuation'
+        rule /\(/, Punctuation, :command
+        rule /\)/, Punctuation
 
-        rule id, 'Name.Variable'
+        rule id, Name::Variable
       end
 
       state :command do
-        rule id, 'Name.Function' do |m|
+        rule id, Name::Function do |m|
           if self.class.keywords.include? m[0]
-            token 'Keyword'
+            token Keyword
           elsif self.class.builtins.include? m[0]
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name.Function'
+            token Name::Function
           end
 
           pop!

data/lib/rouge/lexers/scss.rb

@@ -9,10 +9,10 @@ module Rouge
       mimetypes 'text/x-scss'
 
       state :root do
-        rule /\s+/, 'Text'
-        rule %r(//.*?\n), 'Comment.Single'
-        rule %r(/[*].*?[*]/)m, 'Comment.Multiline'
-        rule /@import\b/, 'Keyword', :value
+        rule /\s+/, Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        rule /@import\b/, Keyword, :value
 
         mixin :content_common
 
@@ -23,11 +23,11 @@ module Rouge
       end
 
       state :end_section do
-        rule /\n/, 'Text'
-        rule(/[;{}]/) { token 'Punctuation'; reset_stack }
+        rule /\n/, Text
+        rule(/[;{}]/) { token Punctuation; reset_stack }
       end
 
-      instance_eval(&SASS_COMMON)
+      include SassCommon
     end
   end
 end

data/lib/rouge/lexers/sed.rb

@@ -13,33 +13,33 @@ module Rouge
 
       class Regex < RegexLexer
         state :root do
-          rule /\\./, 'Literal.String.Escape'
-          rule /\[/, 'Punctuation', :brackets
-          rule /[$^.*]/, 'Operator'
-          rule /[()]/, 'Punctuation'
-          rule /./, 'Literal.String.Regex'
+          rule /\\./, Str::Escape
+          rule /\[/, Punctuation, :brackets
+          rule /[$^.*]/, Operator
+          rule /[()]/, Punctuation
+          rule /./, Str::Regex
         end
 
         state :brackets do
           rule /\^?/ do
-            token 'Punctuation'
-            pop!; push :brackets_int
+            token Punctuation
+            goto :brackets_int
           end
         end
 
         state :brackets_int do
           # ranges
-          rule /.-./, 'Name.Variable'
-          rule /\]/, 'Punctuation', :pop!
-          rule /./, 'Literal.String.Regex'
+          rule /.-./, Name::Variable
+          rule /\]/, Punctuation, :pop!
+          rule /./, Str::Regex
         end
       end
 
       class Replacement < RegexLexer
         state :root do
-          rule /\\./m, 'Literal.String.Escape'
-          rule /&/, 'Operator'
-          rule /[^\\&]+/m, 'Text'
+          rule /\\./m, Str::Escape
+          rule /&/, Operator
+          rule /[^\\&]+/m, Text
         end
       end
 
@@ -54,10 +54,10 @@ module Rouge
       start { regex.reset!; replacement.reset! }
 
       state :whitespace do
-        rule /\s+/m, 'Text'
-        rule(/#.*?\n/) { token 'Comment'; reset_stack }
-        rule(/\n/) { token 'Text'; reset_stack }
-        rule(/;/) { token 'Punctuation'; reset_stack }
+        rule /\s+/m, Text
+        rule(/#.*?\n/) { token Comment; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
+        rule(/;/) { token Punctuation; reset_stack }
       end
 
       state :root do
@@ -71,53 +71,53 @@ module Rouge
 
         # subst and transliteration
         rule /(s)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
-          token 'Keyword', m[1]
-          token 'Punctuation', m[2]
+          token Keyword, m[1]
+          token Punctuation, m[2]
           delegate regex, m[3]
-          token 'Punctuation', m[4]
+          token Punctuation, m[4]
           delegate replacement, m[5]
-          token 'Punctuation', m[6]
+          token Punctuation, m[6]
 
 
-          pop!; push :flags
+          goto :flags
         end
 
         rule /(y)(.)(#{edot}*?)(\2)(#{edot}*?)(\2)/m do |m|
-          token 'Keyword', m[1]
-          token 'Punctuation', m[2]
+          token Keyword, m[1]
+          token Punctuation, m[2]
           delegate replacement, m[3]
-          token 'Punctuation', m[4]
+          token Punctuation, m[4]
           delegate replacement, m[5]
-          token 'Punctuation', m[6]
+          token Punctuation, m[6]
 
           pop!
         end
 
         # commands that take a text segment as an argument
         rule /([aic])(\s*)/ do
-          group 'Keyword'; group 'Text'; pop!; push :text
+          group Keyword; group Text; goto :text
         end
 
-        rule /[pd]/, 'Keyword'
+        rule /[pd]/, Keyword
 
         # commands that take a number argument
         rule /([qQl])(\s+)(\d+)/i do
-          group 'Keyword'; group 'Text'; group 'Literal.Number'
+          group Keyword; group Text; group Num
           pop!
         end
 
         # no-argument commands
-        rule /[={}dDgGhHlnpPqx]/, 'Keyword', :pop!
+        rule /[={}dDgGhHlnpPqx]/, Keyword, :pop!
 
         # commands that take a filename argument
         rule /([rRwW])(\s+)(\S+)/ do
-          group 'Keyword'; group 'Text'; group 'Name'
+          group Keyword; group Text; group Name
           pop!
         end
 
         # commands that take a label argument
         rule /([:btT])(\s+)(\S+)/ do
-          group 'Keyword'; group 'Text'; group 'Name.Label'
+          group Keyword; group Text; group Name::Label
           pop!
         end
       end
@@ -126,7 +126,7 @@ module Rouge
         mixin :whitespace
 
         ### address ranges ###
-        addr_tok = 'Keyword.Namespace'
+        addr_tok = Keyword::Namespace
         rule /\d+/, addr_tok
         rule /[$,~+!]/, addr_tok
 
@@ -145,19 +145,19 @@ module Rouge
       end
 
       state :text do
-        rule /[^\\\n]+/, 'Literal.String'
-        rule /\\\n/, 'Literal.String.Escape'
-        rule /\\/, 'Literal.String'
-        rule /\n/, 'Text', :pop!
+        rule /[^\\\n]+/, Str
+        rule /\\\n/, Str::Escape
+        rule /\\/, Str
+        rule /\n/, Text, :pop!
       end
 
       state :flags do
-        rule /[gp]+/, 'Keyword', :pop!
+        rule /[gp]+/, Keyword, :pop!
 
         # writing to a file with the subst command.
         # who'da thunk...?
         rule /([wW])(\s+)(\S+)/ do
-          token 'Keyword'; token 'Text'; token 'Name'
+          token Keyword; token Text; token Name
         end
 
         rule(//) { pop! }

data/lib/rouge/lexers/shell.rb

@@ -29,27 +29,27 @@ module Rouge
       ).join('|')
 
       state :basic do
-        rule /#.*$/, 'Comment'
+        rule /#.*$/, Comment
 
-        rule /\b(#{KEYWORDS})\s*\b/, 'Keyword'
-        rule /\bcase\b/, 'Keyword', :case
+        rule /\b(#{KEYWORDS})\s*\b/, Keyword
+        rule /\bcase\b/, Keyword, :case
 
-        rule /\b(#{BUILTINS})\s*\b(?!\.)/, 'Name.Builtin'
+        rule /\b(#{BUILTINS})\s*\b(?!\.)/, Name::Builtin
 
-        rule /^\S*[\$%>#] +/, 'Generic.Prompt'
+        rule /^\S*[\$%>#] +/, Generic::Prompt
 
         rule /(\b\w+)(=)/ do |m|
-          group 'Name.Variable'
-          group 'Operator'
+          group Name::Variable
+          group Operator
         end
 
-        rule /[\[\]{}()=]/, 'Operator'
-        rule /&&|\|\|/, 'Operator'
-        # rule /\|\|/, 'Operator'
+        rule /[\[\]{}()=]/, Operator
+        rule /&&|\|\|/, Operator
+        # rule /\|\|/, Operator
 
-        rule /<<</, 'Operator' # here-string
+        rule /<<</, Operator # here-string
         rule /<<-?\s*(\'?)\\?(\w+)\1/ do |m|
-          lsh = 'Literal.String.Heredoc'
+          lsh = Str::Heredoc
           token lsh
           heredocstr = Regexp.escape(m[2])
 
@@ -63,82 +63,82 @@ module Rouge
       state :double_quotes do
         # NB: "abc$" is literally the string abc$.
         # Here we prevent :interp from interpreting $" as a variable.
-        rule /(?:\$#?)?"/, 'Literal.String.Double', :pop!
+        rule /(?:\$#?)?"/, Str::Double, :pop!
         mixin :interp
-        rule /[^"`\\$]+/, 'Literal.String.Double'
+        rule /[^"`\\$]+/, Str::Double
       end
 
       state :single_quotes do
-        rule /'/, 'Literal.String.Single', :pop!
-        rule /[^']+/, 'Literal.String.Single'
+        rule /'/, Str::Single, :pop!
+        rule /[^']+/, Str::Single
       end
 
       state :data do
-        rule /\s+/, 'Text'
-        rule /\\./, 'Literal.String.Escape'
-        rule /\$?"/, 'Literal.String.Double', :double_quotes
+        rule /\s+/, Text
+        rule /\\./, Str::Escape
+        rule /\$?"/, Str::Double, :double_quotes
 
         # single quotes are much easier than double quotes - we can
         # literally just scan until the next single quote.
         # POSIX: Enclosing characters in single-quotes ( '' )
         # shall preserve the literal value of each character within the
         # single-quotes. A single-quote cannot occur within single-quotes.
-        rule /$?'/, 'Literal.String.Single', :single_quotes
+        rule /$?'/, Str::Single, :single_quotes
 
-        rule /\*/, 'Keyword'
+        rule /\*/, Keyword
 
-        rule /;/, 'Text'
-        rule /[^=\*\s{}()$"\'`\\<]+/, 'Text'
-        rule /\d+(?= |\Z)/, 'Literal.Number'
-        rule /</, 'Text'
+        rule /;/, Text
+        rule /[^=\*\s{}()$"'`\\<]+/, Text
+        rule /\d+(?= |\Z)/, Num
+        rule /</, Text
         mixin :interp
       end
 
       state :curly do
-        rule /}/, 'Keyword', :pop!
-        rule /:-/, 'Keyword'
-        rule /[a-zA-Z0-9_]+/, 'Name.Variable'
-        rule /[^}:"'`$]+/, 'Punctuation'
+        rule /}/, Keyword, :pop!
+        rule /:-/, Keyword
+        rule /[a-zA-Z0-9_]+/, Name::Variable
+        rule /[^}:"`'$]+/, Punctuation
         mixin :root
       end
 
       state :paren do
-        rule /\)/, 'Keyword', :pop!
+        rule /\)/, Keyword, :pop!
         mixin :root
       end
 
       state :math do
-        rule /\)\)/, 'Keyword', :pop!
-        rule %r([-+*/%^|&]|\*\*|\|\|), 'Operator'
-        rule /\d+/, 'Literal.Number'
+        rule /\)\)/, Keyword, :pop!
+        rule %r([-+*/%^|&]|\*\*|\|\|), Operator
+        rule /\d+/, Num
         mixin :root
       end
 
       state :case do
-        rule /\besac\b/, 'Keyword', :pop!
-        rule /\|/, 'Punctuation'
-        rule /\)/, 'Punctuation', :case_stanza
+        rule /\besac\b/, Keyword, :pop!
+        rule /\|/, Punctuation
+        rule /\)/, Punctuation, :case_stanza
         mixin :root
       end
 
       state :case_stanza do
-        rule /;;/, 'Punctuation', :pop!
+        rule /;;/, Punctuation, :pop!
         mixin :root
       end
 
       state :backticks do
-        rule /`/, 'Literal.String.Backtick', :pop!
+        rule /`/, Str::Backtick, :pop!
         mixin :root
       end
 
       state :interp do
-        rule /\\$/, 'Literal.String.Escape' # line continuation
-        rule /\\./, 'Literal.String.Escape'
-        rule /\$\(\(/, 'Keyword', :math
-        rule /\$\(/, 'Keyword', :paren
-        rule /\${#?/, 'Keyword', :curly
-        rule /`/, 'Literal.String.Backtick', :backticks
-        rule /\$#?(\w+|.)/, 'Name.Variable'
+        rule /\\$/, Str::Escape # line continuation
+        rule /\\./, Str::Escape
+        rule /\$\(\(/, Keyword, :math
+        rule /\$\(/, Keyword, :paren
+        rule /\${#?/, Keyword, :curly
+        rule /`/, Str::Backtick, :backticks
+        rule /\$#?(\w+|.)/, Name::Variable
       end
 
       state :root do

data/lib/rouge/lexers/smalltalk.rb

@@ -12,101 +12,101 @@ module Rouge
 
       state :root do
         rule /(<)(\w+:)(.*?)(>)/ do
-          group 'Punctuation'; group 'Keyword'; group 'Text'; group 'Punctuation'
+          group Punctuation; group Keyword; group Text; group Punctuation
         end
 
         # mixin :squeak_fileout
         mixin :whitespaces
         mixin :method_definition
         rule /([|])([\w\s]*)([|])/ do
-          group 'Punctuation'; group 'Name.Variable'; group 'Punctuation'
+          group Punctuation; group Name::Variable; group Punctuation
         end
         mixin :objects
-        rule /\^|:=|_/, 'Operator'
+        rule /\^|:=|_/, Operator
 
-        rule /[)}\]]/, 'Punctuation', :after_object
-        rule /[({\[!]/, 'Punctuation'
+        rule /[)}\]]/, Punctuation, :after_object
+        rule /[({\[!]/, Punctuation
       end
 
       state :method_definition do
         rule /([a-z]\w*:)(\s*)(\w+)/i do
-          group 'Name.Function'; group 'Text'; group 'Name.Variable'
+          group Name::Function; group Text; group Name::Variable
         end
 
         rule /^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
-          group 'Text'; group 'Name.Function'; group 'Text'
+          group Text; group Name::Function; group Text
         end
 
         rule %r(^(\s*)(#{ops}+)(\s*)(\w+)(\s*)$) do
-          group 'Text'; group 'Name.Function';
-          group 'Text'; group 'Name.Variable'; group 'Text';
+          group Text; group Name::Function;
+          group Text; group Name::Variable; group Text;
         end
       end
 
       state :block_variables do
         mixin :whitespaces
         rule /(:)(\s*)(\w+)/ do
-          group 'Operator'; group 'Text'; group 'Name.Variable'
+          group Operator; group Text; group Name::Variable
         end
 
-        rule /[|]/, 'Punctuation', :pop!
+        rule /[|]/, Punctuation, :pop!
 
         rule(//) { pop! }
       end
 
       state :literals do
-        rule /'(''|.)*?'/m, 'Literal.String', :after_object
-        rule /[$]./, 'Literal.String.Char', :after_object
-        rule /#[(]/, 'Literal.String.Symbol', :parenth
+        rule /'(''|.)*?'/m, Str, :after_object
+        rule /[$]./, Str::Char, :after_object
+        rule /#[(]/, Str::Symbol, :parenth
         rule /(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
-          'Literal.Number', :after_object
+          Num, :after_object
         rule /#("[^"]*"|#{ops}+|[\w:]+)/,
-          'Literal.String.Symbol', :after_object
+          Str::Symbol, :after_object
       end
 
       state :parenth do
         rule /[)]/ do
-          token 'Literal.String.Symbol'
-          pop!; push :after_object
+          token Str::Symbol
+          goto :after_object
         end
 
         mixin :inner_parenth
       end
 
       state :inner_parenth do
-        rule /#[(]/, 'Literal.String.Symbol', :inner_parenth
-        rule /[)]/, 'Literal.String.Symbol', :pop!
+        rule /#[(]/, Str::Symbol, :inner_parenth
+        rule /[)]/, Str::Symbol, :pop!
         mixin :whitespaces
         mixin :literals
-        rule /(#{ops}|[\w:])+/, 'Literal.String.Symbol'
+        rule /(#{ops}|[\w:])+/, Str::Symbol
       end
 
       state :whitespaces do
-        rule /! !$/, 'Keyword' # squeak chunk delimiter
-        rule /\s+/m, 'Text'
-        rule /".*?"/m, 'Comment'
+        rule /! !$/, Keyword # squeak chunk delimiter
+        rule /\s+/m, Text
+        rule /".*?"/m, Comment
       end
 
       state :objects do
-        rule /\[/, 'Punctuation', :block_variables
+        rule /\[/, Punctuation, :block_variables
         rule /(self|super|true|false|nil|thisContext)\b/,
-          'Name.Builtin.Pseudo', :after_object
-        rule /[A-Z]\w*(?!:)\b/, 'Name.Class', :after_object
-        rule /[a-z]\w*(?!:)\b/, 'Name.Variable', :after_object
+          Name::Builtin::Pseudo, :after_object
+        rule /[A-Z]\w*(?!:)\b/, Name::Class, :after_object
+        rule /[a-z]\w*(?!:)\b/, Name::Variable, :after_object
         mixin :literals
       end
 
       state :after_object do
         mixin :whitespaces
         rule /(ifTrue|ifFalse|whileTrue|whileFalse|timesRepeat):/,
-          'Name.Builtin', :pop!
-        rule /new(?!:)\b/, 'Name.Builtin'
-        rule /:=|_/, 'Operator', :pop!
-        rule /[a-z]+\w*:/i, 'Name.Function', :pop!
-        rule /[a-z]+\w*/i, 'Name.Function'
-        rule /#{ops}+/, 'Name.Function', :pop!
-        rule /[.]/, 'Punctuation', :pop!
-        rule /;/, 'Punctuation'
+          Name::Builtin, :pop!
+        rule /new(?!:)\b/, Name::Builtin
+        rule /:=|_/, Operator, :pop!
+        rule /[a-z]+\w*:/i, Name::Function, :pop!
+        rule /[a-z]+\w*/i, Name::Function
+        rule /#{ops}+/, Name::Function, :pop!
+        rule /[.]/, Punctuation, :pop!
+        rule /;/, Punctuation
         rule(//) { pop! }
       end
     end