rouge 0.5.4 → 1.1.0

data/lib/rouge.rb

@@ -49,3 +49,4 @@ load load_dir.join('rouge/themes/thankful_eyes.rb')
 load load_dir.join('rouge/themes/colorful.rb')
 load load_dir.join('rouge/themes/base16.rb')
 load load_dir.join('rouge/themes/github.rb')
+load load_dir.join('rouge/themes/monokai.rb')

data/lib/rouge/demos/moonscript

@@ -0,0 +1,16 @@
+util = require "my.module"
+
+a_table = {
+  foo: 'bar'
+  interpolated: "foo-#{other.stuff 2 + 3}"
+  "string": 2
+  do: 'keyword'
+}
+
+class MyClass extends SomeClass
+  new: (@init, arg2 = 'default') =>
+    @derived = @init + 2
+    super!
+
+  other: =>
+    @foo + 2

data/lib/rouge/demos/ruby

@@ -1,5 +1,5 @@
 class Greeter
-  def initialize(name = "World")
+  def initialize(name="World")
     @name = name
   end
 

data/lib/rouge/formatters/html.rb

@@ -19,8 +19,8 @@ module Rouge
       # the given theme will be inlined in "style" attributes.  This is
       # useful for formats in which stylesheets are not available.
       #
-      # Content will be wrapped in a `<pre>` tag with the given
-      # `:css_class` unless `:wrap` is set to `false`.
+      # Content will be wrapped in a tag (`div` if tableized, `pre` if
+      # not) with the given `:css_class` unless `:wrap` is set to `false`.
       def initialize(opts={})
         @css_class = opts.fetch(:css_class, 'highlight')
         @line_numbers = opts.fetch(:line_numbers, false)
@@ -65,10 +65,10 @@ module Rouge
 
         # generate a string of newline-separated line numbers for the gutter
         numbers = num_lines.times.map do |x|
-          %<<div class="lineno">#{x+1}</div>>
+          %<<pre class="lineno">#{x+1}</pre>>
         end.join
 
-        yield "<pre class=#{@css_class.inspect}>" if @wrap
+        yield "<div class=#{@css_class.inspect}>" if @wrap
         yield "<table><tbody><tr>"
 
         # the "gl" class applies the style for Generic.Lineno
@@ -77,11 +77,13 @@ module Rouge
         yield '</td>'
 
         yield '<td class="code">'
+        yield '<pre>'
         yield formatted
+        yield '</pre>'
         yield '</td>'
 
         yield '</tr></tbody></table>'
-        yield '</pre>' if @wrap
+        yield '</div>' if @wrap
       end
 
       def span(tok, val, &b)

data/lib/rouge/lexer.rb

@@ -17,6 +17,13 @@ module Rouge
         new(opts).lex(stream, &b)
       end
 
+      def load_const(const_name, relpath)
+        return if Lexers.const_defined?(const_name)
+
+        root = Pathname.new(__FILE__).dirname.join('lexers')
+        load root.join(relpath)
+      end
+
       def default_options(o={})
         @default_options ||= {}
         @default_options.merge!(o)

data/lib/rouge/lexers/cpp.rb

@@ -1,7 +1,7 @@
-require 'rouge/lexers/c'
-
 module Rouge
   module Lexers
+    Lexer.load_const :C, 'c.rb'
+
     class Cpp < C
       desc "The C++ programming language"
 

data/lib/rouge/lexers/lua.rb

@@ -1,27 +1,29 @@
+# -*- coding: utf-8 -*- #
+
 module Rouge
   module Lexers
     class Lua < RegexLexer
       desc "Lua (http://www.lua.org)"
       tag 'lua'
       filenames '*.lua', '*.wlua'
-      
+
       mimetypes 'text/x-lua', 'application/x-lua'
-      
+
       def initialize(opts={})
         @function_highlighting = opts.delete(:function_highlighting) { true }
         @disabled_modules = opts.delete(:disabled_modules) { [] }
         super(opts)
       end
-      
+
       def self.analyze_text(text)
         return 1 if text.shebang? 'lua'
       end
