gitlab-rouge 1.9.2

data/lib/rouge/lexers/tex.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class TeX < RegexLexer
+      title "TeX"
+      desc "The TeX typesetting system"
+      tag 'tex'
+      aliases 'TeX', 'LaTeX', 'latex'
+
+      filenames '*.tex', '*.aux', '*.toc'
+      mimetypes 'text/x-tex', 'text/x-latex'
+
+      def self.analyze_text(text)
+        return 1 if text =~ /\A\s*\\documentclass/
+        return 1 if text =~ /\A\s*\\input/
+        return 1 if text =~ /\A\s*\\documentstyle/
+        return 1 if text =~ /\A\s*\\relax/
+      end
+
+      command = /\\([a-z]+|\s+|.)/i
+
+      state :general do
+        rule /%.*$/, Comment
+        rule /[{}&_^]/, Punctuation
+      end
+
+      state :root do
+        rule /\\\[/, Punctuation, :displaymath
+        rule /\\\(/, Punctuation, :inlinemath
+        rule /\$\$/, Punctuation, :displaymath
+        rule /\$/, Punctuation, :inlinemath
+        rule /\\(begin|end)\{.*?\}/, Name::Tag
+
+        rule /(\\verb)\b(\S)(.*?)(\2)/ do |m|
+          groups Name::Builtin, Keyword::Pseudo, Str::Other, Keyword::Pseudo
+        end
+
+        rule command, Keyword, :command
+        mixin :general
+        rule /[^\\$%&_^{}]+/, Text
+      end
+
+      state :math do
+        rule command, Name::Variable
+        mixin :general
+        rule /[0-9]+/, Num
+        rule /[-=!+*\/()\[\]]/, Operator
+        rule /[^=!+*\/()\[\]\\$%&_^{}0-9-]+/, Name::Builtin
+      end
+
+      state :inlinemath do
+        rule /\\\)/, Punctuation, :pop!
+        rule /\$/, Punctuation, :pop!
+        mixin :math
+      end
+
+      state :displaymath do
+        rule /\\\]/, Punctuation, :pop!
+        rule /\$\$/, Punctuation, :pop!
+        rule /\$/, Name::Builtin
+        mixin :math
+      end
+
+      state :command do
+        rule /\[.*?\]/, Name::Attribute
+        rule /\*/, Keyword
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/toml.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class TOML < RegexLexer
+      title "TOML"
+      desc 'the TOML configuration format (https://github.com/mojombo/toml)'
+      tag 'toml'
+
+      filenames '*.toml'
+      mimetypes 'text/x-toml'
+
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A\[[\w.]+\]\s*\w+\s*=\s*("\w+")+/
+      end
+
+      identifier = /[\w.\S]+/
+
+      state :basic do
+        rule /\s+/, Text
+        rule /#.*?$/, Comment
+        rule /(true|false)/, Keyword::Constant
+        rule /(?<!=)\s*\[[\w\d\S]+\]/, Name::Namespace
+
+        rule /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
+
+        rule /(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
+        rule /\d+[eE][+-]?[0-9]+j?/, Num::Float
+        rule /\-?\d+/, Num::Integer
+      end
+
+      state :root do
+        mixin :basic
+
+        rule /(#{identifier})(\s*)(=)/ do
+          groups Name::Property, Text, Punctuation
+          push :value
+        end
+
+      end
+
+      state :value do
+        rule /\n/, Text, :pop!
+        mixin :content
+      end
+
+      state :content do
+        mixin :basic
+        rule /"/, Str, :dq
+        mixin :esc_str
+        rule /\,/, Punctuation
+        rule /\[/, Punctuation, :array
+      end
+
+      state :dq do
+        rule /"/, Str, :pop!
+        mixin :esc_str
+        rule /[^\\"]+/, Str
+      end
+
+      state :esc_str do
+        rule /\\[0t\tn\n "\\ r]/, Str::Escape
+      end
+
+      state :array do
+        mixin :content
+        rule /\]/, Punctuation, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/tulip.rb

@@ -0,0 +1,75 @@
+module Rouge
+  module Lexers
+    class Tulip < RegexLexer
+      tag 'tulip'
+      aliases 'tlp'
+      filenames '*.tlp'
+      desc 'The tulip programming language http://github.com/jneen/tulip'
+
+      id = /\w[\w-]*/
+
+      def self.analyze_text(text)
+        return 1 if text.shebang?('tulip')
+      end
+
+      state :root do
+        rule /\s+/, Text
+        rule /#.*?\n/, Comment
+        rule /%#{id}/, Keyword::Type
+        rule /@#{id}/, Keyword
+        rule /[.][.]?#{id}/, Name::Label
+        rule /-#{id}[?]?/, Str::Symbol
+        rule /\d+/, Num
+        rule %r(/#{id}?), Name::Decorator
+        rule %r((#{id}/)(#{id})) do
+          groups Name::Namespace, Name::Variable
+        end
+
+        rule /"{/, Str, :string_interp
+        rule /'?{/, Str, :string
+        rule /['"][^\s)\]]+/, Str
+
+        rule /[$]/, Name::Variable
+
+        rule /[-+:;~!()\[\]=?>|_%,]/, Punctuation
+        rule /[.][.][.]/, Punctuation
+        rule id, Name
+      end
+
+      state :string_base do
+        rule /{/ do
+          token Str; push
+        end
+
+        rule /}/, Str, :pop!
+        rule /[$]/, Str
+        rule /[^${}\\]+/, Str
+      end
+
+      state :string do
+        mixin :string_base
+        rule /\\/, Str
+      end
+
+      state :interp do
+        rule(/[(]/) { token Punctuation; push }
+        rule /[)]/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :interp_root do
+        rule /[(]/, Str::Interpol, :interp
+        rule /[)]/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :string_interp do
+        rule /\\./, Str::Escape
+        rule /[$][(]/, Str::Interpol, :interp_root
+        rule /[$]#{id}?/, Name::Variable
+        mixin :string_base
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/vb.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class VisualBasic < RegexLexer
+      title "Visual Basic"
+      desc "Visual Basic"
+      tag 'vb'
+      aliases 'visualbasic'
+      filenames '*.vbs'
+      mimetypes 'text/x-visualbasic', 'application/x-visualbasic'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AddHandler Alias ByRef ByVal CBool CByte CChar CDate CDbl CDec
+          CInt CLng CObj CSByte CShort CSng CStr CType CUInt CULng CUShort
+          Call Case Catch Class Const Continue Declare Default Delegate
+          Dim DirectCast Do Each Else ElseIf End EndIf Enum Erase Error
+          Event Exit False Finally For Friend Function Get Global GoSub
+          GoTo Handles If Implements Imports Inherits Interface Let
+          Lib Loop Me Module MustInherit MustOverride MyBase MyClass
+          Namespace Narrowing New Next Not NotInheritable NotOverridable
+          Nothing Of On Operator Option Optional Overloads Overridable
+          Overrides ParamArray Partial Private Property Protected Public
+          RaiseEvent ReDim ReadOnly RemoveHandler Resume Return Select Set
+          Shadows Shared Single Static Step Stop Structure Sub SyncLock
+          Then Throw To True Try TryCast Using Wend When While Widening
+          With WithEvents WriteOnly
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Byte Char Date Decimal Double Integer Long Object
+          SByte Short Single String Variant UInteger ULong UShort
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= Set.new %w(
+          AddressOf And AndAlso As GetType In Is IsNot Like Mod Or OrElse
+          TypeOf Xor
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          Console ConsoleColor
+        )
+      end
+
+      id = /[a-z_]\w*/i
+      upper_id = /[A-Z]\w*/
+
+      state :whitespace do
+        rule /\s+/, Text
+        rule /\n/, Text, :bol
+        rule /rem\b.*?$/i, Comment::Single
+        rule %r(%\{.*?%\})m, Comment::Multiline
+        rule /'.*$/, Comment::Single
+      end
+
+      state :bol do
+        rule /\s+/, Text
+        rule /<.*?>/, Name::Attribute
+        rule(//) { :pop! }
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r(
+            [#]If\b .*? \bThen
+          | [#]ElseIf\b .*? \bThen
+          | [#]End \s+ If
+          | [#]Const
+          | [#]ExternalSource .*? \n
+          | [#]End \s+ ExternalSource
+          | [#]Region .*? \n
+          | [#]End \s+ Region
+          | [#]ExternalChecksum
+        )x, Comment::Preproc
+        rule /[.]/, Punctuation, :dotted
+        rule /[(){}!#,:]/, Punctuation
+        rule /Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
+          Keyword::Declaration
+        rule /End\b/, Keyword, :end
+        rule /(Dim|Const)\b/, Keyword, :dim
+        rule /(Function|Sub|Property)\b/, Keyword, :funcname
+        rule /(Class|Structure|Enum)\b/, Keyword, :classname
+        rule /(Module|Namespace|Imports)\b/, Keyword, :namespace
+
+        rule upper_id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.keywords_type.include? match
+            token Keyword::Type
+          elsif self.class.operator_words.include? match
+            token Operator::Word
+          elsif self.class.builtins.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule(
+          %r(&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]),
+          Operator
+        )
+
+        rule /"/, Str, :string
+        rule /#{id}[%&@!#\$]?/, Name
+        rule /#.*?#/, Literal::Date
+
+        rule /(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
+        rule /\d+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
+
+        rule /_\n/, Keyword
+      end
+
+      state :dotted do
+        mixin :whitespace
+        rule id, Name, :pop!
+      end
+
+      state :string do
+        rule /""/, Str::Escape
+        rule /"C?/, Str, :pop!
+        rule /[^"]+/, Str
+      end
+
+      state :dim do
+        mixin :whitespace
+        rule id, Name::Variable, :pop!
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        mixin :whitespace
+        rule id, Name::Function, :pop!
+      end
+
+      state :classname do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /#{id}([.]#{id})*/, Name::Namespace, :pop!
+      end
+
+      state :end do
+        mixin :whitespace
+        rule /(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
+          Keyword, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/viml.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class VimL < RegexLexer
+      title "VimL"
+      desc "VimL, the scripting language for the Vim editor (vim.org)"
+      tag 'viml'
+      aliases 'vim', 'vimscript', 'ex'
+      filenames '*.vim', '*.vba', '.vimrc', '.exrc', '.gvimrc',
+                '_vimrc', '_exrc', '_gvimrc' # _ names for windows
+
+      mimetypes 'text/x-vim'
+
+      def self.keywords
+        load Pathname.new(__FILE__).dirname.join('viml/keywords.rb')
+        self.keywords
+      end
+
+      state :root do
+        rule /^(\s*)(".*?)$/ do
+          groups Text, Comment
+        end
+
+        rule /^\s*\\/, Str::Escape
+
+        rule /[ \t]+/, Text
+
+        # TODO: regexes can have other delimiters
+        rule %r(/(\\\\|\\/|[^\n/])*/), Str::Regex
+        rule %r("(\\\\|\\"|[^\n"])*"), Str::Double
+        rule %r('(\\\\|\\'|[^\n'])*'), Str::Single
+
+        # if it's not a string, it's a comment.
+        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
+
+        rule /-?\d+/, Num
+        rule /#[0-9a-f]{6}/i, Num::Hex
+        rule /^:/, Punctuation
+        rule /[():<>+=!\[\]{}\|,~.-]/, Punctuation
+        rule /\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
+          Keyword
+
+        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
+
+        rule /[absg]:\w+\b/, Name::Variable
+        rule /\b\w+\b/ do |m|
+          name = m[0]
+          keywords = self.class.keywords
+
+          if mapping_contains?(keywords[:command], name)
+            token Keyword
+          elsif mapping_contains?(keywords[:option], name)
+            token Name::Builtin
+          elsif mapping_contains?(keywords[:auto], name)
+            token Name::Builtin
+          else
+            token Text
+          end
+        end
+
+        # no errors in VimL!
+        rule /./m, Text
+      end
+
+      def mapping_contains?(mapping, word)
+        shortest, longest = find_likely_mapping(mapping, word)
+
+        shortest and word.start_with?(shortest) and
+        longest and longest.start_with?(word)
+      end
+
+      # binary search through the mappings to find the one that's likely
+      # to actually work.
+      def find_likely_mapping(mapping, word)
+        min = 0
+        max = mapping.size
+
+        until max == min
+          mid = (max + min) / 2
+
+          cmp, _ = mapping[mid]
+
+          case word <=> cmp
+          when 1
+            # too low
+            min = mid + 1
+          when -1
+            # too high
+            max = mid
+          when 0
+            # just right, abort!
+            return mapping[mid]
+          end
+        end
+
+        mapping[max - 1]
+      end
+    end
+  end
+end