rouge 3.4.1 → 3.5.0

data/lib/rouge/lexers/json.rb

@@ -9,21 +9,22 @@ module Rouge
       tag 'json'
       filenames '*.json'
       mimetypes 'application/json', 'application/vnd.api+json',
-                'application/hal+json'
+                'application/hal+json', 'application/problem+json',
+                'application/schema+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
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/"/, Str::Double, :string
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/[{},:\[\]]/, Punctuation
+        rule %r/-?(?:0|[1-9]\d*)\.\d+(?:e[+-]?\d+)?/i, Num::Float
+        rule %r/-?(?:0|[1-9]\d*)(?:e[+-]?\d+)?/i, Num::Integer
       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
     end
   end

data/lib/rouge/lexers/json_doc.rb

@@ -10,14 +10,14 @@ module Rouge
       tag 'json-doc'
 
       prepend :root do
-        rule /([$\w]+)(\s*)(:)/ do
+        rule %r/([$\w]+)(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
         end
 
         rule %r(/[*].*?[*]/), Comment
 
         rule %r(//.*?$), Comment::Single
-        rule /(\.\.\.)/, Comment::Single
+        rule %r/(\.\.\.)/, Comment::Single
       end
     end
   end

data/lib/rouge/lexers/jsonnet.rb

@@ -7,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
@@ -93,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]
@@ -125,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

@@ -19,21 +19,21 @@ module Rouge
      
       state :root do
 
-        rule /<%--/, Comment, :jsp_comment
+        rule %r/<%--/, Comment, :jsp_comment
 
-        rule /<%@\s*(#{directives.join('|')})\s*/, Name::Tag, :jsp_directive
+        rule %r/<%@\s*(#{directives.join('|')})\s*/, Name::Tag, :jsp_directive
 
-        rule /<jsp:directive\.(#{directives.join('|')})/, Name::Tag, :jsp_directive2
+        rule %r/<jsp:directive\.(#{directives.join('|')})/, Name::Tag, :jsp_directive2
 
-        rule /<jsp:(#{actions.join('|')})>/, Name::Tag, :jsp_expression
+        rule %r/<jsp:(#{actions.join('|')})>/, Name::Tag, :jsp_expression
 
         # start of tag, e.g. <c:if>
-        rule /<[a-zA-Z]*:[a-zA-Z]*\s*/, Name::Tag, :jsp_tag
+        rule %r/<[a-zA-Z]*:[a-zA-Z]*\s*/, Name::Tag, :jsp_tag
 
         # end of tag, e.g. </c:if>
-        rule /<\/[a-zA-Z]*:[a-zA-Z]*>/, Name::Tag
+        rule %r(</[a-zA-Z]*:[a-zA-Z]*>), Name::Tag
 
-        rule /<%[!=]?/, Name::Tag, :jsp_expression2
+        rule %r/<%[!=]?/, Name::Tag, :jsp_expression2
 
         # fallback to HTML
         rule(/(.+?)(?=(<%|<\/?[a-zA-Z]*:))/m) { delegate parent }
@@ -41,78 +41,78 @@ module Rouge
       end
 
       state :jsp_comment do
-        rule /(--%>)/, Comment, :pop!
-        rule /./m, Comment
+        rule %r/(--%>)/, Comment, :pop!
+        rule %r/./m, Comment
       end
 
       state :jsp_directive do
-        rule /(%>)/, Name::Tag, :pop!
+        rule %r/(%>)/, Name::Tag, :pop!
         mixin :attributes
         rule(/(.+?)(?=%>)/m) { delegate parent }
       end
 
       state :jsp_directive2 do
-        rule /(\/>)/, Name::Tag, :pop!
+        rule %r!(/>)!, Name::Tag, :pop!
         mixin :attributes
         rule(/(.+?)(?=\/>)/m) { delegate parent }
       end
 
       state :jsp_expression do
-        rule /<\/jsp:(#{actions.join('|')})>/, Name::Tag, :pop!
+        rule %r/<\/jsp:(#{actions.join('|')})>/, Name::Tag, :pop!
         mixin :attributes
         rule(/[^<\/]+/) { delegate @java }
       end
 
       state :jsp_expression2 do
-        rule /%>/, Name::Tag, :pop!
+        rule %r/%>/, Name::Tag, :pop!
         rule(/[^%>]+/) { delegate @java }
       end
 
       state :jsp_tag do
-        rule /\/?>/, Name::Tag, :pop!
+        rule %r/\/?>/, Name::Tag, :pop!
         mixin :attributes
         rule(/(.+?)(?=\/?>)/m) { delegate parent }
       end
 
       state :attributes do
-        rule /\s*[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
+        rule %r/\s*[a-zA-Z0-9_:-]+\s*=\s*/m, Name::Attribute, :attr
       end
 
       state :attr do
-        rule /"/ do
+        rule %r/"/ do
           token Str
           goto :double_quotes
         end
 
-        rule /'/ do
+        rule %r/'/ do
           token Str
           goto :single_quotes
         end
 
-        rule /[^\s>]+/, Str, :pop!
+        rule %r/[^\s>]+/, Str, :pop!
       end
 
       state :double_quotes do
-        rule /"/, Str, :pop!
-        rule /\$\{/, Str::Interpol, :jsp_interp
-        rule /[^"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^"]+/, Str
       end
 
       state :single_quotes do
-        rule /'/, Str, :pop!
-        rule /\$\{/, Str::Interpol, :jsp_interp
-        rule /[^']+/, Str
+        rule %r/'/, Str, :pop!
+        rule %r/\$\{/, Str::Interpol, :jsp_interp
+        rule %r/[^']+/, Str
       end
 
       state :jsp_interp do
-        rule /\}/, Str::Interpol, :pop!
-        rule /'/, Literal, :jsp_interp_literal_start 
+        rule %r/\}/, Str::Interpol, :pop!
+        rule %r/'/, Literal, :jsp_interp_literal_start 
         rule(/[^'\}]+/) { delegate @java }
       end
 
       state :jsp_interp_literal_start do
-        rule /'/, Literal, :pop!
-        rule /[^']*/, Literal
+        rule %r/'/, Literal, :pop!
+        rule %r/[^']*/, Literal
       end
 
     end

data/lib/rouge/lexers/jsx.rb

@@ -29,7 +29,7 @@ module Rouge
       start { @html = HTML.new(options) }
 
       state :jsx_tags do
-        rule /</, Punctuation, :jsx_element
+        rule %r/</, Punctuation, :jsx_element
       end
 
       state :jsx_internal do
@@ -38,12 +38,12 @@ module Rouge
           goto :jsx_end_tag
         end
 
-        rule /{/ do
+        rule %r/{/ do
           token Str::Interpol
           start_embed!
         end
 
-        rule /[^<>{]+/ do
+        rule %r/[^<>{]+/ do
           delegate @html
         end
 
@@ -56,29 +56,29 @@ module Rouge
 
       state :jsx_tag do
         mixin :comments_and_whitespace
-        rule /#{id}/ do |m|
+        rule %r/#{id}/ do |m|
           token tag_token(m[0])
         end
 
-        rule /[.]/, Punctuation
+        rule %r/[.]/, Punctuation
       end
 
       state :jsx_end_tag do
         mixin :jsx_tag
-        rule />/, Punctuation, :pop!
+        rule %r/>/, Punctuation, :pop!
       end
 
       state :jsx_element do
-        rule /#{id}=/, Name::Attribute, :jsx_attribute
+        rule %r/#{id}=/, Name::Attribute, :jsx_attribute
         mixin :jsx_tag
-        rule />/ do token Punctuation; goto :jsx_internal end
+        rule %r/>/ 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
+        rule %r/"(\\[\\"]|[^"])*"/, Str::Double, :pop!
+        rule %r/'(\\[\\']|[^'])*'/, Str::Single, :pop!
+        rule %r/{/ do
           token Str::Interpol
           pop!
           start_embed!
@@ -86,15 +86,15 @@ module Rouge
       end
 
       state :jsx_embed_root do
-        rule /[.][.][.]/, Punctuation
-        rule /}/, Str::Interpol, :pop!
+        rule %r/[.][.][.]/, Punctuation
+        rule %r/}/, 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
+        rule %r/{/ do delegate @embed; push :jsx_embed end
+        rule %r/}/ do delegate @embed; pop! end
+        rule %r/[^{}]+/ do
           delegate @embed
         end
       end

data/lib/rouge/lexers/julia.rb

@@ -179,34 +179,34 @@ module Rouge
                               | !==   | =>
                             /x
 
-      PUNCTUATION         = / [ \[ \] { } \( \) , ; ] /x
+      PUNCTUATION         = /[\[\]{}\(\),;]/
 
 
       state :root do
-        rule /\n/, Text
-        rule /[^\S\n]+/, Text
-        rule /#=/, Comment::Multiline, :blockcomment
-        rule /#.*$/, Comment
+        rule %r/\n/, Text
+        rule %r/[^\S\n]+/, Text
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/#.*$/, Comment
         rule OPERATORS, Operator
-        rule /\\\n/, Text
-        rule /\\/, Text
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
 
 
         # functions and macros
-        rule /(function|macro)((?:\s|\\\s)+)/ do
+        rule %r/(function|macro)((?:\s|\\\s)+)/ do
           groups Keyword, Name::Function
           push :funcname
         end
 
         # types
-        rule /((mutable )?struct|(abstract|primitive) type)((?:\s|\\\s)+)/ do
+        rule %r/((mutable )?struct|(abstract|primitive) type)((?:\s|\\\s)+)/ do
           groups Keyword, Name::Class
           push :typename
         end
         rule TYPES, Keyword::Type
 
         # keywords
-        rule /(local|global|const)\b/, Keyword::Declaration
+        rule %r/(local|global|const)\b/, Keyword::Declaration
         rule KEYWORDS, Keyword
 
         # TODO: end is a builtin when inside of an indexing expression
@@ -215,75 +215,75 @@ module Rouge
         # TODO: symbols
 
         # backticks
-        rule /`.*?`/, Literal::String::Backtick
+        rule %r/`.*?`/, 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
+        rule %r/'(\\.|\\[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
+        rule %r/(?<=[.\w)\]])\'+/, Operator
 
         # strings
         # TODO: triple quoted string literals
         # TODO: Detect string interpolation
-        rule /(?:[IL])"/, Literal::String, :string
-        rule /[E]?"/, Literal::String, :string
+        rule %r/(?:[IL])"/, Literal::String, :string
+        rule %r/[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 %r/@[\w.]+/, Name::Decorator
+        rule %r/(?:[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
+        rule %r/(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?/, Literal::Number::Float
+        rule %r/\d+(_\d+)+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/\d+[eEf][+-]?[0-9]+/, Literal::Number::Float
+        rule %r/0b[01]+(_[01]+)+/, Literal::Number::Bin
+        rule %r/0b[01]+/, Literal::Number::Bin
+        rule %r/0o[0-7]+(_[0-7]+)+/, Literal::Number::Oct
+        rule %r/0o[0-7]+/, Literal::Number::Oct
+        rule %r/0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+/, Literal::Number::Hex
+        rule %r/0x[a-fA-F0-9]+/, Literal::Number::Hex
+        rule %r/\d+(_\d+)+/, Literal::Number::Integer
+        rule %r/\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!
+        rule %r/[a-zA-Z_]\w*/, Name::Function, :pop!
+        rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
+        rule %r/[^\s\w{]{1,2}/, Operator, :pop!
       end
 
       state :typename do
-        rule /[a-zA-Z_]\w*/, Name::Class, :pop!
+        rule %r/[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})/,
+        rule %r/\\([\\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
+        rule %r/[^=#]/, Comment::Multiline
+        rule %r/#=/, Comment::Multiline, :blockcomment
+        rule %r/\=#/, Comment::Multiline, :pop!
+        rule %r/[=#]/, 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
+        rule %r/"/, Literal::String, :pop!
+        rule %r/\\\\|\\"|\\\n/, Literal::String::Escape  # included here for raw strings
+        rule %r/\$(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/, Literal::String::Interpol
+        rule %r/[^\\"$]+/, Literal::String
         # quotes, dollar signs, and backslashes must be parsed one at a time
-        rule /["\\]/, Literal::String
+        rule %r/["\\]/, Literal::String
         # unhandled string formatting sign
-        rule /\$/, Literal::String
+        rule %r/\$/, Literal::String
       end
     end
   end