rouge 4.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 555fb3207f31723860f17a269418bbaea9dff23c0ae97dc5f27fabd797fc4ad5
-  data.tar.gz: ad0c9a8de4f66de72f487f8310abda1e763c92816ef2de031a7aea89bcd155c0
+  metadata.gz: 239a3d42bfd3954d0e6f97efe4265a99cfa719bc2d0815a3fbfa1d47cb58fa66
+  data.tar.gz: 54cccb6161415559baa8a6d8003f9bf9c9c3eb8f241b4c21234c96f1b3d9a148
 SHA512:
-  metadata.gz: fcdb09306c5640839523e4ade20a7a272d835f0cd7eec7d2a3b43ae4598d5f0ef50ce2c64e24de31d98e10501f5a8ea53b0e064b51a0e3166756a0669e76b3e9
-  data.tar.gz: 8c2deba5fc1d897f655642ed01f1817743d249fe1a8dabcc9de873b5203378b63315c5f5fd18c25a479d97aed5e726c9efffb43b1f0c83fbcc6aaf75ce1cf23d
+  metadata.gz: 1463511e91aee04d120e090808e232ac5d07435971b3072716046bcc6d43bf5f86c3ef9c1f11b2cfdefded88259951d299f6b476437744ac0861e3dc0516b55f
+  data.tar.gz: a4aba9526815bf9d28a6ae7e0d02e3df29b250fa76b53d1c7bca0500cdcc8bd641198db02448e495bea510ac9b3bc1b42fb09ddc3e76dc1d501594074e7602fd

data/lib/rouge/guessers/disambiguation.rb

@@ -129,6 +129,7 @@ module Rouge
 
       disambiguate '*.cls' do
         next TeX if matches?(/\A\s*(?:\\|%)/)
+        next OpenEdge if matches?(/(no\-undo|BLOCK\-LEVEL|ROUTINE\-LEVEL|&ANALYZE\-SUSPEND)/i)
         next Apex
       end
 
@@ -139,6 +140,12 @@ module Rouge
 
         Puppet
       end
+      
+      disambiguate '*.p' do
+        next Prolog if contains?(':-')
+        next Prolog if matches?(/\A\w+(\(\w+\,\s*\w+\))*\./)
+        next OpenEdge
+      end
     end
   end
 end

data/lib/rouge/lexers/dart.rb

@@ -12,16 +12,16 @@ module Rouge
       mimetypes 'text/x-dart'
 
       keywords = %w(
-        as assert await break case catch continue default do else finally for
-        if in is new rethrow return super switch this throw try while with yield
+        as assert await break case catch continue default do else finally for if
+        in is new rethrow return super switch this throw try while when with yield
       )
 
       declarations = %w(
-        abstract async dynamic const covariant external extends factory final get
-        implements late native on operator required set static sync typedef var
+        abstract base async dynamic const covariant external extends factory final get implements
+        inline interface late native on operator required sealed set static sync typedef var
       )
 
-      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Set String Symbol Type Uri void)
+      types = %w(bool Comparable double Dynamic enum Function int List Map Never Null num Object Pattern Record Set String Symbol Type Uri void)
 
       imports = %w(import deferred export library part\s*of part source)
 
