rouge 1.5.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2656f650042e999c8fd16e15a9d440ea6f2bd11
-  data.tar.gz: dcaba0c54bd59cdcdd6d7cc97fcddc97d2ea9aca
+  metadata.gz: 5d3e680acd54b6dc00269cb0a68721463fa898e6
+  data.tar.gz: 704addb88b523c80da72a59db3999e01ac502282
 SHA512:
-  metadata.gz: d415e5ccd9ebd832db005db83307a700820cb28dea57e17c69ae69a947e9075d5e68809c61f74f5c9b7ef1c1a6b168dc8d62ae2fb10dd1d34df42bddf219f069
-  data.tar.gz: 9db1da0a9913088718d1c0d4759c7923fad6defa487980f713ce135a08fb2f6b2fd77147b900d1a52cee1419f1ebb34d750d57737e7aa0a1aa9e89d2ce882061
+  metadata.gz: d5ac2591c06af1cc03516c314af662998dce6de22cf97be2b021f72e9aaa897c3662e01085c97cb806dfcea3737c7ca7d899dc194969438250eb3af4daa44367
+  data.tar.gz: 031632f8628d96c61f4ad3ce771f32676a0021a00cfa35c7521d3849085669b43a7a1cf5174efcf7fd148310a0ba84f03e66fa14fcce558e9268d429f6043a2c

data/lib/rouge/demos/slim

@@ -0,0 +1,17 @@
+doctype html
+html
+  body
+    h1 Markup examples   
+    #content
+      p 
+      | Slim can have #{ruby_code} interpolated!
+      /[if IE]
+        javascript:
+          alert('Slim supports embedded javascript!')
+
+      - unless items.empty?
+        table
+          - for item in items do
+            tr
+              td.name = item.name
+              td.price = item.price

data/lib/rouge/lexers/common_lisp.rb

@@ -274,7 +274,7 @@ module Rouge
         end
 
         # path
-        rule /#p?"(\\.|[^"])*"/i
+        rule /#p?"(\\.|[^"])*"/i, Str::Symbol
 
         # reference
         rule /#\d+[=#]/, Operator

data/lib/rouge/lexers/haml.rb

@@ -205,11 +205,18 @@ module Rouge
       end
 
       state :interpolation do
