rouge 3.4.1 → 3.5.0

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

data/lib/rouge/lexers/magik.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Magik < RegexLexer
+      title "Magik"
+      desc "Smallworld Magik"
+      tag 'magik'
+      filenames '*.magik'
+      mimetypes 'text/x-magik', 'application/x-magik'
+
+      def self.keywords
+        @keywords ||= %w(
+           _package
+           _pragma
+           _block _endblock
+           _handling _default
+           _protect _protection _endprotect
+           _try _with _when _endtry
+           _catch _endcatch
+           _throw
+           _lock _endlock
+           _if _then _elif _else _endif
+           _for _over _loop _endloop _loopbody _continue _leave
+           _return
+           _local _constant _recursive _global _dynamic _import
+           _private _iter _abstract _method _endmethod
+           _proc _endproc
+           _gather _scatter _allresults _optional
+           _thisthread _self _clone _super
+           _primitive
+           _unset _true _false _maybe
+           _is _isnt _not _and _or _xor _cf _andif _orif
+           _div _mod
+        )
+      end
+
+      def self.string_double
+        @string_double ||= /"[^"\n]*?"/
+      end
+      def self.string_single
+        @string_single ||= /'[^'\n]*?'/
+      end
+
+      def self.digits
+        @digits ||= /[0-9]+/
+      end
+      def self.radix
+        @radix ||= /r[0-9a-z]/i
+      end
+      def self.exponent
+        @exponent ||= /(e|&)[+-]?#{Magik.digits}/i
+      end
+      def self.decimal
+        @decimal ||= /\.#{Magik.digits}/
+      end
+      def self.number
+        @number = /#{Magik.digits}(#{Magik.radix}|#{Magik.exponent}|#{Magik.decimal})*/
+      end
+
+      def self.character
+        @character ||= /%u[0-9a-z]{4}|%[^\s]+/i
+      end
+
+      def self.simple_identifier
+        @simple_identifier ||= /(?>(?:[a-z0-9_!?]|\\.)+)/i
+      end
+      def self.piped_identifier
+        @piped_identifier ||= /\|[^\|\n]*\|/
+      end
+      def self.identifier
+        @identifier ||= /(?:#{Magik.simple_identifier}|#{Magik.piped_identifier})+/i
+      end
+      def self.package_identifier
+        @package_identifier ||= /#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.symbol
+        @symbol ||= /:#{Magik.identifier}/i
+      end
+      def self.global_ref
+        @global_ref ||= /@[\s]*#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.label
+        @label = /@[\s]*#{Magik.identifier}/
+      end
+
+      state :root do
+        rule %r/##(.*)?/, Comment::Doc
+        rule %r/#(.*)?/, Comment::Single
+
+        rule %r/(_method)(\s+)/ do
+          groups Keyword, Text::Whitespace
+          push :method_name
+        end
+
+        rule %r/(?:#{Magik.keywords.join('|')})\b/, Keyword
+
+        rule Magik.string_double, Literal::String
+        rule Magik.string_single, Literal::String
+        rule Magik.symbol, Str::Symbol
+        rule Magik.global_ref, Name::Label
+        rule Magik.label, Name::Label
+        rule Magik.character, Literal::String::Char
+        rule Magik.number, Literal::Number
+        rule Magik.package_identifier, Name
+        rule Magik.identifier, Name
+
+        rule %r/[\[\]{}()\.,;]/, Punctuation
+        rule %r/\$/, Punctuation
+        rule %r/(<<|^<<)/, Operator
+        rule %r/(>>)/, Operator
+        rule %r/[-~+\/*%=&^<>]|!=/, Operator
+
+        rule %r/[\s]+/, Text::Whitespace
+      end
+
+      state :method_name do
+        rule %r/(#{Magik.identifier})(\.)(#{Magik.identifier})/ do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/make.rb

@@ -15,12 +15,6 @@ module Rouge
         include undef error warning if else elif endif for endfor
       )
 
-      gnu_special = %w(
-        ifeq ifneq ifdef ifndef else endif include -include define endef :
-      )
-
-      line = /(?:\\.|\\\n|[^\\\n])*/m
-
       def initialize(opts={})
         super
         @shell = Shell.new(opts)
@@ -29,53 +23,53 @@ module Rouge
       start { @shell.reset! }
 
       state :root do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /#.*?\n/, Comment
+        rule %r/#.*?\n/, Comment
 
-        rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+        rule %r/(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
           groups Keyword, Text
           push :export
         end
 
-        rule /export\s+/, Keyword
+        rule %r/export\s+/, Keyword
 
         # assignment
-        rule /([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
+        rule %r/([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
           token Name::Variable, m[1]
           token Text, m[2]
           token Operator, m[3]
           push :shell_line
         end
 
-        rule /"(\\\\|\\.|[^"\\])*"/, Str::Double
-        rule /'(\\\\|\\.|[^'\\])*'/, Str::Single
-        rule /([^\n:]+)(:+)([ \t]*)/ do
+        rule %r/"(\\\\|\\.|[^"\\])*"/, Str::Double
+        rule %r/'(\\\\|\\.|[^'\\])*'/, Str::Single
+        rule %r/([^\n:]+)(:+)([ \t]*)/ do
           groups Name::Label, Operator, Text
           push :block_header
         end
       end
 
       state :export do