@@ -53,7 +53,7 @@ module Rouge
         rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule %r/(?:#{types.join('|')})\b/, Keyword::Type
         rule %r/(?:true|false|null)\b/, Keyword::Constant
-        rule %r/(?:class|interface|mixin)\b/, Keyword::Declaration, :class
+        rule %r/(?:class|mixin)\b/, Keyword::Declaration, :class
         rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
         rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute

data/lib/rouge/lexers/dot.rb

@@ -8,6 +8,7 @@ module Rouge
       desc "graph description language"
 
       tag 'dot'
+      aliases 'graphviz'
       filenames '*.dot'
       mimetypes 'text/vnd.graphviz'
 

data/lib/rouge/lexers/javascript.rb

@@ -190,7 +190,14 @@ module Rouge
 
         rule %r/function(?=(\(.*\)))/, Keyword::Declaration # For anonymous functions
 
-        rule %r/(#{id})[ \t]*(?=(\(.*\)))/m, Name::Function
+        rule %r/(#{id})[ \t]*(?=(\(.*\)))/m do |m|
+          if self.class.keywords.include? m[1]
+            # "if" in "if (...)" or "switch" in "switch (...)" are recognized as keywords.
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
 
         rule %r/[{}]/, Punctuation, :statement
 

data/lib/rouge/lexers/jinja.rb

@@ -14,25 +14,25 @@ module Rouge
                 'text/html+django', 'text/html+jinja'
 
       def self.keywords
-        @@keywords ||= %w(as context do else extends from ignore missing
-                          import include reversed recursive scoped
-                          autoescape endautoescape block endblock call endcall
-                          filter endfilter for endfor if endif macro endmacro
-                          set endset trans endtrans with endwith without)
+        @keywords ||= %w(as context do else extends from ignore missing
+                         import include reversed recursive scoped
+                         autoescape endautoescape block endblock call endcall
+                         filter endfilter for endfor if endif macro endmacro
+                         set endset trans endtrans with endwith without)
       end
 
       def self.tests
-        @@tests ||= %w(callable defined divisibleby equalto escaped even iterable
-                       lower mapping none number odd sameas sequence string
-                       undefined upper)
+        @tests ||= %w(callable defined divisibleby equalto escaped even iterable
+                      lower mapping none number odd sameas sequence string
+                      undefined upper)
       end
 
       def self.pseudo_keywords
-        @@pseudo_keywords ||= %w(true false none True False None)
+        @pseudo_keywords ||= %w(true false none True False None)
       end
 
       def self.word_operators
-        @@word_operators ||= %w(is in and or not)
+        @word_operators ||= %w(is in and or not)
       end
 
       state :root do

data/lib/rouge/lexers/liquid.rb

@@ -8,228 +8,164 @@ module Rouge
       desc 'Liquid is a templating engine for Ruby (liquidmarkup.org)'
       tag 'liquid'
       filenames '*.liquid'
+      mimetypes 'text/html+liquid'
 
       state :root do
         rule %r/[^\{]+/, Text
 
         rule %r/(\{%-?)(\s*)/ do
-          groups Punctuation, Text::Whitespace
-          push :tag_or_block
+          groups Comment::Preproc, Text::Whitespace
+          push :logic
         end
 
         rule %r/(\{\{-?)(\s*)/ do
-          groups Punctuation, Text::Whitespace
+          groups Comment::Preproc, Text::Whitespace
           push :output
         end
 
         rule %r/\{/, Text
       end
 
-      state :tag_or_block do
+      state :end_logic do
+        rule(/(\s*)(-?%\})/) do
+          groups Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+
+        rule(/\n\s*/) do
+          token Text::Whitespace
+          if in_state? :liquid
+            pop! until state? :liquid
+          end
+        end
+
+        mixin :whitespace
+      end
+
+      state :end_output do
+        rule(/(\s*)(-?\}\})/) do
+          groups Text::Whitespace, Comment::Preproc
+          reset_stack
+        end
+      end
+
+      state :liquid do
+        mixin :end_logic
+        mixin :logic
+      end
+
+      state :logic do
+        rule %r/(liquid)\b/, Name::Tag, :liquid
+
         # builtin logic blocks
-        rule %r/(if|elsif|unless|case)\b/, Keyword::Reserved, :condition
-        rule %r/(when)\b/, Keyword::Reserved, :when
+        rule %r/(if|elsif|unless|case)\b/, Name::Tag, :condition
+        rule %r/(when)\b/, Name::Tag, :value
+        rule %r/(else|ifchanged|end\w+)\b/, Name::Tag, :end_logic
+        rule %r/(break|continue)\b/, Keyword::Reserved, :end_logic
 
-        rule %r/(else)(\s*)(-?%\})/ do
-          groups Keyword::Reserved, Text::Whitespace, Punctuation
-          pop!
+        # builtin iteration blocks
+        rule %r/(for|tablerow)(\s+)(\S+)(\s+)(in)(\s+)/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Name::Tag, Text::Whitespace
+          push :iteration_args
         end
 
         # other builtin blocks
-        rule %r/(capture|(?:in|de)crement)(\s+)([^\s%]+)(\s*)(-?%\})/ do
-          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace, Punctuation
-          pop!
+        rule %r/(capture|(?:in|de)crement)(\s+)([a-zA-Z_](?:\w|-(?!%))*)/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable
+          push :end_logic
         end
 
         rule %r/(comment)(\s*)(-?%\})/ do
-          groups Name::Tag, Text::Whitespace, Punctuation
+          groups Name::Tag, Text::Whitespace, Comment::Preproc
           push :comment
         end
 
         rule %r/(raw)(\s*)(-?%\})/ do
-          groups Name::Tag, Text::Whitespace, Punctuation
+          groups Name::Tag, Text::Whitespace, Comment::Preproc
           push :raw
         end
 
-        # end of block
-        rule %r/(end(?:if|unless|case))(\s*)(-?%\})/ do
-          groups Keyword::Reserved, Text::Whitespace, Punctuation
-          pop!
-        end
-
-        rule %r/(end(?:[^\s%]+))(\s*)(-?%\})/ do
-          groups Name::Tag, Text::Whitespace, Punctuation
-          pop!
-        end
-
         # builtin tags
         rule %r/(assign|echo)\b/, Name::Tag, :assign