-      
+
       def self.builtins
         load Pathname.new(__FILE__).dirname.join('lua/builtins.rb')
         self.builtins
       end
-   
+
       def builtins
         return [] unless @function_highlighting
 
@@ -32,37 +34,37 @@ module Rouge
           end
         end
       end
-      
+
       state :root do
         # lua allows a file to start with a shebang
         rule %r(#!(.*?)$), Comment::Preproc
         rule //, Text, :base
       end
-                  
+
       state :base do
-        rule %r(--\[(=*)\[.*?\]\1\])ms, Comment::Multiline
+        rule %r(--\[(=*)\[.*?\]\1\])m, Comment::Multiline
         rule %r(--.*$), Comment::Single
-        
+
         rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
         rule %r((?i)\d+e[+-]?\d+), Num::Float
         rule %r((?i)0x[0-9a-f]*), Num::Hex
         rule %r(\d+), Num::Integer
-        
+
         rule %r(\n), Text
         rule %r([^\S\n]), Text
         # multiline strings
-        rule %r(\[(=*)\[.*?\]\1\])ms, Str
-        
+        rule %r(\[(=*)\[.*?\]\1\])m, Str
+
         rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), Operator
         rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
         rule %r((and|or|not)\b), Operator::Word
-        
+
         rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), Keyword
         rule %r((local)\b), Keyword::Declaration
         rule %r((true|false|nil)\b), Keyword::Constant
-        
+
         rule %r((function)\b), Keyword, :function_name
-        
+
         rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
           name = m[0]
           if self.builtins.include?(name)
@@ -76,11 +78,11 @@ module Rouge
             token Name
           end
         end
