Mojo language highlighting support. (#2050)

* Mojo language highlighting support.

* Added new line to fix the Linelint error

lib/rouge/demos/mojo

@@ -0,0 +1,10 @@
+fn fib(n: Int): # write Fibonacci series up to n
+    """Print a Fibonacci series up to n."""
+    var a = 0
+    var b = 1
+    while a < n:
+        print(a)
+        a, b = b, a+b
+
+fn main():
+    fib(10)

lib/rouge/lexers/mojo.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Mojo < Python
+      title "Mojo"
+      desc "The Mojo programming language (modular.com)"
+      tag 'mojo'
+      aliases 'mojo'
+      filenames '*.mojo', '*.🔥'
+      mimetypes 'text/x-mojo', 'application/x-mojo'
+
+      def self.detect?(text)
+        return true if text.shebang?(/mojow?(?:[23](?:\.\d+)?)?/)
+      end
+
+      def self.keywords
+        @keywords ||= super + %w(
+          fn self alias inout borrowed owned ref var
+          struct trait raises with in match case
+        )
+      end
+
+      def self.builtins
+        @builtins ||= super + %w(
+          __mlir_attr __mlir_type __mlir_op parameter alwaysinline
+          register_passable
+        )
+      end
+    end
+  end
+end

spec/lexers/mojo_spec.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+describe Rouge::Lexers::Mojo do
+  let(:subject) { Rouge::Lexers::Mojo.new }
+
+  describe 'guessing' do
+    include Support::Guessing
+
+    it 'guesses by filename' do
+      assert_guess :filename => 'foo.mojo'
+      assert_guess :filename => 'foo.🔥'
+    end
+
+    it 'guesses by mimetype' do
+      assert_guess :mimetype => 'text/x-mojo'
+      assert_guess :mimetype => 'application/x-mojo'
+    end
+
+    it 'guesses by source' do
+      assert_guess :source => '#!/usr/bin/env mojo'
+      assert_guess :source => '#!/usr/bin/mojo'
+    end
+  end
+end

spec/visual/samples/mojo

@@ -0,0 +1,229 @@
+fn lex(code: String, lexer: Lexer) raises:
+    """
+    Lex ``code`` with ``lexer`` and return an iterable of tokens.
+    """
+    try:
+        return lexer.get_tokens(code)
+    except e:
+        raise
+
+alias lst = List[Int]
+
+# quotes in strings
+def foo():
+    "it's working"
+
+def foo():
+    'he said "hi"'
+
+def foo():
+    """it's working"""
+    """he said "hi" """
+
+def foo():
+    '''he said "hi"'''
+    '''it's working'''
+
+# unicode docstrings
+def foo():
+    ur"""unicode-raw"""
+
+def bar():
+    u"""unicode"""
+
+def baz():
+    r'raw'
+
+def zap():
+    """docstring"""
+
+# escaped characters in string literals
+fn baz():
+    '\a\b\f\n\r\t\v\"\''
+    '\N{DEGREE SIGN}'
+    '\uaF09'
+    '\UaaaaAF09'
+    '\xaf\xAF\x09'
+    '\007'
+    '.*\[p00t_(d\d{4})\].*' # There are no escape sequences in this string
+
+# escaped characters in raw strings
+def baz():
+    r'\a\b\f\n\r\t\v\"\''
+    r'\N{DEGREE SIGN}'
+    r'\uaF09'
+    r'\UaaaaAF09'
+    r'\xaf\xAF\x09'
+    r'\007'
+    r'.*\[p00t_(d\d{4})\].*'
+
+# line continuations
+apple.filter(x, y)
+apple.\
+    filter(x, y)
+
+1 \
+    . \
+    __str__
+
+from os import path
+from \
+        os \
+        import \
+        path
+
+import os.path as something
+
+import \
+        os.path \
+        as \
+        something
+
+class \
+ Spam:
+    pass
+
+class Spam: pass
+
+trait Spam: pass
+
+@register_passable
+struct Spam:
+    var x: Int
+    fn __init__(inout self):
+        self.x = 0
+        @parameter
+        for i in (range(10)):
+            pass
+
+class Spam(object):
+    pass
+
+class \
+ Spam \
+  (
+   object
+ ) \
+ :
+ pass
+
+
+def \
+ spam \
+  ( \
+  ) \
+  : \
+  pass
+
+def the_word_strand():
+    a = b.strip()
+    a = strand
+    b = band
+    c = strand
+    b = error
+    c = stror
+    c = string
+
+py2_long = -123L
+
+# Python 3
+
+def test():
+    raise Exception from foo
+
+def exceptions():
+    try:
+        print("Hello")
+    except Exception as e:
+        print("Exception")
+
+# PEP 515
+integer_literals = [
+    123, -1_2_0, 0, 00, 0_0_00, 0b1, 0B1_0, 0b_1, 0b00_0,
+    0o1, 0O1_2, 0O_1, 0o00_0, 0x1, 0X1_2, 0x_1, 0x00_0
+]
+float_literals = [
+    0., 1., 00., 0_00., 1_0_0., 0_1., .0,
+    .1_2, 3.4_5, 1_2.3_4, 00_0.0_0_0, 0_0.1_2,
+    0_1_2j, 0_00J, 1.2J, 0.1j, 1_0.J,
+    0_00E+2_34_5, 0.e+1, 00_1.E-0_2, -100.e+20, 1e01,
+    0_00E+2_34_5j, 0.e+1J, 00_1.E-0_2j, -100.e+20J 1e01j
+]
+floats = (19.0, 19.)
+
+# PEP 465
+a = b @ c
+x @= y
+
+# PEP 498
+f'{hello} world {int(x) + 1}'
+f'{{ {4*10} }}'
+f'result: {value:{width}.{precision}}'
+f'{value!r}'
+
+# Unicode identifiers
+α = 10
+def coöperative(б):
+    return f"{б} is Russian"
+
+def __init__(self, input_dim: list, output_dim: int, **kwargs):
+    super(AverageEmbedding, self).__init__(**kwargs)
+    self.input_dim = input_dim
+    self.output_dim = output_dim
+
+@abstractmethod
+def evaluate(self, *args, **kwargs):
+    raise NotImplementedError
+
+def _get_metadata(self, input_samples: list[InputSample]) -> Tuple[str, str, int]:
+    project_name, id = self._get_info()
+
+class Spam:
+    pass
+
+spam = Spam()
+
+# Doctest
+def factorial(n):
+    """Return the factorial of n, an exact integer >= 0.
+
+    >>> [factorial(n) for n in range(6)]
+    [1, 1, 2, 6, 24, 120]
+
+    >>> for i in [factorial(n) for n in range(2)]:
+    ...     print(i)
+    1
+    1
+    >>> factorial(30)
+    265252859812191058636308480000000
+    >>> factorial(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: n must be >= 0
+
+    Factorials of floats are OK, but the float must be an exact integer:
+    >>> factorial(30.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: n must be exact integer
+    >>> factorial(30.0)
+    265252859812191058636308480000000
+
+    It must also not be ridiculously large:
+    >>> factorial(1e100)
+    Traceback (most recent call last):
+        ...
+    OverflowError: n too large
+    """
+    print("hello world")
+
+def do_nothing():
+    if False:
+        return
+        print("a...a")
+
+    with tracer.start_as_current_span('App Init'):
+        logger.info('OTEL Initialized...')
+
+    app = FastAPI()
+    FastAPIInstrumentor.instrument_app(app)