rouge 3.17.0

data/lib/rouge/lexers/cython.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'python.rb'
+
+    class Cython < Python
+      title "Cython"
+      desc "Cython and Pyrex source code (cython.org)"
+      tag 'cython'
+      aliases 'pyx', 'pyrex'
+      filenames '*.pyx', '*.pxd', '*.pxi'
+      mimetypes 'text/x-cython', 'application/x-cython'
+
+      def initialize(opts = {})
+        super opts
+        @indentation = nil
+      end
+
+      def self.keywords
+        @keywords ||= super + %w(
+          by except? fused gil nogil
+        )
+      end
+
+      def self.c_keywords
+        @ckeywords ||= %w(
+          public readonly extern api inline enum union
+        )
+      end
+
+      identifier = /[a-z_]\w*/i
+      dotted_identifier = /[a-z_.][\w.]*/i
+
+      prepend :root do
+        rule %r/cp?def|ctypedef/ do
+          token Keyword
+          push :c_definitions
+          push :c_start
+        end
+
+        rule %r/(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(cimport)/ do
+          groups Keyword::Namespace,
+                 Text,
+                 Name::Namespace,
+                 Text,
+                 Keyword::Namespace
+        end
+
+        rule %r/(cimport)(\s+)(#{dotted_identifier})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+
+        rule %r/(struct)((?:\\\s|\s)+)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        mixin :func_call_fix
+
+        rule %r/[(,]/, Punctuation, :c_start
+      end
+
+      prepend :classname do
+        rule %r/(?:\\\s|\s)+/, Text
+      end
+
+      prepend :funcname do
+        rule %r/(?:\\\s|\s)+/, Text
+      end
+      # This is a fix for the way that function calls are lexed in the Python
+      # lexer. This should be moved to the Python lexer once confirmed that it
+      # does not cause any regressions.
+      state :func_call_fix do
+        rule %r/#{identifier}(?=\()/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.exceptions.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.builtins_pseudo.include? m[0]
+            token Name::Builtin::Pseudo
+          else
+            token Name::Function
+          end
+        end
+      end
+
+      # The Cython lexer adds three states to those already in the Python lexer.
+      # Calls to `cdef`, `cpdef` and `ctypedef` move the lexer into the :c_start
+      # state. The primary purpose of this state is to highlight datatypes. Once
+      # this has been done, the lexer moves to the :c_definitions state where
+      # the majority of text in a definition is lexed. Finally, newlines cause
+      # the lexer to move to :c_indent. This state is used to check whether we
+      # have moved out of a C block.
+
+      state :c_start do
+        rule %r/[^\S\n]+/, Text
+
+        rule %r/cp?def|ctypedef/, Keyword
+
+        rule %r/(?:un)?signed/, Keyword::Type
+
+        # This rule matches identifiers that could be type declarations. The
+        # lookahead matches (1) pointers, (2) arrays and (3) variable names.
+        rule %r/#{identifier}(?=(?:\*+)|(?:[ \t]*\[)|(?:[ \t]+\w))/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+            pop!
+          elsif %w(def).include? m[0]
+            token Keyword
+            goto :funcname
+          elsif %w(struct class).include? m[0]
+            token Keyword::Reserved
+            goto :classname
+          elsif self.class.c_keywords.include? m[0]
+            token Keyword::Reserved
+          else
+            token Keyword::Type
+            pop!
+          end
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :c_definitions do
+        rule %r/\n/, Text, :c_indent
+        mixin :root
+      end
+
+      state :c_indent do
+        rule %r/[ \t]+/ do |m|
+          token Text
+          goto :c_start
+
+          if @indentation.nil?
+            @indentation = m[0]
+          elsif @indentation.length > m[0].length
+            @indentation = nil
+            pop! 2 # Pop :c_start and :c_definitions
+          end
+        end
+
+        rule(//) { @indentation = nil; reset_stack }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/d.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class D < RegexLexer
+      tag 'd'
+      aliases 'dlang'
+      filenames '*.d', '*.di'
+      mimetypes 'application/x-dsrc', 'text/x-dsrc'
+
+      title "D"
+      desc 'The D programming language(dlang.org)'
+
+      keywords = %w(
+        abstract alias align asm assert auto body
+        break case cast catch class const continue
+        debug default delegate delete deprecated do else
+        enum export extern finally final foreach_reverse
+        foreach for function goto if immutable import
+        interface invariant inout in is lazy mixin
+        module new nothrow out override package pragma
+        private protected public pure ref return scope
+        shared static struct super switch synchronized
+        template this throw try typedef typeid typeof
+        union unittest version volatile while with
+        __gshared __traits __vector __parameters
+      )
+
+      keywords_type = %w(
+        bool byte cdouble cent cfloat char creal
+        dchar double float idouble ifloat int ireal
+        long real short ubyte ucent uint ulong
+        ushort void wchar
+      )
+
+      keywords_pseudo = %w(
+        __FILE__ __FILE_FULL_PATH__ __MODULE__ __LINE__ __FUNCTION__
+        __PRETTY_FUNCTION__ __DATE__ __EOF__ __TIME__ __TIMESTAMP__
+        __VENDOR__ __VERSION__
+      )
+
+      state :whitespace do
+        rule %r/\n/m, Text
+        rule %r/\s+/m, Text
+      end
+
+      state :root do
+        mixin :whitespace
+        # Comments
+        rule %r(//.*), Comment::Single
+        rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :nested_comment
+        # Keywords
+        rule %r/(#{keywords.join('|')})\b/, Keyword
+        rule %r/(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/(false|true|null)\b/, Keyword::Constant
+        rule %r/(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
+        rule %r/macro\b/, Keyword::Reserved
+        rule %r/(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
+        # Literals
+        # HexFloat
+        rule %r/0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        # DecimalFloat
+        rule %r/[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule %r/\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        # IntegerLiteral
+        # Binary
+        rule %r/0[Bb][01_]+/, Num::Bin
+        # Octal
+        # TODO: 0[0-7] isn't supported use octal![0-7] instead
+        rule %r/0[0-7_]+/, Num::Oct
+        # Hexadecimal
+        rule %r/0[xX][0-9a-fA-F_]+/, Num::Hex
+        # Decimal
+        rule %r/(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        # CharacterLiteral
+        rule %r/'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
+        # StringLiteral
+        # WysiwygString
+        rule %r/r"[^"]*"[cwd]?/, Str
+        # Alternate WysiwygString
+        rule %r/`[^`]*`[cwd]?/, Str
+        # DoubleQuotedString
+        rule %r/"(\\\\|\\"|[^"])*"[cwd]?/, Str
+        # EscapeSequence
+        rule %r/\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
+        # HexString
+        rule %r/x"[0-9a-fA-F_\s]*"[cwd]?/, Str
+        # DelimitedString
+        rule %r/q"\[/, Str, :delimited_bracket
+        rule %r/q"\(/, Str, :delimited_parenthesis
+        rule %r/q"</, Str, :delimited_angle
+        rule %r/q"\{/, Str, :delimited_curly
+        rule %r/q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
+        rule %r/q"(.).*?\1"/, Str
+        # TokenString
+        rule %r/q\{/, Str, :token_string
+        # Attributes
+        rule %r/@([a-zA-Z_]\w*)?/, Name::Decorator
+        # Tokens
+        rule %r`(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]`, Punctuation
+        # Identifier
+        rule %r/[a-zA-Z_]\w*/, Name
+        # Line
+        rule %r/#line\s.*\n/, Comment::Special
+      end
+
+      state :nested_comment do
+        rule %r([^+/]+), Comment::Multiline
+        rule %r(/\+), Comment::Multiline, :push
+        rule %r(\+/), Comment::Multiline, :pop!
+        rule %r([+/]), Comment::Multiline
+      end
+
+      state :token_string do
+        rule %r/\{/, Punctuation, :token_string_nest
+        rule %r/\}/, Str, :pop!
+        mixin :root
+      end
+
+      state :token_string_nest do
+        rule %r/\{/, Punctuation, :push
+        rule %r/\}/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :delimited_bracket do
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :delimited_inside_bracket
+        rule %r/\]"/, Str, :pop!
+      end
+
+      state :delimited_inside_bracket do
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :push
+        rule %r/\]/, Str, :pop!
+      end
+
+      state :delimited_parenthesis do
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :delimited_inside_parenthesis
+        rule %r/\)"/, Str, :pop!
+      end
+
+      state :delimited_inside_parenthesis do
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :push
+        rule %r/\)/, Str, :pop!
+      end
+
+      state :delimited_angle do
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :delimited_inside_angle
+        rule %r/>"/, Str, :pop!
+      end
+
+      state :delimited_inside_angle do
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :push
+        rule %r/>/, Str, :pop!
+      end
+
+      state :delimited_curly do
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :delimited_inside_curly
+        rule %r/\}"/, Str, :pop!
+      end
+
+      state :delimited_inside_curly do
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :push
+        rule %r/\}/, Str, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/dart.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dart < RegexLexer
+      title "Dart"
+      desc "The Dart programming language (dartlang.com)"
+
+      tag 'dart'
+      filenames '*.dart'
+      mimetypes 'text/x-dart'
+
+      keywords = %w(
+        as assert break case catch continue default do else finally for
+        if in is new rethrow return super switch this throw try while with
+      )
+
+      declarations = %w(
+        abstract dynamic const external extends factory final get implements
+        native operator set static typedef var
+      )
+
+      types = %w(bool double Dynamic enum int num Object Set String void)
+
+      imports = %w(import export library part\s*of part source)
+
+      id = /[a-zA-Z_]\w*/
+
+      state :root do
+        rule %r(^
+          (\s*(?:[a-zA-Z_][a-zA-Z\d_.\[\]]*\s+)+?) # return arguments
+          ([a-zA-Z_]\w*)                           # method name
+          (\s*)(\()                                # signature start
+        )mx do |m|
+          # TODO: do this better, this shouldn't need a delegation
+          delegate Dart, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Punctuation, m[4]
+        end
+
+        rule %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r/"/, Str, :dqs
+        rule %r/'/, Str, :sqs
+        rule %r/r"[^"]*"/, Str::Other
+        rule %r/r'[^']*'/, Str::Other
+        rule %r/##{id}*/i, Str::Symbol
+        rule %r/@#{id}/, Name::Decorator
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{types.join('|')})\b/, Keyword::Type
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
+        rule %r/(\.)(#{id})/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule %r/#{id}:/, Name::Label
+        rule %r/\$?#{id}/, Name
+        rule %r/[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule %r/\d*\.\d+([eE]\-?\d+)?/, Num::Float
+        rule %r/0x[\da-fA-F]+/, Num::Hex
+        rule %r/\d+L?/, Num::Integer
+        rule %r/\n/, Text
+      end
+
+      state :class do
+        rule %r/\s+/m, Text
+        rule id, Name::Class, :pop!
+      end
+
+      state :dqs do
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\\$"]+/, Str
+        mixin :string
+      end
+
+      state :sqs do
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\\$']+/, Str
+        mixin :string
+      end
+
+      state :import do
+        rule %r/;/, Operator, :pop!
+        rule %r/(?:show|hide)\b/, Keyword::Declaration
+        mixin :root
+      end
+
+      state :string do
+        mixin :interpolation
+        rule %r/\\[nrt\"\'\\]/, Str::Escape
+      end
+
+      state :interpolation do
+        rule %r/\$#{id}/, Str::Interpol
+        rule %r/\$\{[^\}]+\}/, Str::Interpol
+      end
+    end
+  end
+end

data/lib/rouge/lexers/diff.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.detect?(text)
+        return true if text.start_with?('Index: ')
+        return true if text =~ %r(\Adiff[^\n]*?\ba/[^\n]*\bb/)
+        return true if text =~ /(---|[+][+][+]).*?\n(---|[+][+][+])/
+      end
+
+      state :root do
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Punctuation)
+        rule(/^[+>]+.*$\n?/, Generic::Inserted)
+        rule(/^\+.*$\n?/, Generic::Inserted)
+        rule(/^[-<]+.*$\n?/, Generic::Deleted)
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^(@@[^@]*@@)([^\n]*\n)/) do
+          groups Punctuation, Text
+        end
+        rule(/^\w.*$\n?/, Punctuation)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/\s.*$\n?/, Text)
+      end
+    end
+  end
+end