rouge 3.3.0 → 3.8.0

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

@@ -8,18 +8,22 @@ module Rouge
       desc "Makefile syntax"
       tag 'make'
       aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
-      filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
+      filenames '*.make', '*.mak', '*.mk', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile', '*,fe1'
       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 :
-      )
+      def self.functions
+        @functions ||= %w(
+          abspath addprefix addsuffix and basename call dir error eval file
+          filter filter-out findstring firstword flavor foreach if join lastword
+          notdir or origin patsubst realpath shell sort strip subst suffix value
+          warning wildcard word wordlist words
+        )
+      end
 
-      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 +33,71 @@ module Rouge
       start { @shell.reset! }
 
       state :root do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
+
+        rule %r/#.*?\n/, Comment
 
-        rule /#.*?\n/, Comment
+        rule %r/([-s]?include)((?:[\t ]+[^\t\n #]+)+)/ do
+          groups Keyword, Literal::String::Other
+        end
+
+        rule %r/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)/ do
+          groups Keyword, Text, Name::Variable
+        end
 
-        rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+        rule %r/(?:else|endif)[\t ]*(?=[#\n])/, Keyword
+
+        rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
           groups Keyword, Text
           push :export
         end
 
-        rule /export\s+/, Keyword
+        rule %r/export[\t ]+/, Keyword
 
         # assignment
-        rule /([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
+        rule %r/([\w${}().-]+)([\t ]*)([!?:+]?=)/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/[\t ]+/, 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/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)(#.*)?(\n)/ do
+          groups Keyword, Text, Name::Variable, Comment, Text
+        end
+
+        rule %r/(else|endif)([\t ]*)(#.*)?(\n)/ do
+          groups Keyword, Text, Comment, Text
+        end
+
+        rule %r/(\t[\t ]*)([@-]?)/ do
           groups Text, Punctuation
           push :shell_line
         end
@@ -85,27 +107,27 @@ module Rouge
 
       state :shell do
         # macro interpolation
-        rule /\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
-        # $(shell ...)
-        rule /(\$\()(\s*)(shell)(\s+)/m do
+        rule %r/\$[({][\t ]*\w[\w:=%.]*[\t ]*[)}]/i, Name::Variable
+        # function invocation
+        rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
           groups Name::Function, Text, Name::Builtin, Text
           push :shell_expr
         end
 
         rule(/\\./m) { delegate @shell }
-        stop = /\$\(|\(|\)|\\|$/
+        stop = /\$\(|\$\{|\(|\)|\}|\\|$/
         rule(/.+?(?=#{stop})/m) { delegate @shell }
         rule(stop) { delegate @shell }
       end
 
       state :shell_expr do
-        rule(/\(/) { delegate @shell; push }
-        rule /\)/, Name::Variable, :pop!
+        rule(/[({]/) { delegate @shell; push }
+        rule %r/[)}]/, Name::Function, :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,44 +24,61 @@ 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 /(\n[ \t]*)(```|~~~)(.*?)(\n.*?\n)(\2)/m do |m|
-          sublexer = Lexer.find_fancy(m[3].strip, m[4], @options)
+        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))
           sublexer.reset!
 
           token Text, m[1]
           token Punctuation, m[2]
           token Name::Label, m[3]
-          delegate sublexer, m[4]
-          token Punctuation, m[5]
+          if m[5]
+            delegate sublexer, m[5]
+          end
+
+          if m[6]
+            token Punctuation, m[6]
+          else
+            push do
+              rule %r/^([ \t]*)(#{m[2]})/ do |mb|
+                pop!
+                token Text, mb[1]
+                token Punctuation, mb[2]
+              end
+              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"
@@ -77,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