rouge 3.18.0

data/lib/rouge/lexers/cypher.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Cypher < RegexLexer
+      tag 'cypher'
+      aliases 'cypher'
+      filenames '*.cypher'
+      mimetypes 'application/x-cypher-query'
+
+      title "Cypher"
+      desc 'The Cypher query language (neo4j.com/docs/cypher-manual)'
+
+      def self.functions
+        @functions ||= Set.new %w(
+          ABS ACOS ALLSHORTESTPATHS ASIN ATAN ATAN2 AVG CEIL COALESCE COLLECT
+          COS COT COUNT DATE DEGREES E ENDNODE EXP EXTRACT FILTER FLOOR
+          HAVERSIN HEAD ID KEYS LABELS LAST LEFT LENGTH LOG LOG10 LOWER LTRIM
+          MAX MIN NODE NODES PERCENTILECONT PERCENTILEDISC PI RADIANS RAND
+          RANGE REDUCE REL RELATIONSHIP RELATIONSHIPS REPLACE REVERSE RIGHT
+          ROUND RTRIM SHORTESTPATH SIGN SIN SIZE SPLIT SQRT STARTNODE STDEV
+          STDEVP STR SUBSTRING SUM TAIL TAN TIMESTAMP TOFLOAT TOINT TOINTEGER
+          TOSTRING TRIM TYPE UPPER
+        )
+      end
+
+      def self.predicates
+        @predicates ||= Set.new %w(
+          ALL AND ANY CONTAINS EXISTS HAS IN NONE NOT OR SINGLE XOR
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AS ASC ASCENDING ASSERT BY CASE COMMIT CONSTRAINT CREATE CSV CYPHER
+          DELETE DESC DESCENDING DETACH DISTINCT DROP ELSE END ENDS EXPLAIN
+          FALSE FIELDTERMINATOR FOREACH FROM HEADERS IN INDEX IS JOIN LIMIT
+          LOAD MATCH MERGE NULL ON OPTIONAL ORDER PERIODIC PROFILE REMOVE
+          RETURN SCAN SET SKIP START STARTS THEN TRUE UNION UNIQUE UNWIND USING
+          WHEN WHERE WITH CALL YIELD
+        )
+      end
+
+      state :root do
+        rule %r/[\s]+/, Text
+        rule %r(//.*?$), Comment::Single
+
+        rule %r([*+\-<>=&|~%^]), Operator
+        rule %r/[{}),;\[\]]/, Str::Symbol
+
+        # literal number
+        rule %r/(\w+)(:)(\s*)(-?[._\d]+)/ do
+          groups Name::Label, Str::Delimiter, Text::Whitespace, Num
+        end
+
+        # function-like
+        # - "name("
+        # - "name  ("
+        # - "name ("
+        rule %r/(\w+)(\s*)(\()/ do |m|
+          name = m[1].upcase
+          if self.class.functions.include? name
+            groups Name::Function, Text::Whitespace, Str::Symbol
+          elsif self.class.keywords.include? name
+            groups Keyword, Text::Whitespace, Str::Symbol
+          else
+            groups Name, Text::Whitespace, Str::Symbol
+          end
+        end
+
+        rule %r/:\w+/, Name::Class
+
+        # number range
+        rule %r/(-?\d+)(\.\.)(-?\d+)/ do
+          groups Num, Operator, Num
+        end
+
+        # numbers
+        rule %r/(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/0[0-7]+/, Num::Oct
+        rule %r/0x[a-f0-9]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+
+        rule %r([.\w]+:), Name::Property
+
+        # remaining "("
+        rule %r/\(/, Str::Symbol
+
+        rule %r/[.\w$]+/ do |m|
+          match = m[0].upcase
+          if self.class.predicates.include? match
+            token Operator::Word
+          elsif self.class.keywords.include? match
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/`(\\\\|\\`|[^`])*`/, Str::Backtick
+      end
+    end
+  end
+end

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