rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/apache.rb

@@ -15,7 +15,7 @@ module Rouge
         attr_reader :keywords
       end
       # Load Apache keywords from separate YML file
-      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('apache/keywords.yml')).tap do |h|
+      @keywords = ::YAML.load_file(File.join(__dir__, 'apache/keywords.yml')).tap do |h|
         h.each do |k,v|
           h[k] = Set.new v
         end
@@ -30,19 +30,19 @@ module Rouge
       end
 
       state :whitespace do
-        rule /\#.*/, Comment
-        rule /\s+/m, Text
+        rule %r/\#.*/, Comment
+        rule %r/\s+/m, Text
       end
 
       state :root do
         mixin :whitespace
 
-        rule /(<\/?)(\w+)/ do |m|
+        rule %r/(<\/?)(\w+)/ do |m|
           groups Punctuation, name_for_token(m[2].downcase, :sections, Name::Label)
           push :section
         end
 
-        rule /\w+/ do |m|
+        rule %r/\w+/ do |m|
           token name_for_token(m[0].downcase, :directives, Name::Class)
           push :directive
         end
@@ -50,7 +50,7 @@ module Rouge
 
       state :section do
         # Match section arguments
-        rule /([^>]+)?(>(?:\r\n?|\n)?)/ do |m|
+        rule %r/([^>]+)?(>(?:\r\n?|\n)?)/ do |m|
           groups Literal::String::Regex, Punctuation
           pop!
         end
@@ -60,11 +60,11 @@ module Rouge
 
       state :directive do
         # Match value literals and other directive arguments
-        rule /\r\n?|\n/, Text, :pop!
+        rule %r/\r\n?|\n/, Text, :pop!
 
         mixin :whitespace
 
-        rule /\S+/ do |m|
+        rule %r/\S+/ do |m|
           token name_for_token(m[0], :values, Literal::String::Symbol)
         end
       end

data/lib/rouge/lexers/apple_script.rb

@@ -319,28 +319,28 @@ module Rouge
       identifiers = %r(\b([a-zA-Z]\w*)\b)
 
       state :root do
