rouge 1.10.1 → 1.11.0

data/lib/rouge/lexers/objective_c.rb

@@ -80,6 +80,7 @@ module Rouge
         rule /[?]/, Punctuation, :ternary
         rule /\[/,  Punctuation, :message
         rule /@\[/, Punctuation, :array_literal
+        rule /@\{/, Punctuation, :dictionary_literal
       end
 
       state :ternary do
@@ -89,6 +90,7 @@ module Rouge
 
       state :message_shared do
         rule /\]/, Punctuation, :pop!
+        rule /\{/, Punctuation, :pop!
         rule /;/, Error
 
         mixin :statement
@@ -109,8 +111,10 @@ module Rouge
       end
 
       state :message_with_args do
+        rule /\{/, Punctuation, :function
         rule /(#{id})(\s*)(:)/ do
           groups(Name::Function, Text, Punctuation)
+          pop!
         end
 
         mixin :message_shared
@@ -122,6 +126,12 @@ module Rouge
         mixin :statements
       end
 
+      state :dictionary_literal do
+        rule /}/, Punctuation, :pop!
+        rule /,/, Punctuation
+        mixin :statements
+      end
+
       state :classname do
         mixin :whitespace
 
@@ -137,6 +147,7 @@ module Rouge
                  Punctuation, Text,
                  Name::Label, Text,
                  Punctuation)
+          pop!
         end
 
         rule id, Name::Class, :pop!

data/lib/rouge/lexers/php.rb

@@ -7,7 +7,7 @@ module Rouge
       desc "The PHP scripting language (php.net)"
       tag 'php'
       aliases 'php', 'php3', 'php4', 'php5'
-      filenames '*.php', '*.php[345]',
+      filenames '*.php', '*.php[345t]','*.phtml',
                 # Support Drupal file extensions, see:
                 # https://github.com/gitlabhq/gitlabhq/issues/8900
                 '*.module', '*.inc', '*.profile', '*.install', '*.test'

data/lib/rouge/lexers/powershell.rb

@@ -10,7 +10,7 @@ module Rouge
       tag 'powershell'
       aliases 'posh'
       filenames '*.ps1', '*.psm1', '*.psd1'
-      mimetypes 'text/plain'
+      mimetypes 'text/x-powershell'
 
       ATTRIBUTES = %w(
         CmdletBinding ConfirmImpact DefaultParameterSetName HelpURI SupportsPaging

data/lib/rouge/lexers/protobuf.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Protobuf < RegexLexer
+      title 'Protobuf'
+      desc 'Google\'s language-neutral, platform-neutral, extensible mechanism for serializing structured data'
+      tag 'protobuf'
+      aliases 'proto'
+      filenames '*.proto'
+      mimetypes 'text/x-proto'
+
+      kw = /\b(ctype|default|extensions|import|max|oneof|option|optional|packed|repeated|required|returns|rpc|to)\b/
+      datatype = /\b(bool|bytes|double|fixed32|fixed64|float|int32|int64|sfixed32|sfixed64|sint32|sint64|string|uint32|uint64)\b/
+
+      state :root do
+        rule /[\s]+/, Text
+        rule /[,;{}\[\]()]/, Punctuation
+        rule /\/(\\\n)?\/(\n|(.|\n)*?[^\\]\n)/, Comment::Single
+        rule /\/(\\\n)?\*(.|\n)*?\*(\\\n)?\//, Comment::Multiline
+        rule kw, Keyword
+        rule datatype, Keyword::Type
+        rule /true|false/, Keyword::Constant
+        rule /(package)(\s+)/ do
+          groups Keyword::Namespace, Text
+          push :package
+        end
+
+        rule /(message|extend)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :message
+        end
+
+        rule /(enum|group|service)(\s+)/ do
+          groups Keyword::Declaration, Text
+          push :type
+        end
+
+        rule /".*?"/, Str
+        rule /'.*?'/, Str
+        rule /(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*/, Num::Float
+        rule /(\d+\.\d*|\.\d+|\d+[fF])[fF]?/, Num::Float
+        rule /(\-?(inf|nan))\b/, Num::Float
+        rule /0x[0-9a-fA-F]+[LlUu]*/, Num::Hex
+        rule /0[0-7]+[LlUu]*/, Num::Oct
+        rule /\d+[LlUu]*/, Num::Integer
+        rule /[+-=]/, Operator
+        rule /([a-zA-Z_][\w.]*)([ \t]*)(=)/ do
+          groups Name::Attribute, Text, Operator
+        end
+        rule /[a-zA-Z_][\w.]*/, Name
+      end
+
+      state :package do
+        rule /[a-zA-Z_]\w*/, Name::Namespace, :pop!
+        rule (//) { pop! }
+      end
+
+      state :message do
+        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule (//) { pop! }
+      end
+
+      state :type do
+        rule /[a-zA-Z_]\w*/, Name, :pop!
+        rule (//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/python.rb

@@ -85,6 +85,16 @@ 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
@@ -141,6 +151,19 @@ module Rouge
         rule identifier, Name::Class, :pop!
       end
 
+      state :raise do
+        rule /from\b/, Keyword
+        rule /raise\b/, Keyword
+        rule /yield\b/, Keyword
+        rule /\n/, Text, :pop!
+        rule /;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :yield do
+        mixin :raise
+      end
+
       state :import do
         # non-line-terminating whitespace
         rule /(?:[ \t]|\\\n)+/, Text

data/lib/rouge/lexers/r.rb

@@ -7,49 +7,82 @@ module Rouge
       desc 'The R statistics language (r-project.org)'
       tag 'r'
       aliases 'r', 'R', 's', 'S'
-      filenames '*.R', '.Rhistory', '.Rprofile'
+      filenames '*.R', '*.r', '.Rhistory', '.Rprofile'
       mimetypes 'text/x-r-source', 'text/x-r', 'text/x-R'
 
       mimetypes 'text/x-r', 'application/x-r'
 
-      def self.keywords
-        @keywords ||= %w(
-          if else for while repeat in next break return switch function
-        )
-      end
+      KEYWORDS = %w(if else for while repeat in next break function)
+
+      KEYWORD_CONSTANTS = %w(
+        NULL Inf TRUE FALSE NaN NA
+        NA_integer_ NA_real_ NA_complex_ NA_character_
+      )
+
+      BUILTIN_CONSTANTS = %w(LETTERS letters month.abb month.name pi T F)
+
+      # These are all the functions in `base` that are implemented as a
+      # `.Primitive`, minus those functions that are also keywords.
+      PRIMITIVE_FUNCTIONS = %w(
+        abs acos acosh all any anyNA Arg as.call as.character
+        as.complex as.double as.environment as.integer as.logical
+        as.null.default as.numeric as.raw asin asinh atan atanh attr
+        attributes baseenv browser c call ceiling class Conj cos cosh
+        cospi cummax cummin cumprod cumsum digamma dim dimnames
+        emptyenv exp expression floor forceAndCall gamma gc.time
+        globalenv Im interactive invisible is.array is.atomic is.call
+        is.character is.complex is.double is.environment is.expression
+        is.finite is.function is.infinite is.integer is.language
+        is.list is.logical is.matrix is.na is.name is.nan is.null
+        is.numeric is.object is.pairlist is.raw is.recursive is.single
+        is.symbol lazyLoadDBfetch length lgamma list log max min
+        missing Mod names nargs nzchar oldClass on.exit pos.to.env
+        proc.time prod quote range Re rep retracemem return round
+        seq_along seq_len seq.int sign signif sin sinh sinpi sqrt
+        standardGeneric substitute sum switch tan tanh tanpi tracemem
+        trigamma trunc unclass untracemem UseMethod xtfrm
+      )
 
       def self.analyze_text(text)
         return 1 if text.shebang? 'Rscript'
       end
 
       state :root do
+        rule /#'.*?\n/, Comment::Doc
         rule /#.*?\n/, Comment::Single
-        rule /\s+/m, Text
-        rule /[.]?[a-zA-Z_][\w.]*/ do |m|
-          if self.class.keywords.include? m[0]
-            token Keyword
-          else
-            token Name
-          end
-        end
+        rule /\s+/m, Text::Whitespace
 
-        rule /`.*?`/, Str::Backtick
+        rule /`[^`]+?`/, Name
         rule /'(\\.|.)*?'/m, Str::Single
         rule /"(\\.|.)*?"/m, Str::Double
 
-        rule /\b(NULL|Inf|TRUE|FALSE|NaN)\b/, Keyword::Constant
-        rule /\bNA(_(integer|real|complex|character)_)?\b/,
-          Keyword::Constant
-        rule /\b[TF]\b/, Keyword::Variable
+        rule /%[^%]*?%/, Operator
 
         rule /0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?/, Num::Hex
         rule /[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?[Li]?/,
           Num
 
+        # Only recognize built-in functions when they are actually used as a
+        # function call, i.e. followed by an opening parenthesis.
+        # `Name::Builtin` would be more logical, but is usually not
+        # highlighted specifically; thus use `Name::Function`.
+        rule /\b(?<!.)(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
+
+        rule /[a-zA-Z.]([a-zA-Z_][\w.]*)?/ do |m|
+          if KEYWORDS.include? m[0]
+            token Keyword
+          elsif KEYWORD_CONSTANTS.include? m[0]
+            token Keyword::Constant
+          elsif BUILTIN_CONSTANTS.include? m[0]
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
         rule /[\[\]{}();,]/, Punctuation
 
         rule %r([-<>?*+^/!=~$@:%&|]), Operator
-        rule /[.][.][.]/, Keyword
       end
     end
   end

data/lib/rouge/lexers/ruby.rb

@@ -228,17 +228,17 @@ module Rouge
       end
 
       state :has_heredocs do
-        rule /(?<!\w)(<<-?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
+        rule /(?<!\w)(<<[-~]?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
           token Operator, m[1]
           token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
-          @heredoc_queue << [m[1] == '<<-', m[3]]
+          @heredoc_queue << [['<<-', '<<~'].include?(m[1]), m[3]]
           push :heredoc_queue unless state? :heredoc_queue
         end
 
-        rule /(<<-?)(["'])(\2)/ do |m|
+        rule /(<<[-~]?)(["'])(\2)/ do |m|
           token Operator, m[1]
           token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
-          @heredoc_queue << [m[1] == '<<-', '']
+          @heredoc_queue << [['<<-', '<<~'].include?(m[1]), '']
           push :heredoc_queue unless state? :heredoc_queue
         end
       end

data/lib/rouge/lexers/rust.rb

@@ -29,10 +29,10 @@ module Rouge
           c_int clock_t c_long c_longlong Cons Const Copy c_schar c_short
           c_uchar c_uint c_ulong c_ulonglong c_ushort c_void dev_t DIR
           dirent Div Either Eq Err f32 f64 Failure FILE float fpos_t
-          i16 i32 i64 i8 Index ino_t int intptr_t Left mode_t Modulo Mul
+          i16 i32 i64 i8 isize Index ino_t int intptr_t Left mode_t Modulo Mul
           Neg Nil None Num off_t Ok Option Ord Owned pid_t Ptr ptrdiff_t
           Right Send Shl Shr size_t Some ssize_t str Sub Success time_t
-          u16 u32 u64 u8 uint uintptr_t
+          u16 u32 u64 u8 usize uint uintptr_t
           Box Vec String Gc Rc Arc
         )
       end

data/lib/rouge/lexers/shell_session.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class ShellSession < RegexLexer
+      tag 'shell_session'
+      title "Shell Session"
+      desc 'A generic lexer for shell session and command line'
+      aliases 'terminal', 'console'
+      filenames '*.cap'
+
+      state :root do
+        rule /^([^ \n]*# )([^ \n]*)(.*(\n|$))/ do |m|
+          token Name::Entity, m[1]
+          token Name::Class, m[2]
+          token Keyword::Variable, m[3]
+        end
+        rule /^([^ \n]*\$ )([^ \n]*)(.*(\n|$))/ do |m|
+          token Text::Whitespace, m[1]
+          token Name::Class, m[2]
+          token Keyword::Variable, m[3]
+        end
+        rule /^<...>$/, Comment
+        rule /.*\n/, Text
+      end
+    end
+  end
+end
+### tag function class label

data/lib/rouge/lexers/smarty.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Smarty < TemplateLexer
+      title "Smarty"
+      desc 'Smarty Template Engine'
+      tag 'smarty'
+      aliases 'smarty'
+      filenames '*.tpl', '*.smarty'
+      mimetypes 'application/x-smarty', 'text/x-smarty'
+
+      def self.analyze_text(text)
+        rv = 0.0
+        rv += 0.15 if text =~ /\{if\s+.*?\}.*?\{\/if\}/
+        rv += 0.15 if text =~ /\{include\s+file=.*?\}/
+        rv += 0.15 if text =~ /\{foreach\s+.*?\}.*?\{\/foreach\}/
+        rv += 0.01 if text =~ /\{\$.*?\}/
+        return rv
+      end
+
+
+
+      def self.builtins
+        @builtins ||= %w(
+          append assign block call capture config_load debug extends
+          for foreach foreachelse break continue function if elseif
+          else include include_php insert ldelim rdelim literal nocache
+          php section sectionelse setfilter strip while
+          counter cycle eval fetch html_checkboxes html_image html_options
+          html_radios html_select_date html_select_time html_table
+          mailto math textformat
+          capitalize cat count_characters count_paragraphs
+          count_sentences count_words date_format default escape
+          from_charset indent lower nl2br regex_replace replace spacify
+          string_format strip strip_tags to_charset truncate unescape
+          upper wordwrap
+        )
+      end
+
+
+      state :root do
+        rule(/\{\s+/) { delegate parent }
+
+        # block comments
+        rule /\{\*.*?\*\}/m, Comment
+
+        rule /\{\/?(?![\s*])/ do
+          token Keyword
+          push :smarty
+        end
+
+
+        rule(/.*?(?={[\/a-zA-Z0-9$#*"'])|.*/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :comment do
+        rule(/{\*/) { token Comment; push }
+        rule(/\*}/) { token Comment; pop! }
+        rule(/[^{}]+/m) { token Comment }
+      end
+
+      state :smarty do
+        # allow nested tags
+        rule /\{\/?(?![\s*])/ do
+          token Keyword
+          push :smarty
+        end
+
+        rule /}/, Keyword, :pop!
+        rule /\s+/m, Text
+        rule %r([~!%^&*()+=|\[\]:;,.<>/@?-]), Operator
+        rule /#[a-zA-Z_]\w*#/, Name::Variable
+        rule /\$[a-zA-Z_]\w*(\.\w+)*/, Name::Variable
+        rule /(true|false|null)\b/, Keyword::Constant
+	rule /[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?/, Num
+	rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+	rule /([a-zA-Z_]\w*)/ do |m|
+	  if self.class.builtins.include? m[0]
+	    token Name::Builtin
+	  else
+	    token Name::Attribute
+	  end
+	end
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/sql.rb

@@ -89,7 +89,7 @@ module Rouge
 
       state :root do
         rule /\s+/m, Text
-        rule /--.*?\n/, Comment::Single
+        rule /--.*/, Comment::Single
         rule %r(/\*), Comment::Multiline, :multiline_comments
         rule /\d+/, Num::Integer
         rule /'/, Str::Single, :single_string

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
+        associativity didSet get infix inout left mutating none nonmutating operator override postfix precedence prefix right set unowned weak willSet throws rethrows associatedtype
       )
 
       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
+        class deinit enum extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype
       )
 
       constants = Set.new %w(
@@ -42,7 +42,7 @@ module Rouge
 
       state :inline_whitespace do
         rule /\s+/m, Text
-        rule %r((?<re>\/\*(?:(?>[^\/\*\*\/]+)|\g<re>)*\*\/))m, Comment::Multiline
+        mixin :has_comments
       end
 
       state :whitespace do
@@ -51,6 +51,17 @@ module Rouge
         mixin :inline_whitespace
       end
 
+      state :has_comments do
+        rule %r(/[*]), Comment::Multiline, :nested_comment
+      end
+
+      state :nested_comment do
+        mixin :has_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+)m, Comment::Multiline
+        rule /./, Comment::Multiline
+      end
+
       state :root do
         mixin :whitespace
         rule /\$(([1-9]\d*)?\d)/, Name::Variable
@@ -85,6 +96,10 @@ module Rouge
         end
         
         rule /#available\([^)]+\)/, Keyword::Declaration
+        
+        rule /(#selector\()([^)]+?(?:[(].*?[)])?)(\))/ do
+          groups Keyword::Declaration, Name::Function, Keyword::Declaration
+        end
 
         rule /(let|var)\b(\s*)(#{id})/ do
           groups Keyword, Text, Name::Variable
@@ -98,8 +113,8 @@ module Rouge
           end
         end
         
-        rule /as[?!]?/, Keyword
-        rule /try[!]?/, Keyword
+        rule /as[?!]?(?=\s)/, Keyword
+        rule /try[!]?(?=\s)/, Keyword
 
         rule /(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
           groups Name::Variable, Text, Punctuation