rouge 3.17.0

data/lib/rouge/lexers/make.rb

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Make < RegexLexer
+      title "Make"
+      desc "Makefile syntax"
+      tag 'make'
+      aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
+      filenames '*.make', '*.mak', '*.mk', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile', '*,fe1'
+      mimetypes 'text/x-makefile'
+
+      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
+
+      # TODO: Add support for special keywords
+      # bsd_special = %w(
+      #   include undef error warning if else elif endif for endfor
+      # )
+
+      def initialize(opts={})
+        super
+        @shell = Shell.new(opts)
+      end
+
+      start { @shell.reset! }
+
+      state :root do
+        rule %r/\s+/, Text
+
+        rule %r/#.*?\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 %r/(?:else|endif)[\t ]*(?=[#\n])/, Keyword
+
+        rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
+          groups Keyword, Text
+          push :export
+        end
+
+        rule %r/export[\t ]+/, Keyword
+
+        # assignment
+        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 %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 %r/[\w\${}()-]/, Name::Variable
+        rule %r/\n/, Text, :pop!
+        rule %r/[\t ]+/, Text
+      end
+
+      state :block_header 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 %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
+
+        rule(//) { @shell.reset!; pop! }
+      end
+
+      state :shell do
+        # macro interpolation
+        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 = /\$\(|\$\{|\(|\)|\}|\\|$/
+        rule(/.+?(?=#{stop})/m) { delegate @shell }
+        rule(stop) { delegate @shell }
+      end
+
+      state :shell_expr do
+        rule(/[({]/) { delegate @shell; push }
+        rule %r/[)}]/, Name::Function, :pop!
+        mixin :shell
+      end
+
+      state :shell_line do
+        rule %r/\n/, Text, :pop!
+        mixin :shell
+      end
+    end
+  end
+end

data/lib/rouge/lexers/markdown.rb

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Markdown < RegexLexer
+      title "Markdown"
+      desc "Markdown, a light-weight markup language for authors"
+
+      tag 'markdown'
+      aliases 'md', 'mkd'
+      filenames '*.markdown', '*.md', '*.mkd'
+      mimetypes 'text/x-markdown'
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      start { html.reset! }
+
+      edot = /\\.|[^\\\n]/
+
+      state :root do
+        # YAML frontmatter
+        rule(/\A(---\s*\n.*?\n?)^(---\s*$\n?)/m) { delegate YAML }
+
+        rule %r/\\./, Str::Escape
+
+        rule %r/^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule %r/^[\S ]+\n(?:===*)\n/, Generic::Subheading
+
+        rule %r/^#(?=[^#]).*?$/, Generic::Heading
+        rule %r/^##*.*?$/, Generic::Subheading
+
+        rule %r/^([ \t]*)(`{3,}|~{3,})([^\n]*\n)((.*?)(\n\1)(\2))?/m do |m|
+          name = m[3].strip
+          sublexer =
+            begin
+              Lexer.find_fancy(name.empty? ? "guess" : name, m[5], @options)
+            rescue Guesser::Ambiguous => e
+              e.alternatives.first.new(@options)
+            end
+
+          sublexer ||= PlainText.new(@options.merge(:token => Str::Backtick))
+          sublexer.reset!
+
+          token Text, m[1]
+          token Punctuation, m[2]
+          token Name::Label, m[3]
+          if m[5]
+            delegate sublexer, m[5]
+          end
+
+          token Text, m[6]
+
+          if m[7]
+            token Punctuation, m[7]
+          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 %r/\n\n((    |\t).*?\n|\n)+/, Str::Backtick
+
+        rule %r/(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
+
+        # various uses of * are in order of precedence
+
+        # line breaks
+        rule %r/^(\s*[*]){3,}\s*$/, Punctuation
+        rule %r/^(\s*[-]){3,}\s*$/, Punctuation
+
+        # bulleted lists
+        rule %r/^\s*[*+-](?=\s)/, Punctuation
+
+        # numbered lists
+        rule %r/^\s*\d+\./, Punctuation
+
+        # blockquotes
+        rule %r/^\s*>.*?$/, Generic::Traceback
+
+        # link references
+        # [foo]: bar "baz"
+        rule %r(^
+          (\s*) # leading whitespace
+          (\[) (#{edot}+?) (\]) # the reference
+          (\s*) (:) # colon
+        )x do
+          groups Text, Punctuation, Str::Symbol, Punctuation, Text, Punctuation
+
+          push :title
+          push :url
+        end
+
+        # links and images
+        rule %r/(!?\[)(#{edot}*?)(\])(?=[\[(])/ do
+          groups Punctuation, Name::Variable, Punctuation
+          push :link
+        end
+
+        rule %r/[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule %r/__#{edot}*?__/, Generic::Strong
+
+        rule %r/[*]#{edot}*?[*]/, Generic::Emph
+        rule %r/_#{edot}*?_/, Generic::Emph
+
+        # Automatic links
+        rule %r/<.*?@.+[.].+>/, Name::Variable
+        rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
+
+        rule %r/[^\\`\[*\n&<]+/, Text
+
+        # inline html
+        rule(/&\S*;/) { delegate html }
+        rule(/<#{edot}*?>/) { delegate html }
+        rule %r/[&<]/, Text
+
+        # An opening square bracket that is not a link
+        rule %r/\[/, Text
+
+        rule %r/\n/, Text
+      end
+
+      state :link do
+        rule %r/(\[)(#{edot}*?)(\])/ do
+          groups Punctuation, Str::Symbol, Punctuation
+          pop!
+        end
+
+        rule %r/[(]/ do
+          token Punctuation
+          push :inline_title
+          push :inline_url
+        end
+
+        rule %r/[ \t]+/, Text
+
+        rule(//) { pop! }
+      end
+
+      state :url do
+        rule %r/[ \t]+/, Text
+
+        # the url
+        rule %r/(<)(#{edot}*?)(>)/ do
+          groups Name::Tag, Str::Other, Name::Tag
+          pop!
+        end
+
+        rule %r/\S+/, Str::Other, :pop!
+      end
+
+      state :title do
+        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 %r/[)]/, Punctuation, :pop!
+        mixin :title
+      end
+
+      state :inline_url do
+        rule %r/[^<\s)]+/, Str::Other, :pop!
+        rule %r/\s+/m, Text
+        mixin :url
+      end
+    end
+  end
+end

data/lib/rouge/lexers/mason.rb

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Mason < TemplateLexer
+      title 'Mason'
+      desc 'The HTML::Mason framework (https://metacpan.org/pod/HTML::Mason)'
+      tag 'mason'
+      filenames '*.mi', '*.mc', '*.mas', '*.m', '*.mhtml', '*.mcomp', 'autohandler', 'dhandler'
+      mimetypes 'text/x-mason', 'application/x-mason'
+
+      def initialize(*)
+        super
+        @perl = Perl.new
+      end
+  
+      # Note: If you add a tag in the lines below, you also need to modify "disambiguate '*.m'" in file disambiguation.rb
+      TEXT_BLOCKS = %w(text doc)
+      PERL_BLOCKS = %w(args flags attr init once shared perl cleanup filter)
+      COMPONENTS = %w(def method)
+  
+      state :root do
+        mixin :mason_tags
+      end
+
+      state :mason_tags do
+        rule %r/\s+/, Text::Whitespace
+
+        rule %r/<%(#{TEXT_BLOCKS.join('|')})>/oi, Comment::Preproc, :text_block
+
+        rule %r/<%(#{PERL_BLOCKS.join('|')})>/oi, Comment::Preproc, :perl_block
+
+        rule %r/(<%(#{COMPONENTS.join('|')}))([^>]*)(>)/oi do |m|
+          token Comment::Preproc, m[1]
+          token Name, m[3]
+          token Comment::Preproc, m[4]
+          push :component_block
+        end
+        
+        # perl line
+        rule %r/^(%)(.*)$/ do |m|
+          token Comment::Preproc, m[1]
+          delegate @perl, m[2]
+        end
+
+        # start of component call
+        rule %r/<%/, Comment::Preproc, :component_call
+
+         # start of component with content
+        rule %r/<&\|/ do
+          token Comment::Preproc
+          push :component_with_content
+          push :component_sub
+        end
+
+        # start of component substitution
+        rule %r/<&/, Comment::Preproc, :component_sub
+
+        # fallback to HTML until a mason tag is encountered
+        rule(/(.+?)(?=(<\/?&|<\/?%|^%|^#))/m) { delegate parent }
+
+        # if we get here, there's no more mason tags, so we parse the rest of the doc as HTML
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :perl_block do
+        rule %r/<\/%(#{PERL_BLOCKS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        rule(/(.*?[^"])(?=<\/%)/m) { delegate @perl }
+      end
+
+      state :text_block do
+        rule %r/<\/%(#{TEXT_BLOCKS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        rule %r/(.*?[^"])(?=<\/%)/m, Comment
+      end
+
+      state :component_block do
+        rule %r/<\/%(#{COMPONENTS.join('|')})>/oi, Comment::Preproc, :pop!
+        rule %r/\s+/, Text::Whitespace
+        rule %r/^(#.*)$/, Comment
+        mixin :mason_tags
+      end
+
+      state :component_with_content do
+        rule %r/<\/&>/ do 
+          token Comment::Preproc
+          pop!
+        end
+
+        mixin :mason_tags
+      end
+
+      state :component_sub do
+        rule %r/&>/, Comment::Preproc, :pop!
+
+        rule(/(.*?)(?=&>)/m) { delegate @perl }
+      end
+
+      state :component_call do
+        rule %r/%>/, Comment::Preproc, :pop!
+
+        rule(/(.*?)(?=%>)/m) { delegate @perl }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/mathematica.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Mathematica < RegexLexer
+      title "Mathematica"
+      desc "Wolfram Mathematica, the world's definitive system for modern technical computing."
+      tag 'mathematica'
+      aliases 'wl'
+      filenames '*.m', '*.wl'
+      mimetypes 'application/vnd.wolfram.mathematica.package', 'application/vnd.wolfram.wl'
+
+      # Mathematica has various input forms for numbers. We need to handle numbers in bases, precision, accuracy,
+      # and *^ scientific notation. All this works for integers and real numbers. Some examples
+      # 1  1234567  1.1  .3  0.2  1*^10  2*^+10  3*^-10
+      # 1`1  1``1  1.2`  1.2``1.234*^-10  1.2``1.234*^+10  1.2``1.234*^10
+      # 2^^01001 10^^1.2``20.1234*^-10
+      base = /(?:\d+)/
+      number = /(?:\.\d+|\d+\.\d*|\d+)/
+      number_base = /(?:\.\w+|\w+\.\w*|\w+)/
+      precision = /`(`?#{number})?/
+
+      operators = /[+\-*\/|,;.:@~=><&`'^?!_%]/
+      braces = /[\[\](){}]/
+
+      string = /"(\\\\|\\"|[^"])*"/
+
+      # symbols and namespaced symbols. Note the special form \[Gamma] for named characters. These are also symbols.
+      # Module With Block Integrate Table Plot
+      # x32 $x x$ $Context` Context123`$x `Private`Context
+      # \[Gamma] \[Alpha]x32 Context`\[Xi]
+      identifier = /[a-zA-Z$][$a-zA-Z0-9]*/
+      named_character = /\\\[#{identifier}\]/
+      symbol = /(#{identifier}|#{named_character})+/
+      context_symbol = /`?#{symbol}(`#{symbol})*`?/
+
+      # Slots for pure functions.
+      # Examples: # ## #1 ##3 #Test #"Test" #[Test] #["Test"]
+      association_slot = /#(#{identifier}|\"#{identifier}\")/
+      slot = /#{association_slot}|#[0-9]*/
+
+      # Handling of message like symbol::usage or symbol::"argx"
+      message = /::(#{identifier}|#{string})/
+
+      # Highlighting of the special in and out markers that are prepended when you copy a cell
+      in_out = /(In|Out)\[[0-9]+\]:?=/
+
+      # Although Module, With and Block are normal built-in symbols, we give them a special treatment as they are
+      # the most important expressions for defining local variables
+      def self.keywords
+        @keywords = Set.new %w(
+          Module With Block
+        )
+      end
+
+      # The list of built-in symbols comes from a wolfram server and is created automatically by rake
+      def self.builtins
+        load File.join(__dir__, 'mathematica/builtins.rb')
+        self.builtins
+      end
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\(\*/, Comment, :comment
+        rule %r/#{base}\^\^#{number_base}#{precision}?(\*\^[+-]?\d+)?/, Num # a number with a base
+        rule %r/(?:#{number}#{precision}?(?:\*\^[+-]?\d+)?)/, Num # all other numbers
+        rule message, Name::Tag
+        rule in_out, Generic::Prompt
+        rule %r/#{context_symbol}/m do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Name::Builtin::Pseudo
+          elsif self.class.builtins.include? match
+            token Name::Builtin
+          else
+            token Name::Variable
+          end
+        end
+        rule slot, Name::Function
+        rule operators, Operator
+        rule braces, Punctuation
+        rule string, Str
+      end
+
+      # Allow for nested comments and special treatment of ::Section:: or :Author: markup
+      state :comment do
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\*\)/, Comment, :pop!
+        rule %r/::#{identifier}::/, Comment::Preproc
+        rule %r/[ ]:(#{identifier}|[^\S])+:[ ]/, Comment::Preproc
+        rule %r/./, Comment
+      end
+    end
+  end
+end