rouge 0.2.1 → 0.2.2

data/Gemfile

@@ -8,7 +8,8 @@ gem 'wrong', '~> 0.6.2'
 
 gem 'rake'
 
-gem 'redcarpet'
+# don't try to install redcarpet under jruby
+gem 'redcarpet', :platforms => :ruby
 
 # for visual tests
 gem 'sinatra'

data/lib/rouge.rb

@@ -7,7 +7,7 @@ module Rouge
       lexer = Lexer.find(lexer) unless lexer.respond_to? :lex
       raise "unknown lexer #{lexer}" unless lexer
 
-      formatter.render(lexer.lex(text))
+      formatter.format(lexer.lex(text))
     end
   end
 end
@@ -39,10 +39,13 @@ load load_dir.join('rouge/lexers/viml.rb')
 load load_dir.join('rouge/lexers/javascript.rb')
 load load_dir.join('rouge/lexers/css.rb')
 load load_dir.join('rouge/lexers/html.rb')
-load load_dir.join('rouge/lexers/haml.rb')
 load load_dir.join('rouge/lexers/xml.rb')
 load load_dir.join('rouge/lexers/php.rb')
 
+load load_dir.join('rouge/lexers/haml.rb')
+load load_dir.join('rouge/lexers/sass.rb')
+load load_dir.join('rouge/lexers/scss.rb')
+
 load load_dir.join('rouge/lexers/erb.rb')
 
 load load_dir.join('rouge/lexers/tcl.rb')
@@ -50,6 +53,8 @@ load load_dir.join('rouge/lexers/python.rb')
 load load_dir.join('rouge/lexers/ruby.rb')
 load load_dir.join('rouge/lexers/perl.rb')
 load load_dir.join('rouge/lexers/factor.rb')
+load load_dir.join('rouge/lexers/clojure.rb')
+load load_dir.join('rouge/lexers/groovy.rb')
 
 load load_dir.join('rouge/lexers/haskell.rb')
 load load_dir.join('rouge/lexers/scheme.rb')

data/lib/rouge/formatter.rb

@@ -18,10 +18,15 @@ module Rouge
     end
 
     # Format a token stream.
-    def render(tokens)
+    def format(tokens)
       enum_for(:stream, tokens).to_a.join
     end
 
+    def render(tokens)
+      warn 'Formatter#render is deprecated, use #format instead.'
+      format(tokens)
+    end
+
     # @abstract
     # yield strings that, when concatenated, form the formatted output
     def stream(tokens, &b)

data/lib/rouge/formatters/terminal256.rb

@@ -146,12 +146,21 @@ module Rouge
     # private
       def escape_sequence(token)
         @escape_sequences ||= {}
-        @escape_sequences[token.name] ||= begin
-          esc = EscapeSequence.new(theme.get_style(token))
-          # don't highlight text backgrounds
-          esc.style.delete(:bg) if token.name == 'Text'
-          esc
-        end
+        @escape_sequences[token.name] ||=
+          EscapeSequence.new(get_style(token))
+      end
+
+      def get_style(token)
+        return text_style if token.name == 'Text'
+
+        theme.get_own_style(token) || text_style
+      end
+
+      def text_style
+        style = theme.get_style(Token['Text'])
+        # don't highlight text backgrounds
+        style.delete :bg
+        style
       end
     end
   end

data/lib/rouge/lexer.rb

@@ -25,6 +25,40 @@ module Rouge
         registry[name.to_s]
       end
 
+      # Find a lexer, with fancy shiny features.
+      #
+      # * The string you pass can include CGI-style options
+      #
+      #     Lexer.find_fancy('erb?parent=tex')
+      #
+      # * You can pass the special name 'guess' so we guess for you,
+      #   and you can pass a second argument of the code to guess by
+      #
+      #     Lexer.find_fancy('guess', "#!/bin/bash\necho Hello, world")
+      #
+      # This is used in the Redcarpet plugin as well as Rouge's own
+      # markdown lexer for highlighting internal code blocks.
+      #
+      def find_fancy(str, code=nil)
+        name, opts = str ? str.split('?', 2) : [nil, '']
+
+        # parse the options hash from a cgi-style string
+        opts = CGI.parse(opts || '').map do |k, vals|
+          [ k.to_sym, vals.empty? ? true : vals[0] ]
+        end
+
+        opts = Hash[opts]
+
+        lexer_class = case name
+        when 'guess', nil
+          self.guess(:source => code, :mimetype => opts[:mimetype])
+        when String
+          self.find(name)
+        end
+
+        lexer_class && lexer_class.new(opts)
+      end
+
       # Specify or get this lexer's description.
       def desc(arg=:absent)
         if arg == :absent
