rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/verilog.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -9,8 +10,6 @@ module Rouge
       filenames '*.v', '*.sv', '*.svh'
       mimetypes 'text/x-verilog', 'text/x-systemverilog'
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       def self.keywords
@@ -81,7 +80,7 @@ module Rouge
 
       state :expr_bol do
         mixin :inline_whitespace
-        rule /`define/, Comment::Preproc, :macro
+        rule %r/`define/, Comment::Preproc, :macro
 
         rule(//) { pop! }
       end
@@ -89,47 +88,47 @@ module Rouge
       # :expr_bol is the same as :bol but without labels, since
       # labels can only appear at the beginning of a statement.
       state :bol do
-        rule /#{id}:(?!:)/, Name::Label
+        rule %r/#{id}:(?!:)/, Name::Label
         mixin :expr_bol
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
-        rule /\\\n/, Text # line continuation
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
         rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
       end
 
       state :whitespace do
-        rule /\n+/m, Text, :bol
-        rule %r(//(\\.|.)*?\n), Comment::Single, :bol
+        rule %r/\n+/m, Text, :bol
+        rule %r(//(\\.|.)*?$), Comment::Single, :bol
         mixin :inline_whitespace
       end
 
       state :expr_whitespace do
-        rule /\n+/m, Text, :expr_bol
+        rule %r/\n+/m, Text, :expr_bol
         mixin :whitespace
       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
 
       state :statement do
         mixin :whitespace
-        rule /L?"/, Str, :string
-        rule /([0-9_]+\.[0-9_]*|[0-9_]*\.[0-9_]+)(e[+-]?[0-9_]+)?/i, Num::Float
-        rule /[0-9_]+e[+-]?[0-9_]+/i, Num::Float
-        rule /[0-9]*'h[0-9a-fA-F_?]+/, Num::Hex
-        rule /[0-9]*'b?[01xz_?]+/, Num::Bin
-        rule /[0-9]*'d[0-9_?]+/, Num::Integer
-        rule /[0-9_]+[lu]*/i, Num::Integer
-        rule %r([~!%^&*+-=\|?:<>/@{}]), Operator
-        rule /[()\[\],.$\#]/, Punctuation
-        rule /`(\w+)/, Comment::Preproc
+        rule %r/L?"/, Str, :string
+        rule %r/([0-9_]+\.[0-9_]*|[0-9_]*\.[0-9_]+)(e[+-]?[0-9_]+)?/i, Num::Float
+        rule %r/[0-9_]+e[+-]?[0-9_]+/i, Num::Float
+        rule %r/[0-9]*'h[0-9a-fA-F_?]+/, Num::Hex
+        rule %r/[0-9]*'b?[01xz_?]+/, Num::Bin
+        rule %r/[0-9]*'d[0-9_?]+/, Num::Integer
+        rule %r/[0-9_]+[lu]*/i, Num::Integer
+        rule %r([-~!%^&*+=\|?:<>/@{}]), Operator
+        rule %r/[()\[\],.$\#;]/, Punctuation
+        rule %r/`(\w+)/, Comment::Preproc
 
         rule id do |m|
           name = m[0]
@@ -152,11 +151,11 @@ module Rouge
       end
 
       state :macro do
-        rule /\n/, Comment::Preproc, :pop!
+        rule %r/\n/, Comment::Preproc, :pop!
         mixin :inline_whitespace
-        rule /;/, Punctuation
-        rule /\=/, Operator
-        rule /(\w+)/, Text
+        rule %r/;/, Punctuation
+        rule %r/\=/, Operator
+        rule %r/(\w+)/, Text
       end
 
     end

data/lib/rouge/lexers/vhdl.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -40,30 +41,30 @@ module Rouge
       id = /[a-zA-Z][a-zA-Z0-9_]*/
 
       state :whitespace do
-        rule /\s+/, Text
-        rule /\n/, Text
+        rule %r/\s+/, Text
+        rule %r/\n/, Text
         # Find Comments (VHDL doesn't support multiline comments)
-        rule /--.*$/, Comment::Single
+        rule %r/--.*$/, Comment::Single
       end
 
       state :statements do
 
         # Find Numbers
-        rule /-?\d+/i, Num::Integer
-        rule /-?\d+[.]\d+/i, Num::Float
+        rule %r/-?\d+/i, Num::Integer
+        rule %r/-?\d+[.]\d+/i, Num::Float
 
         # Find Strings
-        rule /[box]?"[^"]*"/i, Str::Single
-        rule /'[^']?'/i, Str::Char
+        rule %r/[box]?"[^"]*"/i, Str::Single
+        rule %r/'[^']?'/i, Str::Char
 
         # Find Attributes
