rouge 3.10.0 → 3.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fb254c48c7225eb55006a7e1fb0cd713afa34faf35d4f4c92bec44c663a7a49
-  data.tar.gz: 0d5193efc0336f18a8012f09135deb4eb988051367b78928c5b7bc61f3f0b49c
+  metadata.gz: 6194cfb5ce21bf2ed70d2204150a338095ad016b480801c970995c3ecf9cebde
+  data.tar.gz: 6999fdfdc81eeb5aaa808934d27288af6f40280146b13c03ba6d404f1ed73320
 SHA512:
-  metadata.gz: 41128ed9650fe8aa804d9c93c44ebaf8f93131ee156ed1b57acfd1b790f435cf9f7f2233fd7ca3701b206b7131d979a2517abbf87da6c01ca931ec8d7ac4c04b
-  data.tar.gz: 255518b66c766562b22005ade1eebc7bf092e3b29b1f5fe298b0497801a86de2e350e726b57ac52380d58e9aa28bfb84cff2f917759053548704bd2bb4bf4b8c
+  metadata.gz: f85788d5d1c66521b7b554717d8d1d6b48c7455d01e2e32f13a48d0af26d358b9f1eb66ae0de614b9983d568383f28946add9061aea7ac31e1172d7c09c13f1a
+  data.tar.gz: 790a1f59fc106f19b8ce33ef5df8d3f7255fadcd667cce2dabb38dff424f52df1193c5ac135093ecf3fced1f1f11b924c3c8f158454075dbaf2ae6b02b8f5d5b

data/lib/rouge/demos/apex

@@ -0,0 +1,9 @@
+public class with sharing Trigger {
+    @Deprecated
+    public void resolveSum(int x, int y) {
+        System.debug('x is ' + x);
+        System.debug('y is ' + y);
+
+        System.debug('x + y = ' + (x+y));
+    }
+}

data/lib/rouge/demos/csvs

@@ -0,0 +1,8 @@
+version 1.1
+@totalColumns 5
+@separator ','
+Transaction_Date: xDate
+Transaction_ID: notEmpty
+Originator_Name: notEmpty
+Originator_Address: any("yes","no")
+Originator_Country: notEmpty

data/lib/rouge/demos/liquid

@@ -5,7 +5,6 @@
       Only {{ product.price | format_as_money }}
 
       <p>{{ product.description | prettyprint | truncate: 200  }}</p>
-
     </li>
   {% endfor %}
 </ul>

data/lib/rouge/demos/robot_framework

@@ -0,0 +1,27 @@
+*** Settings ***
+Document	  Example taken from http://robotframework.org/
+Suite Setup       Open Browser To Login Page
+Suite Teardown    Close Browser
+Test Setup        Go To Login Page
+Test Template     Login With Invalid Credentials Should Fail
+Resource          resource.txt
+
+*** Test Cases ***               User Name        Password
+Invalid Username                 invalid          ${VALID PASSWORD}
+Invalid Password                 ${VALID USER}    invalid
+Invalid Username And Password    invalid          whatever
+Empty Username                   ${EMPTY}         ${VALID PASSWORD}
+Empty Password                   ${VALID USER}    ${EMPTY}
+Empty Username And Password      ${EMPTY}         ${EMPTY}
+
+*** Keywords ***
+Login With Invalid Credentials Should Fail
+    [Arguments]    ${username}    ${password}
+    Input Username    ${username}
+    Input Password    ${password}
+    Submit Credentials
+    Login Should Have Failed
+
+Login Should Have Failed
+    Location Should Be    ${ERROR URL}
+    Title Should Be    Error Page

data/lib/rouge/guessers/disambiguation.rb

@@ -126,6 +126,11 @@ module Rouge
 
         next PlainText
       end
+
+      disambiguate '*.cls' do
+        next TeX if matches?(/\A\s*(?:\\|%)/)
+        next Apex
+      end
     end
   end
 end