-        rule /\s+/, Text::Whitespace
-        rule /¬\n/, Literal::String::Escape
-        rule /'s\s+/, Text
-        rule /(--|#).*?$/, Comment::Single
-        rule /\(\*/, Comment::Multiline
-        rule /[\(\){}!,.:]/, Punctuation
-        rule /(«)([^»]+)(»)/ do |match|
+        rule %r/\s+/, Text::Whitespace
+        rule %r/¬\n/, Literal::String::Escape
+        rule %r/'s\s+/, Text
+        rule %r/(--|#).*?$/, Comment::Single
+        rule %r/\(\*/, Comment::Multiline
+        rule %r/[\(\){}!,.:]/, Punctuation
+        rule %r/(«)([^»]+)(»)/ do |match|
           token Text, match[1]
           token Name::Builtin, match[2]
           token Text, match[3]
         end
-        rule /\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)/ do |match|
+        rule %r/\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)/ do |match|
           token Keyword, match[1]
           token Name::Builtin, match[2]
         end
-        rule /(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|\/|÷|\^)/, Operator
+        rule %r/(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|\/|÷|\^)/, Operator
         rule operators, Operator::Word
-        rule /^(\s*(?:on|end)\s+)'r'(%s)/ do |match|
+        rule %r/^(\s*(?:on|end)\s+)'r'(%s)/ do |match|
           token Keyword, match[1]
           token Name::Function, match[2]
         end
-        rule /^(\s*)(in|on|script|to)(\s+)/ do |match|
+        rule %r/^(\s*)(in|on|script|to)(\s+)/ do |match|
           token Text, match[1]
           token Keyword, match[2]
           token Text, match[3]
@@ -349,6 +349,7 @@ module Rouge
           token Keyword, match[1]
           token Name::Class, match[2]
         end
+        rule literals, Name::Builtin
         rule commands, Name::Builtin
         rule controls, Keyword
         rule declarations, Keyword
@@ -359,10 +360,10 @@ module Rouge
         rule studio_classes, Name::Builtin
         rule studio_commands, Name::Builtin
         rule references, Name::Builtin
-        rule /"(\\\\|\\"|[^"])*"/, Literal::String::Double
+        rule %r/"(\\\\|\\"|[^"])*"/, Literal::String::Double
         rule identifiers, Name::Variable
-        rule /[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?/, Literal::Number::Float
-        rule /[-+]?\d+/, Literal::Number::Integer
+        rule %r/[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?/, Literal::Number::Float
+        rule %r/[-+]?\d+/, Literal::Number::Integer
       end
     end
   end

data/lib/rouge/lexers/awk.rb

@@ -47,7 +47,7 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(#.*?$), Comment::Single
       end
 
@@ -57,7 +57,7 @@ module Rouge
           token Str::Regex
           goto :regex
         end
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -68,14 +68,14 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
@@ -85,20 +85,20 @@ module Rouge
       state :regex_group do
         # specially highlight / in a group to indicate that it doesn't
         # close the regex
-        rule /\//, Str::Escape
+        rule %r(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       state :root do
@@ -106,17 +106,17 @@ module Rouge
         rule %r((?<=\n)(?=\s|/)), Text, :expr_start
         rule %r([-<>+*/%\^!=]=?|in\b|\+\+|--|\|), Operator, :expr_start
         rule %r(&&|\|\||~!?), Operator, :expr_start
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -138,19 +138,19 @@ module Rouge
           end
         end
 
-        rule /[0-9]+\.[0-9]+/, Num::Float
-        rule /[0-9]+/, Num::Integer
-        rule /"(\\[\\"]|[^"])*"/, Str::Double
-        rule /:/, Punctuation
+        rule %r/[0-9]+\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\[\\"]|[^"])*"/, Str::Double
+        rule %r/:/, Punctuation
       end
 
       state :statement do
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
         mixin :expr_start
       end
 
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end

data/lib/rouge/lexers/biml.rb

@@ -26,16 +26,16 @@ module Rouge
       end
 
       state :directive_as_csharp do
-        rule /\s*#>\s*/m, Name::Tag, :pop!
+        rule %r/\s*#>\s*/m, Name::Tag, :pop!
         rule %r(.*?(?=\s*#>\s*))m do
           delegate CSharp
         end
       end
 
       state :directive_tag do
-        rule /\s+/m, Text
-        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
-        rule /[\w]+\s*/m, Name::Attribute
+        rule %r/\s+/m, Text
+        rule %r/[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule %r/\w+\s*/m, Name::Attribute
         rule %r(/?\s*#>), Name::Tag, :pop!
       end
     end

data/lib/rouge/lexers/bpf.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class BPF < RegexLexer
+      title "BPF"
+      desc "BPF bytecode syntax"
+      tag 'bpf'
+
+      TYPE_KEYWORDS = %w(
+        u8 u16 u32 u64 ll
+      ).join('|')
+
+      MISC_KEYWORDS = %w(
+        be16 be32 be64 exit lock
+      ).join('|')
+
+      state :root do
+        # Calls to helpers
+        rule %r/(call)(\s+)(\d+)/i do |m|
+          groups Keyword, Text::Whitespace, Literal::Number::Integer
+        end
+
+        # Unconditional jumps
+        rule %r/(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+          groups Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        end
+
+        # Conditional jumps
+        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        end
+        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(r\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+          groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Name, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
+        end
+
+        # Dereferences
+        rule %r/(\*)(\s*)(\()(#{TYPE_KEYWORDS})(\s*)(\*)(\))/i do |m|
+          groups Operator, Text::Whitespace, Punctuation, Keyword::Type, Text::Whitespace, Operator, Punctuation
+          push :address
+        end
+
+        # Operators
+        rule %r/[+-\/\*&|><^s]{0,3}=/i, Operator
+
+        # Registers
+        rule %r/([+-]?)(r\d+)/i do |m|
+          groups Punctuation, Name
+        end
+
+        # Comments
+        rule %r/\/\//, Comment::Single, :linecomment
+        rule %r/\/\*/, Comment::Multiline, :multilinescomment
+
+        rule %r/#{MISC_KEYWORDS}/i, Keyword
+
+        # Literals and global objects (maps) refered by name
+        rule %r/(0x\h+|[-]?\d+)(\s*)(ll)?/i do |m|
+          groups Literal::Number, Text::Whitespace, Keyword::Type
+        end
+        rule %r/(\w+)(\s*)(ll)/i do |m|
+          groups Name, Text::Whitespace, Keyword::Type
+        end
+
+        # Labels
+        rule %r/(\w+)(\s*)(:)/i do |m|
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+
+        rule %r{.}m, Text
+      end
+
+      state :address do
+        # Address is offset from register
+        rule %r/(\()(r\d+)(\s*)([+-])(\s*)(\d+)(\))/i do |m|
+          groups Punctuation, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number::Integer, Punctuation
+          pop!
+        end
+
+        # Address is array subscript
+        rule %r/(\w+)(\[)(\d+)(\])/i do |m|
+          groups Name, Punctuation, Literal::Number::Integer, Punctuation
+          pop!
+        end
+        rule %r/(\w+)(\[)(r\d+)(\])/i do |m|
+          groups Name, Punctuation, Name, Punctuation
+          pop!
+        end
+      end
+
+      state :linecomment do
+        rule %r/\n/, Comment::Single, :pop!
+        rule %r/.+/, Comment::Single
+      end
+
+      state :multilinescomment do
+        rule %r/\*\//, Comment::Multiline, :pop!
+        rule %r/([^\*\/]+)/, Comment::Multiline
+        rule %r/([\*\/])/, Comment::Multiline
+      end
+    end
+  end
+end

data/lib/rouge/lexers/brainfuck.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Brainfuck < RegexLexer
+      tag 'brainfuck'
+      filenames '*.b', '*.bf'
+      mimetypes 'text/x-brainfuck'
+
+      title "Brainfuck"
+      desc "The Brainfuck programming language"
+
+      start { push :bol }
+
+      state :bol do
+        rule %r/\s+/m, Text
+        rule %r/\[/, Comment::Multiline, :comment_multi
+        rule(//) { pop! }
+      end
+
+      state :root do
+        rule %r/\]/, Error
+        rule %r/\[/, Punctuation, :loop
+
+        mixin :comment_single
+        mixin :commands
+      end
+
+      state :comment_multi do
+        rule %r/\[/, Comment::Multiline, :comment_multi
+        rule %r/\]/, Comment::Multiline, :pop!
+        rule %r/[^\[\]]+?/m, Comment::Multiline
+      end
+
+      state :comment_single do
+        rule %r/[^><+\-.,\[\]]+/, Comment::Single
+      end
+
+      state :loop do
+        rule %r/\[/, Punctuation, :loop
+        rule %r/\]/, Punctuation, :pop!
+        mixin :comment_single
+        mixin :commands
+      end
+
+      state :commands do
+        rule %r/[><]+/, Name::Builtin
+        rule %r/[+\-.,]+/, Name::Function
+      end
+    end
+  end
+end

data/lib/rouge/lexers/bsl.rb

@@ -60,22 +60,22 @@ module Rouge
                     )\s*(?=\()/ix
 
       state :root do
-        rule /\n/, Text
-        rule /[^\S\n]+/, Text
-        rule /\/\/.*$/, Comment::Single
-        rule /[\[\]:(),;]/, Punctuation
-        rule /(?<=[^\wа-яё]|^)\&.*$/, Keyword::Declaration
-        rule /[-+\/=<>*%=<>.?&]/, Operator
-        rule /(?<=[^\wа-яё]|^)\#.*$/, Keyword::Declaration
+        rule %r/\n/, Text
+        rule %r/[^\S\n]+/, Text
+        rule %r(//.*$), Comment::Single
+        rule %r/[\[\]:(),;]/, Punctuation
+        rule %r/(?<=[^\wа-яё]|^)\&.*$/, Keyword::Declaration
+        rule %r/[-+\/*%=<>.?&]/, Operator
+        rule %r/(?<=[^\wа-яё]|^)\#.*$/, Keyword::Declaration
         rule KEYWORDS, Keyword
         rule BUILTINS, Name::Builtin
-        rule /[\wа-яё_][\wа-яё0-9_]*/i, Name::Variable
+        rule %r/[\wа-яё][\wа-яё]*/i, Name::Variable
 
         #literals
-        rule /\b((\h{8}-(\h{4}-){3}\h{12})|\d+\.?\d*)\b/, Literal::Number
-        rule /\'.*\'/, Literal::Date
-        rule /".*?("|$)/, Literal::String::Single
-        rule /(?<=[^\wа-яё]|^)\|((?!\"\").)*?(\"|$)/, Literal::String
+        rule %r/\b((\h{8}-(\h{4}-){3}\h{12})|\d+\.?\d*)\b/, Literal::Number
+        rule %r/\'.*\'/, Literal::Date
+        rule %r/".*?("|$)/, Literal::String::Single
+        rule %r/(?<=[^\wа-яё]|^)\|((?!\"\").)*?(\"|$)/, Literal::String
       end
     end
   end

data/lib/rouge/lexers/c.rb

@@ -65,8 +65,8 @@ module Rouge
       state :expr_bol do
         mixin :inline_whitespace
 
-        rule /#if\s0/, Comment, :if_0
-        rule /#/, Comment::Preproc, :macro
+        rule %r/#if\s0/, Comment, :if_0
+        rule %r/#/, Comment::Preproc, :macro
 
         rule(//) { pop! }
       end
@@ -74,41 +74,41 @@ 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+/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 :statements do
         mixin :whitespace
-        rule /(u8|u|U|L)?"/, Str, :string
+        rule %r/(u8|u|U|L)?"/, Str, :string
         rule %r((u8|u|U|L)?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
         rule %r((\d+[.]\d*|[.]?\d+)e[+-]?\d+[lu]*)i, Num::Float
         rule %r(\d+e[+-]?\d+[lu]*)i, Num::Float
-        rule /0x[0-9a-f]+[lu]*/i, Num::Hex
-        rule /0[0-7]+[lu]*/i, Num::Oct
-        rule /\d+[lu]*/i, Num::Integer
+        rule %r/0x[0-9a-f]+[lu]*/i, Num::Hex
+        rule %r/0[0-7]+[lu]*/i, Num::Oct
+        rule %r/\d+[lu]*/i, Num::Integer
         rule %r(\*/), Error
         rule %r([~!%^&*+=\|?:<>/-]), Operator
-        rule /[()\[\],.;]/, Punctuation
-        rule /\bcase\b/, Keyword, :case
-        rule /(?:true|false|NULL)\b/, Name::Builtin
+        rule %r/[()\[\],.;]/, Punctuation
+        rule %r/\bcase\b/, Keyword, :case
+        rule %r/(?:true|false|NULL)\b/, Name::Builtin
         rule id do |m|
           name = m[0]
 
@@ -127,7 +127,7 @@ module Rouge
       end
 
       state :case do
-        rule /:/, Punctuation, :pop!
+        rule %r/:/, Punctuation, :pop!
         mixin :statements
       end
 
@@ -149,41 +149,41 @@ module Rouge
             push :function
           end
         end
-        rule /\{/, Punctuation, :function
+        rule %r/\{/, Punctuation, :function
         mixin :statements
       end
 
       state :function do
         mixin :whitespace
         mixin :statements
-        rule /;/, Punctuation
-        rule /{/, Punctuation, :function
-        rule /}/, Punctuation, :pop!
+        rule %r/;/, Punctuation
+        rule %r/{/, Punctuation, :function
+        rule %r/}/, Punctuation, :pop!
       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 :macro do
         # NB: pop! goes back to :bol
-        rule /\n/, Comment::Preproc, :pop!
+        rule %r/\n/, Comment::Preproc, :pop!
         rule %r([^/\n\\]+), Comment::Preproc
-        rule /\\./m, Comment::Preproc
+        rule %r/\\./m, Comment::Preproc
         mixin :inline_whitespace
         rule %r(/), Comment::Preproc
       end
 
       state :if_0 do
         # NB: no \b here, to cover #ifdef and #ifndef
-        rule /^\s*#if/, Comment, :if_0
-        rule /^\s*#\s*el(?:se|if)/, Comment, :pop!
-        rule /^\s*#\s*endif\b.*?(?<!\\)\n/m, Comment, :pop!
-        rule /.*?\n/, Comment
+        rule %r/^\s*#if/, Comment, :if_0
+        rule %r/^\s*#\s*el(?:se|if)/, Comment, :pop!
+        rule %r/^\s*#\s*endif\b.*?(?<!\\)\n/m, Comment, :pop!
+        rule %r/.*?\n/, Comment
       end
     end
   end