-        rule %r/(include|render)\b/, Name::Tag, :include
 
-        rule %r/(cycle)(\s+)(?:([^\s:]*)(\s*)(:))?(\s*)/ do |m|
+        rule %r/(include|render)(\s+)([\/\w-]+(?:\.[\w-]+)+\b)?/ do
+          groups Name::Tag, Text::Whitespace, Text
+          push :include
+        end
+
+        rule %r/(cycle)(\s+)(?:([\w-]+|'[^']*'|"[^"]*")(\s*)(:))?(\s*)/ do |m|
           token_class = case m[3]
                         when %r/'[^']*'/ then Str::Single
                         when %r/"[^"]*"/ then Str::Double
                         else
                           Name::Attribute
                         end
-
           groups Name::Tag, Text::Whitespace, token_class,
                  Text::Whitespace, Punctuation, Text::Whitespace
-
-          push :variable_tag_markup
+          push :tag_args
         end
 
-        # iteration
-        rule %r/
-          (for|tablerow)(\s+)
-          ([\w-]+)(\s+)
-          (in)(\s+)
-          (
-            (?: [^\s%,\|'"] | (?:"[^"]*"|'[^']*') )+
-          )(\s*)
-        /x do |m|
-          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
-                 Name::Tag, Text::Whitespace
-
-          token_class = case m[7]
-                        when %r/'[^']*'/ then Str::Single
-                        when %r/"[^"]*"/ then Str::Double
-                        else
-                          Name::Variable
-                        end
-          token token_class, m[7]
-          token Text::Whitespace, m[8]
-          push :tag_markup
-        end
+        # custom tags or blocks
+        rule %r/(\w+)\b/, Name::Tag, :block_args
 
-        # other tags or blocks
-        rule %r/([^\s%]+)(\s*)/ do
-          groups Name::Tag, Text::Whitespace
-          push :tag_markup
-        end
+        mixin :end_logic
       end
 
       state :output do
-        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
-          groups Punctuation, Text::Whitespace, Name::Function
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
           push :filters
+          push :filter
         end
 
-        mixin :end_of_tag
-        mixin :generic
-      end
-
-      state :filters do
-        rule %r/(\|)(\s*)([a-zA-Z_][^\s%}\|:]*)/ do
-          groups Punctuation, Text::Whitespace, Name::Function
-        end
-
-        mixin :end_of_tag
-        mixin :end_of_block
-        mixin :variable_param_markup
+        mixin :end_output
+        mixin :static
+        mixin :variable
       end
 
       state :condition do
         rule %r/([=!]=|[<>]=?)/, Operator
         rule %r/(and|or|contains)\b/, Operator::Word
 
-        mixin :end_of_block
-        mixin :generic
-      end
-
-      state :when do
-        mixin :end_of_block
-        mixin :generic
-      end
-
-      state :end_of_tag do
-        rule(/-?\}\}/) { token Punctuation; reset_stack }
+        mixin :value
       end
 
-      state :end_of_block do
-        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/[,:]/, Punctuation
-      end
-
-      state :default_param_markup do
-        mixin :param_markup
-
-        rule %r/\S+/, Text
-      end
-
-      state :variable_param_markup do
-        mixin :param_markup
+      state :value do
+        mixin :end_logic
+        mixin :static
         mixin :variable
-
-        rule %r/\S+/, Text
-      end
-
-      state :tag_markup do
-        rule %r/(reversed)\b/, Name::Attribute
-
-        mixin :end_of_block
-        mixin :default_param_markup
-      end
-
-      state :variable_tag_markup do
-        mixin :end_of_block
-        mixin :variable_param_markup
       end
 