data/lib/rouge/lexers/apex.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Apex < RegexLexer
+      title "Apex"
+      desc "The Apex programming language (provided by salesforce)"
+
+      tag 'apex'
+      filenames '*.cls'
+      mimetypes 'text/x-apex'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break case catch continue default do else finally for if goto
+          instanceof new return switch this throw try while insert update
+          delete
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract const enum extends final implements native private protected
+          public static super synchronized throws transient volatile with
+          sharing without inherited virtual global testmethod
+        )
+      end
+
+      def self.soql
+        @soql ||= Set.new %w(
+          SELECT FROM WHERE UPDATE LIKE TYPEOF END USING SCOPE WITH DATA
+          CATEGORY GROUP BY ROLLUP CUBE HAVING ORDER BY ASC DESC NULLS FIRST
+          LAST LIMIT OFFSET FOR VIEW REFERENCE UPDATE TRACKING VIEWSTAT OR AND
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          String boolean byte char double float int long short var void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      id = /[a-z_][a-z0-9_]*/i
+
+      state :root do
+        rule %r/\s+/m, Text
+        
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        rule %r/([@$.]?)(#{id})([:(]?)/io do |m|
+          if self.class.keywords.include? m[0].downcase
+            token Keyword
+          elsif self.class.soql.include? m[0].upcase
+            token Keyword
+          elsif self.class.declarations.include? m[0].downcase
+            token Keyword::Declaration
+          elsif self.class.types.include? m[0].downcase
+            token Keyword::Type
+          elsif self.class.constants.include? m[0].downcase
+            token Keyword::Constant
+          elsif 'package'.casecmp m[0]
+            token Keyword::Namespace
+          elsif m[1] == "@"
+            token Name::Decorator
+          elsif m[3] == ":"
+            groups Operator, Name::Label, Punctuation
+          elsif m[3] == "("
+            groups Operator, Name::Function, Punctuation
+          elsif m[1] == "."
+            groups Operator, Name::Property, Punctuation
+          else
+            token Name
+          end
+        end
+
+        rule %r/"/, Str::Double, :dq
+        rule %r/'/, Str::Single, :sq
+
+        digit = /[0-9]_+[0-9]|[0-9]/
+        rule %r/#{digit}+\.#{digit}+([eE]#{digit}+)?[fd]?/, Num::Float
+        rule %r/0b(?:[01]_+[01]|[01])+/i, Num::Bin
+        rule %r/0x(?:\h_+\h|\h)+/i, Num::Hex
+        rule %r/0(?:[0-7]_+[0-7]|[0-7])+/, Num::Oct
+        rule %r/#{digit}+L?/, Num::Integer
+
+        rule %r/[-+\/*~^!%&<>|=.?]/, Operator
+        rule %r/[\[\](){},:;]/, Punctuation;
+      end
+
+      state :class do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/m, Text
+        rule %r/[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+      end
+
+      state :escape do
+        rule %r/\\[btnfr\\"']/, Str::Escape
+      end
+
+      state :dq do
+        mixin :escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        mixin :escape
+        rule %r/[^\\']+/, Str::Double
+        rule %r/'/, Str::Double, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/coq.rb

@@ -58,7 +58,7 @@ module Rouge
 
       def self.keyopts
         @keyopts ||= Set.new %w(
-          := => -> /\\ \\/ _ ; :> :
+          := => -> /\\ \\/ _ ; :> : ⇒ → ↔ ⇔ ≔ ≡ ∀ ∃ ∧ ∨ ¬ ⊤ ⊥ ⊢ ⊨ ∈
         )
       end
 
@@ -115,14 +115,6 @@ module Rouge
         end
         rule %r(/\\), Operator
         rule %r/\\\//, Operator
-        rule operator do |m|
-          match = m[0]
-          if self.class.keyopts.include? match
-            token Punctuation
-          else
-            token Operator
-          end
-        end
 
         rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
         rule %r/\d[\d_]*/, Num::Integer
@@ -131,6 +123,17 @@ module Rouge
         rule %r/'/, Keyword
         rule %r/"/, Str::Double, :string
         rule %r/[~?]#{id}/, Name::Variable
+
+        rule %r/./ do |m|
+          match = m[0]
+          if self.class.keyopts.include? match
+            token Punctuation
+          elsif match =~ operator
+            token Operator
+          else
+            token Error
+          end
+        end
       end
 
       state :comment do

data/lib/rouge/lexers/csvs.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class CSVS < RegexLexer
+      tag 'csvs'
+      title "csvs"
+      desc 'The CSV Schema Language (digital-preservation.github.io)'
+      filenames '*.csvs'
+
+      state :root do
+        rule %r/\s+/m, Text
+
+        rule %r(//[\S\t ]*), Comment::Single
+        rule %r(/\*[^*]*\*/)m, Comment::Multiline
+
+        rule %r/(version)( )(\d+\.\d+)/ do
+          groups Keyword, Text::Whitespace, Num::Float
+        end
+
+        rule %r/T?\d{2}:\d{2}:\d{2}(\.\d{5})?(Z|(?:[-+]\d{2}:\d{2}))?/, Literal::Date
+        rule %r/\d{4}-\d{2}-\d{2}/, Literal::Date
+        rule %r/\d{2}\/\d{2}\/\d{4}/, Literal::Date
+
+        rule %r((\d+[.]?\d*|\d*[.]\d+)(e[+-]?[0-9]+)?)i, Num::Float
+        rule %r/\d+/, Num::Integer
+
+        rule %r/@\w+/, Keyword::Pseudo
+
+        rule %r/[-.\w]+:/, Name::Variable
+        rule %r/^"[^"]+"/, Name::Variable
+        rule %r/\$([-.\w]+|("[^"]+"))\/?/, Name::Variable
+
+        rule %r/[A-Z]+/i, Keyword
+
+        rule %r/"[^"]*"/, Str::Double
+        rule %r/'[^\r\n\f']'/, Str::Char
+
+        rule %r/[,()*]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json.rb

@@ -34,7 +34,7 @@ module Rouge
       end
 
       state :name do
-        rule %r/("(?:\\.|[^"\n])*?")(\s*)(:)/ do
+        rule %r/("(?:\\.|[^"\\\n])*?")(\s*)(:)/ do
           groups Name::Label, Text::Whitespace, Punctuation
         end
       end

