rouge 0.2.2 → 0.2.3

data/lib/rouge.rb

@@ -45,8 +45,10 @@ 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/coffeescript.rb')
 
 load load_dir.join('rouge/lexers/erb.rb')
+load load_dir.join('rouge/lexers/handlebars.rb')
 
 load load_dir.join('rouge/lexers/tcl.rb')
 load load_dir.join('rouge/lexers/python.rb')
@@ -64,6 +66,8 @@ load load_dir.join('rouge/lexers/c.rb')
 load load_dir.join('rouge/lexers/cpp.rb')
 load load_dir.join('rouge/lexers/java.rb')
 
+load load_dir.join('rouge/lexers/smalltalk.rb')
+
 load load_dir.join('rouge/formatter.rb')
 load load_dir.join('rouge/formatters/html.rb')
 load load_dir.join('rouge/formatters/terminal256.rb')

data/lib/rouge/lexers/coffeescript.rb

@@ -0,0 +1,176 @@
+module Rouge
+  module Lexers
+    class Coffeescript < RegexLexer
+      tag 'coffeescript'
+      aliases 'coffee', 'coffee-script'
+      filenames '*.coffee', 'Cakefile'
+      mimetypes 'text/coffeescript'
+
+      desc 'The Coffeescript programming language (coffeescript.org)'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'coffee'
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          for in of while break return continue switch when then if else
+          throw try catch finally new delete typeof instanceof super
+          extends this class by
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false yes no on off null NaN Infinity undefined
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          Array Boolean Date Error Function Math netscape Number Object
+          Packages RegExp String sun decodeURI decodeURIComponent
+          encodeURI encodeURIComponent eval isFinite isNaN parseFloat
+          parseInt document window
+        )
+      end
+
+      id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+      lval = /@?#{id}([.]#{id})*/
+
+      state :comments_and_whitespace do
+        rule /\s+/m, 'Text'
+        rule /###.*?###/m, 'Comment.Multiline'
+        rule /#.*?\n/, 'Comment.Single'
+      end
+
+      state :multiline_regex do
+        mixin :comments_and_whitespace
+        rule %r(///([gim]+\b|\B)), 'Literal.String.Regex', :pop!
+        rule %r(/), 'Literal.String.Regex'
+        rule %r([^/#]+), 'Literal.String.Regex'
+      end
+
+      state :slash_starts_regex do
+        mixin :comments_and_whitespace
+        rule %r(///) do
+          token 'Literal.String.Regex'
+          pop!; push :multiline_regex
+        end
+
+        rule %r(
+          /(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*\])+/ # a regex
+          ([gim]+\b|\B)
+        )x, 'Literal.String.Regex', :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :root do
+        rule(%r(^(?=\s|/|<!--))) { push :slash_starts_regex }
+        mixin :comments_and_whitespace
+        rule %r(
+          [+][+]|--|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|[?]|:|=|
+          [|][|]|\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*`%&|^/])=?
+        )x, 'Operator', :slash_starts_regex
+
+        rule /[-=]>/, 'Name.Function'
+
+        rule /(@)([ \t]*)(#{id})/ do
+          group 'Name.Variable.Instance'; group 'Text'
+          group 'Name.Attribute'
+          push :slash_starts_regex
+        end
+
+        rule /([.])([ \t]*)(#{id})/ do
+          group 'Punctuation'; group 'Text'
+          group 'Name.Attribute'
+          push :slash_starts_regex
+        end
+
+        rule /#{id}(?=\s*:)/, 'Name.Attribute', :slash_starts_regex
+
+        rule /#{id}/, 'Name.Other', :slash_starts_regex
+
+        rule /[{(\[;,]/, 'Punctuation', :slash_starts_regex
+        rule /[})\].]/, 'Punctuation'
+
+        rule /\d+[.]\d+([eE]\d+)?[fd]?/, 'Literal.Number.Float'
+        rule /0x[0-9a-fA-F]+/, 'Literal.Number.Hex'
+        rule /\d+/, 'Literal.Number.Integer'
+        rule /"""/, 'Literal.String', :tdqs
+        rule /'''/, 'Literal.String', :tsqs
+        rule /"/, 'Literal.String', :dqs
+        rule /'/, 'Literal.String', :sqs
+      end
+
+      state :strings do
+        # all coffeescript strings are multi-line
+        rule /[^#\\'"]+/m, 'Literal.String'
+
+        rule /\\./, 'Literal.String.Escape'
+        rule /#/, 'Literal.String'
+      end
+
+      state :double_strings do
+        rule /'/, 'Literal.String'
+        mixin :has_interpolation
+        mixin :strings
+      end
+
+      state :single_strings do
+        rule /"/, 'Literal.String'
+        mixin :strings
+      end
+
+      state :interpolation do
+        rule /}/, 'Literal.String.Interpol', :pop!
+        mixin :root
+      end
+
+      state :has_interpolation do
+        rule /[#][{]/, 'Literal.String.Interpol', :interpolation
+      end
+
+      state :dqs do
+        rule /"/, 'Literal.String', :pop!
+        mixin :double_strings
+      end
+
+      state :tdqs do
+        rule /"""/, 'Literal.String', :pop!
+        rule /"/, 'Literal.String'
+        mixin :double_strings
+      end
+
+      state :sqs do
+        rule /'/, 'Literal.String', :pop!
+        mixin :single_strings
+      end
+
+      state :tsqs do
+        rule /'''/, 'Literal.String', :pop!
+        rule /'/, 'Literal.String'
+        mixin :single_strings
+      end
+
+      postprocess 'Name' do |tok, val|
+        if tok.name == 'Name.Attribute'
+          if self.class.keywords.include? val
+            tok = 'Error' # keywords as attributes = nono
+          else
+            # pass. leave attributes alone.
+          end
+        elsif self.class.keywords.include? val
+          tok = 'Keyword'
+        elsif self.class.constants.include? val
+            tok = 'Name.Constant'
+        elsif self.class.builtins.include? val
+          tok = 'Name.Builtin'
+        end
+
+        token tok, val
+      end
+    end
+  end
+end

data/lib/rouge/lexers/handlebars.rb

@@ -0,0 +1,76 @@
+module Rouge
+  module Lexers
+    class Handlebars < TemplateLexer
+      desc 'the Handlebars and Mustache templating languages'
+      tag 'handlebars'
+      aliases 'hbs', 'mustache'
+      filenames '*.handlebars', '*.hbs', '*.mustache'
+      mimetypes 'text/x-handlebars', 'text/x-mustache'
+
+      id = %r([\w$-]+)
+
+      state :root do
+        # escaped slashes
+        rule(/\\{+/) { delegate parent }
+
+        # block comments
+        rule /{{!--/, 'Comment', :comment
+        rule /{{!.*?}}/, 'Comment'
+
+        rule /{{{?/ do
+          token 'Keyword'
+          push :stache
+          push :open_sym
+        end
+
+        rule(/(.+?)(?=\\|{{)/m) { delegate parent }
+
+        # if we get here, there's no more mustache tags, so we eat
+        # the rest of the doc
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :comment do
+        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'
+      end
+
+      state :open_sym do
+        rule %r([#/]) do
+          token 'Keyword'
+          pop!; push :block_name
+        end
+
+        rule /[>^&]/, 'Keyword'
+
+        rule(//) { pop! }
+      end
+
+      state :block_name do
+        rule /if(?=[}\s])/, 'Keyword'
+        rule id, 'Name.Namespace', :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/sass.rb

@@ -3,6 +3,8 @@ module Rouge
     class Sass < RegexLexer
       include Indentation
 
+      desc 'The Sass stylesheet language language (sass-lang.com)'
+
       tag 'sass'
       filenames '*.sass'
       mimetypes 'text/x-sass'

data/lib/rouge/lexers/smalltalk.rb

@@ -0,0 +1,114 @@
+module Rouge
+  module Lexers
+    class Smalltalk < RegexLexer
+      desc 'The Smalltalk programming language'
+
+      tag 'smalltalk'
+      aliases 'st', 'squeak'
+      filenames '*.st'
+      mimetypes 'text/x-smalltalk'
+
+      ops = %r([-+*/\\~<>=|&!?,@%])
+
+      state :root do
+        rule /(<)(\w+:)(.*?)(>)/ do
+          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'
+        end
+        mixin :objects
+        rule /\^|:=|_/, 'Operator'
+
+        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'
+        end
+
+        rule /^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
+          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';
+        end
+      end
+
+      state :block_variables do
+        mixin :whitespaces
+        rule /(:)(\s*)(\w+)/ do
+          group 'Operator'; group 'Text'; group 'Name.Variable'
+        end
+
+        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 /(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
+          'Literal.Number', :after_object
+        rule /#("[^"]*"|#{ops}+|[\w:]+)/,
+          'Literal.String.Symbol', :after_object
+      end
+
+      state :parenth do
+        rule /[)]/ do
+          token 'Literal.String.Symbol'
+          pop!; push :after_object
+        end
+
+        mixin :inner_parenth
+      end
+
+      state :inner_parenth do
+        rule /#[(]/, 'Literal.String.Symbol', :inner_parenth
+        rule /[)]/, 'Literal.String.Symbol', :pop!
+        mixin :whitespaces
+        mixin :literals
+        rule /(#{ops}|[\w:])+/, 'Literal.String.Symbol'
+      end
+
+      state :whitespaces do
+        rule /! !$/, 'Keyword' # squeak chunk delimiter
+        rule /\s+/m, 'Text'
+        rule /".*?"/m, 'Comment'
+      end
+
+      state :objects do
+        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
+        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'
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/regex_lexer.rb

@@ -196,7 +196,7 @@ module Rouge
     # @see #step #step (where (2.) is implemented)
     def stream_tokens(stream, &b)
       stream_without_postprocessing(stream) do |tok, val|
-        _, processor = self.class.postprocesses.find { |t, _| t == tok }
+        _, processor = self.class.postprocesses.find { |t, _| t === tok }
 
         if processor
           with_output_stream(b) do
@@ -385,6 +385,7 @@ module Rouge
 
   private
     def with_output_stream(output_stream, &b)
+      old_output_stream = @output_stream
       @output_stream = Yielder.new do |tok, val|
         debug { "    yielding #{tok.to_s.inspect}, #{val.inspect}" }
         output_stream.call(Token[tok], val)
@@ -393,7 +394,7 @@ module Rouge
       yield
 
     ensure
-      @output_stream = nil
+      @output_stream = old_output_stream
     end
   end
 end

data/lib/rouge/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-13 00:00:00.000000000 Z
+date: 2012-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -53,9 +53,11 @@ files:
 - lib/rouge/lexers/javascript.rb
 - lib/rouge/lexers/diff.rb
 - lib/rouge/lexers/viml.rb
+- lib/rouge/lexers/smalltalk.rb
 - lib/rouge/lexers/php/builtins.rb
 - lib/rouge/lexers/haskell.rb
 - lib/rouge/lexers/c.rb
+- lib/rouge/lexers/handlebars.rb
 - lib/rouge/lexers/tex.rb
 - lib/rouge/lexers/text.rb
 - lib/rouge/lexers/html.rb
@@ -63,6 +65,7 @@ files:
 - lib/rouge/lexers/java.rb
 - lib/rouge/lexers/php.rb
 - lib/rouge/lexers/yaml.rb
+- lib/rouge/lexers/coffeescript.rb
 - lib/rouge/lexers/tcl.rb
 - lib/rouge/lexers/css.rb
 - lib/rouge/lexers/cpp.rb