-        rule /[\w\${}-]/, Name::Variable
-        rule /\n/, Text, :pop!
-        rule /\s+/, Text
+        rule %r/[\w\${}-]/, Name::Variable
+        rule %r/\n/, Text, :pop!
+        rule %r/\s+/, Text
       end
 
       state :block_header do
-        rule /[^,\\\n#]+/, Name::Function
-        rule /,/, Punctuation
-        rule /#.*?/, Comment
-        rule /\\\n/, Text
-        rule /\\./, Text
-        rule /\n/ do
+        rule %r/[^,\\\n#]+/, Name::Function
+        rule %r/,/, Punctuation
+        rule %r/#.*?/, Comment
+        rule %r/\\\n/, Text
+        rule %r/\\./, Text
+        rule %r/\n/ do
           token Text
           goto :block_body
         end
       end
 
       state :block_body do
-        rule /(\t[\t ]*)([@-]?)/ do |m|
+        rule %r/(\t[\t ]*)([@-]?)/ do |m|
           groups Text, Punctuation
           push :shell_line
         end
@@ -85,9 +79,9 @@ module Rouge
 
       state :shell do
         # macro interpolation
-        rule /\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
+        rule %r/\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
         # $(shell ...)
-        rule /(\$\()(\s*)(shell)(\s+)/m do
+        rule %r/(\$\()(\s*)(shell)(\s+)/m do
           groups Name::Function, Text, Name::Builtin, Text
           push :shell_expr
         end
@@ -100,12 +94,12 @@ module Rouge
 
       state :shell_expr do
         rule(/\(/) { delegate @shell; push }
-        rule /\)/, Name::Variable, :pop!
+        rule %r/\)/, Name::Variable, :pop!
         mixin :shell
       end
 
       state :shell_line do
-        rule /\n/, Text, :pop!
+        rule %r/\n/, Text, :pop!
         mixin :shell
       end
     end

data/lib/rouge/lexers/markdown.rb

@@ -24,15 +24,15 @@ module Rouge
         # YAML frontmatter
         rule(/\A(---\s*\n.*?\n?)^(---\s*$\n?)/m) { delegate YAML }
 
-        rule /\\./, Str::Escape
+        rule %r/\\./, Str::Escape
 
-        rule /^[\S ]+\n(?:---*)\n/, Generic::Heading
-        rule /^[\S ]+\n(?:===*)\n/, Generic::Subheading
+        rule %r/^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule %r/^[\S ]+\n(?:===*)\n/, Generic::Subheading
 
-        rule /^#(?=[^#]).*?$/, Generic::Heading
-        rule /^##*.*?$/, Generic::Subheading
+        rule %r/^#(?=[^#]).*?$/, Generic::Heading
+        rule %r/^##*.*?$/, Generic::Subheading
 
-        rule /^([ \t]*)(```|~~~)([^\n]*\n)((.*?)(\2))?/m do |m|
+        rule %r/^([ \t]*)(```|~~~)([^\n]*\n)((.*?)(\2))?/m do |m|
           name = m[3].strip
           sublexer = Lexer.find_fancy(name.empty? ? "guess" : name, m[5], @options)
           sublexer ||= PlainText.new(@options.merge(:token => Str::Backtick))
@@ -49,36 +49,36 @@ module Rouge
             token Punctuation, m[6]
           else
             push do
-              rule /^([ \t]*)(#{m[2]})/ do |mb|
+              rule %r/^([ \t]*)(#{m[2]})/ do |mb|
                 pop!
                 token Text, mb[1]
                 token Punctuation, mb[2]
               end
-              rule /^.*\n/ do |mb|
+              rule %r/^.*\n/ do |mb|
                 delegate sublexer, mb[1]
               end
             end
           end
         end
 
-        rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick
+        rule %r/\n\n((    |\t).*?\n|\n)+/, Str::Backtick
 
-        rule /(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
+        rule %r/(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
 
         # various uses of * are in order of precedence
 
         # line breaks
-        rule /^(\s*[*]){3,}\s*$/, Punctuation
-        rule /^(\s*[-]){3,}\s*$/, Punctuation
+        rule %r/^(\s*[*]){3,}\s*$/, Punctuation
+        rule %r/^(\s*[-]){3,}\s*$/, Punctuation
 
         # bulleted lists
-        rule /^\s*[*+-](?=\s)/, Punctuation
+        rule %r/^\s*[*+-](?=\s)/, Punctuation
 
         # numbered lists
-        rule /^\s*\d+\./, Punctuation
+        rule %r/^\s*\d+\./, Punctuation
 
         # blockquotes
-        rule /^\s*>.*?$/, Generic::Traceback
+        rule %r/^\s*>.*?$/, Generic::Traceback
 
         # link references
         # [foo]: bar "baz"
@@ -94,77 +94,77 @@ module Rouge
         end
 
         # links and images
-        rule /(!?\[)(#{edot}*?)(\])/ do
+        rule %r/(!?\[)(#{edot}*?)(\])/ do
           groups Punctuation, Name::Variable, Punctuation
           push :link
         end
 
-        rule /[*][*]#{edot}*?[*][*]/, Generic::Strong
-        rule /__#{edot}*?__/, Generic::Strong
+        rule %r/[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule %r/__#{edot}*?__/, Generic::Strong
 
-        rule /[*]#{edot}*?[*]/, Generic::Emph
-        rule /_#{edot}*?_/, Generic::Emph
+        rule %r/[*]#{edot}*?[*]/, Generic::Emph
+        rule %r/_#{edot}*?_/, Generic::Emph
 
         # Automatic links
-        rule /<.*?@.+[.].+>/, Name::Variable
+        rule %r/<.*?@.+[.].+>/, Name::Variable
         rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
 
 
-        rule /[^\\`\[*\n&<]+/, Text
+        rule %r/[^\\`\[*\n&<]+/, Text
 
         # inline html
         rule(/&\S*;/) { delegate html }
         rule(/<#{edot}*?>/) { delegate html }
-        rule /[&<]/, Text
+        rule %r/[&<]/, Text
 
-        rule /\n/, Text
+        rule %r/\n/, Text
       end
 
       state :link do
-        rule /(\[)(#{edot}*?)(\])/ do
+        rule %r/(\[)(#{edot}*?)(\])/ do
           groups Punctuation, Str::Symbol, Punctuation
           pop!
         end
 
-        rule /[(]/ do
+        rule %r/[(]/ do
           token Punctuation
           push :inline_title
           push :inline_url
         end
 
-        rule /[ \t]+/, Text
+        rule %r/[ \t]+/, Text
 
         rule(//) { pop! }
       end
 
       state :url do
-        rule /[ \t]+/, Text
+        rule %r/[ \t]+/, Text
 
         # the url
-        rule /(<)(#{edot}*?)(>)/ do
+        rule %r/(<)(#{edot}*?)(>)/ do
           groups Name::Tag, Str::Other, Name::Tag
           pop!
         end
 
-        rule /\S+/, Str::Other, :pop!
+        rule %r/\S+/, Str::Other, :pop!
       end
 
       state :title do
-        rule /"#{edot}*?"/, Name::Namespace
-        rule /'#{edot}*?'/, Name::Namespace
-        rule /[(]#{edot}*?[)]/, Name::Namespace
-        rule /\s*(?=["'()])/, Text
+        rule %r/"#{edot}*?"/, Name::Namespace
+        rule %r/'#{edot}*?'/, Name::Namespace
+        rule %r/[(]#{edot}*?[)]/, Name::Namespace
+        rule %r/\s*(?=["'()])/, Text
         rule(//) { pop! }
       end
 
       state :inline_title do
-        rule /[)]/, Punctuation, :pop!
+        rule %r/[)]/, Punctuation, :pop!
         mixin :title
       end
 
       state :inline_url do
-        rule /[^<\s)]+/, Str::Other, :pop!
-        rule /\s+/m, Text
+        rule %r/[^<\s)]+/, Str::Other, :pop!
+        rule %r/\s+/m, Text
         mixin :url
       end
     end