data/lib/rouge/lexers/kotlin.rb

@@ -24,19 +24,12 @@ module Rouge
         while yield
       )
 
-      name = %r'@?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
-      name_backtick = %r'#{name}|`#{name}`'
+      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
-      id = %r'(#{name_backtick})'
+      class_name = %r'`?[\p{Lu}]#{name_chars}`?'
+      name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'
 
       state :root do
-        rule %r'(\))(\s*)(:)(\s+)(#{name_backtick})(<)' do
-          groups Punctuation, Text, Punctuation, Text, Name::Class, Punctuation
-          push :generic_parameters
-        end
-        rule %r'(\))(\s*)(:)(\s+)(#{name_backtick})' do
-          groups Punctuation, Text, Punctuation, Text, Name::Class
-        end
         rule %r'\b(companion)(\s+)(object)\b' do
           groups Keyword, Text, Keyword
         end
@@ -48,13 +41,6 @@ module Rouge
           groups Keyword, Text
           push :function
         end
-        rule %r'(#{name_backtick})(:)(\s+)(#{name_backtick})(<)' do
-          groups Name::Variable, Punctuation, Text, Name::Class, Punctuation
-          push :generic_parameters
-        end
-        rule %r'(#{name_backtick})(:)(\s+)(#{name_backtick})' do
-          groups Name::Variable, Punctuation, Text, Name::Class
-        end
         rule %r'\b(package|import)(\s+)' do
           groups Keyword, Text
           push :package
@@ -67,8 +53,8 @@ module Rouge
           groups Keyword::Declaration, Text
           push :property
         end
