rouge 0.4.0 → 0.5.0

data/lib/rouge/lexers/rust.rb

@@ -52,9 +52,9 @@ module Rouge
 
       state :start_line do
         mixin :whitespace
-        rule /\s+/, 'Text'
+        rule /\s+/, Text
         rule /#\[/ do
-          token 'Comment.Preproc'; push :attribute
+          token Comment::Preproc; push :attribute
         end
         rule(//) { pop! }
       end
@@ -62,44 +62,44 @@ module Rouge
       state :attribute do
         mixin :whitespace
         mixin :has_literals
-        rule /[(,)=]/, 'Comment.Preproc'
-        rule /\]/, 'Comment.Preproc', :pop!
-        rule id, 'Comment.Preproc'
+        rule /[(,)=]/, Comment::Preproc
+        rule /\]/, Comment::Preproc, :pop!
+        rule id, Comment::Preproc
       end
 
       state :whitespace do
-        rule /\s+/, 'Text'
-        rule %r(//[^\n]*), 'Comment'
-        rule %r(/[*].*?[*]/)m, 'Comment.Multiline'
+        rule /\s+/, Text
+        rule %r(//[^\n]*), Comment
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
       end
 
       state :root do
-        rule /\n/, 'Text', :start_line
+        rule /\n/, Text, :start_line
         mixin :whitespace
-        rule /\b(?:#{Rust.keywords.join('|')})\b/, 'Keyword'
+        rule /\b(?:#{Rust.keywords.join('|')})\b/, Keyword
         mixin :has_literals
 
-        rule %r([=-]>), 'Keyword'
-        rule %r(<->), 'Keyword'
-        rule /[()\[\]{}|,:;]/, 'Punctuation'
-        rule /[*!@~&+%^<>=-]/, 'Operator'
+        rule %r([=-]>), Keyword
+        rule %r(<->), Keyword
+        rule /[()\[\]{}|,:;]/, Punctuation
+        rule /[*!@~&+%^<>=-]/, Operator
 
-        rule /([.]\s*)?#{id}(?=\s*[(])/m, 'Name.Function'
-        rule /[.]\s*#{id}/, 'Name.Property'
+        rule /([.]\s*)?#{id}(?=\s*[(])/m, Name::Function
+        rule /[.]\s*#{id}/, Name::Property
         rule /(#{id})(::)/m do
-          group 'Name.Namespace'; group 'Punctuation'
+          group Name::Namespace; group Punctuation
         end
 
         # macros
-        rule /\bmacro_rules!/, 'Name.Decorator', :macro_rules
-        rule /#{id}!/, 'Name.Decorator', :macro
+        rule /\bmacro_rules!/, Name::Decorator, :macro_rules
+        rule /#{id}!/, Name::Decorator, :macro
 
         rule /#{id}/ do |m|
           name = m[0]
           if self.class.builtins.include? name
-            token 'Name.Builtin'
+            token Name::Builtin
           else
-            token 'Name'
+            token Name
           end
         end
       end
@@ -110,40 +110,40 @@ module Rouge
         rule /[\[{(]/ do |m|
           @macro_delims[delim_map[m[0]]] += 1
           debug { "    macro_delims: #{@macro_delims.inspect}" }
-          token 'Punctuation'
+          token Punctuation
         end
 
         rule /[\]})]/ do |m|
           @macro_delims[m[0]] -= 1
           debug { "    macro_delims: #{@macro_delims.inspect}" }
           pop! if macro_closed?
-          token 'Punctuation'
+          token Punctuation
         end
 
         # same as the rule in root, but don't push another macro state
-        rule /#{id}!/, 'Name.Decorator'
+        rule /#{id}!/, Name::Decorator
         mixin :root
 
         # No syntax errors in macros
-        rule /./, 'Text'
+        rule /./, Text
       end
 
       state :macro_rules do
-        rule /[$]#{id}(:#{id})?/, 'Name.Variable'
-        rule /[$]/, 'Name.Variable'
+        rule /[$]#{id}(:#{id})?/, Name::Variable
+        rule /[$]/, Name::Variable
 
         mixin :macro
       end
 
       state :has_literals do
         # constants
-        rule /\b(?:true|false|nil)\b/, 'Keyword.Constant'
+        rule /\b(?:true|false|nil)\b/, Keyword::Constant
         # characters
         rule %r(
           ' (?: #{escapes} | [^\\] ) '
-        )x, 'Literal.String.Char'
+        )x, Str::Char
 
-        rule /"/, 'Literal.String', :string
+        rule /"/, Str, :string
 
         # numbers
         dot = /[.][0-9_]+/
@@ -156,21 +156,21 @@ module Rouge
           |#{dot}? #{exp}  #{flt}?
           |#{dot}? #{exp}? #{flt}
           )
-        )x, 'Literal.Number.Float'
+        )x, Num::Float
 
         rule %r(
           ( 0b[10_]+
           | 0x[0-9a-fA-F-]+
           | [0-9]+
           ) (u#{size}?|i#{size})?
-        )x, 'Literal.Number.Integer'
+        )x, Num::Integer
 
       end
 
       state :string do
-        rule /"/, 'Literal.String', :pop!
-        rule escapes, 'Literal.String.Escape'
-        rule /%%/, 'Literal.String.Interpol'
+        rule /"/, Str, :pop!
+        rule escapes, Str::Escape
+        rule /%%/, Str::Interpol
         rule %r(
           %
           ( [0-9]+ [$] )?  # Parameter
@@ -178,8 +178,8 @@ module Rouge
           ( [0-9]+ [$]? )? # Width
           ( [.] [0-9]+ )?  # Precision
           [bcdfiostuxX?]   # Type
-        )x, 'Literal.String.Interpol'
-        rule /[^%"\\]+/m, 'Literal.String'
+        )x, Str::Interpol
+        rule /[^%"\\]+/m, Str
       end
     end
   end

data/lib/rouge/lexers/sass.rb

@@ -14,30 +14,30 @@ module Rouge
       id = /[\w-]+/
 
       state :root do
-        rule /[ \t]*\n/, 'Text'
-        rule(/[ \t]*/) { |m| token 'Text'; indentation(m[0]) }
+        rule /[ \t]*\n/, Text
+        rule(/[ \t]*/) { |m| token Text; indentation(m[0]) }
       end
 
       state :content do
         # block comments
         rule %r(//.*?\n) do
-          token 'Comment.Single'
+          token Comment::Single
           pop!; starts_block :single_comment
         end
 
         rule %r(/[*].*?\n) do
-          token 'Comment.Multiline'
+          token Comment::Multiline
           pop!; starts_block :multi_comment
         end
 
-        rule /@import\b/, 'Keyword', :import
+        rule /@import\b/, Keyword, :import
 
         mixin :content_common
 
-        rule %r(=#{id}), 'Name.Function', :value
-        rule %r([+]#{id}), 'Name.Decorator', :value
+        rule %r(=#{id}), Name::Function, :value
+        rule %r([+]#{id}), Name::Decorator, :value
 
-        rule /:/, 'Name.Attribute', :old_style_attr
+        rule /:/, Name::Attribute, :old_style_attr
 
         rule(/(?=.+?:([^a-z]|$))/) { push :attribute }
 
@@ -45,17 +45,17 @@ module Rouge
       end
 
       state :single_comment do
-        rule /.*?\n/, 'Comment.Single', :pop!
+        rule /.*?\n/, Comment::Single, :pop!
       end
 
       state :multi_comment do
-        rule /.*?\n/, 'Comment.Multiline', :pop!
+        rule /.*?\n/, Comment::Multiline, :pop!
       end
 
       state :import do
-        rule /[ \t]+/, 'Text'
-        rule /\S+/, 'Literal.String'
-        rule /\n/, 'Text', :pop!
+        rule /[ \t]+/, Text
+        rule /\S+/, Str
+        rule /\n/, Text, :pop!
       end
 
       state :old_style_attr do
@@ -64,10 +64,10 @@ module Rouge
       end
 
       state :end_section do
-        rule(/\n/) { token 'Text'; reset_stack }
+        rule(/\n/) { token Text; reset_stack }
       end
 
-      instance_eval(&SASS_COMMON)
+      include SassCommon
     end
   end
 end

data/lib/rouge/lexers/sass/common.rb

@@ -2,171 +2,179 @@ module Rouge
   module Lexers
     # shared states with SCSS
     # TODO: make this less nasty to do
-    SASS_COMMON = proc do
-      id = /[\w-]+/
+    module SassCommon
+      include Token::Tokens
 
-      state :content_common do
-        rule /@for\b/, 'Keyword', :for
-        rule /@(debug|warn|if|while)/, 'Keyword', :value
-        rule /(@mixin)(\s+)(#{id})/ do
-          group 'Keyword'; group 'Text'; group 'Name.Function'
-          push :value
-        end
+      def self.included(klass)
+        klass.class_eval(&INCLUDED_PROC)
+      end
 
-        rule /@extend\b/, 'Keyword', :selector
+      INCLUDED_PROC = proc do
+        id = /[\w-]+/
 
-        rule /(@include)(\s+)(#{id})/ do
-          group 'Keyword'; group 'Text'; group 'Name.Decorator'
-          push :value
-        end
+        state :content_common do
+          rule /@for\b/, Keyword, :for
+          rule /@(debug|warn|if|while)/, Keyword, :value
+          rule /(@mixin)(\s+)(#{id})/ do
+            group Keyword; group Text; group Name::Function
+            push :value
+          end
+
+          rule /@extend\b/, Keyword, :selector
 
-        rule /@#{id}/, 'Keyword', :selector
+          rule /(@include)(\s+)(#{id})/ do
+            group Keyword; group Text; group Name::Decorator
+            push :value
+          end
+
+          rule /@#{id}/, Keyword, :selector
 
-        # $variable: assignment
-        rule /([$]#{id})([ \t]*)(:)/ do
-          group 'Name.Variable'; group 'Text'; group 'Punctuation'
-          push :value
+          # $variable: assignment
+          rule /([$]#{id})([ \t]*)(:)/ do
+            group Name::Variable; group Text; group Punctuation
+            push :value
+          end
         end
-      end
 
-      state :value do
-        mixin :end_section
-        rule /[ \t]+/, 'Text'
-        rule /[$]#{id}/, 'Name.Variable'
-        rule /url[(]/, 'Literal.String.Other', :string_url
-        rule /#{id}(?=\s*[(])/, 'Name.Function'
-        rule /%#{id}/, 'Name.Decorator'
-
-        # named literals
-        rule /(true|false)\b/, 'Name.Pseudo'
-        rule /(and|or|not)\b/, 'Operator.Word'
-
-        # colors and numbers
-        rule /#[a-z0-9]{1,6}/i, 'Literal.Number.Hex'
-        rule /-?\d+(%|[a-z]+)?/, 'Literal.Number'
-        rule /-?\d*\.\d+(%|[a-z]+)?/, 'Literal.Number.Integer'
-
-        mixin :has_strings
-        mixin :has_interp
-
-        rule /[~^*!&%<>\|+=@:,.\/?-]+/, 'Operator'
-        rule /[\[\]()]+/, 'Punctuation'
-        rule %r(/[*]), 'Comment.Multiline', :inline_comment
-        rule %r(//[^\n]*), 'Comment.Single'
-
-        # identifiers
-        rule(id) do |m|
-          if CSS.builtins.include? m[0]
-            token 'Name.Builtin'
-          elsif CSS.constants.include? m[0]
-            token 'Name.Constant'
-          else
-            token 'Name'
+        state :value do
+          mixin :end_section
+          rule /[ \t]+/, Text
+          rule /[$]#{id}/, Name::Variable
+          rule /url[(]/, Str::Other, :string_url
+          rule /#{id}(?=\s*[(])/, Name::Function
+          rule /%#{id}/, Name::Decorator
+
+          # named literals
+          rule /(true|false)\b/, Name::Builtin::Pseudo
+          rule /(and|or|not)\b/, Operator::Word
+
+          # colors and numbers
+          rule /#[a-z0-9]{1,6}/i, Num::Hex
+          rule /-?\d+(%|[a-z]+)?/, Num
+          rule /-?\d*\.\d+(%|[a-z]+)?/, Num::Integer
+
+          mixin :has_strings
+          mixin :has_interp
+
+          rule /[~^*!&%<>\|+=@:,.\/?-]+/, Operator
+          rule /[\[\]()]+/, Punctuation
+          rule %r(/[*]), Comment::Multiline, :inline_comment
+          rule %r(//[^\n]*), Comment::Single
+
+          # identifiers
+          rule(id) do |m|
+            if CSS.builtins.include? m[0]
+              token Name::Builtin
+            elsif CSS.constants.include? m[0]
+              token Name::Constant
+            else
+              token Name
+            end
           end
         end
-      end
 
-      state :has_interp do
-        rule /[#][{]/, 'Literal.String.Interpol', :interpolation
-      end
+        state :has_interp do
+          rule /[#][{]/, Str::Interpol, :interpolation
+        end
 
-      state :has_strings do
-        rule /"/, 'Literal.String.Double', :dq
-        rule /'/, 'Literal.String.Single', :sq
-      end
+        state :has_strings do
+          rule /"/, Str::Double, :dq
+          rule /'/, Str::Single, :sq
+        end
 
-      state :interpolation do
-        rule /}/, 'Literal.String.Interpol', :pop!
-        mixin :value
-      end
+        state :interpolation do
+          rule /}/, Str::Interpol, :pop!
+          mixin :value
+        end
 
-      state :selector do
-        mixin :end_section
-
-        mixin :has_strings
-        mixin :has_interp
-        rule /[ \t]+/, 'Text'
-        rule /:/, 'Name.Decorator', :pseudo_class
-        rule /[.]/, 'Name.Class', :class
-        rule /#/, 'Name.Namespace', :id
-        rule /%/, 'Name.Variable', :placeholder
-        rule id, 'Name.Tag'
-        rule /&/, 'Keyword'
-        rule /[~^*!&\[\]()<>\|+=@:;,.\/?-]/, 'Operator'
-      end
+        state :selector do
+          mixin :end_section
+
+          mixin :has_strings
+          mixin :has_interp
+          rule /[ \t]+/, Text
+          rule /:/, Name::Decorator, :pseudo_class
+          rule /[.]/, Name::Class, :class
+          rule /#/, Name::Namespace, :id
+          rule /%/, Name::Variable, :placeholder
+          rule id, Name::Tag
+          rule /&/, Keyword
+          rule /[~^*!&\[\]()<>\|+=@:;,.\/?-]/, Operator
+        end
 
-      state :dq do
-        rule /"/, 'Literal.String.Double', :pop!
-        mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n"#])+/, 'Literal.String.Double'
-      end
+        state :dq do
+          rule /"/, Str::Double, :pop!
+          mixin :has_interp
+          rule /(\\.|#(?![{])|[^\n"#])+/, Str::Double
+        end
 
-      state :sq do
-        rule /'/, 'Literal.String.Single', :pop!
-        mixin :has_interp
-        rule /(\\.|#(?![{])|[^\n'#])+/, 'Literal.String.Single'
-      end
+        state :sq do
+          rule /'/, Str::Single, :pop!
+          mixin :has_interp
+          rule /(\\.|#(?![{])|[^\n'#])+/, Str::Single
+        end
 
-      state :string_url do
-        rule /[)]/, 'Literal.String.Other', :pop!
-        rule /(\\.|#(?![{])|[^\n)#])+/, 'Literal.String.Other'
-        mixin :has_interp
-      end
+        state :string_url do
+          rule /[)]/, Str::Other, :pop!
+          rule /(\\.|#(?![{])|[^\n)#])+/, Str::Other
+          mixin :has_interp
+        end
 
-      state :selector_piece do
-        mixin :has_interp
-        rule(//) { pop! }
-      end
+        state :selector_piece do
+          mixin :has_interp
+          rule(//) { pop! }
+        end
 
-      state :pseudo_class do
-        rule id, 'Name.Decorator'
-        mixin :selector_piece
-      end
+        state :pseudo_class do
+          rule id, Name::Decorator
+          mixin :selector_piece
+        end
 
-      state :class do
-        rule id, 'Name.Class'
-        mixin :selector_piece
-      end
+        state :class do
+          rule id, Name::Class
+          mixin :selector_piece
+        end
 
-      state :id do
-        rule id, 'Name.Namespace'
-        mixin :selector_piece
-      end
+        state :id do
+          rule id, Name::Namespace
+          mixin :selector_piece
+        end
 
-      state :placeholder do
-        rule id, 'Name.Variable'
-        mixin :selector_piece
-      end
+        state :placeholder do
+          rule id, Name::Variable
+          mixin :selector_piece
+        end
 
-      state :for do
-        rule /(from|to|through)/, 'Operator.Word'
-        mixin :value
-      end
+        state :for do
+          rule /(from|to|through)/, Operator::Word
+          mixin :value
+        end
 
-      state :attr_common do
-        mixin :has_interp
-        rule id do |m|
-          if CSS.attributes.include? m[0]
-            token 'Name.Label'
-          else
-            token 'Name.Attribute'
+        state :attr_common do
+          mixin :has_interp
+          rule id do |m|
+            if CSS.attributes.include? m[0]
+              token Name::Label
+            else
+              token Name::Attribute
+            end
           end
         end
-      end
 
-      state :attribute do
-        mixin :attr_common
+        state :attribute do
+          mixin :attr_common
 
-        rule /([ \t]*)(:)/ do
-          group 'Text'; group 'Punctuation'
-          push :value
+          rule /([ \t]*)(:)/ do
+            group Text; group Punctuation
+            push :value
+          end
         end
-      end
 
-      state :inline_comment do
-        rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, 'Comment.Multiline'
-        mixin :has_interp
-        rule %r([*]/), 'Comment.Multiline', :pop!
+        state :inline_comment do
+          rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, Comment::Multiline
+          mixin :has_interp
+          rule %r([*]/), Comment::Multiline, :pop!
+        end
       end
     end
   end