rouge 3.0.0 → 3.18.0

data/lib/rouge/lexers/jinja.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -36,82 +37,89 @@ module Rouge
 
       state :root do
         # Comments
-        rule /{#/, Comment, :comment
+        rule %r/{#/, Comment, :comment
+        rule %r/##.*/, Comment
 
         # Statements
-        rule /\{\%/ do
+        rule %r/\{\%/ do
           token Comment::Preproc
           push :statement
         end
 
         # Expressions
-        rule /\{\{/ do
+        rule %r/\{\{/ do
           token Comment::Preproc
           push :expression
         end
 
-        rule(/(.+?)(?=\\|{{|{%|{#)/m) { delegate parent }
+        rule(/(.+?)(?=\\|{{|{%|{#|##)/m) { delegate parent }
         rule(/.+/m) { delegate parent }
       end
 
       state :filter do
         # Filters are called like variable|foo(arg1, ...)
-        rule /(\|)(\w+)/ do
+        rule %r/(\|\s*)(\w+)/ do
           groups Operator, Name::Function
         end
       end
 
       state :function do
-        rule /(\w+)(\()/ do
+        rule %r/(\w+)(\()/ do
           groups Name::Function, Punctuation
         end
       end
 
       state :text do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
       end
 
       state :literal do
         # Strings
-        rule /"(\\.|.)*?"/, Str::Double
-        rule /'(\\.|.)*?'/, Str::Single
+        rule %r/"(\\.|.)*?"/, Str::Double
+        rule %r/'(\\.|.)*?'/, Str::Single
 
         # Numbers
-        rule /\d+(?=}\s)/, Num
+        rule %r/\d+(?=}\s)/, Num
 
         # Arithmetic operators (+, -, *, **, //, /)
         # TODO : implement modulo (%)
-        rule /(\+|\-|\*|\/\/?|\*\*?)/, Operator
+        rule %r/(\+|\-|\*|\/\/?|\*\*?|=)/, Operator
 
         # Comparisons operators (<=, <, >=, >, ==, ===, !=)
-        rule /(<=?|>=?|===?|!=)/, Operator
+        rule %r/(<=?|>=?|===?|!=)/, Operator
 
         # Punctuation (the comma, [], ())
-        rule /,/,  Punctuation
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
-        rule /\(/, Punctuation
-        rule /\)/, Punctuation
+        rule %r/,/,  Punctuation
+        rule %r/\[/, Punctuation
+        rule %r/\]/, Punctuation
+        rule %r/\(/, Punctuation
+        rule %r/\)/, Punctuation
       end
 
       state :comment do
-        rule(/[^{#]+/m) { token Comment }
+        rule %r/[^#]+/m, Comment
         rule(/#}/) { token Comment; pop! }
+        rule %r/#/, Comment
       end
 
       state :expression do
-        rule /\w+\.?/m, Name::Variable
+        rule %r/\w+\.?/m, Name::Variable
 
         mixin :filter
         mixin :function
         mixin :literal
         mixin :text
 
-        rule /%}|}}/, Comment::Preproc, :pop!
+        rule %r/%}|}}/, Comment::Preproc, :pop!
       end
 
       state :statement do
-        rule /(\w+\.?)/ do |m|
+        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])
@@ -130,7 +138,16 @@ module Rouge
         mixin :literal
         mixin :text
 
-        rule /\%\}/, Comment::Preproc, :pop!
+        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

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

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -6,23 +7,65 @@ module Rouge
       title 'JSON'
       desc "JavaScript Object Notation (json.org)"
       tag 'json'
-      filenames '*.json'
+      filenames '*.json', 'Pipfile.lock'
       mimetypes 'application/json', 'application/vnd.api+json',
-                'application/hal+json'
+                'application/hal+json', 'application/problem+json',
+                'application/schema+json'
+
+      state :whitespace do
+        rule %r/\s+/, Text::Whitespace
+      end
 
       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
+        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 /[^\\"]+/, Str::Double
-        rule /\\./, Str::Escape
-        rule /"/, Str::Double, :pop!
+        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

data/lib/rouge/lexers/json_doc.rb

@@ -1,22 +1,25 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
     load_lexer 'json.rb'
 
     class JSONDOC < JSON
-      desc "JavaScript Object Notation with extenstions for documentation"
+      desc "JavaScript Object Notation with extensions for documentation"
       tag 'json-doc'
+      aliases 'jsonc'
 
-      prepend :root do
-        rule /([$\w]+)(\s*)(:)/ do
+      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 /(\.\.\.)/, Comment::Single
+        rule %r/(\.\.\.)/, Comment::Single
       end
     end
   end

data/lib/rouge/lexers/jsonnet.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -6,7 +7,7 @@ module Rouge
       title 'Jsonnet'
       desc 'An elegant, formally-specified config language for JSON'
       tag 'jsonnet'
-      filenames '*.jsonnet'
+      filenames '*.jsonnet', '*.libsonnet'
       mimetypes 'text/x-jsonnet'
 
       def self.keywords
@@ -92,21 +93,21 @@ module Rouge
       identifier = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule /\s+/, Text
+        rule %r/\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 %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]\d+)?/i, Num::Integer
 
-        rule /[{}:\.,;+\[\]=%\(\)]/, Punctuation
+        rule %r/[{}:\.,;+\[\]=%\(\)]/, Punctuation
 
-        rule /"/, Str, :string_double
-        rule /'/, Str, :string_single
-        rule /\|\|\|/, Str, :string_block
+        rule %r/"/, Str, :string_double
+        rule %r/'/, Str, :string_single
+        rule %r/\|\|\|/, Str, :string_block
 
-        rule /\$/, Keyword
+        rule %r/\$/, Keyword
 
         rule identifier do |m|
           if self.class.keywords.include? m[0]
@@ -124,27 +125,27 @@ module Rouge
       end
 
       state :string do
-        rule /\\([\\\/bfnrt]|(u[0-9a-fA-F]{4}))/, Str::Escape
+        rule %r/\\([\\\/bfnrt]|(u[0-9a-fA-F]{4}))/, Str::Escape
       end
 
       state :string_double do
         mixin :string
-        rule /\\"/, Str::Escape
-        rule /"/, Str, :pop!
-        rule /[^\\"]+/, Str
+        rule %r/\\"/, Str::Escape
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\"]+/, Str
       end
 
       state :string_single do
         mixin :string
-        rule /\\'/, Str::Escape
-        rule /'/, Str, :pop!
-        rule /[^\\']+/, Str
+        rule %r/\\'/, Str::Escape
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\']+/, Str
       end
 
       state :string_block do
         mixin :string
-        rule /\|\|\|/, Str, :pop!
-        rule /.*/, Str
+        rule %r/\|\|\|/, Str, :pop!
+        rule %r/.*/, Str
       end
     end
   end

data/lib/rouge/lexers/jsp.rb

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class JSP < TemplateLexer
+      desc 'JSP'
+      tag 'jsp'
+      filenames '*.jsp'
+      mimetypes 'text/x-jsp', 'application/x-jsp'
+
+      def initialize(*)
+        super
+        @java = Java.new
+      end
+
+      directives = %w(page include taglib)
+      actions = %w(scriptlet declaration expression)
+
+      state :root do
+
+        rule %r/<%--/, Comment, :jsp_comment
+
+        rule %r/<%@\s*(#{directives.join('|')})\s*/, Name::Tag, :jsp_directive
+
+        rule %r/<jsp:directive\.(#{directives.join('|')})/, Name::Tag, :jsp_directive2
+
+        rule %r/<jsp:(#{actions.join('|')})>/, Name::Tag, :jsp_expression
+
+        # start of tag, e.g. <c:if>
+        rule %r/<[a-zA-Z]*:[a-zA-Z]*\s*/, Name::Tag, :jsp_tag
+
+        # end of tag, e.g. </c:if>
+        rule %r(</[a-zA-Z]*:[a-zA-Z]*>), Name::Tag
+
+        rule %r/<%[!=]?/, Name::Tag, :jsp_expression2
+
+        # fallback to HTML
+        rule(/(.+?)(?=(<%|<\/?[a-zA-Z]*:))/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :jsp_comment do
+        rule %r/(--%>)/, Comment, :pop!
+        rule %r/./m, Comment
+      end
+
+      state :jsp_directive do
+        rule %r/(%>)/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=%>)/m) { delegate parent }
+      end
+
+      state :jsp_directive2 do
+        rule %r!(/>)!, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=\/>)/m) { delegate parent }
+      end
+
+      state :jsp_expression do
+        rule %r/<\/jsp:(#{actions.join('|')})>/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/[^<\/]+/) { delegate @java }
+      end
+
+      state :jsp_expression2 do
+        rule %r/%>/, Name::Tag, :pop!
+        rule(/[^%>]+/) { delegate @java }
+      end
+
+      state :jsp_tag do
+        rule %r/\/?>/, Name::Tag, :pop!
+        mixin :attributes
+        rule(/(.+?)(?=\/?>)/m) { delegate parent }
+      end
+
+      state :attributes do
+        rule %r/\s*[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
+      end
+
+      state :attr do
+        rule %r/"/ do
+          token Str
+          goto :double_quotes
+        end
+
+        rule %r/'/ do
+          token Str
+          goto :single_quotes
+        end
+
+        rule %r/[^\s>]+/, Str, :pop!
+      end
+
+      state :double_quotes do
+        rule %r/"/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^"]+/, Str
+      end
+
+      state :single_quotes do
+        rule %r/'/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^']+/, Str
+      end
+
+      state :jsp_interp do
+        rule %r/\}/, Str::Interpol, :pop!
+        rule %r/'/, Literal, :jsp_interp_literal_start
+        rule(/[^'\}]+/) { delegate @java }
+      end
+
+      state :jsp_interp_literal_start do
+        rule %r/'/, Literal, :pop!
+        rule %r/[^']*/, Literal
+      end
+
+    end
+  end
+end