-        rule %r/\bfun\b/, Keyword
-        rule %r/\b(?:#{keywords.join('|')})\b/, Keyword
+        rule %r'\bfun\b', Keyword
+        rule %r'\b(?:#{keywords.join('|')})\b', Keyword
         rule %r'^\s*\[.*?\]', Name::Attribute
         rule %r'[^\S\n]+', Text
         rule %r'\\\n', Text # line continuation
@@ -85,43 +71,50 @@ module Rouge
         rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
         rule %r"'\\.'|'[^\\]'", Str::Char
         rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
-        rule %r/@#{id}/, Name::Decorator
-        rule id, Name
+        rule %r'(@#{class_name})', Name::Decorator
+        rule %r'(#{class_name})(<)' do
+          groups Name::Class, Punctuation
+          push :generic_parameters
+        end
+        rule class_name, Name::Class
+        rule %r'(#{name})(?=\s*[({])', Name::Function
+        rule name, Name
       end
 
       state :package do
-        rule %r/\S+/, Name::Namespace, :pop!
+        rule %r'\S+', Name::Namespace, :pop!
       end
 
       state :class do
-        rule id, Name::Class, :pop!
+        rule class_name, Name::Class, :pop!
       end
 
       state :function do
         rule %r'(<)', Punctuation, :generic_parameters
         rule %r'(\s+)', Text
-        rule %r'(#{name_backtick})(\.)' do
+        rule %r'(#{class_name})(\.)' do
           groups Name::Class, Punctuation
         end
-        rule id, Name::Function, :pop!
+        rule name, Name::Function, :pop!
       end
 
       state :generic_parameters do
-        rule id, Name::Class
+        rule class_name, Name::Class
+        rule %r'(<)', Punctuation, :generic_parameters
         rule %r'(,)', Punctuation
         rule %r'(\s+)', Text
         rule %r'(>)', Punctuation, :pop!
       end
 
       state :property do
-        rule id, Name::Property, :pop!
+        rule name, Name::Property, :pop!
       end
 
       state :destructure do
         rule %r'(,)', Punctuation
         rule %r'(\))', Punctuation, :pop!
         rule %r'(\s+)', Text
-        rule id, Name::Property
+        rule name, Name::Property
       end
 
       state :comment do

data/lib/rouge/lexers/liquid.rb

@@ -12,12 +12,12 @@ module Rouge
       state :root do
         rule %r/[^\{]+/, Text
 
-        rule %r/(\{%)(\s*)/ do
+        rule %r/(\{%-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :tag_or_block
         end
 
-        rule %r/(\{\{)(\s*)/ do
+        rule %r/(\{\{-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :output
         end
@@ -27,78 +27,70 @@ module Rouge
 
       state :tag_or_block do
         # builtin logic blocks
-        rule %r/(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+        rule %r/(if|elsif|unless|case)\b/, Keyword::Reserved, :condition
+        rule %r/(when)\b/, Keyword::Reserved, :when
 
-        rule %r/(when)(\s+)/ do
-          groups Keyword::Reserved, Text::Whitespace
-          push :when
-        end
-
-        rule %r/(else)(\s*)(%\})/ do
+        rule %r/(else)(\s*)(-?%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
         # other builtin blocks
-        rule %r/(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
-          groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
+        rule %r/(capture|(?:in|de)crement)(\s+)([^\s%]+)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule %r/(comment)(\s*)(%\})/ do
+        rule %r/(comment)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :comment
         end
 
-        rule %r/(raw)(\s*)(%\})/ do
+        rule %r/(raw)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :raw
         end
 
-        rule %r/assign/, Name::Tag, :assign
-        rule %r/include/, Name::Tag, :include
-
         # end of block
-        rule %r/(end(?:case|unless|if))(\s*)(%\})/ do
+        rule %r/(end(?:if|unless|case))(\s*)(-?%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule %r/(end(?:[^\s%]+))(\s*)(%\})/ do
+        rule %r/(end(?:[^\s%]+))(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           pop!
         end
 
         # builtin tags
-        rule %r/(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
-          token Name::Tag, m[1]
-          token Text::Whitespace, m[2]
+        rule %r/(assign|echo)\b/, Name::Tag, :assign
+        rule %r/(include|render)\b/, Name::Tag, :include
 
-          if m[4] =~ /'[^']*'/
-            token Str::Single, m[4]
-          elsif m[4] =~ /"[^"]*"/
-            token Str::Double, m[4]
-          else
-            token Name::Attribute, m[4]
-          end
+        rule %r/(cycle)(\s+)(?:([^\s:]*)(\s*)(:))?(\s*)/ do |m|
+          token_class = case m[3]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Attribute
+                        end
 
-          token Punctuation, m[5]
-          token Text::Whitespace, m[6]
+          groups Name::Tag, Text::Whitespace, token_class,
+                 Text::Whitespace, Punctuation, Text::Whitespace
 
           push :variable_tag_markup
         end
 
         # iteration
         rule %r/
-          (for)(\s+)
+          (for|tablerow)(\s+)
           ([\w-]+)(\s+)
           (in)(\s+)
           (
-            (?: [^\s,\|'"] | (?:"[^"]*"|'[^']*') )+
+            (?: [^\s%,\|'"] | (?:"[^"]*"|'[^']*') )+
           )(\s*)
         /x do |m|
           groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
-                 Keyword::Reserved, Text::Whitespace
+                 Name::Tag, Text::Whitespace
 
           token_class = case m[7]
                         when %r/'[^']*'/ then Str::Single
@@ -119,105 +111,76 @@ module Rouge
       end
 
       state :output do
-        mixin :whitespace
-        mixin :generic
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
+        end
 
-        rule %r/\}\}/, Punctuation, :pop!
-        rule %r/\|/, Punctuation, :filters
+        mixin :end_of_tag
+        mixin :generic
       end
 
       state :filters do
-        mixin :whitespace
-
-        rule(/\}\}/) { token Punctuation; reset_stack }
-
-        rule %r/([^\s\|:]+)(:?)(\s*)/ do
-          groups Name::Function, Punctuation, Text::Whitespace
-          push :filter_markup
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
         end
-      end
-
-      state :filter_markup do
-        rule %r/\|/, Punctuation, :pop!
 
         mixin :end_of_tag
         mixin :end_of_block
-        mixin :default_param_markup
+        mixin :variable_param_markup
       end
 
       state :condition do
-        mixin :end_of_block
-        mixin :whitespace
-
-        rule %r/([=!><]=?)/, Operator
-
-        rule %r/\b(?:(!)|(not\b))/ do
-          groups Operator, Operator::Word
-        end
-
-        rule %r/(contains)/, Operator::Word
+        rule %r/([=!]=|[<>]=?)/, Operator
+        rule %r/(and|or|contains)\b/, Operator::Word
 
+        mixin :end_of_block
         mixin :generic
-        mixin :whitespace
       end
 
       state :when do
         mixin :end_of_block
-        mixin :whitespace
         mixin :generic
       end
 
-      state :operator do
-        rule %r/(\s*)((?:=|!|>|<)=?)(\s*)/ do
-          groups Text::Whitespace, Operator, Text::Whitespace
-          pop!
-        end
-
-        rule %r/(\s*)(\bcontains\b)(\s*)/ do
-          groups Text::Whitespace, Operator::Word, Text::Whitespace
-          pop!
-        end
-      end
-
       state :end_of_tag do
-        rule(/\}\}/) { token Punctuation; reset_stack }
+        rule(/-?\}\}/) { token Punctuation; reset_stack }
       end
 
       state :end_of_block do
-        rule(/%\}/) { token Punctuation; reset_stack }
+        rule(/-?%\}/) { token Punctuation; reset_stack }
       end
 
       # states for unknown markup
       state :param_markup do
         mixin :whitespace