-        rule /'#{id}/i, Name::Attribute
-        
+        rule %r/'#{id}/i, Name::Attribute
+
         # Punctuations
-        rule /[(),:;]/, Punctuation
+        rule %r/[(),:;]/, Punctuation
 
         # Boolean and NULL
-        rule /(?:true|false|null)\b/i, Name::Builtin
+        rule %r/(?:true|false|null)\b/i, Name::Builtin
 
         rule id do |m|
           match = m[0].downcase   #convert to lower case

data/lib/rouge/lexers/viml.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -13,18 +14,18 @@ module Rouge
       mimetypes 'text/x-vim'
 
       def self.keywords
-        load Pathname.new(__FILE__).dirname.join('viml/keywords.rb')
+        load File.join(Lexers::BASE_DIR, 'viml/keywords.rb')
         self.keywords
       end
 
       state :root do
-        rule /^(\s*)(".*?)$/ do
+        rule %r/^(\s*)(".*?)$/ do
           groups Text, Comment
         end
 
-        rule /^\s*\\/, Str::Escape
+        rule %r/^\s*\\/, Str::Escape
 
-        rule /[ \t]+/, Text
+        rule %r/[ \t]+/, Text
 
         # TODO: regexes can have other delimiters
         rule %r(/(\\\\|\\/|[^\n/])*/), Str::Regex
@@ -32,19 +33,19 @@ module Rouge
         rule %r('(\\\\|\\'|[^\n'])*'), Str::Single
 
         # if it's not a string, it's a comment.
-        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
+        rule %r/(?<=\s)"[^-:.%#=*].*?$/, Comment
 
-        rule /-?\d+/, Num
-        rule /#[0-9a-f]{6}/i, Num::Hex
-        rule /^:/, Punctuation
-        rule /[():<>+=!\[\]{}\|,~.-]/, Punctuation
-        rule /\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
+        rule %r/-?\d+/, Num
+        rule %r/#[0-9a-f]{6}/i, Num::Hex
+        rule %r/^:/, Punctuation
+        rule %r/[():<>+=!\[\]{}\|,~.-]/, Punctuation
+        rule %r/\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
           Keyword
 
-        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
+        rule %r/\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
 
-        rule /[absg]:\w+\b/, Name::Variable
-        rule /\b\w+\b/ do |m|
+        rule %r/[absg]:\w+\b/, Name::Variable
+        rule %r/\b\w+\b/ do |m|
           name = m[0]
           keywords = self.class.keywords
 
@@ -60,7 +61,7 @@ module Rouge
         end
 
         # no errors in VimL!
-        rule /./m, Text
+        rule %r/./m, Text
       end
 
       def mapping_contains?(mapping, word)

data/lib/rouge/lexers/viml/keywords.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 # DO NOT EDIT: automatically generated by `rake builtins:vim`.
 # see tasks/vim.rake for more info.
 module Rouge

data/lib/rouge/lexers/vue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     load_lexer 'html.rb'
@@ -34,21 +36,21 @@ module Rouge
       start { @js.reset! }
 
       prepend :root do
-        rule /(<)(\s*)(template)/ do
+        rule %r/(<)(\s*)(template)/ do
           groups Name::Tag, Text, Keyword
           @lang = HTML
           push :template
           push :lang_tag
         end
 
-        rule /(<)(\s*)(style)/ do
+        rule %r/(<)(\s*)(style)/ do
           groups Name::Tag, Text, Keyword
           @lang = CSS
           push :style
           push :lang_tag
         end
 
-        rule /(<)(\s*)(script)/ do
+        rule %r/(<)(\s*)(script)/ do
           groups Name::Tag, Text, Keyword
           @lang = Javascript
           push :script
@@ -56,8 +58,12 @@ module Rouge
         end
       end
 
+      prepend :tag do
+        rule %r/[a-zA-Z0-9_:#\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+      end
+
       state :style do
-        rule /(<\s*\/\s*)(style)(\s*>)/ do
+        rule %r/(<\s*\/\s*)(style)(\s*>)/ do
           groups Name::Tag, Keyword, Name::Tag
           pop!
         end
@@ -67,7 +73,7 @@ module Rouge
       end
 
       state :script do
-        rule /(<\s*\/\s*)(script)(\s*>)/ do
+        rule %r/(<\s*\/\s*)(script)(\s*>)/ do
           groups Name::Tag, Keyword, Name::Tag
           pop!
         end
@@ -77,7 +83,7 @@ module Rouge
       end
 
       state :lang_tag do
-        rule /(lang\s*=)(\s*)("(?:\\.|[^\\])*?"|'(\\.|[^\\])*?'|[^\s>]+)/ do |m|
+        rule %r/(lang\s*=)(\s*)("(?:\\.|[^\\])*?"|'(\\.|[^\\])*?'|[^\s>]+)/ do |m|
           groups Name::Attribute, Text, Str
           @lang = lookup_lang(m[3])
         end
@@ -91,7 +97,7 @@ module Rouge
           pop!
         end
 
-        rule /{{/ do
+        rule %r/{{/ do
           token Str::Interpol
           push :template_interpol
           @js.reset!
@@ -101,8 +107,8 @@ module Rouge
       end
 
       state :template_interpol do
-        rule /}}/, Str::Interpol, :pop!
-        rule /}/, Error
+        rule %r/}}/, Str::Interpol, :pop!
+        rule %r/}/, Error
         mixin :template_interpol_inner
       end
 
@@ -119,4 +125,3 @@ module Rouge
     end
   end
 end
-

data/lib/rouge/lexers/wollok.rb

@@ -1,4 +1,5 @@
-# -*- coding: utf-8 -*- # 
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -6,7 +7,7 @@ module Rouge
       title 'Wollok'
       desc 'Wollok lang'
       tag 'wollok'
-      filenames *%w(*.wlk *.wtest *.wpgm)
+      filenames '*.wlk', '*.wtest', '*.wpgm'
 
       keywords = %w(new super return if else var const override constructor)
 
@@ -16,23 +17,23 @@ module Rouge
       entities = []
 
       state :whitespaces_and_comments do
-        rule /\s+/m, Text::Whitespace
-        rule /$+/m, Text::Whitespace
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/$+/m, Text::Whitespace
         rule %r(//.*$), Comment::Single
         rule %r(/\*(.|\s)*?\*/)m, Comment::Multiline
       end
 
       state :root do
         mixin :whitespaces_and_comments
-        rule /(import)(.+$)/ do
+        rule %r/(import)(.+$)/ do
           groups Keyword::Reserved, Text
         end
-        rule /(class|object|mixin)/, Keyword::Reserved, :foo
-        rule /test|program/, Keyword::Reserved #, :chunk_naming
-        rule /(package)(\s+)(#{entity_name})/ do
+        rule %r/(class|object|mixin)/, Keyword::Reserved, :foo
+        rule %r/test|program/, Keyword::Reserved #, :chunk_naming
+        rule %r/(package)(\s+)(#{entity_name})/ do
           groups Keyword::Reserved, Text::Whitespace, Name::Class
         end
-        rule /{|}/, Text
+        rule %r/{|}/, Text
         mixin :keywords
         mixin :symbols
         mixin :objects
@@ -40,13 +41,13 @@ module Rouge
 
       state :foo do
         mixin :whitespaces_and_comments
-        rule /inherits|mixed|with|and/, Keyword::Reserved
-        rule /#{entity_name}(?=\s*{)/ do |m|
+        rule %r/inherits|mixed|with|and/, Keyword::Reserved
+        rule %r/#{entity_name}(?=\s*{)/ do |m|
           token Name::Class
           entities << m[0]
           pop!
         end
-        rule /#{entity_name}/ do |m|
+        rule %r/#{entity_name}/ do |m|
           token Name::Class
           entities << m[0]
         end
@@ -57,9 +58,9 @@ module Rouge
           /#{expressions.map { |keyword| "#{keyword}\\b" }.join('|')}/
         end
 
-        rule /self\b/, Name::Builtin::Pseudo
+        rule %r/self\b/, Name::Builtin::Pseudo
         rule any(keywords), Keyword::Reserved
-        rule /(method)(\s+)(#{variable_naming})/ do
+        rule %r/(method)(\s+)(#{variable_naming})/ do
           groups Keyword::Reserved, Text::Whitespace, Text
         end
       end
@@ -73,30 +74,30 @@ module Rouge
             token Keyword::Variable
           end
         end
-        rule /\.#{entity_name}/, Text
+        rule %r/\.#{entity_name}/, Text
         mixin :literals
       end
 
       state :literals do
         mixin :whitespaces_and_comments
-        rule /[0-9]+\.?[0-9]*/, Literal::Number
-        rule /"[^"]*"/m, Literal::String
-        rule /\[|\#{/, Punctuation, :lists
+        rule %r/[0-9]+\.?[0-9]*/, Literal::Number
+        rule %r/"[^"]*"/m, Literal::String
+        rule %r/\[|\#{/, Punctuation, :lists
       end
 
       state :lists do
-        rule /,/, Punctuation
-        rule /]|}/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/]|}/, Punctuation, :pop!
         mixin :objects
       end
 
       state :symbols do
-        rule /\+\+|--|\+=|-=|\*\*|!/, Operator
-        rule /\+|-|\*|\/|%/, Operator
-        rule /<=|=>|===|==|<|>/, Operator
-        rule /and\b|or\b|not\b/, Operator
-        rule /\(|\)|=/, Text
-        rule /,/, Punctuation
+        rule %r/\+\+|--|\+=|-=|\*\*|!/, Operator
+        rule %r/\+|-|\*|\/|%/, Operator
+        rule %r/<=|=>|===|==|<|>/, Operator
+        rule %r/and\b|or\b|not\b/, Operator
+        rule %r/\(|\)|=/, Text
+        rule %r/,/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/xml.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -6,14 +7,10 @@ module Rouge
       title "XML"
       desc %q(<desc for="this-lexer">XML</desc>)
       tag 'xml'
-      filenames *%w(*.xml *.xsl *.rss *.xslt *.xsd *.wsdl *.svg)
-      mimetypes *%w(
-        text/xml
-        application/xml
-        image/svg+xml
-        application/rss+xml
-        application/atom+xml
-      )
+      filenames '*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.svg',
+                '*.plist'
+      mimetypes 'text/xml', 'application/xml', 'image/svg+xml',
+                'application/rss+xml', 'application/atom+xml'
 
       def self.detect?(text)
         return false if text.doctype?(/html/)
@@ -22,12 +19,12 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/, Text
-        rule /&\S*?;/, Name::Entity
-        rule /<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/, Comment::Preproc
-        rule /<![^>]*>/, Comment::Preproc
+        rule %r/[^<&]+/, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!\[CDATA\[.*?\]\]\>/, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/, Comment::Preproc
+        rule %r/<![^>]*>/, Comment::Preproc
 
         # open tags
         rule %r(<\s*[\w:.-]+)m, Name::Tag, :tag
@@ -37,20 +34,20 @@ module Rouge
       end
 
       state :comment do
-        rule /[^-]+/m, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/m, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule %r/\s+/m, Text
+        rule %r/[\w.:-]+\s*=/m, Name::Attribute, :attr
         rule %r(/?\s*>), Name::Tag, :pop!
       end
 
       state :attr do
-        rule /\s+/m, Text
-        rule /".*?"|'.*?'|[^\s>]+/m, Str, :pop!
+        rule %r/\s+/m, Text
+        rule %r/".*?"|'.*?'|[^\s>]+/m, Str, :pop!
       end
     end
   end