rouge 3.0.0 → 3.18.0

data/lib/rouge/lexers/praat.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -100,84 +101,84 @@ module Rouge
       )
 
       state :root do
-        rule /(\s+)(#.*?$)/ do
+        rule %r/(\s+)(#.*?$)/ do
           groups Text, Comment::Single
         end
 
-        rule /^#.*?$/,         Comment::Single
-        rule /;[^\n]*/,        Comment::Single
-        rule /\s+/,            Text
+        rule %r/^#.*?$/,         Comment::Single
+        rule %r/;[^\n]*/,        Comment::Single
+        rule %r/\s+/,            Text
 
-        rule /(\bprocedure)(\s+)/ do
+        rule %r/(\bprocedure)(\s+)/ do
           groups Keyword, Text
           push :procedure_definition
         end
 
-        rule /(\bcall)(\s+)/ do
+        rule %r/(\bcall)(\s+)/ do
           groups Keyword, Text
           push :procedure_call
         end
 
-        rule /@/,              Name::Function, :procedure_call
+        rule %r/@/,              Name::Function, :procedure_call
 
         mixin :function_call
 
-        rule /\b(?:select all)\b/, Keyword
-        rule /\b(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/\b(?:select all)\b/, Keyword
+        rule %r/\b(?:#{keywords.join('|')})\b/, Keyword
 
-        rule /(\bform\b)(\s+)([^\n]+)/ do
+        rule %r/(\bform\b)(\s+)([^\n]+)/ do
           groups Keyword, Text, Literal::String
           push :old_form
         end
 
-        rule /(print(?:line|tab)?|echo|exit|asserterror|pause|send(?:praat|socket)|include|execute|system(?:_nocheck)?)(\s+)/ do
+        rule %r/(print(?:line|tab)?|echo|exit|asserterror|pause|send(?:praat|socket)|include|execute|system(?:_nocheck)?)(\s+)/ do
           groups Keyword, Text
           push :string_unquoted
         end
 
-        rule /(goto|label)(\s+)(\w+)/ do
+        rule %r/(goto|label)(\s+)(\w+)/ do
           groups Keyword, Text, Name::Label
         end
 
         mixin :variable_name
         mixin :number
 
-        rule /"/, Literal::String, :string
+        rule %r/"/, Literal::String, :string
 
-        rule /\b(?:#{objects.join('|')})(?=\s+\S+\n)/, Name::Class, :string_unquoted
+        rule %r/\b(?:#{objects.join('|')})(?=\s+\S+\n)/, Name::Class, :string_unquoted
 
-        rule /\b(?=[A-Z])/, Text, :command
-        rule /(\.{3}|[)(,\$])/, Punctuation
+        rule %r/\b(?=[A-Z])/, Text, :command
+        rule %r/(\.{3}|[)(,\$])/, Punctuation
       end
 
       state :command do
-        rule /( ?([^\s:\.'])+ ?)/, Keyword
+        rule %r/( ?([^\s:\.'])+ ?)/, Keyword
         mixin :string_interpolated
 
-        rule /\.{3}/ do
+        rule %r/\.{3}/ do
           token Keyword
           pop!
           push :old_arguments
         end
 
-        rule /:/ do
+        rule %r/:/ do
           token Keyword
           pop!
           push :comma_list
         end
 
-        rule /[\s]/,    Text, :pop!
+        rule %r/[\s]/,    Text, :pop!
       end
 
       state :procedure_call do
         mixin :string_interpolated
 
-        rule /(:|\s*\()/, Punctuation, :pop!
+        rule %r/(:|\s*\()/, Punctuation, :pop!
 
-        rule /'/,            Name::Function
-        rule /[^:\('\s]+/, Name::Function
+        rule %r/'/,            Name::Function
+        rule %r/[^:\('\s]+/, Name::Function
 
-        rule /(?=\s+)/ do
+        rule %r/(?=\s+)/ do
           token Text
           pop!
           push :old_arguments
@@ -185,23 +186,23 @@ module Rouge
       end
 
       state :procedure_definition do
-        rule /(:|\s*\()/, Punctuation, :pop!
+        rule %r/(:|\s*\()/, Punctuation, :pop!
 
-        rule /[^:\(\s]+/, Name::Function
+        rule %r/[^:\(\s]+/, Name::Function
 
-        rule /(\s+)/, Text, :pop!
+        rule %r/(\s+)/, Text, :pop!
       end
 
       state :function_call do
-        rule /\b(#{functions_string.join('|')})\$(?=\s*[:(])/, Name::Function, :function
-        rule /\b(#{functions_array.join('|')})#(?=\s*[:(])/,   Name::Function, :function
-        rule /\b(#{functions_numeric.join('|')})(?=\s*[:(])/,  Name::Function, :function
+        rule %r/\b(#{functions_string.join('|')})\$(?=\s*[:(])/, Name::Function, :function
+        rule %r/\b(#{functions_array.join('|')})#(?=\s*[:(])/,   Name::Function, :function
+        rule %r/\b(#{functions_numeric.join('|')})(?=\s*[:(])/,  Name::Function, :function
       end
 
       state :function do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /(?::|\s*\()/ do
+        rule %r/(?::|\s*\()/ do
           token Text
           pop!
           push :comma_list
@@ -209,140 +210,140 @@ module Rouge
       end
 
       state :comma_list do
-        rule /(\s*\n\s*)(\.{3})/ do
+        rule %r/(\s*\n\s*)(\.{3})/ do
           groups Text, Punctuation
         end
 
-        rule /\s*[\])\n]/, Text, :pop!
+        rule %r/\s*[\])\n]/, Text, :pop!
 
-        rule /\s+/, Text
-        rule /"/,   Literal::String, :string
-        rule /\b(if|then|else|fi|endif)\b/, Keyword
+        rule %r/\s+/, Text
+        rule %r/"/,   Literal::String, :string
+        rule %r/\b(if|then|else|fi|endif)\b/, Keyword
 
         mixin :function_call
         mixin :variable_name
         mixin :operator
         mixin :number
 
-        rule /[()]/, Text
-        rule /,/, Punctuation
+        rule %r/[()]/, Text
+        rule %r/,/, Punctuation
       end
 
       state :old_arguments do
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
 
         mixin :variable_name
         mixin :operator
         mixin :number
 
-        rule /"/, Literal::String, :string
-        rule /[^\n]/, Text
+        rule %r/"/, Literal::String, :string
+        rule %r/[^\n]/, Text
       end
 
       state :number do
-        rule /\n/, Text, :pop!
-        rule /\b\d+(\.\d*)?([eE][-+]?\d+)?%?/, Literal::Number
+        rule %r/\n/, Text, :pop!
+        rule %r/\b\d+(\.\d*)?([eE][-+]?\d+)?%?/, Literal::Number
       end
 
       state :variable_name do
         mixin :operator
         mixin :number
 
-        rule /\b(?:#{variables_string.join('|')})\$/,  Name::Builtin
-        rule /\b(?:#{variables_numeric.join('|')})(?!\$)\b/, Name::Builtin
+        rule %r/\b(?:#{variables_string.join('|')})\$/,  Name::Builtin
+        rule %r/\b(?:#{variables_numeric.join('|')})(?!\$)\b/, Name::Builtin
 
-        rule /\b(Object|#{objects.join('|')})_/ do
+        rule %r/\b(Object|#{objects.join('|')})_/ do
           token Name::Builtin
           push :object_reference
         end
 
-        rule /\.?[a-z][a-zA-Z0-9_.]*(\$|#)?/, Text
-        rule /[\[\]]/, Text, :comma_list
+        rule %r/\.?[a-z][a-zA-Z0-9_.]*(\$|#)?/, Text
+        rule %r/[\[\]]/, Text, :comma_list
         mixin :string_interpolated
       end
 
       state :object_reference do
         mixin :string_interpolated
-        rule /([a-z][a-zA-Z0-9_]*|\d+)/, Name::Builtin
+        rule %r/([a-z][a-zA-Z0-9_]*|\d+)/, Name::Builtin
 
-        rule /\.(#{object_attributes.join('|')})\b/, Name::Builtin, :pop!
+        rule %r/\.(#{object_attributes.join('|')})\b/, Name::Builtin, :pop!
 
-        rule /\$/, Name::Builtin
-        rule /\[/, Text, :pop!
+        rule %r/\$/, Name::Builtin
+        rule %r/\[/, Text, :pop!
       end
 
       state :operator do
         # This rule incorrectly matches === or +++++, which are not operators
-        rule /([+\/*<>=!-]=?|[&*|][&*|]?|\^|<>)/,       Operator
-        rule /(?<![\w.])(and|or|not|div|mod)(?![\w.])/, Operator::Word
+        rule %r/([+\/*<>=!-]=?|[&*|][&*|]?|\^|<>)/,       Operator
+        rule %r/(?<![\w.])(and|or|not|div|mod)(?![\w.])/, Operator::Word
       end
 
       state :string_interpolated do
-        rule /'[\._a-z][^\[\]'":]*(\[([\d,]+|"[\w\d,]+")\])?(:[0-9]+)?'/, Literal::String::Interpol
+        rule %r/'[\._a-z][^\[\]'":]*(\[([\d,]+|"[\w,]+")\])?(:[0-9]+)?'/, Literal::String::Interpol
       end
 
       state :string_unquoted do
-        rule /\n\s*\.{3}/, Punctuation
-        rule /\n/,         Text, :pop!
-        rule /\s/,         Text
+        rule %r/\n\s*\.{3}/, Punctuation
+        rule %r/\n/,         Text, :pop!
+        rule %r/\s/,         Text
 
         mixin :string_interpolated
 
-        rule /'/,          Literal::String
-        rule /[^'\n]+/,    Literal::String
+        rule %r/'/,          Literal::String
+        rule %r/[^'\n]+/,    Literal::String
       end
 
       state :string do
-        rule /\n\s*\.{3}/, Punctuation
-        rule /"/,          Literal::String,           :pop!
+        rule %r/\n\s*\.{3}/, Punctuation
+        rule %r/"/,          Literal::String,           :pop!
 
         mixin :string_interpolated
 
-        rule /'/,          Literal::String
-        rule /[^'"\n]+/,   Literal::String
+        rule %r/'/,          Literal::String
+        rule %r/[^'"\n]+/,   Literal::String
       end
 
       state :old_form do
-        rule /(\s+)(#.*?$)/ do
+        rule %r/(\s+)(#.*?$)/ do
           groups Text, Comment::Single
         end
 
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /(optionmenu|choice)([ \t]+\S+:[ \t]+)/ do
+        rule %r/(optionmenu|choice)([ \t]+\S+:[ \t]+)/ do
           groups Keyword, Text
           push :number
         end
 
-        rule /(option|button)([ \t]+)/ do
+        rule %r/(option|button)([ \t]+)/ do
           groups Keyword, Text
           push :string_unquoted
         end
 
-        rule /(sentence|text)([ \t]+\S+)/ do
+        rule %r/(sentence|text)([ \t]+\S+)/ do
           groups Keyword, Text
           push :string_unquoted
         end
 
-        rule /(word)([ \t]+\S+[ \t]*)(\S+)?([ \t]+.*)?/ do
+        rule %r/(word)([ \t]+\S+[ \t]*)(\S+)?([ \t]+.*)?/ do
           groups Keyword, Text, Literal::String, Text
         end
 
-        rule /(boolean)(\s+\S+\s*)(0|1|"?(?:yes|no)"?)/ do
+        rule %r/(boolean)(\s+\S+\s*)(0|1|"?(?:yes|no)"?)/ do
           groups Keyword, Text, Name::Variable
         end
 
-        rule /(real|natural|positive|integer)([ \t]+\S+[ \t]*)([+-]?)/ do
+        rule %r/(real|natural|positive|integer)([ \t]+\S+[ \t]*)([+-]?)/ do
           groups Keyword, Text, Operator
           push :number
         end
 
-        rule /(comment)(\s+)/ do
+        rule %r/(comment)(\s+)/ do
           groups Keyword, Text
           push :string_unquoted
         end
 
-        rule /\bendform\b/, Keyword, :pop!
+        rule %r/\bendform\b/, Keyword, :pop!
       end
 
     end

data/lib/rouge/lexers/prolog.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -10,36 +11,43 @@ module Rouge
       filenames '*.pro', '*.P', '*.prolog', '*.pl'
       mimetypes 'text/x-prolog'
 
+      start { push :bol }
+
+      state :bol do
+        rule %r/#.*/, Comment::Single
+        rule(//) { pop! }
+      end
+
       state :basic do
-        rule /\s+/, Text
-        rule /^#.*/, Comment::Single
-        rule /\/\*/, Comment::Multiline, :nested_comment
+        rule %r/\s+/, Text
+        rule %r/%.*/, Comment::Single
+        rule %r/\/\*/, Comment::Multiline, :nested_comment
 
-        rule /[\[\](){}|.,;!]/, Punctuation
-        rule /:-|-->/, Punctuation
+        rule %r/[\[\](){}|.,;!]/, Punctuation
+        rule %r/:-|-->/, Punctuation
 
-        rule /"[^"]*"/, Str::Double
+        rule %r/"[^"]*"/, Str::Double
 
-        rule /\d+\.\d+/, Num::Float
-        rule /\d+/, Num
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num
       end
 
       state :atoms do
-        rule /[[:lower:]]([_[:word:][:digit:]])*/, Str::Symbol
-        rule /'[^']*'/, Str::Symbol
+        rule %r/[[:lower:]]([[:word:]])*/, Str::Symbol
+        rule %r/'[^']*'/, Str::Symbol
       end
 
       state :operators do
-        rule /(<|>|=<|>=|==|=:=|=|\/|\/\/|\*|\+|-)(?=\s|[a-zA-Z0-9\[])/,
+        rule %r/(<|>|=<|>=|==|=:=|=|\/|\/\/|\*|\+|-)(?=\s|[a-zA-Z0-9\[])/,
           Operator
-        rule /is/, Operator
-        rule /(mod|div|not)/, Operator
-        rule /[#&*+-.\/:<=>?@^~]+/, Operator
+        rule %r/is/, Operator
+        rule %r/(mod|div|not)/, Operator
+        rule %r/[#&*+-.\/:<=>?@^~]+/, Operator
       end
 
       state :variables do
-        rule /[A-Z]+\w*/, Name::Variable
-        rule /_[[:word:]]*/, Name::Variable
+        rule %r/[A-Z]+\w*/, Name::Variable
+        rule %r/_[[:word:]]*/, Name::Variable
       end
 
       state :root do
@@ -50,9 +58,9 @@ module Rouge
       end
 
       state :nested_comment do
-        rule /\/\*/, Comment::Multiline, :push
-        rule /\s*\*[^*\/]+/, Comment::Multiline
-        rule /\*\//, Comment::Multiline, :pop!
+        rule %r(/\*), Comment::Multiline, :push
+        rule %r/\s*\*[^*\/]+/, Comment::Multiline
+        rule %r(\*/), Comment::Multiline, :pop!
       end
     end
   end

data/lib/rouge/lexers/prometheus.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rouge
   module Lexers
     class Prometheus < RegexLexer
@@ -24,21 +26,21 @@ module Rouge
         mixin :strings
         mixin :whitespace
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+[smhdwy]?/, Num::Integer
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+[smhdwy]?/, Num::Integer
 
         mixin :operators
 
-        rule /(ignoring|on)(\()/ do
+        rule %r/(ignoring|on)(\()/ do
           groups Keyword::Pseudo, Punctuation
           push :label_list
         end
-        rule /(group_left|group_right)(\()/ do
+        rule %r/(group_left|group_right)(\()/ do
           groups Keyword::Type, Punctuation
         end
-        rule /(bool|offset)\b/, Keyword
-        rule /(without|by)\b/, Keyword, :label_list
-        rule /[\w:]+/ do |m|
+        rule %r/(bool|offset)\b/, Keyword
+        rule %r/(without|by)\b/, Keyword, :label_list
+        rule %r/[\w:]+/ do |m|
           if self.class.functions.include?(m[0])
             token Name::Builtin
           else
@@ -50,17 +52,17 @@ module Rouge
       end
 
       state :metrics do
-        rule /[a-zA-Z0-9_-]+/, Name
+        rule %r/[a-zA-Z0-9_-]+/, Name
 
-        rule /[\(\)\]:.,]/, Punctuation
-        rule /\{/, Punctuation, :filters
-        rule /\[/, Punctuation
+        rule %r/[\(\)\]:.,]/, Punctuation
+        rule %r/\{/, Punctuation, :filters
+        rule %r/\[/, Punctuation
       end
 
       state :strings do
-        rule /"/, Str::Double, :double_string_escaped
-        rule /'/, Str::Single, :single_string_escaped
-        rule /`.*`/, Str::Backtick
+        rule %r/"/, Str::Double, :double_string_escaped
+        rule %r/'/, Str::Single, :single_string_escaped
+        rule %r/`.*`/, Str::Backtick
       end
 
       [
@@ -68,52 +70,52 @@ module Rouge
         [:single, Str::Single, "'"]
       ].each do |name, tok, fin|
         state :"#{name}_string_escaped" do
-          rule /\\[\\abfnrtv#{fin}]/, Str::Escape
-          rule /[^\\#{fin}]+/m, tok
-          rule /#{fin}/, tok, :pop!
+          rule %r/\\[\\abfnrtv#{fin}]/, Str::Escape
+          rule %r/[^\\#{fin}]+/m, tok
+          rule %r/#{fin}/, tok, :pop!
         end
       end
 
       state :filters do
         mixin :inline_whitespace
-        rule /,/, Punctuation
+        rule %r/,/, Punctuation
         mixin :labels
         mixin :filter_matching_operators
         mixin :strings
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
       end
 
       state :label_list do
-        rule /\(/, Punctuation
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
-        rule /,/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/,/, Punctuation
         mixin :whitespace
-        rule /\)/, Punctuation, :pop!
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :labels do
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/[a-zA-Z0-9_:-]+/, Name::Attribute
       end
 
       state :operators do
         rule %r([+\-\*/%\^]), Operator  # Arithmetic
         rule %r(=|==|!=|<|>|<=|>=), Operator # Comparison
-        rule /and|or|unless/, Operator # Logical/Set
-        rule /(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
+        rule %r/and|or|unless/, Operator # Logical/Set
+        rule %r/(sum|min|max|avg|stddev|stdvar|count|count_values|bottomk|topk)\b/, Name::Function
       end
 
       state :filter_matching_operators do
-        rule /!(=|~)|=~?/, Operator
+        rule %r/!(=|~)|=~?/, Operator
       end
 
       state :inline_whitespace do
-        rule /[ \t\r]+/, Text
+        rule %r/[ \t\r]+/, Text
       end
 
       state :whitespace do
         mixin :inline_whitespace
-        rule /\n\s*/m, Text
-        rule /#.*?$/, Comment
+        rule %r/\n\s*/m, Text
+        rule %r/#.*?$/, Comment
       end
     end
   end