-      # states for different values types
-      state :keyword do
-        rule %r/(false|true|nil)\b/, Keyword::Constant
-      end
+      state :iteration_args do
+        rule %r/(reversed|continue)\b/, Name::Attribute
+        rule %r/\(/, Punctuation, :range
 
-      state :variable do
-        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
+        mixin :tag_args
       end
 
-      state :string do
-        rule %r/'[^']*'/, Str::Single
-        rule %r/"[^"]*"/, Str::Double
-      end
+      state :block_args do
+        rule %r/(\{\{-?)/, Comment::Preproc, :output_embed
 
-      state :number do
-        rule %r/-/, Operator
-        rule %r/\d+\.\d+/, Num::Float
-        rule %r/\d+/, Num::Integer
-      end
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :filters
+          push :filter
+        end
 
-      state :generic do
-        mixin :whitespace
-        mixin :keyword
-        mixin :string
-        mixin :number
-        mixin :variable
+        mixin :tag_args
       end
 
-      state :whitespace do
-        rule %r/[ \t]+/, Text::Whitespace
+      state :tag_args do
+        mixin :end_logic
+        mixin :args
       end
 
       state :comment do
         rule %r/[^\{]+/, Comment
 
         rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
-          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          groups Comment::Preproc, Text::Whitespace, Name::Tag, Text::Whitespace, Comment::Preproc
           reset_stack
         end
 
@@ -240,7 +176,7 @@ module Rouge
         rule %r/[^\{]+/, Text
 
         rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
-          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          groups Comment::Preproc, Text::Whitespace, Name::Tag, Text::Whitespace, Comment::Preproc
           reset_stack
         end
 
@@ -249,36 +185,100 @@ module Rouge
 
       state :assign do
         rule %r/=/, Operator
+        rule %r/\(/, Punctuation, :range
 
-        rule %r/(\|)(\s*)([a-zA-Z_][^\s%\|:]*)/ do
-          groups Punctuation, Text::Whitespace, Name::Function
+        rule %r/(\|)(\s*)/ do
+          groups Punctuation, Text::Whitespace
           push :filters
+          push :filter
         end
 
-        mixin :end_of_block
-        mixin :generic
+        mixin :value
       end
 
       state :include do
-        rule %r/(\{\{-?)(\s*)/ do
+        rule %r/(\{\{-?)/, Comment::Preproc, :output_embed
+        rule %r/(with|for|as)\b/, Keyword::Reserved
+
+        mixin :tag_args
+      end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_](?:\w|-(?!}))*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Comment::Preproc, :pop!
+
+        mixin :args
+      end
+
+      state :range do
+        rule %r/\.\./, Punctuation
+        rule %r/\)/, Punctuation, :pop!
+
+        mixin :whitespace
+        mixin :number
+        mixin :variable
+      end
+
+      state :filters do
+        rule %r/(\|)(\s*)/ do
           groups Punctuation, Text::Whitespace
-          push :output_embed
+          push :filter
         end
 
-        rule %r/(with|for)\b/, Name::Tag
-        rule %r/[\/\w-]+(\.[\w-]+)+\b/, Text
+        mixin :end_logic
+        mixin :end_output
+        mixin :args
+      end
 
-        mixin :variable_tag_markup
+      state :filter do
+        rule %r/[a-zA-Z_](?:\w|-(?![%}]))*/, Name::Function, :pop!
+        
+        mixin :whitespace
       end
 
-      state :output_embed do
-        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
-          groups Punctuation, Text::Whitespace, Name::Function
+      state :args do
+        mixin :static
+
+        rule %r/([a-zA-Z_][\w-]*)(\s*)(=|:)/ do
+          groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule %r/-?\}\}/, Punctuation, :pop!
+        mixin :variable
+      end
 
-        mixin :variable_param_markup
+      state :static do
+        rule %r/(false|true|nil)\b/, Keyword::Constant
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
+        rule %r/[,:]/, Punctuation
+
+        mixin :whitespace
+        mixin :number
+      end
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/#.*?(?=$|-?[}%]})/, Comment
+      end
+
+      state :number do
+        rule %r/-/, Operator
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
+      end
+
+      state :variable do
+        rule %r/(\.)(\s*)(first|last|size)\b(?![?!\/])/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/\.(?= *\w)|\[|\]/, Punctuation
+        rule %r/(empty|blank|(for|tablerow)loop\.(parentloop\.)*\w+)\b(?![?!\/])/, Name::Builtin
+        rule %r/[a-zA-Z_][\w-]*\b-?(?![?!\/])/, Name::Variable
+        rule %r/\S+/, Text
       end
     end
   end

data/lib/rouge/lexers/mosel.rb

@@ -13,10 +13,6 @@ module Rouge
 
       mimetypes 'text/x-mosel'
 
-      def self.detect?(text)
-        return true if text =~ /^\s*(model|package)\s+/
-      end
-
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       ############################################################################################################################