rougegal 2.1.2

data/lib/rouge/lexers/jinja.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Jinja < TemplateLexer
+      title "Jinja"
+      desc "Django/Jinja template engine (jinja.pocoo.org)"
+
+      tag 'jinja'
+      aliases 'django'
+
+      mimetypes 'application/x-django-templating', 'application/x-jinja',
+                'text/html+django', 'text/html+jinja'
+
+      def self.keywords
+        @@keywords ||= %w(as context do else extends from ignore missing
+                          import include reversed recursive scoped
+                          autoescape endautoescape block endblock call endcall
+                          filter endfilter for endfor if endif macro endmacro
+                          set endset trans endtrans with endwith without)
+      end
+
+      def self.tests
+        @@tests ||= %w(callable defined divisibleby equalto escaped even iterable
+                       lower mapping none number odd sameas sequence string
+                       undefined upper)
+      end
+
+      def self.pseudo_keywords
+        @@pseudo_keywords ||= %w(true false none True False None)
+      end
+
+      def self.word_operators
+        @@word_operators ||= %w(is in and or not)
+      end
+
+      state :root do
+        # Comments
+        rule /{#/, Comment, :comment
+
+        # Statements
+        rule /\{\%/ do
+          token Comment::Preproc
+          push :statement
+        end
+
+        # Expressions
+        rule /\{\{/ do
+          token Comment::Preproc
+          push :expression
+        end
+
+        rule(/(.+?)(?=\\|{{|{%|{#)/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :filter do
+        # Filters are called like variable|foo(arg1, ...)
+        rule /(\|)(\w+)/ do
+          groups Operator, Name::Function
+        end
+      end
+
+      state :function do
+        rule /(\w+)(\()/ do
+          groups Name::Function, Punctuation
+        end
+      end
+
+      state :text do
+        rule /\s+/m, Text
+      end
+
+      state :literal do
+        # Strings
+        rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+
+        # Numbers
+        rule /\d+(?=}\s)/, Num
+
+        # Arithmetic operators (+, -, *, **, //, /)
+        # TODO : implement modulo (%)
+        rule /(\+|\-|\*|\/\/?|\*\*?)/, Operator
+
+        # Comparisons operators (<=, <, >=, >, ==, ===, !=)
+        rule /(<=?|>=?|===?|!=)/, Operator
+
+        # Punctuation (the comma, [], ())
+        rule /,/,  Punctuation
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+        rule /\(/, Punctuation
+        rule /\)/, Punctuation
+      end
+
+      state :comment do
+        rule(/[^{#]+/m) { token Comment }
+        rule(/#}/) { token Comment; pop! }
+      end
+
+      state :expression do
+        rule /\w+\.?/m, Name::Variable
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /%}|}}/, Comment::Preproc, :pop!
+      end
+
+      state :statement do
+        rule /(\w+\.?)/ do |m|
+          if self.class.keywords.include?(m[0])
+            groups Keyword
+          elsif self.class.pseudo_keywords.include?(m[0])
+            groups Keyword::Pseudo
+          elsif self.class.word_operators.include?(m[0])
+            groups Operator::Word
+          elsif self.class.tests.include?(m[0])
+            groups Name::Builtin
+          else
+            groups Name::Variable
+          end
+        end
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /\%\}/, Comment::Preproc, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class JSON < RegexLexer
+      title 'JSON'
+      desc "JavaScript Object Notation (json.org)"
+      tag 'json'
+      filenames '*.json'
+      mimetypes 'application/json', 'application/vnd.api+json',
+                'application/hal+json'
+
+      state :root do
+        rule /\s+/m, Text::Whitespace
+        rule /"/, Str::Double, :string
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /[{},:\[\]]/, Punctuation
+        rule /-?(?:0|[1-9]\d*)\.\d+(?:e[+-]?\d+)?/i, Num::Float
+        rule /-?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
+      end
+
+      state :string do
+        rule /[^\\"]+/, Str::Double
+        rule /\\./, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json_doc.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'json.rb'
+
+    class JSONDOC < JSON
+      desc "JavaScript Object Notation with extenstions for documentation"
+      tag 'json-doc'
+
+      prepend :root do
+        rule /([$\w]+)(\s*)(:)/ do
+          groups Name::Attribute, Text, Punctuation
+        end
+
+        rule %r(/[*].*?[*]/), Comment
+
+        rule %r(//.*?$), Comment::Single
+        rule /(\.\.\.)/, Comment::Single
+      end
+    end
+  end
+end

data/lib/rouge/lexers/jsonnet.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Jsonnet < RegexLexer
+      title 'Jsonnet'
+      desc 'An elegant, formally-specified config language for JSON'
+      tag 'jsonnet'
+      filenames '*.jsonnet'
+      mimetypes 'text/x-jsonnet'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          self super local for in if then else import importstr error
+          tailstrict assert
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          function
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          null true false
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          acos
+          asin
+          atan
+          ceil
+          char
+          codepoint
+          cos
+          exp
+          exponent
+          filter
+          floor
+          force
+          length
+          log
+          makeArray
+          mantissa
+          objectFields
+          objectHas
+          pow
+          sin
+          sqrt
+          tan
+          thisFile
+          type
+          abs
+          assertEqual
+          escapeStringBash
+          escapeStringDollars
+          escapeStringJson
+          escapeStringPython
+          filterMap
+          flattenArrays
+          foldl
+          foldr
+          format
+          join
+          lines
+          manifestIni
+          manifestPython
+          manifestPythonVars
+          map
+          max
+          min
+          mod
+          range
+          set
+          setDiff
+          setInter
+          setMember
+          setUnion
+          sort
+          split
+          stringChars
+          substr
+          toString
+          uniq
+        )
+      end
+
+      identifier = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      state :root do
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule /-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule /-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
+
+        rule /[{}:\.,;+\[\]=%\(\)]/, Punctuation
+
+        rule /"/, Str, :string_double
+        rule /'/, Str, :string_single
+        rule /\|\|\|/, Str, :string_block
+
+        rule /\$/, Keyword
+
+        rule identifier do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+      end
+
+      state :string do
+        rule /\\([\\\/bfnrt]|(u[0-9a-fA-F]{4}))/, Str::Escape
+      end
+
+      state :string_double do
+        mixin :string
+        rule /\\"/, Str::Escape
+        rule /"/, Str, :pop!
+        rule /[^\\"]+/, Str
+      end
+
+      state :string_single do
+        mixin :string
+        rule /\\'/, Str::Escape
+        rule /'/, Str, :pop!
+        rule /[^\\']+/, Str
+      end
+
+      state :string_block do
+        mixin :string
+        rule /\|\|\|/, Str, :pop!
+        rule /.*/, Str
+      end
+    end
+  end
+end

data/lib/rouge/lexers/jsx.rb

@@ -0,0 +1,102 @@
+module Rouge
+  module Lexers
+    load_lexer 'javascript.rb'
+
+    class JSX < Javascript
+      title 'JSX'
+      desc 'React JSX (https://facebook.github.io/react/)'
+      tag 'jsx'
+      aliases 'jsx', 'react'
+      filenames '*.jsx'
+
+      mimetypes 'text/x-jsx', 'application/x-jsx'
+
+      id = Javascript.id_regex
+
+      def start_embed!
+        @embed ||= JSX.new(options)
+        @embed.reset!
+        @embed.push(:expr_start)
+        push :jsx_embed_root
+      end
+
+      def tag_token(name)
+        name[0] =~ /\p{Lower}/ ? Name::Tag : Name::Class
+      end
+
+      start { @html = HTML.new(options) }
+
+      state :jsx_tags do
+        rule /</, Punctuation, :jsx_element
+      end
+
+      state :jsx_internal do
+        rule %r(</) do
+          token Punctuation
+          goto :jsx_end_tag
+        end
+
+        rule /{/ do
+          token Str::Interpol
+          start_embed!
+        end
+
+        rule /[^<>{]+/ do
+          delegate @html
+        end
+
+        mixin :jsx_tags
+      end
+
+      prepend :expr_start do
+        mixin :jsx_tags
+      end
+
+      state :jsx_tag do
+        mixin :comments_and_whitespace
+        rule /#{id}/ do |m|
+          token tag_token(m[0])
+        end
+
+        rule /[.]/, Punctuation
+      end
+
+      state :jsx_end_tag do
+        mixin :jsx_tag
+        rule />/, Punctuation, :pop!
+      end
+
+      state :jsx_element do
+        rule /#{id}=/, Name::Attribute, :jsx_attribute
+        mixin :jsx_tag
+        rule />/ do token Punctuation; goto :jsx_internal end
+        rule %r(/>), Punctuation, :pop!
+      end
+
+      state :jsx_attribute do
+        rule /"(\\[\\"]|[^"])*"/, Str::Double, :pop!
+        rule /'(\\[\\']|[^'])*'/, Str::Single, :pop!
+        rule /{/ do
+          token Str::Interpol
+          pop!
+          start_embed!
+        end
+      end
+
+      state :jsx_embed_root do
+        rule /[.][.][.]/, Punctuation
+        rule /}/, Str::Interpol, :pop!
+        mixin :jsx_embed
+      end
+
+      state :jsx_embed do
+        rule /{/ do delegate @embed; push :jsx_embed end
+        rule /}/ do delegate @embed; pop! end
+        rule /[^{}]+/ do
+          delegate @embed
+        end
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/julia.rb

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Julia < RegexLexer
+      title "Julia"
+      desc "The Julia programming language"
+      tag 'julia'
+      aliases 'jl'
+      filenames '*.jl'
+      mimetypes 'text/x-julia', 'application/x-julia'
+
+      def self.analyze_text(text)
+        1 if text.shebang? 'julia'
+      end
+
+      BUILTINS            = /\b(?:
+                              applicable      | assert    | convert
+                            | dlopen          | dlsym     | edit
+                            | eps             | error     | exit
+                            | finalizer       | hash      | im
+                            | Inf             | invoke    | is
+                            | isa             | isequal   | load
+                            | method_exists   | Nan       | new
+                            | ntuple          | pi        | promote
+                            | promote_type    | realmax   | realmin
+                            | sizeof          | subtype   | system
+                            | throw           | tuple     | typemax
+                            | typemin         | typeof    | uid
+                            | whos
+                            )\b/x
+
+      KEYWORDS            = /\b(?:
+                              function | return | module | import | export
+                            | if       | else   | elseif | end    | for
+                            | in       | while  | try    | catch  | super
+                            | const
+                            )\b/x
+
+      TYPES               = /\b(?:
+                              Int         | UInt           | Int8
+                            | UInt8       | Int16          | UInt16
+                            | Int32       | UInt32         | Int64
+                            | UInt64      | Int128         | UInt128
+                            | Float16     | Float32        | Float64
+                            | Bool        | Inf            | Inf16
+                            | Inf32       | NaN            | NaN16
+                            | NaN32       | BigInt         | BigFloat
+                            | Char        | ASCIIString    | UTF8String
+                            | UTF16String | UTF32String    | AbstractString
+                            | WString     | String         | Regex
+                            | RegexMatch  | Complex64      | Complex128
+                            | Any         | Nothing        | None
+                            )\b/x
+
+      OPERATORS           = / \+      | =        | -     | \*   | \/
+                              | \\    | &        | \|    | \$   | ~
+                              | \^    | %        | !     | >>>  | >>
+                              | <<    | &&       | \|\|  | \+=  | -=
+                              | \*=   | \/=      | \\=   | ÷=   | %=
+                              | \^=   | &=       | \|=   | \$=  | >>>=
+                              | >>=   | <<=      | ==    | !=   | ≠
+                              | <=    | ≤        | >=    | ≥    | \.
+                              | ::    | <:       | ->    | \?   | \.\*
+                              | \.\^  | \.\\     | \.\/  | \\   | <
+                              | >
+                            /x
+
+      PUNCTUATION         = / [ \[ \] { } : \( \) , ; @ ] /x
+
+
+      state :root do
+        rule /\n/, Text
+        rule /[^\S\n]+/, Text
+        rule /#=/, Comment::Multiline, :blockcomment
+        rule /#.*$/, Comment
+        rule OPERATORS, Operator
+        rule /\\\n/, Text
+        rule /\\/, Text
+
+
+        # functions
+        rule /(function)((?:\s|\\\s)+)/ do
+          groups Keyword, Name::Function
+          push :funcname
+        end
+
+        # types
+        rule /(type|typealias|abstract)((?:\s|\\\s)+)/ do
+          groups Keyword, Name::Class
+          push :typename
+        end
+        rule TYPES, Keyword::Type
+
+        # keywords
+        rule /(local|global|const)\b/, Keyword::Declaration
+        rule KEYWORDS, Keyword
+
+        rule BUILTINS, Name::Builtin
+
+        # backticks
+        rule /`.*?`/, Literal::String::Backtick
+
+        # chars
+        rule /'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'/, Literal::String::Char
+
+        # try to match trailing transpose
+        rule /(?<=[.\w)\]])\'+/, Operator
+
+        # strings
+        rule /(?:[IL])"/, Literal::String, :string
+        rule /[E]?"/, Literal::String, :string
+
+        # names
+        rule /@[\w.]+/, Name::Decorator
+        rule /(?:[a-zA-Z_\u00A1-\uffff]|[\u1000-\u10ff])(?:[a-zA-Z_0-9\u00A1-\uffff]|[\u1000-\u10ff])*!*/, Name
+
+        rule PUNCTUATION, Other
+
+        # numbers
+        rule /(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule /(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule /\d+(_\d+)+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule /\d+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule /0b[01]+(_[01]+)+/, Literal::Number::Bin
+        rule /0b[01]+/, Literal::Number::Bin
+        rule /0o[0-7]+(_[0-7]+)+/, Literal::Number::Oct
+        rule /0o[0-7]+/, Literal::Number::Oct
+        rule /0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+/, Literal::Number::Hex
+        rule /0x[a-fA-F0-9]+/, Literal::Number::Hex
+        rule /\d+(_\d+)+/, Literal::Number::Integer
+        rule /\d+/, Literal::Number::Integer
+      end
+
+
+      state :funcname do
+        rule /[a-zA-Z_]\w*/, Name::Function, :pop!
+        rule /\([^\s\w{]{1,2}\)/, Operator, :pop!
+        rule /[^\s\w{]{1,2}/, Operator, :pop!
+      end
+
+      state :typename do
+        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+      end
+
+      state :stringescape do
+        rule /\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})/,
+          Literal::String::Escape
+      end
+
+      state :blockcomment do
+        rule /[^=#]/, Comment::Multiline
+        rule /#=/, Comment::Multiline, :blockcomment
+        rule /\=#/, Comment::Multiline, :pop!
+        rule /[=#]/, Comment::Multiline
+      end
+
+      state :string do
+        mixin :stringescape
+
+        rule /"/, Literal::String, :pop!
+        rule /\\\\|\\"|\\\n/, Literal::String::Escape  # included here for raw strings
+        rule /\$(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/, Literal::String::Interpol
+        rule /[^\\"$]+/, Literal::String
+        # quotes, dollar signs, and backslashes must be parsed one at a time
+        rule /["\\]/, Literal::String
+        # unhandled string formatting sign
+        rule /\$/, Literal::String
+      end
+    end
+  end
+end