-        rule /(#\{)(#{dot}*?)(\})/ do |m|
-          token Str::Interpol, m[1]
-          delegate ruby, m[2]
-          token Str::Interpol, m[3]
-        end
+        rule /#[{]/, Str::Interpol, :ruby
+      end
+
+      state :ruby do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_inner
+      end
+
+      state :ruby_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
       end
 
       state :indented_block do

data/lib/rouge/lexers/javascript.rb

@@ -20,30 +20,61 @@ module Rouge
       state :comments_and_whitespace do
         rule /\s+/, Text
         rule /<!--/, Comment # really...?
-        rule %r(//.*?\n), Comment::Single
+        rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
       end
 
-      state :slash_starts_regex do
+      state :expr_start do
         mixin :comments_and_whitespace
 
-        rule %r(
-          / # opening slash
-          ( \\. # escape sequences
-          | [^/\\\n] # regular characters
-          | \[ (\\. | [^\]\\\n])* \] # character classes
-          )+
-          / # closing slash
-          (?:[gim]+\b|\B) # flags
-        )x, Str::Regex, :pop!
-
-        # if it's not matched by the above r.e., it's not
-        # a valid expression, so we use :bad_regex to eat until the
-        # end of the line.
-        rule %r(/), Str::Regex, :bad_regex
+        rule %r(/) do
+          token Str::Regex
+          goto :regex
+        end
+
+        rule /[{]/, Punctuation, :object
+
         rule //, Text, :pop!
       end
 
+      state :regex do
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r([^/]\n), Error, :pop!
+
+        rule /\n/, Error, :pop!
+        rule /\[\^/, Str::Escape, :regex_group
+        rule /\[/, Str::Escape, :regex_group
+        rule /\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule /[{][\d,]+[}]/, Str::Escape
+        rule /[()?]/, Str::Escape
+        rule /./, Str::Regex
+      end
+
+      state :regex_end do
+        rule /[gim]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        # specially highlight / in a group to indicate that it doesn't
+        # close the regex
+        rule /\//, Str::Escape
+
+        rule %r([^/]\n) do
+          token Error
+          pop! 2
+        end
+
+        rule /\]/, Str::Escape, :pop!
+        rule /\\./, Str::Escape
+        rule /./, Str::Regex
+      end
+
       state :bad_regex do
         rule /[^\n]+/, Error, :pop!
       end
@@ -86,37 +117,33 @@ module Rouge
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule /\A\s*#!.*?\n/m, Comment::Preproc
-        rule %r((?<=\n)(?=\s|/|<!--)), Text, :slash_starts_regex
+        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule /\n/, Text, :statement
+        rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
         mixin :comments_and_whitespace
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
-          Operator, :slash_starts_regex
-        rule %r([-<>+*%&|\^/!=]=?), Operator, :slash_starts_regex
-        rule /[(\[;,]/, Punctuation, :slash_starts_regex
+          Operator, :expr_start
+        rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
+        rule /[(\[,]/, Punctuation, :expr_start
+        rule /;/, Punctuation, :statement
         rule /[)\].]/, Punctuation
 
         rule /[?]/ do
           token Punctuation
           push :ternary
-          push :slash_starts_regex
+          push :expr_start
         end
 
-        rule /[{](?=\s*(#{id}|"[^\n]*?")\s*:)/m, Punctuation, :object
-
-        rule /[{]/ do
-          token Punctuation
-          push :block
-          push :slash_starts_regex
-        end
+        rule /[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
             token Keyword
-            push :slash_starts_regex
+            push :expr_start
           elsif self.class.declarations.include? m[0]
             token Keyword::Declaration
-            push :slash_starts_regex
+            push :expr_start
           elsif self.class.reserved.include? m[0]
             token Keyword::Reserved
           elsif self.class.constants.include? m[0]
@@ -136,28 +163,38 @@ module Rouge
       end
 
       # braced parts that aren't object literals
-      state :block do
+      state :statement do
         rule /(#{id})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
         end
 
-        rule /[}]/, Punctuation, :pop!
-        mixin :root
+        mixin :expr_start
       end
 
       # object literals
       state :object do
-        rule /[}]/, Punctuation, :pop!
+        mixin :comments_and_whitespace
+        rule /[}]/ do
+          token Punctuation
+          goto :statement
+        end
+
         rule /(#{id})(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
+          push :expr_start
         end
+
         rule /:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/, Punctuation, :pop!
+        rule /:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
         mixin :root
       end
     end

data/lib/rouge/lexers/objective_c.rb

@@ -46,7 +46,7 @@ module Rouge
 
       prepend :statements do
         rule /@"/, Str, :string
-        rule /@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/
+        rule /@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
           Str::Char
         rule /@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
           Num::Float

data/lib/rouge/lexers/php.rb

@@ -72,7 +72,7 @@ module Rouge
         rule /#.*?\n/, Comment::Single
         rule %r(//.*?\n), Comment::Single
         # empty comment, otherwise seen as the start of a docstring
-        rule %r(/\*\*/)
+        rule %r(/\*\*/), Comment::Multiline
         rule %r(/\*\*.*?\*/)m, Str::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
         rule /(->|::)(\s*)([a-zA-Z_][a-zA-Z0-9_]*)/ do

data/lib/rouge/lexers/qml.rb

@@ -22,6 +22,8 @@ module Rouge
           groups Keyword::Type, Text, Keyword, Text, Name::Label, Text, Punctuation
           push :type_block
         end
+
+        rule /[{]/, Punctuation, :push
       end
 
       state :type_block do
@@ -31,7 +33,7 @@ module Rouge
 
         rule /(#{id_with_dots})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
-          push :slash_starts_regex
+          push :expr_start
         end
 
         rule /(signal)(\s+)(#{id_with_dots})/ do
@@ -41,7 +43,7 @@ module Rouge
 
         rule /(property)(\s+)(#{id_with_dots})(\s+)(#{id_with_dots})(\s*)(:?)/ do
           groups Keyword::Declaration, Text, Keyword::Type, Text, Name::Label, Text, Punctuation
-          push :slash_starts_regex
+          push :expr_start
         end
 
         rule /[}]/, Punctuation, :pop!

data/lib/rouge/lexers/slim.rb

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    # A lexer for the Slim tempalte language
+    # @see http://slim-lang.org
+    class Slim < RegexLexer
+      include Indentation
+
+      desc 'The Slim template language'
+
+      tag 'slim'
+
+      filenames '*.slim'
+
+      # Ruby identifier characters
+      ruby_chars = /[\w\!\?\@\$]/
+
+      # Since you are allowed to wrap lines with a backslash, include \\\n in characters
+      dot = /(\\\n|.)/
+
+      def self.analyze_text(text)
+        return 1 if text.start_with? 'doctype'
+        return 1 if text =~ /(\*)(\{.+?\})/ # Contans a hash splat
+      end
+
+      def ruby
+        @ruby ||= Ruby.new(options)
+      end
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      def filters
+        @filters ||= {
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'coffee' => Coffeescript.new(options),
+          'markdown' => Markdown.new(options),
+          'scss' => Scss.new(options),
+          'sass' => Sass.new(options)
+        }
+      end
+
+      state :root do
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+
+        rule /\/#{dot}*/, Comment, :indented_block
+
+        rule /(doctype)(\s+)(.*)/ do
+          groups Name::Namespace, Text::Whitespace, Text
+          pop!
+        end
+
+        # filters, shamelessly ripped from HAML
+        rule /(\w*):\s*\n/ do |m|
+          token Name::Decorator
+          pop!
+          starts_block :filter_block
+
+          filter_name = m[1].strip
+
+          @filter_lexer = self.filters[filter_name]
+          @filter_lexer.reset! unless @filter_lexer.nil?
+
+          puts "    slim: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        # Text
+        rule %r([\|'](?=\s)) do
+          token Punctuation
+          pop!
+          starts_block :plain_block
+          goto :plain_block
+        end
+
+        rule /-|==|=/, Punctuation, :ruby_line
+
+        # Dynamic tags
+        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        #rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+          pop!
+        end
+
+        # Ordinary slim tags
+        rule /\w+/, Name::Tag, :tag
+
+      end
+
+      state :tag do
+        mixin :css
+        mixin :indented_block
+        mixin :interpolation
+
+        # Whitespace control
+        rule /[<>]/, Punctuation
+
+        # Trim whitespace
+        rule /\s+?/, Text::Whitespace
+
+        # Splats, these two might be mergable?
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        rule /(\*)(\{#{dot}+?\})/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        # Attributes
+        rule /([\w\-]+)(\s*)(\=)/ do |m|
+          token Name::Attribute, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :html_attr
+        end
+
+        # Ruby value
+        rule /(\=)(#{dot}+)/ do |m|
+          token Punctuation, m[1]
+          #token Keyword::Constant, m[2]
+          delegate ruby, m[2]
+        end
+
+        rule /#{dot}+?/, Text
+
+        rule /\s*\n/, Text::Whitespace, :pop!
+      end
+
+      state :css do
+        rule(/\.\w+/) { token Name::Class; goto :tag }
+        rule(/#\w+/) { token Name::Function; goto :tag }
+      end
+
+      state :html_attr do
+        # Strings, double/single quoted
+        rule %r(\s*(['"])#{dot}*\1), Literal::String, :pop!
+
+        # Ruby stuff
+        rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
+        rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
+
+        rule /\s+/, Text::Whitespace
+      end
+
+      state :ruby_line do
+        # Need at top
+        mixin :indented_block
+
+        rule(/,\s*\n/) { delegate ruby }
+        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :filter_block do
+        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :plain_block do
+        mixin :interpolation
+
+        rule %r((</?[\w\s\=\'\"]+?/?>)) do |m| # Dirty html
+          delegate html, m[1]
+        end
+
+        #rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule /#{dot}+?/, Text
+
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule /#[{]/, Str::Interpol, :ruby_interp
+      end
+
+      state :ruby_interp do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_interp_inner
+      end
+
+      state :ruby_interp_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_interp_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
+      end
+
+      state :indented_block do
+        rule(/(?<!\\)\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end

data/lib/rouge/regex_lexer.rb

@@ -93,6 +93,10 @@ module Rouge
       #   {RegexLexer#token}, and {RegexLexer#delegate}.  The first
       #   argument can be used to access the match groups.
       def rule(re, tok=nil, next_state=nil, &callback)
+        if tok.nil? && callback.nil?
+          raise "please pass `rule` a token to yield or a callback"
+        end
+
         callback ||= case next_state
         when :pop!
           proc do |stream|
@@ -103,6 +107,8 @@ module Rouge
           end
         when :push
           proc do |stream|
+            puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
+            @output_stream.call(tok, stream[0])
             puts "    pushing #{@stack.last.name}" if @debug
             @stack.push(@stack.last)
           end
@@ -114,11 +120,13 @@ module Rouge
             puts "    pushing #{state.name}" if @debug
             @stack.push(state)
           end
-        else
+        when nil
           proc do |stream|
             puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
           end
+        else
+          raise "invalid next state: #{next_state.inspect}"
         end
 
         rules << Rule.new(re, callback)

data/lib/rouge/version.rb

@@ -2,6 +2,6 @@
 
 module Rouge
   def self.version
-    "1.5.1"
+    "1.6.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.1
 platform: ruby
 authors:
 - Jay Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-13 00:00:00.000000000 Z
+date: 2014-07-26 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -79,6 +79,7 @@ files:
 - lib/rouge/demos/scss
 - lib/rouge/demos/sed
 - lib/rouge/demos/shell
+- lib/rouge/demos/slim
 - lib/rouge/demos/smalltalk
 - lib/rouge/demos/sml
 - lib/rouge/demos/sql
@@ -155,6 +156,7 @@ files:
 - lib/rouge/lexers/scss.rb
 - lib/rouge/lexers/sed.rb
 - lib/rouge/lexers/shell.rb
+- lib/rouge/lexers/slim.rb
 - lib/rouge/lexers/smalltalk.rb
 - lib/rouge/lexers/sml.rb
 - lib/rouge/lexers/sql.rb