rouge 3.18.0

data/lib/rouge/lexers/jinja.rb

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+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 %r/{#/, Comment, :comment
+        rule %r/##.*/, Comment
+
+        # Statements
+        rule %r/\{\%/ do
+          token Comment::Preproc
+          push :statement
+        end
+
+        # Expressions
+        rule %r/\{\{/ 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 %r/(\|\s*)(\w+)/ do
+          groups Operator, Name::Function
+        end
+      end
+
+      state :function do
+        rule %r/(\w+)(\()/ do
+          groups Name::Function, Punctuation
+        end
+      end
+
+      state :text do
+        rule %r/\s+/m, Text
+      end
+
+      state :literal do
+        # Strings
+        rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
+
+        # Numbers
+        rule %r/\d+(?=}\s)/, Num
+
+        # Arithmetic operators (+, -, *, **, //, /)
+        # TODO : implement modulo (%)
+        rule %r/(\+|\-|\*|\/\/?|\*\*?|=)/, Operator
+
+        # Comparisons operators (<=, <, >=, >, ==, ===, !=)
+        rule %r/(<=?|>=?|===?|!=)/, Operator
+
+        # Punctuation (the comma, [], ())
+        rule %r/,/,  Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/\)/, Punctuation
+      end
+
+      state :comment do
+        rule %r/[^#]+/m, Comment
+        rule(/#}/) { token Comment; pop! }
+        rule %r/#/, Comment
+      end
+
+      state :expression do
+        rule %r/\w+\.?/m, Name::Variable
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule %r/%}|}}/, Comment::Preproc, :pop!
+      end
+
+      state :statement do
+        rule %r/(raw|verbatim)(\s+)(\%\})/ do
+          groups Keyword, Text, Comment::Preproc
+          goto :raw
+        end
+
+        rule %r/(\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 %r/\%\}/, Comment::Preproc, :pop!
+      end
+
+      state :raw do
+        rule %r{(\{\%)(\s+)(endverbatim|endraw)(\s+)(\%\})} do
+          groups Comment::Preproc, Text, Keyword, Text, Comment::Preproc
+          pop!
+        end
+
+        rule %r/(.+?)/m, Text
+      end
+    end
+  end
+end

data/lib/rouge/lexers/jsl.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class JSL < RegexLexer
+      title "JSL"
+      desc "The JMP Scripting Language (JSL) (jmp.com)"
+
+      tag 'jsl'
+      filenames '*.jsl'
+
+      state :root do
+        rule %r/\s+/m, Text::Whitespace
+
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        # messages
+        rule %r/(<<)(.*?)(\(|;)/ do |m|
+          groups Operator, Name::Function, Punctuation
+        end
+
+        # covers built-in and custom functions
+        rule %r/([a-z_][\w\s'%.\\]*)(\()/i do |m|
+          groups Keyword, Punctuation
+        end
+
+        rule %r/\b[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+|\.)(?:e[+-]?[0-9]+)?i?\b/i, Num
+
+        rule %r/\d{2}(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d{2}(\d{2})?(:\d{2}:\d{2}(:\d{2}(\.\d*)?)?)?/i, Literal::Date
+
+        rule %r/::[a-z_][\w\s'%.\\]*/i, Name::Variable
+        rule %r/:\w+/, Name
+        rule %r/[a-z_][\w\s'%.\\]*/i, Name::Variable
+        rule %r/"(?:\\!"|[^"])*?"n/m, Name::Variable
+
+        rule %r/(")(\\\[)(.*?)(\]\\)(")/m do
+          groups Str::Double, Str::Escape, Str::Double, Str::Escape, Str::Double  # escaped string
+        end
+        rule %r/"/, Str::Double, :dq
+
+        rule %r/[-+*\/!%&<>\|=:]/, Operator
+        rule %r/[\[\](){},;]/, Punctuation
+      end
+
+      state :dq do
+        rule %r/\\![btrnNf0\\"]/, Str::Escape
+        rule %r/\\/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\"]*/m, Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class JSON < RegexLexer
+      title 'JSON'
+      desc "JavaScript Object Notation (json.org)"
+      tag 'json'
+      filenames '*.json', 'Pipfile.lock'
+      mimetypes 'application/json', 'application/vnd.api+json',
+                'application/hal+json', 'application/problem+json',
+                'application/schema+json'
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r/{/, Punctuation, :object
+        rule %r/\[/, Punctuation, :array
+
+        mixin :name
+        mixin :value
+
+        # These characters may be invalid but syntax correctness is a non-goal
+        rule %r/[\]}]/, Punctuation
+      end
+
+      state :object do
+        mixin :whitespace
+        mixin :name
+        mixin :value
+        rule %r/}/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+      end
+
+      state :name do
+        rule %r/("(?:\\.|[^"\\\n])*?")(\s*)(:)/ do
+          groups Name::Label, Text::Whitespace, Punctuation
+        end
+      end
+
+      state :value do
+        mixin :whitespace
+        mixin :constants
+        rule %r/"/, Str::Double, :string
+        rule %r/\[/, Punctuation, :array
+        rule %r/{/, Punctuation, :object
+      end
+
+      state :string do
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/\\./, Str::Escape
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :array do
+        mixin :value
+        rule %r/\]/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+      end
+
+      state :constants do
+        rule %r/(?:true|false|null)/, Keyword::Constant
+        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]?\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
+      end
+    end
+  end
+end

data/lib/rouge/lexers/json_doc.rb

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

data/lib/rouge/lexers/jsonnet.rb

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Jsonnet < RegexLexer
+      title 'Jsonnet'
+      desc 'An elegant, formally-specified config language for JSON'
+      tag 'jsonnet'
+      filenames '*.jsonnet', '*.libsonnet'
+      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 %r/\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(#.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+
+        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
+
+        rule %r/[{}:\.,;+\[\]=%\(\)]/, Punctuation
+
+        rule %r/"/, Str, :string_double
+        rule %r/'/, Str, :string_single
+        rule %r/\|\|\|/, Str, :string_block
+
+        rule %r/\$/, 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 %r/\\([\\\/bfnrt]|(u[0-9a-fA-F]{4}))/, Str::Escape
+      end
+
+      state :string_double do
+        mixin :string
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\"]+/, Str
+      end
+
+      state :string_single do
+        mixin :string
+        rule %r/\\'/, Str::Escape
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\']+/, Str
+      end
+
+      state :string_block do
+        mixin :string
+        rule %r/\|\|\|/, Str, :pop!
+        rule %r/.*/, Str
+      end
+    end
+  end
+end