rouge 2.0.5 → 2.0.6

data/lib/rouge/lexers/jsx.rb

@@ -0,0 +1,101 @@
+module Rouge
+  module Lexers
+    load_lexer 'javascript.rb'
+
+    class JSX < Javascript
+      desc 'jsx'
+      tag 'jsx'
+      aliases 'jsx', 'react'
+      filenames '*.jsx'
+
+      mimetypes 'text/x-jsx', 'application/x-jsx'
+
+      id = Javascript.id_regex
+
+      def start_embed!
+        @embed ||= JSX.new(options)
+        @embed.reset!
+        @embed.push(:expr_start)
+        push :jsx_embed_root
+      end
+
+      def tag_token(name)
+        name[0] =~ /\p{Lower}/ ? Name::Tag : Name::Class
+      end
+
+      start { @html = HTML.new(options) }
+
+      state :jsx_tags do
+        rule /</, Punctuation, :jsx_element
+      end
+
+      state :jsx_internal do
+        rule %r(</) do
+          token Punctuation
+          goto :jsx_end_tag
+        end
+
+        rule /{/ do
+          token Str::Interpol
+          start_embed!
+        end
+
+        rule /[^<>{]+/ do
+          delegate @html
+        end
+
+        mixin :jsx_tags
+      end
+
+      prepend :expr_start do
+        mixin :jsx_tags
+      end
+
+      state :jsx_tag do
+        mixin :comments_and_whitespace
+        rule /#{id}/ do |m|
+          token tag_token(m[0])
+        end
+
+        rule /[.]/, Punctuation
+      end
+
+      state :jsx_end_tag do
+        mixin :jsx_tag
+        rule />/, Punctuation, :pop!
+      end
+
+      state :jsx_element do
+        rule /#{id}=/, Name::Attribute, :jsx_attribute
+        mixin :jsx_tag
+        rule />/ do token Punctuation; goto :jsx_internal end
+        rule %r(/>), Punctuation, :pop!
+      end
+
+      state :jsx_attribute do
+        rule /"(\\[\\"]|[^"])*"/, Str::Double, :pop!
+        rule /'(\\[\\']|[^'])*'/, Str::Single, :pop!
+        rule /{/ do
+          token Str::Interpol
+          pop!
+          start_embed!
+        end
+      end
+
+      state :jsx_embed_root do
+        rule /[.][.][.]/, Punctuation
+        rule /}/, Str::Interpol, :pop!
+        mixin :jsx_embed
+      end
+
+      state :jsx_embed do
+        rule /{/ do delegate @embed; push :jsx_embed end
+        rule /}/ do delegate @embed; pop! end
+        rule /[^{}]+/ do
+          delegate @embed
+        end
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/markdown.rb

@@ -31,10 +31,10 @@ module Rouge
         rule /^#(?=[^#]).*?$/, Generic::Heading
         rule /^##*.*?$/, Generic::Subheading
 
-        # TODO: syntax highlight the code block, github style
-        rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?)(\2)/m do |m|
+        rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?\n)(\2)/m do |m|
           sublexer = Lexer.find_fancy(m[3].strip, m[4])
           sublexer ||= PlainText.new(:token => Str::Backtick)
+          sublexer.options(self.options)
           sublexer.reset!
 
           token Text, m[1]
@@ -46,7 +46,7 @@ module Rouge
 
         rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick
 