@@ -75,12 +109,14 @@ module Rouge
         fname = File.basename(fname)
         registry.values.detect do |lexer|
           lexer.filenames.any? do |pattern|
-            File.fnmatch?(pattern, fname)
+            File.fnmatch?(pattern, fname, File::FNM_DOTMATCH)
           end
         end
       end
 
       def guess_by_source(source)
+        assert_utf8!(source)
+
         source = TextAnalyzer.new(source)
 
         best_result = 0
@@ -155,6 +191,15 @@ module Rouge
         (@mimetypes ||= []).concat(mts)
       end
 
+      # @private
+      def assert_utf8!(str)
+        return if %w(US-ASCII UTF-8).include? str.encoding.name
+        raise EncodingError.new(
+          "Bad encoding: #{str.encoding.names.join(',')}. " +
+          "Please convert your string to UTF-8."
+        )
+      end
+
     private
       def registry
         @registry ||= {}
@@ -217,8 +262,11 @@ module Rouge
     def lex(string, opts={}, &b)
       return enum_for(:lex, string) unless block_given?
 
+      Lexer.assert_utf8!(string)
+
       reset! unless opts[:continue]
 
+      # consolidate consecutive tokens of the same type
       last_token = nil
       last_val = nil
       stream_tokens(StringScanner.new(string)) do |tok, val|
@@ -237,6 +285,11 @@ module Rouge
       b.call(last_token, last_val) if last_token
     end
 
+    # delegated to {Lexer.tag}
+    def tag
+      self.class.tag
+    end
+
     # @abstract
     #
     # Yield `[token, chunk]` pairs, given a prepared input stream.  This

data/lib/rouge/lexers/clojure.rb