-        
+
         rule %r('), Str::Single, :escape_sqs
         rule %r("), Str::Double, :escape_dqs
       end
-      
+
       state :function_name do
         rule /\s+/, Text
         rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
@@ -90,36 +92,30 @@ module Rouge
         # inline function
         rule %r(\(), Punctuation, :pop!
       end
-      
+
       state :escape_sqs do
         mixin :string_escape
         mixin :sqs
       end
-      
+
       state :escape_dqs do
         mixin :string_escape
         mixin :dqs
       end
-      
+
       state :string_escape do
         rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
       end
-      
+
       state :sqs do
-        rule %r('), Str, :pop!
-        mixin :string
+        rule %r('), Str::Single, :pop!
+        rule %r([^']+), Str::Single
       end
-      
+
       state :dqs do
-        rule %r("), Str, :pop!
-        mixin :string
-      end
-      
-      # Lua is 8-bit clean, every character is valid in a string
-      state :string do
-        rule /./, Str
+        rule %r("), Str::Double, :pop!
+        rule %r([^"]+), Str::Double
       end
-      
     end
   end
 end

data/lib/rouge/lexers/moonscript.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    Lexer.load_const :Lua, 'lua.rb'
+
+    class Moonscript < RegexLexer
+      desc "Moonscript (http://www.moonscript.org)"
+      tag 'moonscript'
+      aliases 'moon'
+      filenames '*.moon'
+      mimetypes 'text/x-moonscript', 'application/x-moonscript'
+
+      def initialize(opts={})
+        @function_highlighting = opts.delete(:function_highlighting) { true }
+        @disabled_modules = opts.delete(:disabled_modules) { [] }
+        super(opts)
+      end
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'moon'
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          Rouge::Lexers::Lua.builtins.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        rule %r(#!(.*?)$), Comment::Preproc # shebang
+        rule //, Text, :main
+      end
+
+      state :base do
+        ident = '(?:[\w_][\w\d_]*)'
+
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
+        rule %r(@#{ident}*), Name::Variable::Instance
+        rule %r([A-Z][\w\d_]*), Name::Class
+        rule %r("?[^"]+":), Literal::String::Symbol
+        rule %r(#{ident}:), Literal::String::Symbol
+        rule %r(:#{ident}), Literal::String::Symbol
+
+        rule %r(\s+), Text::Whitespace
+        rule %r((==|~=|!=|<=|>=|\.\.\.|\.\.|->|=>|[=+\-*/%^<>#!\\])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
+
+        keywords = %w{
+          break class continue do else elseif end extends for if import in
+          repeat return switch super then unless until using when with while
+        }
+        rule %r((#{keywords.join('|')})\b), Keyword
+        rule %r((local|export)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
+
+        rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
+          name = m[0]
+          if self.builtins.include?(name)
+            token Name::Builtin
+          elsif name =~ /\./
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+      end
+
+      state :main do
+        rule %r(--.*$), Comment::Single
+        rule %r(\[(=*)\[.*?\]\1\])m, Str::Heredoc
+
+        mixin :base
+
+        rule %r('), Str::Single, :sqs
+        rule %r("), Str::Double, :dqs
+      end
+
+      state :sqs do
+        rule %r('), Str::Single, :pop!
+        rule %r([^']+), Str::Single
+      end
+
+      state :interpolation do
+        rule %r(\}), Str::Interpol, :pop!
+        mixin :base
+      end
+
+      state :dqs do
+        rule %r(#\{), Str::Interpol, :interpolation
+        rule %r("), Str::Double, :pop!
+        rule %r(#[^{]), Str::Double
+        rule %r([^"#]+), Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/objective_c.rb

@@ -1,7 +1,7 @@
-require 'rouge/lexers/c'
-
 module Rouge
   module Lexers
+    Lexer.load_const :C, 'c.rb'
+
     class ObjectiveC < C
       desc 'objective_c'
       tag 'objective_c'

data/lib/rouge/lexers/sass.rb

@@ -1,7 +1,7 @@
-require 'rouge/lexers/sass/common'
-
 module Rouge
   module Lexers
+    Lexer.load_const :SassCommon, 'sass/common.rb'
+
     class Sass < SassCommon
       include Indentation
 

data/lib/rouge/lexers/scss.rb

@@ -1,7 +1,7 @@
-require 'rouge/lexers/sass/common'
-
 module Rouge
   module Lexers
+    Lexer.load_const :SassCommon, 'sass/common.rb'
+
     class Scss < SassCommon
       desc "SCSS stylesheets (sass-lang.com)"
       tag 'scss'

data/lib/rouge/lexers/sml.rb

@@ -0,0 +1,115 @@
+module Rouge
+  module Lexers
+    class SML < RegexLexer
+      desc 'Standard ML'
+      tag 'sml'
+      aliases 'ml'
+      filenames '*.sml', '*.sig', '*.fun'
+
+      mimetypes 'text/x-standardml', 'application/x-standardml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abstype and andalso as case datatype do else end exception
+          fn fun handle if in infix infixr let local nonfix of op open
+          orelse raise rec then type val with withtype while
+          eqtype functor include sharing sig signature struct structure
+          where
+        )
+      end
+
+      id = /[a-z][\w']*/i
+      symbol = %r([!%&$#/:<=>?@\\~`^|*+-]+)
+
+      def self.analyze_text(text)
+        return 0
+      end
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule /[(][*]/, Comment, :comment
+      end
+
+      state :delimiters do
+        rule /[(\[{]/, Punctuation, :main
+        rule /[)\]}]/, Punctuation, :pop!
+
+        rule /\b(let|if|local)\b(?!')/, Keyword::Reserved do
+          push; push
+        end
+
+        rule /\b(struct|sig|while)\b(?!')/ do
+          token Keyword::Reserved
+          push
+        end
+
+        rule /\b(do|else|end|in|then)\b(?!')/, Keyword::Reserved, :pop!
+      end
+
+      def token_for_id_with_dot(id)
+        if self.class.keywords.include? id
+          Error
+        else
+          Name::Namespace
+        end
+      end
+
+      def token_for_final_id(id)
+        if self.class.keywords.include? id or self.class.symbolic_reserved.include? id
+          Error
+        else
+          Name
+        end
+      end
+
+      def token_for_id(id)
+        if self.class.keywords.include? id
+          Keyword::Reserved
+        elsif self.class.symbolic_reserved.include? id
+          Punctuation
+        else
+          Name
+        end
+      end
+
+      state :core do
+        rule /[()\[\]{},;_]|[.][.][.]/, Punctuation
+        rule /#"/, Str::Char, :char
+        rule /~?0x[0-9a-fA-F]+/, Num::Hex
+        rule /0wx[0-9a-fA-F]+/, Num::Hex
+        rule /0w\d+/, Num::Integer
+        rule /~?\d+[.]\d+[eE]~?\d+/, Num::Float
+        rule /~?\d+[.]\d+/, Num::Float
+        rule /~?\d+/, Num::Integer
+
+        rule /#\s*[1-9][0-9]*/, Name::Label
+        rule /#\s*#{id}/, Name::Label
+        rule /#\s+#{symbol}/, Name::Label
+
+        rule /\b(datatype|abstype)\b(?!')/, Keyword::Reserved, :dname
+        rule(/(?=\bexception\b(?!'))/) { push :ename }
+        rule /\b(functor|include|open|signature|structure)\b(?!')/,
+          Keyword::Reserved, :sname
+        rule /\b(type|eqtype)\b(?!')/, Keyword::Reserved, :tname
+
+        rule /'#{id}/, Name::Decorator
+        rule /(#{id})([.])/ do |m|
+          groups(token_for_id_with_dot(m[1]), Punctuation)
+          push :dotted
+        end
+
+        state :dotted do
+          rule /(#{id})([.])/ do |m|
+            groups(token_for_id_with_dot(m[1]), Punctuation)
+          end
+        end
+      end
+
+      state :root do
+        rule /#!.*?\n/, Comment::Preproc
+        rule(//) { push :main }
+      end
+    end
+  end
+end
+

data/lib/rouge/regex_lexer.rb

@@ -290,7 +290,7 @@ module Rouge
     MAX_NULL_SCANS = 5
 
     # @private
-    def run_rule(rule, scanner, &b)
+    def run_rule(rule, scanner)
       # XXX HACK XXX
       # StringScanner's implementation of ^ is b0rken.
       # see http://bugs.ruby-lang.org/issues/7092

data/lib/rouge/theme.rb

@@ -142,6 +142,7 @@ module Rouge
       # shared styles for tableized line numbers
       yield "#{@scope} table { border-spacing: 0; }"
       yield "#{@scope} table td { padding: 5px; }"
+      yield "#{@scope} table pre { margin: 0; }"
       yield "#{@scope} table .gutter { text-align: right; }"
 
       styles.each do |tok, style|

data/lib/rouge/themes/monokai.rb

@@ -0,0 +1,86 @@
+module Rouge
+  module Themes
+    class Monokai < CSSTheme
+      name 'monokai'
+
+      palette :black          => '#000000'
+      palette :bright_green   => '#a6e22e'
+      palette :bright_pink    => '#f92672'
+      palette :carmine        => '#960050'
+      palette :dark           => '#49483e'
+      palette :dark_grey      => '#888888'
+      palette :dark_red       => '#aa0000'
+      palette :dimgrey        => '#75715e'
+      palette :emperor        => '#555555'
+      palette :grey           => '#999999'
+      palette :light_grey     => '#aaaaaa'
+      palette :light_violet   => '#ae81ff'
+      palette :soft_cyan      => '#66d9ef'
+      palette :soft_yellow    => '#e6db74'
+      palette :very_dark      => '#1e0010'
+      palette :whitish        => '#f8f8f2'
+
+      style Comment,
+            Comment::Multiline,
+            Comment::Single,                  :fg => :dimgrey, :italic => true
+      style Comment::Preproc,                 :fg => :dimgrey, :bold => true
+      style Comment::Special,                 :fg => :dimgrey, :italic => true, :bold => true
+      style Error,                            :fg => :carmine, :bg => :very_dark
+      style Generic::Deleted,
+            Generic::Inserted,                :fg => :black
+      style Generic::Emph,                    :fg => :black, :italic => true
+      style Generic::Error,
+            Generic::Traceback,               :fg => :dark_red
+      style Generic::Heading,                 :fg => :grey
+      style Generic::Output,                  :fg => :dark_grey
+      style Generic::Prompt,                  :fg => :emperor
+      style Generic::Strong,                  :bold => true
+      style Generic::Subheading,              :fg => :light_grey
+      style Keyword,
+            Keyword::Constant,
+            Keyword::Declaration,
+            Keyword::Pseudo,
+            Keyword::Reserved,
+            Keyword::Type,                    :fg => :soft_cyan, :bold => true
+      style Keyword::Namespace,
+            Operator::Word,
+            Operator,                         :fg => :bright_pink, :bold => true
+      style Literal::Number::Float,
+            Literal::Number::Hex,
+            Literal::Number::Integer::Long,
+            Literal::Number::Integer,
+            Literal::Number::Oct,
+            Literal::Number,
+            Literal::String::Escape,          :fg => :light_violet
+      style Literal::String::Backtick,
+            Literal::String::Char,
+            Literal::String::Doc,
+            Literal::String::Double,
+            Literal::String::Heredoc,
+            Literal::String::Interpol,
+            Literal::String::Other,
+            Literal::String::Regex,
+            Literal::String::Single,
+            Literal::String::Symbol,
+            Literal::String,                  :fg => :soft_yellow
+      style Name::Attribute,                  :fg => :bright_green
+      style Name::Class,
+            Name::Decorator,
+            Name::Exception,
+            Name::Function,                   :fg => :bright_green, :bold => true
+      style Name::Constant,                   :fg => :soft_cyan
+      style Name::Builtin::Pseudo,
+            Name::Builtin,
+            Name::Entity,
+            Name::Namespace,
+            Name::Variable::Class,
+            Name::Variable::Global,
+            Name::Variable::Instance,
+            Name::Variable,
+            Text::Whitespace,                 :fg => :whitish
+      style Name::Label,                      :fg => :whitish, :bold => true
+      style Name::Tag,                        :fg => :bright_pink
+      style Text,                             :fg => :whitish, :bg => :dark
+    end
+  end
+end

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "0.5.4"
+    "1.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-22 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -36,6 +36,7 @@ files:
 - lib/rouge/themes/thankful_eyes.rb
 - lib/rouge/themes/base16.rb
 - lib/rouge/themes/github.rb
+- lib/rouge/themes/monokai.rb
 - lib/rouge/themes/colorful.rb
 - lib/rouge/text_analyzer.rb
 - lib/rouge/regex_lexer.rb
@@ -60,6 +61,7 @@ files:
 - lib/rouge/lexers/viml/keywords.rb
 - lib/rouge/lexers/css.rb
 - lib/rouge/lexers/toml.rb
+- lib/rouge/lexers/moonscript.rb
 - lib/rouge/lexers/puppet.rb
 - lib/rouge/lexers/ruby.rb
 - lib/rouge/lexers/http.rb
@@ -82,6 +84,7 @@ files:
 - lib/rouge/lexers/viml.rb
 - lib/rouge/lexers/java.rb
 - lib/rouge/lexers/common_lisp.rb
+- lib/rouge/lexers/sml.rb
 - lib/rouge/lexers/scheme.rb
 - lib/rouge/lexers/haml.rb
 - lib/rouge/lexers/erb.rb
@@ -103,6 +106,7 @@ files:
 - lib/rouge.rb
 - bin/rougify
 - lib/rouge/demos/erlang
+- lib/rouge/demos/moonscript
 - lib/rouge/demos/sass
 - lib/rouge/demos/ruby
 - lib/rouge/demos/factor
@@ -140,6 +144,7 @@ files:
 - lib/rouge/demos/sed
 - lib/rouge/demos/common_lisp
 - lib/rouge/demos/groovy
+- lib/rouge/demos/sml
 - lib/rouge/demos/nginx
 - lib/rouge/demos/toml
 - lib/rouge/demos/gherkin