+        mixin :keyword
         mixin :string
+        mixin :number
 
         rule %r/([^\s=:]+)(\s*)(=|:)/ do
           groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule %r/(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
-          groups Punctuation, Text::Whitespace, Text, Text::Whitespace, Punctuation
-        end
-
-        mixin :number
-        mixin :keyword
-
-        rule %r/,/, Punctuation
+        rule %r/[,:]/, Punctuation
       end
 
       state :default_param_markup do
         mixin :param_markup
-        rule %r/./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :variable_param_markup do
         mixin :param_markup
         mixin :variable
-        rule %r/./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :tag_markup do
+        rule %r/(reversed)\b/, Name::Attribute
+
         mixin :end_of_block
         mixin :default_param_markup
       end
@@ -229,12 +192,14 @@ module Rouge
 
       # states for different values types
       state :keyword do
-        rule %r/\b(false|true)\b/, Keyword::Constant
+        rule %r/(false|true|nil)\b/, Keyword::Constant
       end
 
       state :variable do
-        rule %r/\.(?=\w)/, Punctuation
-        rule %r/[a-zA-Z_]\w*\??/, Name::Variable
+        rule %r/(empty|blank|forloop\.[^\s%}\|:]+)\b/, Name::Builtin
+        rule %r/\.(?=\w)|\[|\]/, Punctuation
+        rule %r/(first|last|size)\b/, Name::Function
+        rule %r/[a-zA-Z_][\w-]*\??/, Name::Variable
       end
 
       state :string do
