rouge 3.4.1 → 3.6.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,127 @@
+# -*- 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 _while _loop _endloop _loopbody _continue _leave
+           _return
+           _class
+           _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

@@ -11,15 +11,10 @@ module Rouge
       filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
       mimetypes 'text/x-makefile'
 
-      bsd_special = %w(
-        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
+      # TODO: Add support for special keywords
+      # bsd_special = %w(
+      #   include undef error warning if else elif endif for endfor
+      # )
 
       def initialize(opts={})
         super
@@ -29,53 +24,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
           groups Text, Punctuation
           push :shell_line
         end
@@ -85,9 +80,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 +95,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