-        rule /(`+)#{edot}+?\1/, Str::Backtick
+        rule /(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
 
         # various uses of * are in order of precedence
 

data/lib/rouge/lexers/mxml.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class MXML < RegexLexer
+      title "MXML"
+      desc "MXML"
+      tag 'mxml'
+      filenames '*.mxml'
+      mimetypes 'application/xv+xml'
+
+      state :root do
+        rule /[^<&]+/, Text
+        rule /&\S*?;/, Name::Entity
+
+        rule /<!\[CDATA\[/m do
+          token Comment::Preproc
+          push :actionscript_content
+        end
+
+        rule /<!--/, Comment, :comment
+        rule /<\?.*?\?>/, Comment::Preproc
+        rule /<![^>]*>/, Comment::Preproc
+
+        rule %r(<\s*[\w:.-]+)m, Name::Tag, :tag # opening tags
+        rule %r(<\s*/\s*[\w:.-]+\s*>)m, Name::Tag # closing tags
+      end
+
+      state :comment do
+        rule /[^-]+/m, Comment
+        rule /-->/, Comment, :pop!
+        rule /-/, Comment
+      end
+
+      state :tag do
+        rule /\s+/m, Text
+        rule /[\w.:-]+\s*=/m, Name::Attribute, :attribute
+        rule %r(/?\s*>), Name::Tag, :root
+      end
+
+      state :attribute do
+        rule /\s+/m, Text
+        rule /(")({|@{)/m do
+          groups Str, Punctuation
+          push :actionscript_attribute
+        end
+        rule /".*?"|'.*?'|[^\s>]+/, Str, :tag
+      end
+
+      state :actionscript_content do
+        rule /\]\]\>/m, Comment::Preproc, :pop!
+        rule /.*?(?=\]\]\>)/m do
+          delegate Actionscript
+        end
+      end
+
+      state :actionscript_attribute do
+        rule /(})(")/m do
+          groups Punctuation, Str
+          push :tag
+        end
+        rule /.*?(?=}")/m do
+          delegate Actionscript
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -52,16 +52,16 @@ module Rouge
       re_tok = Str::Regex
 
       state :balanced_regex do
-        rule %r(/(\\\\|\\/|[^/])*/[egimosx]*)m, re_tok, :pop!
-        rule %r(!(\\\\|\\!|[^!])*![egimosx]*)m, re_tok, :pop!
+        rule %r(/(\\[\\/]|[^/])*/[egimosx]*)m, re_tok, :pop!
+        rule %r(!(\\[\\!]|[^!])*![egimosx]*)m, re_tok, :pop!
         rule %r(\\(\\\\|[^\\])*\\[egimosx]*)m, re_tok, :pop!
-        rule %r({(\\\\|\\}|[^}])*}[egimosx]*), re_tok, :pop!
-        rule %r(<(\\\\|\\>|[^>])*>[egimosx]*), re_tok, :pop!
-        rule %r(\[(\\\\|\\\]|[^\]])*\][egimosx]*), re_tok, :pop!
-        rule %r[\((\\\\|\\\)|[^\)])*\)[egimosx]*], re_tok, :pop!
-        rule %r(@(\\\\|\\\@|[^\@])*@[egimosx]*), re_tok, :pop!
-        rule %r(%(\\\\|\\\%|[^\%])*%[egimosx]*), re_tok, :pop!
-        rule %r(\$(\\\\|\\\$|[^\$])*\$[egimosx]*), re_tok, :pop!
+        rule %r({(\\[\\}]|[^}])*}[egimosx]*), re_tok, :pop!
+        rule %r(<(\\[\\>]|[^>])*>[egimosx]*), re_tok, :pop!
+        rule %r(\[(\\[\\\]]|[^\]])*\][egimosx]*), re_tok, :pop!
+        rule %r[\((\\[\\\)]|[^\)])*\)[egimosx]*], re_tok, :pop!
+        rule %r(@(\\[\\@]|[^@])*@[egimosx]*), re_tok, :pop!
+        rule %r(%(\\[\\%]|[^%])*%[egimosx]*), re_tok, :pop!
+        rule %r(\$(\\[\\\$]|[^\$])*\$[egimosx]*), re_tok, :pop!
       end
 
       state :root do

data/lib/rouge/lexers/prometheus.rb

@@ -0,0 +1,121 @@
+module Rouge
+  module Lexers
+    class Prometheus < RegexLexer
+      desc 'prometheus'
+      tag 'prometheus'
+      aliases 'prometheus'
+      filenames '*.prometheus'
+
+      mimetypes 'text/x-prometheus', 'application/x-prometheus'
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs absent ceil changes clamp_max clamp_min count_scalar day_of_month
+          day_of_week days_in_month delta deriv drop_common_labels exp floor
+          histogram_quantile holt_winters hour idelta increase irate label_replace
+          ln log2 log10 month predict_linear rate resets round scalar sort
+          sort_desc sqrt time vector year avg_over_time min_over_time
+          max_over_time sum_over_time count_over_time quantile_over_time
+          stddev_over_time stdvar_over_time
+        )
+      end
+
+      state :root do
+        mixin :strings
+        mixin :whitespace
+
+        rule /-?\d+\.\d+/, Num::Float
+        rule /-?\d+[smhdwy]?/, Num::Integer
+
+        mixin :operators
+
+        rule /(ignoring|on)(\()/ do
+          groups Keyword::Pseudo, Punctuation
+          push :label_list
+        end
+        rule /(group_left|group_right)(\()/ do
+          groups Keyword::Type, Punctuation
+        end
+        rule /(bool|offset)\b/, Keyword
+        rule /(without|by)\b/, Keyword, :label_list
+        rule /[\w:]+/ do |m|
+          if self.class.functions.include?(m[0])
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        mixin :metrics
+      end
+
+      state :metrics do
+        rule /[a-zA-Z0-9_-]+/, Name
+
+        rule /[\(\)\]:.,]/, Punctuation
+        rule /\{/, Punctuation, :filters
+        rule /\[/, Punctuation
+      end
+
+      state :strings do
+        rule /"/, Str::Double, :double_string_escaped
+        rule /'/, Str::Single, :single_string_escaped
+        rule /`.*`/, Str::Backtick
+      end
+
+      [
+        [:double, Str::Double, '"'],
+        [:single, Str::Single, "'"]
+      ].each do |name, tok, fin|
+        state :"#{name}_string_escaped" do
+          rule /\\[\\abfnrtv#{fin}]/, Str::Escape
+          rule /[^\\#{fin}]+/m, tok
+          rule /#{fin}/, tok, :pop!
+        end
+      end
+
+      state :filters do
+        mixin :inline_whitespace
+        rule /,/, Punctuation
+        mixin :labels
+        mixin :filter_matching_operators
+        mixin :strings
+        rule /}/, Punctuation, :pop!
+      end
+
+      state :label_list do
+        rule /\(/, Punctuation
+        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule /,/, Punctuation
+        mixin :whitespace
+        rule /\)/, Punctuation, :pop!
+      end
+
+      state :labels do
+        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+      end
+
+      state :operators do
+        rule %r([+\-\*/%\^]), Operator  # Arithmetic
+        rule %r(=|==|!=|<|>|<=|>=), Operator # Comparison
+        rule /and|or|unless/, Operator # Logical/Set
+        rule /(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
+      end
+
+      state :filter_matching_operators do
+        rule /!(=|~)|=~?/, Operator
+      end
+
+      state :inline_whitespace do
+        rule /[ \t\r]+/, Text
+      end
+
+      state :whitespace do
+        mixin :inline_whitespace
+        rule /\n\s*/m, Text
+        rule /#.*?$/, Comment
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/python.rb

@@ -18,7 +18,7 @@ module Rouge
         @keywords ||= %w(
           assert break continue del elif else except exec
           finally for global if lambda pass print raise
-          return try while yield as with
+          return try while yield as with from import yield
         )
       end
 
@@ -75,6 +75,17 @@ module Rouge
         rule /(in|is|and|or|not)\b/, Operator::Word
         rule /!=|==|<<|>>|[-~+\/*%=<>&^|.]/, Operator
 
+        rule /(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(import)/ do
+          groups Keyword::Namespace,
+                 Text,
+                 Name::Namespace,
+                 Text,
+                 Keyword::Namespace
+        end
+        rule /(import)(\s+)(#{dotted_identifier})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+
         rule /(def)((?:\s|\\\s)+)/ do
           groups Keyword, Text
           push :funcname
@@ -85,26 +96,6 @@ module Rouge
           push :classname
         end
 
-        rule /(yield)((?:\s|\\\s)+)/ do
-           groups Keyword, Text
-           push :raise
-        end
-
-        rule /(raise)((?:\s|\\\s)+)/ do
-           groups Keyword, Text
-           push :raise
-        end
-
-        rule /(from)((?:\s|\\\s)+)/ do
-          groups Keyword::Namespace, Text
-          push :fromimport
-        end
-
-        rule /(import)((?:\s|\\\s)+)/ do
-          groups Keyword::Namespace, Text
-          push :import
-        end
-
         # TODO: not in python 3
         rule /`.*?`/, Str::Backtick
         rule /(?:r|ur|ru)"""/i, Str, :raw_tdqs

data/lib/rouge/lexers/swift.rb

@@ -18,11 +18,11 @@ module Rouge
 
         as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
 
-        associativity didSet get infix inout left mutating none nonmutating operator override postfix precedence prefix right set unowned weak willSet throws rethrows associatedtype
+        associativity didSet get infix inout mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
       )
 
       declarations = Set.new %w(
-        class deinit enum extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype
+        class deinit enum extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate
       )
 
       constants = Set.new %w(
@@ -97,9 +97,11 @@ module Rouge
         
         rule /#available\([^)]+\)/, Keyword::Declaration
         
-        rule /(#selector\()([^)]+?(?:[(].*?[)])?)(\))/ do
+        rule /(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
           groups Keyword::Declaration, Name::Function, Keyword::Declaration
         end
+        
+        rule /#(line|file|column|function|dsohandle)/, Keyword::Declaration
 
         rule /(let|var)\b(\s*)(#{id})/ do
           groups Keyword, Text, Name::Variable

data/lib/rouge/lexers/tulip.rb

@@ -28,21 +28,32 @@ module Rouge
         rule /@#{id}/, Keyword
 
 
-        rule /[>,!\[\]:{}()=;\/]/, Punctuation
-
         rule /(\\#{id})([{])/ do
-          groups Name::Variable, Str
+          groups Name::Function, Str
+          push :nested_string
+        end
+
+        rule /([+]#{id})([{])/ do
+          groups Name::Decorator, Str
           push :nested_string
         end
 
         rule /\\#{id}/, Name::Function
+        rule /[+]#{id}/, Name::Decorator
 
+        rule /"[{]/, Str, :dqi
         rule /"/, Str, :dq
 
         rule /'{/, Str, :nested_string
+        rule /'#{id}/, Str
 
         rule /[.]#{id}/, Name::Tag
-        rule /[$]#{id}/, Name::Variable
+        rule /[$]#{id}?/, Name::Variable
+        rule /-#{id}:?/, Name::Label
+        rule /%#{id}/, Name::Function
+        rule /`#{id}/, Operator::Word
+
+        rule /[?~%._>,!\[\]:{}()=;\/-]/, Punctuation
 
         rule /[0-9]+([.][0-9]+)?/, Num
 
@@ -57,6 +68,25 @@ module Rouge
         rule /\\./, Str::Escape
       end
 
+      state :dqi do
+        rule /[$][(]/, Str::Interpol, :interp_root
+        rule /[{]/, Str, :dqi
+        rule /[}]/, Str, :pop!
+        rule /[^{}$]+/, Str
+        rule /./, Str
+      end
+
+      state :interp_root do
+        rule /[)]/, Str::Interpol, :pop!
+        mixin :interp
+      end
+
+      state :interp do
+        rule /[(]/, Punctuation, :interp
+        rule /[)]/, Punctuation, :pop!
+        mixin :root
+      end
+
       state :nested_string do
         rule /\\./, Str::Escape
         rule(/{/) { token Str; push :nested_string }