rouge 3.3.0 → 3.8.0

data/lib/rouge/lexers/liquid.rb

@@ -10,67 +10,67 @@ module Rouge
       filenames '*.liquid'
 
       state :root do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)/ do
+        rule %r/(\{%)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :tag_or_block
         end
 
-        rule /(\{\{)(\s*)/ do
+        rule %r/(\{\{)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :output
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :tag_or_block do
         # builtin logic blocks
-        rule /(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+        rule %r/(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
 
-        rule /(when)(\s+)/ do
+        rule %r/(when)(\s+)/ do
           groups Keyword::Reserved, Text::Whitespace
           push :when
         end
 
-        rule /(else)(\s*)(%\})/ do
+        rule %r/(else)(\s*)(%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
         # other builtin blocks
-        rule /(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
+        rule %r/(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(comment)(\s*)(%\})/ do
+        rule %r/(comment)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :comment
         end
 
-        rule /(raw)(\s*)(%\})/ do
+        rule %r/(raw)(\s*)(%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :raw
         end
 
-        rule /assign/, Name::Tag, :assign
-        rule /include/, Name::Tag, :include
+        rule %r/assign/, Name::Tag, :assign
+        rule %r/include/, Name::Tag, :include
 
         # end of block
-        rule /(end(case|unless|if))(\s*)(%\})/ do
-          groups Keyword::Reserved, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:case|unless|if))(\s*)(%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(end([^\s%]+))(\s*)(%\})/ do
-          groups Name::Tag, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:[^\s%]+))(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
           pop!
         end
 
         # builtin tags
-        rule /(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
+        rule %r/(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
           token Name::Tag, m[1]
           token Text::Whitespace, m[2]
 
@@ -88,8 +88,31 @@ module Rouge
           push :variable_tag_markup
         end
 
+        # iteration
+        rule %r/
+          (for)(\s+)
+          ([\w-]+)(\s+)
+          (in)(\s+)
+          (
+            (?: [^\s,\|'"] | (?:"[^"]*"|'[^']*') )+
+          )(\s*)
+        /x do |m|
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Keyword::Reserved, 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
+
         # other tags or blocks
-        rule /([^\s%]+)(\s*)/ do
+        rule %r/([^\s%]+)(\s*)/ do
           groups Name::Tag, Text::Whitespace
           push :tag_markup
         end
@@ -99,8 +122,8 @@ module Rouge
         mixin :whitespace
         mixin :generic
 
-        rule /\}\}/, Punctuation, :pop!
-        rule /\|/, Punctuation, :filters
+        rule %r/\}\}/, Punctuation, :pop!
+        rule %r/\|/, Punctuation, :filters
       end
 
       state :filters do
@@ -108,14 +131,14 @@ module Rouge
 
         rule(/\}\}/) { token Punctuation; reset_stack }
 
-        rule /([^\s\|:]+)(:?)(\s*)/ do
+        rule %r/([^\s\|:]+)(:?)(\s*)/ do
           groups Name::Function, Punctuation, Text::Whitespace
           push :filter_markup
         end
       end
 
       state :filter_markup do
-        rule /\|/, Punctuation, :pop!
+        rule %r/\|/, Punctuation, :pop!
 
         mixin :end_of_tag
         mixin :end_of_block
@@ -126,13 +149,13 @@ module Rouge
         mixin :end_of_block
         mixin :whitespace
 
-        rule /([=!><]=?)/, Operator
+        rule %r/([=!><]=?)/, Operator
 
-        rule /\b((!)|(not\b))/ do
-          groups nil, Operator, Operator::Word
+        rule %r/\b(?:(!)|(not\b))/ do
+          groups Operator, Operator::Word
         end
 
-        rule /(contains)/, Operator::Word
+        rule %r/(contains)/, Operator::Word
 
         mixin :generic
         mixin :whitespace
@@ -145,12 +168,12 @@ module Rouge
       end
 
       state :operator do
-        rule /(\s*)((=|!|>|<)=?)(\s*)/ do
-          groups Text::Whitespace, Operator, nil, Text::Whitespace
+        rule %r/(\s*)((?:=|!|>|<)=?)(\s*)/ do
+          groups Text::Whitespace, Operator, Text::Whitespace
           pop!
         end
 
-        rule /(\s*)(\bcontains\b)(\s*)/ do
+        rule %r/(\s*)(\bcontains\b)(\s*)/ do
           groups Text::Whitespace, Operator::Word, Text::Whitespace
           pop!
         end
@@ -169,29 +192,29 @@ module Rouge
         mixin :whitespace
         mixin :string
 
-        rule /([^\s=:]+)(\s*)(=|:)/ do
+        rule %r/([^\s=:]+)(\s*)(=|:)/ do
           groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule /(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
-          groups Punctuation, Text::Whitespace, nil, Text::Whitespace, Punctuation
+        rule %r/(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
+          groups Punctuation, Text::Whitespace, Text, Text::Whitespace, Punctuation
         end
 
         mixin :number
         mixin :keyword
 
-        rule /,/, Punctuation
+        rule %r/,/, Punctuation
       end
 
       state :default_param_markup do
         mixin :param_markup
-        rule /./, Text
+        rule %r/./, Text
       end
 
       state :variable_param_markup do
         mixin :param_markup
         mixin :variable
-        rule /./, Text
+        rule %r/./, Text
       end
 
       state :tag_markup do
@@ -206,27 +229,27 @@ module Rouge
 
       # states for different values types
       state :keyword do
-        rule /\b(false|true)\b/, Keyword::Constant
+        rule %r/\b(false|true)\b/, Keyword::Constant
       end
 
       state :variable do
-        rule /\.(?=\w)/, Punctuation
-        rule /[a-zA-Z_]\w*\??/, Name::Variable
+        rule %r/\.(?=\w)/, Punctuation
+        rule %r/[a-zA-Z_]\w*\??/, Name::Variable
       end
 
       state :string do
-        rule /'[^']*'/, Str::Single
-        rule /"[^"]*"/, Str::Double
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
       end
 
       state :number do
-        rule /\d+\.\d+/, Num::Float
-        rule /\d+/, Num::Integer
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
       end
 
       state :array_index do
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
       end
 
       state :generic do
@@ -238,38 +261,38 @@ module Rouge
       end
 
       state :whitespace do
-        rule /[ \t]+/, Text::Whitespace
+        rule %r/[ \t]+/, Text::Whitespace
       end
 
       state :comment do
-        rule /(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+        rule %r/(\{%)(\s*)(endcomment)(\s*)(%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /./, Comment
+        rule %r/./, Comment
       end
 
       state :raw do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)(endraw)(\s*)(%\})/ do
+        rule %r/(\{%)(\s*)(endraw)(\s*)(%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :assign do
         mixin :whitespace
         mixin :end_of_block
 
-        rule /(\s*)(=)(\s*)/ do
+        rule %r/(\s*)(=)(\s*)/ do
           groups Text::Whitespace, Operator, Text::Whitespace
         end
 
-        rule /\|/, Punctuation, :filters
+        rule %r/\|/, Punctuation, :filters
 
         mixin :generic
       end
@@ -277,7 +300,7 @@ module Rouge
       state :include do
         mixin :whitespace
 
-        rule /([^\.]+)(\.)(html|liquid)/ do
+        rule %r/([^\.]+)(\.)(html|liquid)/ do
           groups Name::Attribute, Punctuation, Name::Attribute
         end
 

data/lib/rouge/lexers/literate_coffeescript.rb

@@ -21,11 +21,11 @@ module Rouge
       start { markdown.reset!; coffee.reset! }
 
       state :root do
-        rule /^(    .*?\n)+/m do
+        rule %r/^(    .*?\n)+/m do
           delegate coffee
         end
 
-        rule /^([ ]{0,3}(\S.*?|)\n)*/m do
+        rule %r/^([ ]{0,3}(\S.*?|)\n)*/m do
           delegate markdown
         end
       end

data/lib/rouge/lexers/literate_haskell.rb

@@ -19,18 +19,18 @@ module Rouge
 
       # TODO: support TeX versions as well.
       state :root do
-        rule /\s*?\n(?=>)/, Text, :code
-        rule /.*?\n/, Text
-        rule /.+\z/, Text
+        rule %r/\s*?\n(?=>)/, Text, :code
+        rule %r/.*?\n/, Text
+        rule %r/.+\z/, Text
       end
 
       state :code do
-        rule /(>)( .*?(\n|\z))/ do |m|
+        rule %r/(>)( .*?(\n|\z))/ do |m|
           token Name::Label, m[1]
           delegate haskell, m[2]
         end
 
-        rule /\s*\n(?=\s*[^>])/, Text, :pop!
+        rule %r/\s*\n(?=\s*[^>])/, Text, :pop!
       end
     end
   end

data/lib/rouge/lexers/llvm.rb

@@ -15,21 +15,22 @@ module Rouge
       identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
 
       state :basic do
-        rule /;.*?$/, Comment::Single
-        rule /\s+/, Text
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/, Text
 
-        rule /#{identifier}\s*:/, Name::Label
+        rule %r/#{identifier}\s*:/, Name::Label
 
-        rule /@(#{identifier}|\d+)/, Name::Variable::Global
-        rule /(%|!)#{identifier}/, Name::Variable
-        rule /(%|!)\d+/, Name::Variable
+        rule %r/@(#{identifier}|\d+)/, Name::Variable::Global
+        rule %r/#\d+/, Name::Variable::Global
+        rule %r/(%|!)#{identifier}/, Name::Variable
+        rule %r/(%|!)\d+/, Name::Variable
 
-        rule /c?#{string}/, Str
+        rule %r/c?#{string}/, Str
 
-        rule /0[xX][a-fA-F0-9]+/, Num
-        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+        rule %r/0[xX][a-fA-F0-9]+/, Num
+        rule %r/-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
 
-        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
+        rule %r/[=<>{}\[\]()*.,!]|x/, Punctuation
       end
 
       builtin_types = %w(
@@ -37,12 +38,12 @@ module Rouge
       )
 
       state :types do
-        rule /i[1-9]\d*/, Keyword::Type
-        rule /#{builtin_types.join('|')}/, Keyword::Type
+        rule %r/i[1-9]\d*/, Keyword::Type
+        rule %r/#{builtin_types.join('|')}/, Keyword::Type
       end
 
       builtin_keywords = %w(
-        begin end true false declare define global constant personality private
+        begin end true false declare define global constant alignstack private
         landingpad linker_private internal available_externally linkonce_odr
         linkonce weak weak_odr appending dllimport dllexport common default
         hidden protected extern_weak external thread_local zeroinitializer
@@ -54,7 +55,13 @@ module Rouge
         nest readnone readonly inlinehint noinline alwaysinline optsize ssp
         sspreq noredzone noimplicitfloat naked type opaque eq ne slt sgt sle
         sge ult ugt ule uge oeq one olt ogt ole oge ord uno unnamed_addr ueq
-        une uwtable x
+        une uwtable x personality allocsize builtin cold convergent
+        inaccessiblememonly inaccessiblemem_or_argmemonly jumptable minsize
+        no-jump-tables nobuiltin noduplicate nonlazybind noredzone norecurse
+        optforfuzzing optnone writeonly argmemonly returns_twice safestack
+        sanitize_address sanitize_memory sanitize_thread sanitize_hwaddress
+        speculative_load_hardening speculatable sspstrong strictfp nocf_check
+        shadowcallstack attributes
       )
 
       builtin_instructions = %w(
@@ -67,8 +74,8 @@ module Rouge
       )
 
       state :keywords do
-        rule /#{builtin_instructions.join('|')}/, Keyword
-        rule /#{builtin_keywords.join('|')}/, Keyword
+        rule %r/#{builtin_instructions.join('|')}/, Keyword
+        rule %r/#{builtin_keywords.join('|')}/, Keyword
       end
 
       state :root do

data/lib/rouge/lexers/lua.rb

@@ -25,7 +25,7 @@ module Rouge
       end
 
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('lua/builtins.rb')
+        load File.join(__dir__, 'lua/builtins.rb')
         self.builtins
       end
 
@@ -43,7 +43,7 @@ module Rouge
       state :root do
         # lua allows a file to start with a shebang
         rule %r(#!(.*?)$), Comment::Preproc
-        rule //, Text, :base
+        rule %r//, Text, :base
       end
 
       state :base do
@@ -89,7 +89,7 @@ module Rouge
       end
 
       state :function_name do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
           groups Name::Class, Punctuation, Name::Function
           pop!

data/lib/rouge/lexers/m68k.rb

@@ -9,7 +9,6 @@ module Rouge
       title "M68k"
       desc "Motorola 68k Assembler"
 
-      ws = %r((?:\s|;.*?\n/)+)
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       def self.keywords
@@ -83,11 +82,11 @@ module Rouge
       end
 
       state :inline_whitespace do
-        rule /[\s\t\r]+/, Text
+        rule %r/\s+/, Text
       end
 
       state :whitespace do
-        rule /\n+/m, Text, :expr_bol
+        rule %r/\n+/m, Text, :expr_bol
         rule %r(^\*(\\.|.)*?\n), Comment::Single, :expr_bol
         rule %r(;(\\.|.)*?\n), Comment::Single, :expr_bol
         mixin :inline_whitespace
@@ -99,19 +98,19 @@ module Rouge
 
       state :statements do
         mixin :whitespace
-        rule /"/, Str, :string
-        rule /#/, Name::Decorator
-        rule /^\.?[a-zA-Z0-9_]+:?/, Name::Label
-        rule /\.[bswl]\s/i, Name::Decorator
+        rule %r/"/, Str, :string
+        rule %r/#/, Name::Decorator
+        rule %r/^\.?[a-zA-Z0-9_]+:?/, Name::Label
+        rule %r/\.[bswl]\s/i, Name::Decorator
         rule %r('(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
-        rule /\$[0-9a-f]+/i, Num::Hex
-        rule /@[0-8]+/i, Num::Oct
-        rule /%[01]+/i, Num::Bin
-        rule /\d+/i, Num::Integer
+        rule %r/\$[0-9a-f]+/i, Num::Hex
+        rule %r/@[0-8]+/i, Num::Oct
+        rule %r/%[01]+/i, Num::Bin
+        rule %r/\d+/i, Num::Integer
         rule %r([*~&+=\|?:<>/-]), Operator
-        rule /\\./, Comment::Preproc
-        rule /[(),.]/, Punctuation
-        rule /\[[a-zA-Z0-9]*\]/, Punctuation
+        rule %r/\\./, Comment::Preproc
+        rule %r/[(),.]/, Punctuation
+        rule %r/\[[a-zA-Z0-9]*\]/, Punctuation
 
         rule id do |m|
           name = m[0]
@@ -133,11 +132,11 @@ module Rouge
       end
 
       state :string do
-        rule /"/, Str, :pop!
-        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
-        rule /[^\\"\n]+/, Str
-        rule /\\\n/, Str
-        rule /\\/, Str # stray backslash
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
       end
     end
   end