@@ -0,0 +1,108 @@
+module Rouge
+  module Lexers
+    class Clojure < RegexLexer
+      desc "The Clojure programming language (clojure.org)"
+
+      tag 'clojure'
+      aliases 'clj'
+
+      filenames '*.clj'
+
+      mimetypes 'text/x-clojure', 'application/x-clojure'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          fn def defn defmacro defmethod defmulti defn- defstruct if
+          cond let for
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          . ..  * + - -> / < <= = == > >= accessor agent agent-errors
+          aget alength all-ns alter and append-child apply array-map
+          aset aset-boolean aset-byte aset-char aset-double aset-float
+          aset-int aset-long aset-short assert assoc await await-for bean
+          binding bit-and bit-not bit-or bit-shift-left bit-shift-right
+          bit-xor boolean branch?  butlast byte cast char children
+          class clear-agent-errors comment commute comp comparator
+          complement concat conj cons constantly construct-proxy
+          contains? count create-ns create-struct cycle dec  deref
+          difference disj dissoc distinct doall doc dorun doseq dosync
+          dotimes doto double down drop drop-while edit end? ensure eval
+          every? false? ffirst file-seq filter find find-doc find-ns
+          find-var first float flush fnseq frest gensym get-proxy-class
+          get hash-map hash-set identical? identity if-let import in-ns
+          inc index insert-child insert-left insert-right inspect-table
+          inspect-tree instance? int interleave intersection into
+          into-array iterate join key keys keyword keyword? last lazy-cat
+          lazy-cons left lefts line-seq list* list load load-file locking
+          long loop macroexpand macroexpand-1 make-array make-node map
+          map-invert map? mapcat max max-key memfn merge merge-with meta
+          min min-key name namespace neg? new newline next nil? node not
+          not-any? not-every? not= ns-imports ns-interns ns-map ns-name
+          ns-publics ns-refers ns-resolve ns-unmap nth nthrest or parse
+          partial path peek pop pos? pr pr-str print print-str println
+          println-str prn prn-str project proxy proxy-mappings quot
+          rand rand-int range re-find re-groups re-matcher re-matches
+          re-pattern re-seq read read-line reduce ref ref-set refer rem
+          remove remove-method remove-ns rename rename-keys repeat replace
+          replicate resolve rest resultset-seq reverse rfirst right
+          rights root rrest rseq second select select-keys send send-off
+          seq seq-zip seq? set short slurp some sort sort-by sorted-map
+          sorted-map-by sorted-set special-symbol? split-at split-with
+          str string?  struct struct-map subs subvec symbol symbol?
+          sync take take-nth take-while test time to-array to-array-2d
+          tree-seq true? union up update-proxy val vals var-get var-set
+          var? vector vector-zip vector? when when-first when-let
+          when-not with-local-vars with-meta with-open with-out-str
+          xml-seq xml-zip zero? zipmap zipper'
+        )
+      end
+
+      identifier = %r([\w!$%*+,<=>?/.-]+)
+
+      def name_token(name)
+        return 'Keyword' if self.class.keywords.include?(name)
+        return 'Name.Builtin' if self.class.builtins.include?(name)
+        nil
+      end
+
+      state :root do
+        rule /;.*?\n/, 'Comment.Single'
+        rule /\s+/m, 'Text.Whitespace'
+
+        rule /-?\d+\.\d+/, 'Literal.Number.Float'
+        rule /-?\d+/, 'Literal.Number.Integer'
+        rule /0x-?[0-9a-fA-F]+/, 'Literal.Number.Hex'
+
+        rule /"(\\.|[^"])*"/, 'Literal.String'
+        rule /'#{identifier}/, 'Literal.String.Symbol'
+        rule /\\(.|[a-z]+)/i, 'Literal.String.Char'
+
+        rule /:#{identifier}/, 'Name.Constant'
+
+        rule /~@|[`\'#^~&]/, 'Operator'
+
+        rule /(\()(\s*)(#{identifier})/m do |m|
+          token 'Punctuation', m[1]
+          token 'Text.Whitespace', m[2]
+          token(name_token(m[3]) || 'Name.Function', m[3])
+        end
+
+        rule identifier do |m|
+          token name_token(m[0]) || 'Name.Variable'
+        end
+
+        # vectors
+        rule /[\[\]]/, 'Punctuation'
+
+        # maps
+        rule /[{}]/, 'Punctuation'
+
+        # parentheses
+        rule /[()]/, 'Punctuation'
+      end
+    end
+  end
+end

data/lib/rouge/lexers/css.rb

@@ -9,93 +9,105 @@ module Rouge
 
       identifier = /[a-zA-Z0-9_-]+/
       number = /-?(?:[0-9]+(\.[0-9]+)?|\.[0-9]+)/
-      keywords = %w(
-        azimuth background-attachment background-color
-        background-image background-position background-repeat
-        background border-bottom-color border-bottom-style
-        border-bottom-width border-left-color border-left-style
-        border-left-width border-right border-right-color
-        border-right-style border-right-width border-top-color
-        border-top-style border-top-width border-bottom
-        border-collapse border-left border-width border-color
-        border-spacing border-style border-top border caption-side
-        clear clip color content counter-increment counter-reset
-        cue-after cue-before cue cursor direction display
-        elevation empty-cells float font-family font-size
-        font-size-adjust font-stretch font-style font-variant
-        font-weight font height letter-spacing line-height
-        list-style-type list-style-image list-style-position
-        list-style margin-bottom margin-left margin-right
-        margin-top margin marker-offset marks max-height max-width
-        min-height min-width opacity orphans outline outline-color
-        outline-style outline-width overflow(?:-x -y ) padding-bottom
-        padding-left padding-right padding-top padding page
-        page-break-after page-break-before page-break-inside
-        pause-after pause-before pause pitch pitch-range
-        play-during position quotes richness right size
-        speak-header speak-numeral speak-punctuation speak
-        speech-rate stress table-layout text-align text-decoration
-        text-indent text-shadow text-transform top unicode-bidi
-        vertical-align visibility voice-family volume white-space
-        widows width word-spacing z-index bottom left
-        above absolute always armenian aural auto avoid baseline
-        behind below bidi-override blink block bold bolder both
-        capitalize center-left center-right center circle
-        cjk-ideographic close-quote collapse condensed continuous
-        crop crosshair cross cursive dashed decimal-leading-zero
-        decimal default digits disc dotted double e-resize embed
-        extra-condensed extra-expanded expanded fantasy far-left
-        far-right faster fast fixed georgian groove hebrew help
-        hidden hide higher high hiragana-iroha hiragana icon
-        inherit inline-table inline inset inside invert italic
-        justify katakana-iroha katakana landscape larger large
-        left-side leftwards level lighter line-through list-item
-        loud lower-alpha lower-greek lower-roman lowercase ltr
-        lower low medium message-box middle mix monospace
-        n-resize narrower ne-resize no-close-quote no-open-quote
-        no-repeat none normal nowrap nw-resize oblique once
-        open-quote outset outside overline pointer portrait px
-        relative repeat-x repeat-y repeat rgb ridge right-side
-        rightwards s-resize sans-serif scroll se-resize
-        semi-condensed semi-expanded separate serif show silent
-        slow slower small-caps small-caption smaller soft solid
-        spell-out square static status-bar super sw-resize
-        table-caption table-cell table-column table-column-group
-        table-footer-group table-header-group table-row
-        table-row-group text text-bottom text-top thick thin
-        transparent ultra-condensed ultra-expanded underline
-        upper-alpha upper-latin upper-roman uppercase url
-        visible w-resize wait wider x-fast x-high x-large x-loud
-        x-low x-small x-soft xx-large xx-small yes
-      )
-
-      builtins = %w(
-        indigo gold firebrick indianred yellow darkolivegreen
-        darkseagreen mediumvioletred mediumorchid chartreuse
-        mediumslateblue black springgreen crimson lightsalmon brown
-        turquoise olivedrab cyan silver skyblue gray darkturquoise
-        goldenrod darkgreen darkviolet darkgray lightpink teal
-        darkmagenta lightgoldenrodyellow lavender yellowgreen thistle
-        violet navy orchid blue ghostwhite honeydew cornflowerblue
-        darkblue darkkhaki mediumpurple cornsilk red bisque slategray
-        darkcyan khaki wheat deepskyblue darkred steelblue aliceblue
-        gainsboro mediumturquoise floralwhite coral purple lightgrey
-        lightcyan darksalmon beige azure lightsteelblue oldlace
-        greenyellow royalblue lightseagreen mistyrose sienna
-        lightcoral orangered navajowhite lime palegreen burlywood
-        seashell mediumspringgreen fuchsia papayawhip blanchedalmond
-        peru aquamarine white darkslategray ivory dodgerblue
-        lemonchiffon chocolate orange forestgreen slateblue olive
-        mintcream antiquewhite darkorange cadetblue moccasin
-        limegreen saddlebrown darkslateblue lightskyblue deeppink
-        plum aqua darkgoldenrod maroon sandybrown magenta tan
-        rosybrown pink lightblue palevioletred mediumseagreen
-        dimgray powderblue seagreen snow mediumblue midnightblue
-        paleturquoise palegoldenrod whitesmoke darkorchid salmon
-        lightslategray lawngreen lightgreen tomato hotpink
-        lightyellow lavenderblush linen mediumaquamarine green
-        blueviolet peachpuff
-      )
+
+      def self.attributes
+        @attributes ||= Set.new %w(
+          azimuth background background-attachment background-color
+          background-image background-position background-repeat
+          border border-bottom border-bottom-color border-bottom-style
+          border-bottom-width border-collapse border-color border-left
+          border-left-color border-left-style border-left-width
+          border-right border-right-color border-right-style
+          border-right-width border-spacing border-style border-top
+          border-top-color border-top-style border-top-width
+          border-width bottom caption-side clear clip color content
+          counter-increment counter-reset cue cue-after cue-before cursor
+          direction display elevation empty-cells float font font-family
+          font-size font-size-adjust font-stretch font-style font-variant
+          font-weight height left letter-spacing line-height list-style
+          list-style-image list-style-position list-style-type margin
+          margin-bottom margin-left margin-right margin-top marker-offset
+          marks max-height max-width min-height min-width opacity orphans
+          outline outline-color outline-style outline-width overflow-x
+          overflow-y padding padding-bottom padding-left padding-right
+          padding-top page page-break-after page-break-before
+          page-break-inside pause pause-after pause-before pitch
+          pitch-range play-during position quotes richness right size
+          speak speak-header speak-numeral speak-punctuation speech-rate
+          src stress table-layout text-align text-decoration text-indent
+          text-shadow text-transform top unicode-bidi vertical-align
+          visibility voice-family volume white-space widows width
+          word-spacing z-index
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          above absolute always armenian aural auto avoid left bottom
+          baseline behind below bidi-override blink block bold bolder
+          both bottom capitalize center center-left center-right circle
+          cjk-ideographic close-quote collapse condensed continuous crop
+          cross crosshair cursive dashed decimal decimal-leading-zero
+          default digits disc dotted double e-resize embed expanded
+          extra-condensed extra-expanded fantasy far-left far-right fast
+          faster fixed georgian groove hebrew help hidden hide high higher
+          hiragana hiragana-iroha icon inherit inline inline-table inset
+          inside invert italic justify katakana katakana-iroha landscape
+          large larger left left-side leftwards level lighter line-through
+          list-item loud low lower lower-alpha lower-greek lower-roman
+          lowercase ltr medium message-box middle mix monospace n-resize
+          narrower ne-resize no-close-quote no-open-quote no-repeat none
+          normal nowrap nw-resize oblique once open-quote outset outside
+          overline pointer portrait px relative repeat repeat-x repeat-y
+          rgb ridge right right-side rightwards s-resize sans-serif scroll
+          se-resize semi-condensed semi-expanded separate serif show
+          silent slow slower small-caps small-caption smaller soft solid
+          spell-out square static status-bar super sw-resize table-caption
+          table-cell table-column table-column-group table-footer-group
+          table-header-group table-row table-row-group text text-bottom
+          text-top thick thin top transparent ultra-condensed
+          ultra-expanded underline upper-alpha upper-latin upper-roman
+          uppercase url visible w-resize wait wider x-fast x-high x-large
+          x-loud x-low x-small x-soft xx-large xx-small yes
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          indigo gold firebrick indianred yellow darkolivegreen
+          darkseagreen mediumvioletred mediumorchid chartreuse
+          mediumslateblue black springgreen crimson lightsalmon brown
+          turquoise olivedrab cyan silver skyblue gray darkturquoise
+          goldenrod darkgreen darkviolet darkgray lightpink teal
+          darkmagenta lightgoldenrodyellow lavender yellowgreen thistle
+          violet navy orchid blue ghostwhite honeydew cornflowerblue
+          darkblue darkkhaki mediumpurple cornsilk red bisque slategray
+          darkcyan khaki wheat deepskyblue darkred steelblue aliceblue
+          gainsboro mediumturquoise floralwhite coral purple lightgrey
+          lightcyan darksalmon beige azure lightsteelblue oldlace
+          greenyellow royalblue lightseagreen mistyrose sienna lightcoral
+          orangered navajowhite lime palegreen burlywood seashell
+          mediumspringgreen fuchsia papayawhip blanchedalmond peru
+          aquamarine white darkslategray ivory dodgerblue lemonchiffon
+          chocolate orange forestgreen slateblue olive mintcream
+          antiquewhite darkorange cadetblue moccasin limegreen saddlebrown
+          darkslateblue lightskyblue deeppink plum aqua darkgoldenrod
+          maroon sandybrown magenta tan rosybrown pink lightblue
+          palevioletred mediumseagreen dimgray powderblue seagreen snow
+          mediumblue midnightblue paleturquoise palegoldenrod whitesmoke
+          darkorchid salmon lightslategray lawngreen lightgreen tomato
+          hotpink lightyellow lavenderblush linen mediumaquamarine green
+          blueviolet peachpuff
+        )
+      end
+
+      # source: http://www.w3.org/TR/CSS21/syndata.html#vendor-keyword-history
+      def self.vendor_prefixes
+        @vendor_prefixes ||= Set.new %w(
+          -ah- -atsc- -hp- -khtml- -moz- -ms- -o- -rim- -ro- -tc- -wap-
+          -webkit- -xv- mso- prince-
+        )
+      end
 
       state :root do
         mixin :basics
@@ -116,7 +128,15 @@ module Rouge
         rule /[\[\]():\/.]/, 'Punctuation'
         rule /"(\\\\|\\"|[^"])*"/, 'Literal.String.Single'
         rule /'(\\\\|\\'|[^'])*'/, 'Literal.String.Double'
-        rule identifier, 'Name'
+        rule(identifier) do |m|
+          if self.class.constants.include? m[0]
+            token 'Name.Constant'
+          elsif self.class.builtins.include? m[0]
+            token 'Name.Builtin'
+          else
+            token 'Name'
+          end
+        end
       end
 
       state :at_rule do
@@ -151,15 +171,18 @@ module Rouge
       state :stanza do
         mixin :basics
         rule /}/, 'Punctuation', :pop!
-        rule /(#{identifier}\s*):/m do |m|
-          if keywords.include? m[1]
-            token 'Keyword'
-          elsif builtins.include? m[1]
-            token 'Name.Builtin'
+        rule /(#{identifier})(\s*)(:)/m do |m|
+          if self.class.attributes.include? m[1]
+            group 'Name.Label'
+          elsif self.class.vendor_prefixes.any? { |p| m[1].start_with?(p) }
+            group 'Name.Label'
           else
-            token 'Name'
+            group 'Name.Property'
           end
 
+          group 'Text'
+          group 'Punctuation'
+
           push :stanza_value
         end
       end

data/lib/rouge/lexers/groovy.rb

@@ -0,0 +1,102 @@
+module Rouge
+  module Lexers
+    class Groovy < RegexLexer
+      desc 'The Groovy programming language (groovy.codehaus.org)'
+      tag 'groovy'
+      filenames '*.groovy'
+      mimetypes 'text/x-groovy'
+
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break case catch continue default do else finally for
+          if goto instanceof new return switch this throw try while in as
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract const enum extends final implements native private
+          protected public static strictfp super synchronized throws
+          transient volatile
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          def boolean byte char double float int long short void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      state :root do
+        rule %r(^
+          (\s*(?:\w[\w\d.\[\]]*\s+)+?) # return arguments
+          (\w[\w\d]*) # method name
+          (\s*) (\() # signature start
+        )x do |m|
+          delegate self.clone, m[1]
+          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 /"(\\\\|\\"|[^"])*"/, '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 /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
+          group 'Operator'
+          group 'Name.Attribute'
+        end
+
+        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'
+          elsif self.class.declarations.include? m[0]
+            token 'Keyword.Declaration'
+          elsif self.class.types.include? m[0]
+            token 'Keyword.Type'
+          elsif self.class.constants.include? m[0]
+            token 'Keyword.Constant'
+          else
+            token 'Name'
+          end
+        end
+
+        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'
+      end
+
+      state :class do
+        rule /\s+/, 'Text'
+        rule /\w[\w\d]*/, 'Name.Class', :pop!
+      end
+
+      state :import do
+        rule /\s+/, 'Text'
+        rule /[\w\d.]+[*]?/, 'Name.Namespace', :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/haml.rb

@@ -3,6 +3,8 @@ module Rouge
     # A lexer for the Haml templating system for Ruby.
     # @see http://haml.info
     class Haml < RegexLexer
+      include Indentation
+
       desc "The Haml templating system for Ruby (haml.info)"
 
       tag 'haml'
@@ -56,33 +58,6 @@ module Rouge
 
       start { ruby.reset!; html.reset! }
 
-      # push a state for the next indented block
-      def starts_block(block_state)
-        @block_state = block_state
-        @block_indentation = @last_indentation || ''
-        debug { "    haml: starts_block #{block_state.inspect}" }
-        debug { "    haml: block_indentation: #{@block_indentation.inspect}" }
-      end
-
-      def indentation(indent_str)
-        debug { "    haml: indentation #{indent_str.inspect}" }
-        debug { "    haml: block_indentation: #{@block_indentation.inspect}" }
-        @last_indentation = indent_str
-
-        # if it's an indent and we know where to go next,
-        # push that state.  otherwise, push content and
-        # clear the block state.
-        if (@block_state &&
-            indent_str.start_with?(@block_indentation) &&
-            indent_str != @block_indentation
-        )
-          push @block_state
-        else
-          @block_state = @block_indentation = nil
-          push :content
-        end
-      end
-
       identifier = /[\w:-]+/
       ruby_var = /[a-z]\w*/
 

data/lib/rouge/lexers/markdown.rb

@@ -30,29 +30,13 @@ module Rouge
 
         # TODO: syntax highlight the code block, github style
         rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?)(\2)/m do |m|
-          sublexer, opts = m[3].strip.split('?', 2)
-
-          if sublexer
-            sublexer = Lexer.find(sublexer)
-
-            # parse the options hash from a cgi-style string
-            opts = CGI.parse(opts || '').map do |k, vals|
-              [ k.to_sym, vals.empty? ? true : vals[0] ]
-            end
-
-            opts = Hash[opts]
-
-            sublexer &&= sublexer.new(opts)
-          end
+          sublexer = Lexer.find_fancy(m[3].strip, m[4])
+          sublexer ||= Text.new(:token => 'Literal.String.Backtick')
 
           token 'Text', m[1]
           token 'Punctuation', m[2]
           token 'Name.Label', m[3]
-          if sublexer
-            delegate sublexer, m[4]
-          else
-            token 'Literal.String.Backtick', m[4]
-          end
+          delegate sublexer, m[4]
           token 'Punctuation', m[5]
         end
 

data/lib/rouge/lexers/sass.rb

@@ -0,0 +1,228 @@
+module Rouge
+  module Lexers
+    class Sass < RegexLexer
+      include Indentation
+
+      tag 'sass'
+      filenames '*.sass'
+      mimetypes 'text/x-sass'
+
+      id = /[\w-]+/
+
+      state :root do
+        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'
+          pop!; starts_block :single_comment
+        end
+
+        rule %r(/[*].*?\n) do
+          token 'Comment.Multiline'
+          pop!; starts_block :multi_comment
+        end
+
+        rule /@import\b/, 'Keyword', :import
+
+        mixin :content_common
+
+        rule %r(=#{id}), 'Name.Function', :value
+        rule %r([+]#{id}), 'Name.Decorator', :value
+
+        rule /:/, 'Name.Attribute', :old_style_attr
+
+        rule(/(?=.+?:(^a-z|$))/) { push :attribute }
+
+        rule(//) { push :selector }
+      end
+
+      state :single_comment do
+        rule /.*?\n/, 'Comment.Single', :pop!
+      end
+
+      state :multi_comment do
+        rule /.*?\n/, 'Comment.Multiline', :pop!
+      end
+
+      state :import do
+        rule /[ \t]+/, 'Text'
+        rule /\S+/, 'Literal.String'
+        rule /\n/, 'Text', :pop!
+      end
+
+      state :old_style_attr do
+        mixin :attr_common
+        rule(//) { pop!; push :value }
+      end
+
+      state :end_section do
+        rule(/\n/) { token 'Text'; reset_stack }
+      end
+
+      # shared states with SCSS
+      # TODO: make this less nasty to do
+      COMMON = proc do
+        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 /(@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
+          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'
+
+          # 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'
+            end
+          end
+        end
+
+        state :has_interp do
+          rule /[#][{]/, 'Literal.String.Interpol', :interpolation
+        end
+
+        state :has_strings do
+          rule /"/, 'Literal.String.Double', :dq
+          rule /'/, 'Literal.String.Single', :sq
+        end
+
+        state :interpolation do
+          rule /}/, 'Literal.String.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 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 :sq do
+          rule /'/, 'Literal.String.Single', :pop!
+          mixin :has_interp
+          rule /(\\.|#(?![{])|[^\n'#])+/, 'Literal.String.Single'
+        end
+
+        state :string_url do
+          rule /[)]/, 'Literal.String.Other', :pop!
+          rule /(\\.|#(?![{])|[^\n)#])+/, 'Literal.String.Other'
+          mixin :has_interp
+        end
+
+        state :selector_piece do
+          mixin :has_interp
+          rule(//) { pop! }
+        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 :id do
+          rule id, 'Name.Namespace'
+          mixin :selector_piece
+        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'
+            end
+          end
+        end
+
+        state :attribute do
+          mixin :attr_common
+
+          rule /([ \t]*)(:)/ do
+            group 'Text'; group 'Punctuation'
+            push :value
+          end
+        end
+
+        state :inline_comment do
+          rule /(\\#|#(?=[^\n{])|\*(?=[^\n\/])|[^\n#*])+/, 'Comment.Multiline'
+          mixin :has_interp
+          rule %r([*]/), 'Comment.Multiline', :pop!
+        end
+      end
+
+      class_eval(&COMMON)
+    end
+  end
+end

data/lib/rouge/lexers/scss.rb

@@ -0,0 +1,31 @@
+module Rouge
+  module Lexers
+    class Scss < RegexLexer
+      desc "SCSS stylesheets (sass-lang.com)"
+      tag 'scss'
+      filenames '*.scss'
+      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
+
+        mixin :content_common
+
+        rule(/(?=[^;{}][;}])/) { push :attribute }
+        rule(/(?=[^;{}:]+:[^a-z])/) { push :attribute }
+
+        rule(//) { push :selector }
+      end
+
+      state :end_section do
+        rule /\n/, 'Text'
+        rule(/[;{}]/) { token 'Punctuation'; reset_stack }
+      end
+
+      instance_eval(&Sass::COMMON)
+    end
+  end
+end

data/lib/rouge/lexers/text.rb

@@ -7,8 +7,14 @@ module Rouge
       filenames '*.txt'
       mimetypes 'text/plain'
 
+      default_options :token => 'Text'
+
+      def token
+        @token ||= Token[option :token]
+      end
+
       def stream_tokens(stream, &b)
-        yield Token['Text'], stream.string
+        yield self.token, stream.string
       end
     end
   end

data/lib/rouge/lexers/yaml.rb

@@ -2,9 +2,15 @@ module Rouge
   module Lexers
     class YAML < RegexLexer
       desc "Yaml Ain't Markup Language (yaml.org)"
+      mimetypes 'text/x-yaml'
       tag 'yaml'
       aliases 'yml'
 
+      def self.analyze_text(text)
+        # look for the %YAML directive
+        return 1 if text =~ /\A\s*%YAML/m
+      end
+
       filenames '*.yaml', '*.yml'
       # NB: Tabs are forbidden in YAML, which is why you see things
       # like /[ ]+/.

data/lib/rouge/plugins/redcarpet.rb

@@ -2,9 +2,6 @@
 #
 #    require 'rouge/plugins/redcarpet'
 
-# this plugin depends on redcarpet
-require 'redcarpet'
-
 # stdlib
 require 'cgi'
 
@@ -12,33 +9,20 @@ module Rouge
   module Plugins
     module Redcarpet
       def block_code(code, language)
-        name, opts = language ? language.split('?', 2) : [nil, '']
-
-        # parse the options hash from a cgi-style string
-        opts = CGI.parse(opts || '').map do |k, vals|
-          [ k.to_sym, vals.empty? ? true : vals[0] ]
-        end
-
-        opts = Hash[opts]
-
-        lexer_class = case name
-        when 'guess', nil
-          lexer = Lexer.guess(:source => code, :mimetype => opts[:mimetype])
-        when String
-          Lexer.find(name)
-        end || Lexers::Text
+        lexer = Lexer.find_fancy(language, code) || Lexers::Text
 
         # XXX HACK: Redcarpet strips hard tabs out of code blocks,
         # so we assume you're not using leading spaces that aren't tabs,
         # and just replace them here.
-        if lexer_class.tag == 'make'
+        if lexer.tag == 'make'
           code.gsub! /^    /, "\t"
         end
 
-        lexer = lexer_class.new(opts)
-        formatter = Formatters::HTML.new(:css_class => "highlight #{lexer_class.tag}")
+        formatter = Formatters::HTML.new(
+          :css_class => "highlight #{lexer.tag}"
+        )
 
-        Rouge.highlight(code, lexer, formatter)
+        formatter.format(lexer.lex(code))
       end
     end
   end

data/lib/rouge/theme.rb

@@ -76,12 +76,14 @@ module Rouge
         end
       end
 
-      def get_style(token)
+      def get_own_style(token)
         token.ancestors do |anc|
           return styles[anc.name] if styles[anc.name]
         end
+      end
 
-        styles['Text']
+      def get_style(token)
+        get_own_style(token) || style['Text']
       end
 
       def name(n=nil)

data/lib/rouge/themes/thankful_eyes.rb

@@ -59,6 +59,7 @@ module Rouge
       style 'Name.Entity', :fg => '#999999', :bold => true
       style 'Text.Whitespace', :fg => '#BBBBBB'
       style 'Name.Function',
+            'Name.Property',
             'Name.Attribute', :fg => :chilly
       style 'Name.Variable', :fg => :chilly, :bold => true
     end

data/lib/rouge/util.rb

@@ -70,4 +70,40 @@ module Rouge
     end
     alias << push
   end
+
+  # shared methods for some indentation-sensitive lexers
+  module Indentation
+    def reset!
+      super
+      @block_state = @block_indentation = nil
+    end
+
+    # push a state for the next indented block
+    def starts_block(block_state)
+      @block_state = block_state
+      @block_indentation = @last_indentation || ''
+      debug { "    starts_block #{block_state.inspect}" }
+      debug { "    block_indentation: #{@block_indentation.inspect}" }
+    end
+
+    # handle a single indented line
+    def indentation(indent_str)
+      debug { "    indentation #{indent_str.inspect}" }
+      debug { "    block_indentation: #{@block_indentation.inspect}" }
+      @last_indentation = indent_str
+
+      # if it's an indent and we know where to go next,
+      # push that state.  otherwise, push content and
+      # clear the block state.
+      if (@block_state &&
+          indent_str.start_with?(@block_indentation) &&
+          indent_str != @block_indentation
+      )
+        push @block_state
+      else
+        @block_state = @block_indentation = nil
+        push :content
+      end
+    end
+  end
 end

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "0.2.1"
+    "0.2.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-11 00:00:00.000000000 Z
+date: 2012-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -42,11 +42,13 @@ files:
 - lib/rouge/lexers/common_lisp.rb
 - lib/rouge/lexers/erb.rb
 - lib/rouge/lexers/scheme.rb
+- lib/rouge/lexers/clojure.rb
 - lib/rouge/lexers/xml.rb
 - lib/rouge/lexers/shell.rb
 - lib/rouge/lexers/haml.rb
 - lib/rouge/lexers/ruby.rb
 - lib/rouge/lexers/make.rb
+- lib/rouge/lexers/scss.rb
 - lib/rouge/lexers/perl.rb
 - lib/rouge/lexers/javascript.rb
 - lib/rouge/lexers/diff.rb
@@ -66,6 +68,8 @@ files:
 - lib/rouge/lexers/cpp.rb
 - lib/rouge/lexers/factor.rb
 - lib/rouge/lexers/viml/keywords.rb
+- lib/rouge/lexers/groovy.rb
+- lib/rouge/lexers/sass.rb
 - lib/rouge/plugins/redcarpet.rb
 - lib/rouge/themes/thankful_eyes.rb
 - lib/rouge/themes/colorful.rb