@@ -243,21 +208,17 @@ module Rouge
       end
 
       state :number do
+        rule %r/-/, Operator
         rule %r/\d+\.\d+/, Num::Float
         rule %r/\d+/, Num::Integer
       end
 
-      state :array_index do
-        rule %r/\[/, Punctuation
-        rule %r/\]/, Punctuation
-      end
-
       state :generic do
-        mixin :array_index
+        mixin :whitespace
         mixin :keyword
         mixin :string
-        mixin :variable
         mixin :number
+        mixin :variable
       end
 
       state :whitespace do
@@ -265,18 +226,20 @@ module Rouge
       end
 
       state :comment do
-        rule %r/(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+        rule %r/[^\{]+/, Comment
+
+        rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule %r/./, Comment
+        rule %r/\{/, Comment
       end
 
       state :raw do
         rule %r/[^\{]+/, Text
 
-        rule %r/(\{%)(\s*)(endraw)(\s*)(%\})/ do
+        rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
@@ -285,27 +248,38 @@ module Rouge
       end
 
       state :assign do
-        mixin :whitespace
-        mixin :end_of_block
+        rule %r/=/, Operator
 
-        rule %r/(\s*)(=)(\s*)/ do
-          groups Text::Whitespace, Operator, Text::Whitespace
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
         end
 
-        rule %r/\|/, Punctuation, :filters
-
+        mixin :end_of_block
         mixin :generic
       end
 
       state :include do
-        mixin :whitespace
-
-        rule %r/([^\.]+)(\.)(html|liquid)/ do
-          groups Name::Attribute, Punctuation, Name::Attribute
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output_embed
         end
 
+        rule %r/(with|for)\b/, Name::Tag
+        rule %r/[^\s\.]+(\.[^\s\.]+)+\b/, Name::Other
+
         mixin :variable_tag_markup
       end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Punctuation, :pop!
+
+        mixin :variable_param_markup
+      end
     end
   end
 end

data/lib/rouge/lexers/perl.rb

@@ -127,7 +127,7 @@ module Rouge
         rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
         rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
         rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
-        rule %r/(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
+        rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
 
         rule %r/package\s+/, Keyword, :modulename
         rule %r/sub\s+/, Keyword, :funcname

data/lib/rouge/lexers/robot_framework.rb

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class RobotFramework < RegexLexer
+      tag 'robot_framework'
+      aliases 'robot', 'robot-framework'
+
+      title "Robot Framework"
+      desc 'Robot Framework is a generic open source automation testing framework (robotframework.org)'
+
+      filenames '*.robot'
+      mimetypes 'text/x-robot'
+
+      def initialize(opts = {})
+        super(opts)
+        @col = 0
+        @next = nil
+        @is_template = false
+      end
+
+      def self.settings_with_keywords
+        @settings_with_keywords ||= Set.new [
+          "library", "resource", "setup", "teardown", "template", "suite setup",
+          "suite teardown", "task setup", "task teardown", "task template",
+          "test setup", "test teardown", "test template", "variables"
+        ]
+      end
+      
+      def self.settings_with_args
+        @settings_with_args ||= Set.new [
+          "arguments", "default tags", "documentation", "force tags",
+          "metadata", "return", "tags", "timeout", "task timeout",
+          "test timeout"
+        ]
+      end
+
+      id = %r/(?:\\|[^|$@&% \t\n])+(?: (?:\\.|[^|$@&% \t\n])+)*/
+      bdd = %r/(?:Given|When|Then|And|But) /i
+      sep = %r/ +\| +|[ ]{2,}|\t+/
+
+      start do
+        push :prior_text
+      end
+
+      state :prior_text do
+        rule %r/^[^*].*/, Text
+        rule(//) { pop! }
+      end
+
+      # Mixins
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
+
+      state :section_include do
+        mixin :end_section
+        mixin :sep
+        mixin :newline
+      end
+
+      state :end_section do
+        rule(/(?=^(?:\| )?\*)/) { pop! }
+      end
+
+      state :return do
+        rule(//) { pop! }
+      end
+
+      state :sep do
+        rule %r/\| /, Text::Whitespace
+
+        rule sep do
+          token Text::Whitespace
+          @col = @col + 1
+          if @next
+            push @next
+          elsif @is_template
+            push :args
+          elsif @col == 1
+            @next = :keyword
+            push :keyword
+          else
+            push :args
+          end
+          push :cell_start
+        end
+
+        rule %r/\.\.\. */ do
+          token Text::Whitespace
+          @col = @col + 1
+          push :args
+        end
+        
+        rule %r/ ?\|/, Text::Whitespace
+      end
+
+      state :newline do
+        rule %r/\n/ do
+          token Text::Whitespace
+          @col = 0
+          @next = nil
+          push :cell_start
+        end
+      end
+
+      # States
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^(?:\| )?\*[* ]*([A-Z]+(?: [A-Z]+)?).*/i do |m|
+          token Generic::Heading, m[0]
+          case m[1].chomp("s").downcase
+          when "setting" then push :section_settings
+          when "test case" then push :section_tests
+          when "task" then push :section_tasks
+          when "keyword" then push :section_keywords
+          when "variable" then push :section_variables
+          end
+        end
+      end
+
+      state :section_settings do
+        mixin :section_include
+
+        rule %r/([A-Z]+(?: [A-Z]+)?)(:?)/i do |m|
+          match = m[1].downcase
+          @next = if self.class.settings_with_keywords.include? match
+                    :keyword
+                  elsif self.class.settings_with_args.include? match
+                    :args
+                  end
+          groups Name::Builtin::Pseudo, Punctuation
+        end
+      end
+
+      state :section_tests do
+        mixin :section_include
+        
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+
+        rule id do
+          @is_template = false
+          token Name::Label
+        end
+      end
+
+      state :section_tasks do
+        mixin :section_tests
+      end
+
+      state :section_keywords do
+        mixin :section_include
+  
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          push :var
+        end
+        
+        rule %r/[$@&%{}]+/, Name::Label
+        rule %r/( )(?![ |])/, Name::Label
+        
+        rule id, Name::Label
+      end
+
+      state :section_variables do
+        mixin :section_include
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :args
+          push :var
+        end
+      end
+
+      state :cell_start do
+        rule %r/#.*/, Comment
+        mixin :return
+      end
+
+      state :keyword do
+        rule %r/(\[)([A-Z]+(?: [A-Z]+)?)(\])/i do |m|
+          groups Punctuation, Name::Builtin::Pseudo, Punctuation
+          
+          match = m[2].downcase
+          @is_template = true if match == "template"
+          if self.class.settings_with_keywords.include? match
+            @next = :keyword
+          elsif self.class.settings_with_args.include? match
+            @next = :args
+          end
+
+          pop!
+        end
+
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/FOR/i do
+          token Name::Function
+          @next = :keyword unless @next.nil?
+        end
+
+        rule %r/( )(?![ |])/, Name::Function
+
+        rule bdd, Name::Builtin
+        rule id do
+          token Name::Function
+          @next = nil
+        end
+
+        mixin :return
+      end
+
+      state :args do
+        rule %r/[$@&%]\{/ do
+          token Name::Variable
+          @next = :keyword unless @next.nil?
+          push :var
+        end
+
+        rule %r/[$@&%]+/, Str
+        rule %r/( )(?![ |])/, Str
+        rule id, Str
+        
+        mixin :return
+      end
+
+      state :var do
+        rule %r/(\})( )(=)/ do
+          groups Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+        rule %r/[$@&%]\{/, Name::Variable, :var
+        rule %r/[{\[]/, Name::Variable, :var
+        rule %r/[}\]]/, Name::Variable, :pop!
+        rule %r/[^$@&%{}\[\]]+/, Name::Variable
+        rule %r/\}\[/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/shell.rb

@@ -9,10 +9,12 @@ module Rouge
 
       tag 'shell'
       aliases 'bash', 'zsh', 'ksh', 'sh'
-      filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
-                '.bashrc', '.zshrc', '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD'
+      filenames '*.sh', '*.bash', '*.zsh', '*.ksh', '.bashrc', '.zshrc',
+                '.kshrc', '.profile', 'APKBUILD', 'PKGBUILD', '*.ebuild',
+                '*.eclass', '*.exheres-0', '*.exlib'
 
-      mimetypes 'application/x-sh', 'application/x-shellscript'
+      mimetypes 'application/x-sh', 'application/x-shellscript', 'text/x-sh',
+                'text/x-shellscript'
 
       def self.detect?(text)
         return true if text.shebang?(/(ba|z|k)?sh/)

data/lib/rouge/lexers/swift.rb

@@ -80,7 +80,7 @@ module Rouge
         rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
         rule %r{[\d]+(?:_\d+)*}, Num::Integer
 
-        rule %r/@#{id}(\([^)]+\))?/, Keyword::Declaration
+        rule %r/@#{id}/, Keyword::Declaration
 
         rule %r/(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
           if m[3] == 'set'

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.10.0"
+    "3.11.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.10.0
+  version: 3.11.1
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-03 00:00:00.000000000 Z
+date: 2019-10-01 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -27,6 +27,7 @@ files:
 - lib/rouge/demos/actionscript
 - lib/rouge/demos/ada
 - lib/rouge/demos/apache
+- lib/rouge/demos/apex
 - lib/rouge/demos/apiblueprint
 - lib/rouge/demos/applescript
 - lib/rouge/demos/armasm
@@ -53,6 +54,7 @@ files:
 - lib/rouge/demos/crystal
 - lib/rouge/demos/csharp
 - lib/rouge/demos/css
+- lib/rouge/demos/csvs
 - lib/rouge/demos/cuda
 - lib/rouge/demos/cython
 - lib/rouge/demos/d
@@ -153,6 +155,7 @@ files:
 - lib/rouge/demos/r
 - lib/rouge/demos/racket
 - lib/rouge/demos/reasonml
+- lib/rouge/demos/robot_framework
 - lib/rouge/demos/ruby
 - lib/rouge/demos/rust
 - lib/rouge/demos/sas
@@ -219,6 +222,7 @@ files:
 - lib/rouge/lexers/ada.rb
 - lib/rouge/lexers/apache.rb
 - lib/rouge/lexers/apache/keywords.yml
+- lib/rouge/lexers/apex.rb
 - lib/rouge/lexers/apiblueprint.rb
 - lib/rouge/lexers/apple_script.rb
 - lib/rouge/lexers/armasm.rb
@@ -245,6 +249,7 @@ files:
 - lib/rouge/lexers/crystal.rb
 - lib/rouge/lexers/csharp.rb
 - lib/rouge/lexers/css.rb
+- lib/rouge/lexers/csvs.rb
 - lib/rouge/lexers/cuda.rb
 - lib/rouge/lexers/cython.rb
 - lib/rouge/lexers/d.rb
@@ -351,6 +356,7 @@ files:
 - lib/rouge/lexers/r.rb
 - lib/rouge/lexers/racket.rb
 - lib/rouge/lexers/reasonml.rb
+- lib/rouge/lexers/robot_framework.rb
 - lib/rouge/lexers/ruby.rb
 - lib/rouge/lexers/rust.rb
 - lib/rouge/lexers/sas.rb