rouge 4.0.1 → 4.1.1

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_]*/
 
       ############################################################################################################################