rouge 0.0.8 → 0.0.9

data/lib/rouge.rb

@@ -30,6 +30,10 @@ load load_dir.join('rouge/lexers/python.rb')
 
 load load_dir.join('rouge/lexers/haskell.rb')
 
+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/formatter.rb')
 load load_dir.join('rouge/formatters/html.rb')
 

data/lib/rouge/lexer.rb

@@ -307,18 +307,24 @@ module Rouge
         stack.last
       end
 
-      MAX_STEPS = 200000
+      MAX_NULL_STEPS = 5
       def scan(re, &b)
-        @steps ||= 0
-        @steps += 1
+        @null_steps ||= 0
 
-        if @steps >= MAX_STEPS
-          raise "too many scans near: #{scanner.peek(20)}..."
+        if @null_steps >= MAX_NULL_STEPS
+          debug { "    too many scans without consuming the string!" }
+          return false
         end
 
         scanner.scan(re)
 
         if scanner.matched?
+          if scanner.matched_size == 0
+            @null_steps += 1
+          else
+            @null_steps = 0
+          end
+
           yield self
           return true
         end

data/lib/rouge/lexers/c.rb

@@ -0,0 +1,143 @@
+module Rouge
+  module Lexers
+    class C < RegexLexer
+      tag 'c'
+      filenames '*.c', '*.h', '*.idc'
+      mimetypes 'text/x-chdr', 'text/x-csrc'
+
+      # optional comment or whitespace
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      keywords = %w(
+        auto break case const continue default do else enum extern
+        for goto if register restricted return sizeof static struct
+        switch typedef union volatile virtual while
+      )
+
+      keywords_type = %w(int long float short double char unsigned signed void)
+
+      __reserved = %w(
+        asm int8 based except int16 stdcall cdecl fastcall int32
+        declspec finally int61 try leave
+      )
+
+      state :whitespace do
+        rule /^#if\s+0\b/, 'Comment.Preproc', :if_0
+        rule /^#/, 'Comment.Preproc', :macro
+        rule /^#{ws}#if\s+0\b/, 'Comment.Preproc', :if_0
+        rule /^#{ws}#/, 'Comment.Preproc', :macro
+        rule /^(\s*)(#{id}:(?!:))/ do
+          group 'Text'
+          group 'Name.Label'
+        end
+
+        rule /\s+/m, 'Text'
+        rule /\\\n/, 'Text' # line continuation
+        rule %r(//(\n|(.|\n)*?[^\\]\n)), 'Comment.Single'
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), 'Comment.Multiline'
+      end
+
+      state :statements do
+        rule /L?"/, 'Literal.String', :string
+        rule %r(L?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, 'Literal.String.Char'
+        rule %r((\d+\.\d*|\.\d+|\d+)[e][+-]?\d+[lu]*)i, 'Literal.Number.Float'
+        rule /0x[0-9a-f]+[lu]*/i, 'Literal.Number.Hex'
+        rule /0[0-7]+[lu]*/i, 'Literal.Number.Oct'
+        rule /\d+[lu]*/i, 'Literal.Number.Integer'
+        rule %r(\*/), 'Error'
+        rule %r([~!%^&*+=\|?:<>/-]), 'Operator'
+        rule /[()\[\],.]/, 'Punctuation'
+        rule /\bcase\b/, 'Keyword', :case
+        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /(?:#{keywords_type.join('|')})\b/, 'Keyword.Type'
+        rule /(?:_{0,2}inline|naked|restrict|thread|typename)\b/, 'Keyword.Reserved'
+        rule /__(?:#{__reserved.join('|')})\b/, 'Keyword.Reserved'
+        rule /(?:true|false|NULL)\b/, 'Name.Builtin'
+        rule id, 'Name'
+      end
+
+      state :case do
+        rule /:/, 'Punctuation', :pop!
+        mixin :statements
+      end
+
+      state :root do
+        mixin :whitespace
+
+        # functions
+        rule %r(
+          ([\w*\s]+?[\s*]) # return arguments
+          (#{id})          # function name
+          (\s*\([^;]*?\))  # signature
+          (#{ws})({)         # open brace
+        )mx do |m|
+          # TODO: do this better.
+          delegate C, m[1]
+          token 'Name.Function', m[2]
+          delegate C, m[3]
+          delegate C, m[4]
+          token 'Punctuation', m[5]
+          push :function
+        end
+
+        # function declarations
+        rule %r(
+          ([\w*\s]+?[\s*]) # return arguments
+          (#{id})          # function name
+          (\s*\([^;]*?\))  # signature
+          (#{ws})(;)       # semicolon
+        )mx do |m|
+          # TODO: do this better.
+          delegate C, m[1]
+          token 'Name.Function'
+          delegate C, m[3]
+          delegate C, m[4]
+          token 'Punctuation'
+          push :statement
+        end
+
+        rule(//) { push :statement }
+      end
+
+      state :statement do
+        rule /;/, 'Punctuation', :pop!
+        mixin :whitespace
+        mixin :statements
+        rule /[{}]/, 'Punctuation'
+      end
+
+      state :function do
+        mixin :whitespace
+        mixin :statements
+        rule /;/, 'Punctuation'
+        rule /{/, 'Punctuation', :function
+        rule /}/, 'Punctuation', :pop!
+      end
+
+      state :string do
+        rule /"/, 'Literal.String', :pop!
+        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, 'Literal.String.Escape'
+        rule /[^\\"\n]+/, 'Literal.String'
+        rule /\\\n/, 'Literal.String'
+        rule /\\/, 'Literal.String' # stray backslash
+      end
+
+      state :macro do
+        rule %r([^/\n]+), 'Comment.Preproc'
+        rule %r(/[*].*?[*]/)m, 'Comment.Multiliine'
+        rule %r(//.*$), 'Comment.Single'
+        rule %r(/), 'Comment.Preproc'
+        rule /(?<=\\)\n/, 'Comment.Preproc'
+        rule /\n/, 'Comment.Preproc', :pop!
+      end
+
+      state :if_0 do
+        rule /^\s*#if.*?(?<!\\)\n/, 'Comment.Preproc', :if_0
+        rule /^\s*#el(?:se|if).*\n/, 'Comment.Preproc', :pop!
+        rule /^\s*#endif.*?(?<!\\)\n/, 'Comment.Preproc', :pop!
+        rule /.*?\n/, 'Comment'
+      end
+    end
+  end
+end

data/lib/rouge/lexers/cpp.rb

@@ -0,0 +1,109 @@
+module Rouge
+  module Lexers
+    class Cpp < RegexLexer
+      tag 'cpp'
+      aliases 'c++'
+      # the many varied filenames of c++ source files...
+      filenames '*.cpp', '*.hpp',
+                '*.c++', '*.h++',
+                '*.cc',  '*.hh',
+                '*.cxx', '*.hxx'
+      mimetypes 'text/x-c++hdr', 'text/x-c++src'
+
+      keywords = %w(
+        asm auto break case catch const const_cast continue
+        default delete do dynamic_cast else enum explicit export
+        extern for friend goto if mutable namespace new operator
+        private protected public register reinterpret_cast return
+        restrict sizeof static static_cast struct switch template
+        this throw throws try typedef typeid typename union using
+        volatile virtual while
+      )
+
+      keywords_type = %w(
+        bool int long float short double char unsigned signed void wchar_t
+      )
+
+      __reserved = %w(
+        asm int8 based except int16 stdcall cdecl fastcall int32 declspec
+        finally int64 try leave wchar_t w64 virtual_inheritance uuidof
+        unaligned super single_inheritance raise noop multiple_inheritance
+        m128i m128d m128 m64 interface identifier forceinline event assume
+      )
+
+      # optional comments or whitespace
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      id = /[a-zA-Z_][a-zA-Z0-9]*/
+
+      state :whitespace do
+        rule /^#if\s+0/, 'Comment.Preproc', :if_0
+        rule /^#/, 'Comment.Preproc', :macro
+        rule /^#{ws}#if\s+0\b/, 'Comment.Preproc', :if_0
+        rule /^#{ws}#/, 'Comment.Preproc', :macro
+        rule /\s+/m, 'Text'
+        rule /\\\n/, 'Text'
+        rule %r(/(\\\n)?/(\n|(.|\n)*?[^\\]\n)), 'Comment.Single'
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), 'Comment.Multiline'
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule /L?"/, 'Literal.String', :string
+        rule %r(L?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, 'Literal.String.Char'
+        rule %r((\d+\.\d*|\.\d+|\d+)[e][+-]?\d+[lu]*)i, 'Literal.Number.Float'
+        rule /0x[0-9a-f]+[lu]*/i, 'Literal.Number.Hex'
+        rule /0[0-7]+[lu]*/i, 'Literal.Number.Oct'
+        rule /\d+[lu]*/i, 'Literal.Number.Integer'
+        rule %r(\*/), 'Error'
+        rule %r([~!%^&*+=\|?:<>/-]), 'Operator'
+        rule /[()\[\],.;{}]/, 'Punctuation'
+
+        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /class\b/, 'Keyword', :classname
+        rule /(?:#{keywords_type.join('|')})\b/, 'Keyword.Type'
+        rule /(?:_{0,2}inline|naked|thread)\b/, 'Keyword.Reserved'
+        rule /__(?:#{__reserved.join('|')})\b/, 'Keyoword.Reserved'
+        # Offload C++ extensions, http://offload.codeplay.com/
+        rule /(?:__offload|__blockingoffload|__outer)\b/, 'Keyword.Pseudo'
+
+        rule /(true|false)\b/, 'Keyword.Constant'
+        rule /NULL\b/, 'Name.Builtin'
+        rule /#{id}:(?!:)/, 'Name.Label'
+        rule id, 'Name'
+      end
+
+      state :classname do
+        rule id, 'Name.Class', :pop!
+
+        # template specification
+        rule /\s*(?=>)/m, 'Text', :pop!
+        mixin :whitespace
+      end
+
+      state :string do
+        rule /"/, 'Literal.String', :pop!
+        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, 'Literal.String.Escape'
+        rule /[^\\"\n]+/, 'Literal.String'
+        rule /\\\n/, 'Literal.String'
+        rule /\\/, 'Literal.String' # stray backslash
+      end
+
+      state :macro do
+        rule %r([^/\n]+), 'Comment.Preproc'
+        rule %r(/[*].*?[*]/)m, 'Comment.Multiliine'
+        rule %r(//.*$), 'Comment.Single'
+        rule %r(/), 'Comment.Preproc'
+        rule /(?<=\\)\n/, 'Comment.Preproc'
+        rule /\n/, 'Comment.Preproc', :pop!
+      end
+
+      state :if_0 do
+        rule /^\s*#if.*?(?<!\\)\n/, 'Comment.Preproc', :if_0
+        rule /^\s*#el(?:se|if).*\n/, 'Comment.Preproc', :pop!
+        rule /^\s*#endif.*?(?<!\\)\n/, 'Comment.Preproc', :pop!
+        rule /.*?\n/, 'Comment'
+      end
+    end
+  end
+end

data/lib/rouge/lexers/java.rb

@@ -0,0 +1,72 @@
+module Rouge
+  module Lexers
+    class Java < RegexLexer
+      tag 'java'
+      filenames '*.java'
+      mimetypes 'text/x-java'
+
+      keywords = %w(
+        assert break case catch continue default do else finally for
+        if goto instanceof new return switch this throw try while
+      )
+
+      declarations = %w(
+        abstract const enum extends final implements native private protected
+        public static strictfp super synchronized throws transient volatile
+      )
+
+      types = %w(boolean byte char double float int long short void)
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule %r(^
+          (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]]*\s+)+?) # return arguments
+          ([a-zA-Z_][a-zA-Z0-9_]*)                  # method name
+          (\s*)(\()                                 # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Java, m[1]
+          token 'Name.Function', m[2]
+          token 'Text', m[3]
+          token 'Punctuation', m[4]
+        end
+
+        rule /\s+/, 'Text'
+        rule %r(//.*?$), 'Comment.Single'
+        rule %r(/\*.*?\*/)m, 'Comment.Multiline'
+        rule /@#{id}/, 'Name.Decorator'
+        rule /(?:#{keywords.join('|')})\b/, 'Keyword'
+        rule /(?:#{declarations.join('|')})\b/, 'Keyword.Declaration'
+        rule /(?:#{types.join('|')})/, 'Keyword.Type'
+        rule /package\b/, 'Keyword.Namespace'
+        rule /(?:true|false|null)\b/, 'Keyword.Constant'
+        rule /(?:class|interface)\b/, 'Keyword.Declaration', :class
+        rule /import\b/, 'Keyword.Namespace', :import
+        rule /"(\\\\|\\"|[^"])*"/, 'Literal.String'
+        rule /'(?:\\.|[^\\]|\\u[0-9a-f]{4})'/, 'Literal.String.Char'
+        rule /(\.)(#{id})/ do
+          group 'Operator'
+          group 'Name.Attribute'
+        end
+        rule /#{id}:/, 'Name.Label'
+        rule /\$?#{id}/, 'Name'
+        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, 'Operator'
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[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+/m, 'Text'
+        rule id, 'Name.Class', :pop!
+      end
+
+      state :import do
+        rule /\s+/m, 'Text'
+        rule /[a-z0-9_.]+\*?/i, 'Name.Namespace', :pop!
+      end
+    end
+  end
+end

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "0.0.8"
+    "0.0.9"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-07 00:00:00.000000000 Z
+date: 2012-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -41,10 +41,13 @@ files:
 - lib/rouge/lexers/javascript.rb
 - lib/rouge/lexers/diff.rb
 - lib/rouge/lexers/haskell.rb
+- lib/rouge/lexers/c.rb
 - lib/rouge/lexers/text.rb
 - lib/rouge/lexers/html.rb
+- lib/rouge/lexers/java.rb
 - lib/rouge/lexers/tcl.rb
 - lib/rouge/lexers/css.rb
+- lib/rouge/lexers/cpp.rb
 - lib/rouge/plugins/redcarpet.rb
 - lib/rouge/themes/thankful_eyes.rb
 - lib/rouge/themes/colorful.rb