rougegal 2.1.2

data/lib/rouge/lexers/tex.rb

@@ -0,0 +1,69 @@
+# -*- 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', '*.sty', '*.cls'
+      mimetypes 'text/x-tex', 'text/x-latex'
+
+      def self.analyze_text(text)
+        return 1 if text =~ /\A\s*\\(documentclass|input|documentstyle|relax|ProvidesPackage|ProvidesClass)/
+      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/tsx.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'jsx.rb'
+    load_lexer 'typescript/common.rb'
+
+    class TSX < JSX
+      include TypescriptCommon
+
+      title 'TypeScript'
+      desc 'tsx'
+
+      tag 'tsx'
+      filenames '*.tsx'
+    end
+  end
+end
+

data/lib/rouge/lexers/tulip.rb

@@ -0,0 +1,107 @@
+module Rouge
+  module Lexers
+    class Tulip < RegexLexer
+      desc 'the tulip programming language (twitter.com/tuliplang)'
+      tag 'tulip'
+      aliases 'tulip'
+
+      filenames '*.tlp'
+
+      mimetypes 'text/x-tulip', 'application/x-tulip'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'tulip'
+        return 0
+      end
+
+      id = /[a-z][\w-]*/i
+      upper_id = /[A-Z][\w-]*/
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule /#.*?$/, Comment
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+
+        rule /@#{id}/, Keyword
+
+
+        rule /(\\#{id})([{])/ do
+          groups Name::Function, Str
+          push :nested_string
+        end
+
+        rule /([+]#{id})([{])/ do
+          groups Name::Decorator, Str
+          push :nested_string
+        end
+
+        rule /\\#{id}/, Name::Function
+        rule /[+]#{id}/, Name::Decorator
+
+        rule /"[{]/, Str, :dqi
+        rule /"/, Str, :dq
+
+        rule /'{/, Str, :nested_string
+        rule /'#{id}/, Str
+
+        rule /[.]#{id}/, Name::Tag
+        rule /[$]#{id}?/, Name::Variable
+        rule /-#{id}:?/, Name::Label
+        rule /%#{id}/, Name::Function
+        rule /`#{id}/, Operator::Word
+
+        rule /[?~%._>,!\[\]:{}()=;\/-]/, Punctuation
+
+        rule /[0-9]+([.][0-9]+)?/, Num
+
+        rule /#{id}/, Name
+
+        rule /</, Comment::Preproc, :angle_brackets
+      end
+
+      state :dq do
+        rule /[^\\"]+/, Str
+        rule /"/, Str, :pop!
+        rule /\\./, Str::Escape
+      end
+
+      state :dqi do
+        rule /[$][(]/, Str::Interpol, :interp_root
+        rule /[{]/, Str, :dqi
+        rule /[}]/, Str, :pop!
+        rule /[^{}$]+/, Str
+        rule /./, Str
+      end
+
+      state :interp_root do
+        rule /[)]/, Str::Interpol, :pop!
+        mixin :interp
+      end
+
+      state :interp do
+        rule /[(]/, Punctuation, :interp
+        rule /[)]/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :nested_string do
+        rule /\\./, Str::Escape
+        rule(/{/) { token Str; push :nested_string }
+        rule(/}/) { token Str; pop! }
+        rule(/[^{}\\]+/) { token Str }
+      end
+
+      state :angle_brackets do
+        mixin :comments_and_whitespace
+        rule />/, Comment::Preproc, :pop!
+        rule /[*:]/, Punctuation
+        rule /#{upper_id}/, Keyword::Type
+        rule /#{id}/, Name::Variable
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/turtle.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Turtle < RegexLexer
+      title "Turtle/TriG"
+      desc "Terse RDF Triple Language, TriG"
+      tag 'turtle'
+      filenames *%w(*.ttl *.trig)
+      mimetypes *%w(
+        text/turtle
+        application/trig
+      )
+
+      def self.analyze_text(text)
+        start = text[0..1000]
+        return 0.5 if start =~ %r(@prefix\b)
+        return 0.5 if start =~ %r(@base\b)
+        return 0.4 if start =~ %r(PREFIX\b)i
+        return 0.4 if start =~ %r(BASE\b)i
+      end
+
+      state :root do
+        rule /@base\b/, Keyword::Declaration
+        rule /@prefix\b/, Keyword::Declaration
+        rule /true\b/, Keyword::Constant
+        rule /false\b/, Keyword::Constant
+        
+        rule /""".*?"""/m, Literal::String
+        rule /"([^"\\]|\\.)*"/, Literal::String
+        rule /'''.*?'''/m, Literal::String
+        rule /'([^'\\]|\\.)*'/, Literal::String
+        
+        rule /#.*$/, Comment::Single
+        
+        rule /@[^\s,.; ]+/, Name::Attribute
+        
+        rule /[+-]?[0-9]+\.[0-9]*E[+-]?[0-9]+/, Literal::Number::Float
+        rule /[+-]?\.[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+        rule /[+-]?[0-9]+E[+-]?[0-9]+/, Literal::Number::Float
+
+        rule /[+-]?[0-9]*\.[0-9]+?/, Literal::Number::Float
+
+        rule /[+-]?[0-9]+/, Literal::Number::Integer
+
+        rule /\./, Punctuation
+        rule /,/, Punctuation
+        rule /;/, Punctuation
+        rule /\(/, Punctuation
+        rule /\)/, Punctuation
+        rule /\{/, Punctuation
+        rule /\}/, Punctuation
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+        rule /\^\^/, Punctuation
+        
+        rule /<[^>]*>/, Name::Label
+
+        rule /base\b/i, Keyword::Declaration
+        rule /prefix\b/i, Keyword::Declaration
+        rule /GRAPH\b/, Keyword
+        rule /a\b/, Keyword
+
+        rule /\s+/, Text::Whitespace
+
+        rule /[^:;<>#\@"\(\).\[\]\{\} ]+:/, Name::Namespace
+        rule /[^:;<>#\@"\(\).\[\]\{\} ]+/, Name
+        
+      end
+    end
+  end
+end

data/lib/rouge/lexers/twig.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'jinja.rb'
+
+    class Twig < Jinja
+      title "Twig"
+      desc "Twig template engine (twig.sensiolabs.org)"
+
+      tag "twig"
+
+      filenames '*.twig'
+
+      mimetypes 'application/x-twig', 'text/html+twig'
+
+      def self.keywords
+        @@keywords ||= %w(as do extends flush from import include use else starts
+                          ends with without autoescape endautoescape block endblock
+                          embed endembed filter endfilter for endfor if endif
+                          macro endmacro sandbox endsandbox set endset
+                          spaceless endspaceless verbatim endverbatim)
+      end
+
+      def self.tests
+        @@tests ||= %w(constant defined divisibleby empty even iterable null odd
+                       sameas)
+      end
+
+      def self.pseudo_keywords
+        @@pseudo_keywords ||= %w(true false none)
+      end
+
+      def self.word_operators
+        @@word_operators ||= %w(b-and b-or b-xor is in and or not)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/typescript.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'javascript.rb'
+    load_lexer 'typescript/common.rb'
+
+    class Typescript < Javascript
+      include TypescriptCommon
+
+      title "TypeScript"
+      desc "TypeScript, a superset of JavaScript"
+
+      tag 'typescript'
+      aliases 'ts'
+
+      filenames '*.ts', '*.d.ts'
+
+      mimetypes 'text/typescript'
+    end
+  end
+end

data/lib/rouge/lexers/typescript/common.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    module TypescriptCommon
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          is namespace static private protected public
+          implements readonly
+        ))
+      end
+
+      def self.declarations
+        @declarations ||= super + Set.new(%w(
+          type abstract
+        ))
+      end
+
+      def self.reserved
+        @reserved ||= super + Set.new(%w(
+          string any void number namespace module
+          declare default interface keyof
+        ))
+      end
+
+      def self.builtins
+        @builtins ||= super + %w(
+          Pick Partial Readonly Record
+        )
+      end
+    end
+  end
+end

data/lib/rouge/lexers/vala.rb

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Vala < RegexLexer
+      tag 'vala'
+      filenames '*.vala'
+      mimetypes 'text/x-vala'
+
+      title "Vala"
+      desc 'A programming language similar to csharp.'
+
+      id = /@?[_a-z]\w*/i
+
+      keywords = %w(
+        abstract as async base break case catch const construct continue
+        default delegate delete do dynamic else ensures enum errordomain
+        extern false finally for foreach get global if in inline interface
+        internal is lock new null out override owned private protected
+        public ref requires return set signal sizeof static switch this
+        throw throws true try typeof unowned var value virtual void weak
+        while yield
+      )
+
+      keywords_type = %w(
+        bool char double float int int8 int16 int32 int64 long short size_t 
+        ssize_t string unichar uint uint8 uint16 uint32 uint64 ulong ushort
+      )
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule /^\s*\[.*?\]/, Name::Attribute
+
+        rule /(<\[)\s*(#{id}:)?/, Keyword
+        rule /\]>/, Keyword
+
+        rule /[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule /@"(\\.|.)*?"/, Str
+        rule /"(\\.|.)*?["\n]/, Str
+        rule /'(\\.|.)'/, Str::Char
+        rule /0x[0-9a-f]+[lu]?/i, Num
+        rule %r(
+          [0-9]
+          ([.][0-9]*)? # decimal
+          (e[+-][0-9]+)? # exponent
+          [fldu]? # type
+        )ix, Num
+        rule /\b(#{keywords.join('|')})\b/, Keyword
+        rule /\b(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule /class|struct/, Keyword, :class
+        rule /namespace|using/, Keyword, :namespace
+        rule /#{id}(?=\s*[(])/, Name::Function
+        rule id, Name
+
+        rule /#.*/, Comment::Preproc
+      end
+
+      state :class do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /(?=[(])/, Text, :pop!
+        rule /(#{id}|[.])+/, Name::Namespace, :pop!
+      end
+    end
+  end
+end