rouge 3.16.0 → 3.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5342709cd08d6095557fbe22c79544c6be522f2343ed53360ab57f96bb37c077
-  data.tar.gz: 25e1d81909ad22cece899eaf4d6c32ec1e0931611031f3ac8a37b6be3bceb497
+  metadata.gz: 1353759e9c75e7413608191e1fc9f670c4ac4f9db4cb3bc82c9c64d11ae54470
+  data.tar.gz: ae8d26b4295c1089d10c6567c3c5796613be6222e5dd22553f5f62fc238b2765
 SHA512:
-  metadata.gz: e1244771613b6d0ec7523c834084974c4c9e6145a06d237e1bf937ffced73af0a7f7c4bf5efbf397b5bf943df7a66d4614cc601c82721f6b2d03425dc9118ecc
-  data.tar.gz: ba9ecdc95aae8f45745820720b167ac102c1ac6d9af431024090cb79dd7805fb2ba981207de97c052339388b2886d2eb79e036b9aa60aaa8b6bc869bef9b5468
+  metadata.gz: ed188bc8fafde40a70384fc5bfb63a179ad23f4bab7c2616811e8260641b7a16fc2843b78c49543a4c45b8f790e47f68508f4979c9a10155ba4de94756c49382
+  data.tar.gz: f88c70213003b8235e275cca3d3776bb48abca5bd6cfdc52f7ef6ef398195028b7201b07c020ebaf5f509683cc7785a2bf93c6e0527a4c51a77f1ef8ca5eece9

data/lib/rouge/demos/ecl

@@ -0,0 +1,18 @@
+/*
+    Example code - use without restriction.  
+*/
+Layout_Person := RECORD
+  UNSIGNED1 PersonID;
+  STRING15  FirstName;
+  STRING25  LastName;
+END;
+
+allPeople := DATASET([ {1,'Fred','Smith'},
+                       {2,'Joe','Blow'},
+                       {3,'Jane','Smith'}],Layout_Person);
+
+somePeople := allPeople(LastName = 'Smith');
+
+//  Outputs  ---
+somePeople;
+

data/lib/rouge/demos/vcl

@@ -0,0 +1,12 @@
+vcl 4.0;
+
+backend server1 {
+      .host = "server1.example.com";
+      .probe = {
+              .url = "/";
+              .timeout = 1s;
+              .interval = 5s;
+              .window = 5;
+              .threshold = 3;
+      }
+}

data/lib/rouge/lexers/coffeescript.rb

@@ -49,33 +49,54 @@ module Rouge
 
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
-      state :comments_and_whitespace do
-        rule %r/\s+/m, Text
+      state :comments do
         rule %r/###[^#].*?###/m, Comment::Multiline
         rule %r/#.*$/, Comment::Single
       end
 
-      state :multiline_regex do
-        # this order is important, so that #{ isn't interpreted
-        # as a comment
-        mixin :has_interpolation
-        mixin :comments_and_whitespace
+      state :whitespace do
+        rule %r/\s+/m, Text
+      end
 
-        rule %r(///([gim]+\b|\B)), Str::Regex, :pop!
-        rule %r(/), Str::Regex
-        rule %r([^/#]+), Str::Regex
+      state :regex_comment do
+        rule %r/^#(?!\{).*$/, Comment::Single
+        rule %r/(\s+)(#(?!\{).*)$/ do
+          groups Text, Comment::Single
+        end
       end
 
-      state :slash_starts_regex do
-        mixin :comments_and_whitespace
+      state :multiline_regex_begin do
         rule %r(///) do
           token Str::Regex
           goto :multiline_regex
         end
+      end
+
+      state :multiline_regex_end do
+        rule %r(///([gimy]+\b|\B)), Str::Regex, :pop!
+      end
+
+      state :multiline_regex do
+        mixin :multiline_regex_end
+        mixin :regex_comment
+        mixin :has_interpolation
+        mixin :comments
+        mixin :whitespace
+        mixin :code_escape
+
+        rule %r/\\\D/, Str::Escape
+        rule %r/\\\d+/, Name::Variable
+        rule %r/./m, Str::Regex
+      end
+
+      state :slash_starts_regex do
+        mixin :comments
+        mixin :whitespace
+        mixin :multiline_regex_begin
 
         rule %r(
           /(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*\])+/ # a regex
-          ([gim]+\b|\B)
+          ([gimy]+\b|\B)
         )x, Str::Regex, :pop!
 
         rule(//) { pop! }
@@ -83,7 +104,9 @@ module Rouge
 
       state :root do
         rule(%r(^(?=\s|/|<!--))) { push :slash_starts_regex }
-        mixin :comments_and_whitespace
+        mixin :comments
+        mixin :whitespace
+
         rule %r(
           [+][+]|--|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\bin\b|\bof\b|
           [?]|:|=|[|][|]|\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*`%&|^/])=?
@@ -129,10 +152,19 @@ module Rouge
         rule %r/'/, Str, :sqs
       end
 
+      state :code_escape do
+        rule %r(\\(
+          c[A-Z]|
+          x[0-9a-fA-F]{2}|
+          u[0-9a-fA-F]{4}|
+          u\{[0-9a-fA-F]{4}\}
+        ))x, Str::Escape
+      end
+
       state :strings do
         # all coffeescript strings are multi-line
         rule %r/[^#\\'"]+/m, Str
-
+        mixin :code_escape
         rule %r/\\./, Str::Escape
         rule %r/#/, Str
       end

data/lib/rouge/lexers/ecl.rb

@@ -0,0 +1,175 @@
+# -*- codding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ECL < RegexLexer
+      tag 'ecl'
+      filenames '*.ecl'
+      mimetypes 'application/x-ecl'
+
+      title "ECL"
+      desc "Enterprise Control Language (hpccsystems.com)"
+
+      id = /(#?)\b([a-z_][\w]*?)(\d*)\b/i
+
+      def self.class_first
+        @class_first ||= Set.new %w(
+          file date str math metaphone metaphone3 uni audit blas system
+        )
+      end
+
+      def self.class_second
+        @class_second ||= Set.new %w(
+          debug email job log thorlib util workunit
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs acos aggregate allnodes apply ascii asin asstring atan _token ave
+          case catch choose choosen choosesets clustersize combine correlation
+          cos cosh count covariance cron dataset dedup define denormalize
+          dictionary distribute distributed distribution ebcdic enth error
+          evaluate event eventextra eventname exists exp failcode failmessage
+          fetch fromunicode fromxml getenv getisvalid global graph group hash
+          hashcrc having httpcall httpheader if iff index intformat isvalid
+          iterate join keyunicode length library limit ln local log loop map
+          matched matchlength matchposition matchtext matchunicode max merge
+          mergejoin min nofold nolocal nonempty normalize parse pipe power
+          preload process project pull random range rank ranked realformat
+          recordof regexfind regexreplace regroup rejected rollup round roundup
+          row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt
+          stepped stored sum table tan tanh thisnode topn tounicode toxml
+          transfer transform trim truncate typeof ungroup unicodeorder variance
+          which workunit xmldecode xmlencode xmltext xmlunicode apply assert
+          build buildindex evaluate fail keydiff keypatch loadxml nothor notify
+          output parallel sequential soapcall wait
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and or in not all any as from atmost before best between case const
+          counter csv descend encrypt end endmacro enum except exclusive expire
+          export extend fail few first flat full function functionmacro group
+          heading hole ifblock import joined keep keyed last left limit load
+          local locale lookup many maxcount maxlength _token module interface
+          named nocase noroot noscan nosort of only opt outer overwrite packed
+          partition penalty physicallength pipe quote record repeat return
+          right rows scan self separator service shared skew skip sql store
+          terminator thor threshold token transform trim type unicodeorder
+          unsorted validate virtual whole wild within xml xpath after cluster
+          compressed compression default encoding escape fileposition forward
+          grouped inner internal linkcounted literal lzw mofn multiple
+          namespace wnotrim noxpath onfail prefetch retry rowset scope smart
+          soapaction stable timelimit timeout unordered unstable update use
+          width
+        )
+      end
+
+      def self.template
+        @template ||= Set.new %w(
+          append apply break constant debug declare demangle else elseif end
+          endregion error expand export exportxml for forall getdatatype if
+          ifdefined inmodule isdefined isvalid line link loop mangle onwarning
+          option region set stored text trace uniquename warning webservice
+          workunit loadxml
+        )
+      end
+
+      def self.type
+        @type ||= Set.new %w(
+          ascii big_endian boolean data decimal ebcdic grouped integer
+          linkcounted pattern qstring real record rule set of streamed string
+          token udecimal unicode utf8 unsigned varstring varunicode
+        )
+      end
+
+      def self.typed
+        @typed ||= Set.new %w(
+          data string qstring varstring varunicode unicode utf8
+        )
+      end
+
+      state :single_quote do
+        rule %r([xDQUV]?'([^'\\]*(?:\\.[^'\\]*)*)'), Str::Single
+        rule %r/\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)/, Text
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text
+        rule %r(//.*), Comment::Single
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :single_quote
+
+        rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
+        rule %r([:=|>|<|<>|/|\\|\+|-|=]), Operator
+        rule %r([\[\]{}();,\&,\.,\%]), Punctuation
+
+        rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
+        rule %r(\b(?i:(embed.*?endembed)))m, Str::Single
+
+        rule %r(\b(\w+)\.(\w+)\.(\w+)) do |m|
+          if m[1] == "std" &&
+             self.class.class_first.include?(m[2]) &&
+             self.class.class_second.include?(m[3])
+            token Name::Class
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r(\b(?i:(u)?decimal)(\d+(_\d+)?)\b), Keyword::Type
+
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?/i, Num::Float
+        rule %r/x[0-9a-f]+/i, Num::Hex
+
+        rule %r/0x[0-9a-f]+/i, Num::Hex
+        rule %r/0[0-9a-f]+x/i, Num::Hex
+        rule %r(0[bB][01]+), Num::Bin
+        rule %r([01]+[bB]), Num::Bin
+        rule %r(\d+), Num::Integer
+
+        rule id do |m|
+          name_only = m[2].downcase
+          name      = name_only + m[3]
+          number    = (m[3] == "") ? nil : m[3].to_i
+          if m[1] == "#"
+            if self.class.template.include? name
+              token Keyword::Type
+            else
+              token Error
+            end
+          elsif self.class.typed.include?(name_only) && number != nil
+            token Keyword::Type
+          elsif self.class.type.include? name
+            token Keyword::Type
+          elsif self.class.keywords.include? name
+            token Keyword
+          elsif self.class.functions.include? name
+            token Name::Function
+          elsif ["integer", "unsigned"].include?(name_only) && (1..8).cover?(number)
+            token Keyword::Type
+          elsif name_only == "real" && [4, 8].include?(number)
+            token Keyword::Type
+          elsif ["true", "false"].include? name
+            token Keyword::Constant
+          else
+            token Name::Other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/markdown.rb

@@ -32,7 +32,7 @@ module Rouge
         rule %r/^#(?=[^#]).*?$/, Generic::Heading
         rule %r/^##*.*?$/, Generic::Subheading
 
-        rule %r/^([ \t]*)(```|~~~)([^\n]*\n)((.*?)(\2))?/m do |m|
+        rule %r/^([ \t]*)(`{3,}|~{3,})([^\n]*\n)((.*?)(\n\1)(\2))?/m do |m|
           name = m[3].strip
           sublexer =
             begin
@@ -51,8 +51,10 @@ module Rouge
             delegate sublexer, m[5]
           end
 
-          if m[6]
-            token Punctuation, m[6]
+          token Text, m[6]
+
+          if m[7]
+            token Punctuation, m[7]
           else
             push do
               rule %r/^([ \t]*)(#{m[2]})/ do |mb|
@@ -100,7 +102,7 @@ module Rouge
         end
 
         # links and images
-        rule %r/(!?\[)(#{edot}*?)(\])/ do
+        rule %r/(!?\[)(#{edot}*?)(\])(?=[\[(])/ do
           groups Punctuation, Name::Variable, Punctuation
           push :link
         end
@@ -115,7 +117,6 @@ module Rouge
         rule %r/<.*?@.+[.].+>/, Name::Variable
         rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
 
-
         rule %r/[^\\`\[*\n&<]+/, Text
 
         # inline html
@@ -123,6 +124,9 @@ module Rouge
         rule(/<#{edot}*?>/) { delegate html }
         rule %r/[&<]/, Text
 
+        # An opening square bracket that is not a link
+        rule %r/\[/, Text
+
         rule %r/\n/, Text
       end
 

data/lib/rouge/lexers/nasm.rb

@@ -1,197 +1,71 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+# Based on Chroma's NASM lexer implementation
+# https://github.com/alecthomas/chroma/blob/498eaa690f5ac6ab0e3d6f46237e547a8935cdc7/lexers/n/nasm.go
 module Rouge
   module Lexers
     class Nasm < RegexLexer
-      tag 'nasm'
-      filenames '*.asm'
-      #mimetypes 'text/x-chdr', 'text/x-csrc'
-
       title "Nasm"
       desc "Netwide Assembler"
 
-      id = /[a-zA-Z_][a-zA-Z0-9_]*/
-
-      #todo: pull more instructions from: http://www.nasm.us/doc/nasmdocb.html
-      #so far, we have sections 1.1 and 1.2
-
-      def self.keywords
-        @keywords ||= Set.new %w(
-           aaa aad aam aas adc add and arpl bb0_reset bb1_reset bound bsf bsr bswap bt btc btr bts
-           call cbw cdq cdqe clc cld cli clts cmc cmp cmpsb cmpsd cmpsq cmpsw cmpxchg
-           cmpxchg16b cmpxchg486 cmpxchg8b cpuid cpu_read cpu_write cqo cwd cwde daa das dec div
-           dmint emms enter equ f2xm1 fabs fadd faddp fbld fbstp fchs fclex fcmovb fcmovbe fcmove
-           fcmovnb fcmovnbe fcmovne fcmovnu fcmovu fcom fcomi fcomip fcomp fcompp fcos fdecstp
-           fdisi fdiv fdivp fdivr fdivrp femms feni ffree ffreep fiadd ficom ficomp fidiv fidivr
-           fild fimul fincstp finit fist fistp fisttp fisub fisubr fld fld1 fldcw fldenv fldl2e
-           fldl2t fldlg2 fldln2 fldpi fldz fmul fmulp fnclex fndisi fneni fninit fnop fnsave fnstcw
-           fnstenv fnstsw fpatan fprem fprem1 fptan frndint frstor fsave fscale fsetpm fsin fsincos
-           fsqrt fst fstcw fstenv fstp fstsw fsub fsubp fsubr fsubrp ftst fucom fucomi fucomip
-           fucomp fucompp fwait fxam fxch fxtract fyl2x fyl2xp1 hlt ibts icebp idiv imul in inc
-           incbin insb insd insw int int01 int03 int1 int3 into invd invlpg invlpga invpcid iret
-           iretd iretq iretw jcxz jecxz jmp jmpe jrcxz lahf lar lds lea leave les lfence lfs
-           lgdt lgs lidt lldt lmsw loadall loadall286 lodsb lodsd lodsq lodsw loop loope loopne
-           loopnz loopz lsl lss ltr mfence monitor monitorx mov movd movq movsb movsd movsq movsw
-           movsx movsxd movzx mul mwait mwaitx neg nop not or out outsb outsd outsw packssdw
-           packsswb packuswb paddb paddd paddsb paddsiw paddsw paddusb paddusw paddw pand pandn
-           pause paveb pavgusb pcmpeqb pcmpeqd pcmpeqw pcmpgtb pcmpgtd pcmpgtw pdistib pf2id pfacc
-           pfadd pfcmpeq pfcmpge pfcmpgt pfmax pfmin pfmul pfrcp pfrcpit1 pfrcpit2 pfrsqit1 pfrsqrt
-           pfsub pfsubr pi2fd pmachriw pmaddwd pmagw pmulhriw pmulhrwa pmulhrwc pmulhw pmullw
-           pmvgezb pmvlzb pmvnzb pmvzb pop popa popad popaw popf popfd popfq popfw por prefetch
-           prefetchw pslld psllq psllw psrad psraw psrld psrlq psrlw psubb psubd psubsb psubsiw
-           psubsw psubusb psubusw psubw punpckhbw punpckhdq punpckhwd punpcklbw punpckldq punpcklwd
-           push pusha pushad pushaw pushf pushfd pushfq pushfw pxor rcl rcr rdm rdmsr rdpmc rdshr
-           rdtsc rdtscp ret retf retn rol ror rsdc rsldt rsm rsts sahf sal salc sar sbb scasb scasd
-           scasq scasw sfence sgdt shl shld shr shrd sidt skinit sldt smi smint smintold smsw
-           stc std sti stosb stosd stosq stosw str sub svdc svldt svts swapgs syscall sysenter
-           sysexit sysret test ud0 ud1 ud2 ud2a ud2b umov verr verw wbinvd wrmsr wrshr xadd xbts
-           xchg xlat xlatb xor
-
-           cmova cmovae cmovb cmovbe cmovc cmove cmovg cmovge cmovl cmovle cmovna cmovnae cmovnb cmovnbe cmovnc cmovne cmovng cmovnge cmovnl cmovnle cmovno cmovnp cmovns cmovnz cmovo cmovp cmovpe cmovpo cmovs cmovz
-
-           ja jae jb jbe jc jcxz jecxz je jg jge jl jle jna jnae jnb jnbe jnc jne jng jnge jnl jnle jno jnp jns jnz jo jp jpe jpo js jz
-
-           seta setae setb setbe setc sete setg setge setl setle setna setnae setnb setnbe setnc setne setng setnge setnl setnle setno setnp setns setnz seto setp setpe setpo sets setz
-
-           AAA AAD AAM AAS ADC ADD AND ARPL BB0_RESET BB1_RESET BOUND BSF BSR BSWAP BT BTC BTR BTS
-           CALL CBW CDQ CDQE CLC CLD CLI CLTS CMC  CMP CMPSB CMPSD CMPSQ CMPSW CMPXCHG
-           CMPXCHG16B CMPXCHG486 CMPXCHG8B CPUID CPU_READ CPU_WRITE CQO CWD CWDE DAA DAS DEC DIV
-           DMINT EMMS ENTER EQU F2XM1 FABS FADD FADDP FBLD FBSTP FCHS FCLEX FCMOVB FCMOVBE FCMOVE
-           FCMOVNB FCMOVNBE FCMOVNE FCMOVNU FCMOVU FCOM FCOMI FCOMIP FCOMP FCOMPP FCOS FDECSTP
-           FDISI FDIV FDIVP FDIVR FDIVRP FEMMS FENI FFREE FFREEP FIADD FICOM FICOMP FIDIV FIDIVR
-           FILD FIMUL FINCSTP FINIT FIST FISTP FISTTP FISUB FISUBR FLD FLD1 FLDCW FLDENV FLDL2E
-           FLDL2T FLDLG2 FLDLN2 FLDPI FLDZ FMUL FMULP FNCLEX FNDISI FNENI FNINIT FNOP FNSAVE FNSTCW
-           FNSTENV FNSTSW FPATAN FPREM FPREM1 FPTAN FRNDINT FRSTOR FSAVE FSCALE FSETPM FSIN FSINCOS
-           FSQRT FST FSTCW FSTENV FSTP FSTSW FSUB FSUBP FSUBR FSUBRP FTST FUCOM FUCOMI FUCOMIP
-           FUCOMP FUCOMPP FWAIT FXAM FXCH FXTRACT FYL2X FYL2XP1 HLT IBTS ICEBP IDIV IMUL IN INC
-           INCBIN INSB INSD INSW INT INT01 INT03 INT1 INT3 INTO INVD INVLPG INVLPGA INVPCID IRET
-           IRETD IRETQ IRETW JCXZ JECXZ JMP JMPE JRCXZ LAHF LAR LDS LEA LEAVE LES LFENCE LFS
-           LGDT LGS LIDT LLDT LMSW LOADALL LOADALL286 LODSB LODSD LODSQ LODSW LOOP LOOPE LOOPNE
-           LOOPNZ LOOPZ LSL LSS LTR MFENCE MONITOR MONITORX MOV MOVD MOVQ MOVSB MOVSD MOVSQ MOVSW
-           MOVSX MOVSXD MOVZX MUL MWAIT MWAITX NEG NOP NOT OR OUT OUTSB OUTSD OUTSW PACKSSDW
-           PACKSSWB PACKUSWB PADDB PADDD PADDSB PADDSIW PADDSW PADDUSB PADDUSW PADDW PAND PANDN
-           PAUSE PAVEB PAVGUSB PCMPEQB PCMPEQD PCMPEQW PCMPGTB PCMPGTD PCMPGTW PDISTIB PF2ID PFACC
-           PFADD PFCMPEQ PFCMPGE PFCMPGT PFMAX PFMIN PFMUL PFRCP PFRCPIT1 PFRCPIT2 PFRSQIT1 PFRSQRT
-           PFSUB PFSUBR PI2FD PMACHRIW PMADDWD PMAGW PMULHRIW PMULHRWA PMULHRWC PMULHW PMULLW
-           PMVGEZB PMVLZB PMVNZB PMVZB POP POPA POPAD POPAW POPF POPFD POPFQ POPFW POR PREFETCH
-           PREFETCHW PSLLD PSLLQ PSLLW PSRAD PSRAW PSRLD PSRLQ PSRLW PSUBB PSUBD PSUBSB PSUBSIW
-           PSUBSW PSUBUSB PSUBUSW PSUBW PUNPCKHBW PUNPCKHDQ PUNPCKHWD PUNPCKLBW PUNPCKLDQ PUNPCKLWD
-           PUSH PUSHA PUSHAD PUSHAW PUSHF PUSHFD PUSHFQ PUSHFW PXOR RCL RCR RDM RDMSR RDPMC RDSHR
-           RDTSC RDTSCP RET RETF RETN ROL ROR RSDC RSLDT RSM RSTS SAHF SAL SALC SAR SBB SCASB SCASD
-           SCASQ SCASW  SFENCE SGDT SHL SHLD SHR SHRD SIDT SKINIT SLDT SMI SMINT SMINTOLD SMSW
-           STC STD STI STOSB STOSD STOSQ STOSW STR SUB SVDC SVLDT SVTS SWAPGS SYSCALL SYSENTER
-           SYSEXIT SYSRET TEST UD0 UD1 UD2 UD2A UD2B UMOV VERR VERW WBINVD WRMSR WRSHR XADD XBTS
-           XCHG XLAT XLATB XOR
-
-           CMOVA CMOVAE CMOVB CMOVBE CMOVC CMOVE CMOVG CMOVGE CMOVL CMOVLE CMOVNA CMOVNAE CMOVNB CMOVNBE CMOVNC CMOVNE CMOVNG CMOVNGE CMOVNL CMOVNLE CMOVNO CMOVNP CMOVNS CMOVNZ CMOVO CMOVP CMOVPE CMOVPO CMOVS CMOVZ
+      tag 'nasm'
+      filenames '*.asm'
+      mimetypes 'text/x-nasm'
 
-           JA JAE JB JBE JC JCXZ JECXZ JE JG JGE JL JLE JNA JNAE JNB JNBE JNC JNE JNG JNGE JNL JNLE JNO JNP JNS JNZ JO JP JPE JPO JS JZ
+      state :root do
+			  rule %r/^\s*%/, Comment::Preproc, :preproc
 
-           SETA SETAE SETB SETBE SETC SETE SETG SETGE SETL SETLE SETNA SETNAE SETNB SETNBE SETNC SETNE SETNG SETNGE SETNL SETNLE SETNO SETNP SETNS SETNZ SETO SETP SETPE SETPO SETS SETZ
-        )
-      end
+			  mixin :whitespace
 
-      def self.keywords_type
-        @keywords_type ||= Set.new %w(
-          DB DW DD DQ DT DO DY DZ RESB RESW RESD RESQ REST RESO RESY RESZ
-          db dq dd dq dt do dy dz resb resw resd resq rest reso resy resz
-        )
-      end
+			  rule %r/[a-z$._?][\w$.?#@~]*:/i, Name::Label
 
-      def self.reserved
-        @reserved ||= Set.new %w(
-          global extern macro endmacro assign rep endrep section
-          GLOBAL EXTERN MACRO ENDMACRO ASSIGN REP ENDREP SECTION
-        )
-      end
+        rule %r/([a-z$._?][\w$.?#@~]*)(\s+)(equ)/i do
+          groups Name::Constant, Keyword::Declaration, Keyword::Declaration
+          push :instruction_args
+        end
+        rule %r/BITS|USE16|USE32|SECTION|SEGMENT|ABSOLUTE|EXTERN|GLOBAL|ORG|ALIGN|STRUC|ENDSTRUC|COMMON|CPU|GROUP|UPPERCASE|IMPORT|EXPORT|LIBRARY|MODULE/, Keyword, :instruction_args
+        rule %r/(?:res|d)[bwdqt]|times/i, Keyword::Declaration, :instruction_args
+        rule %r/[a-z$._?][\w$.?#@~]*/i, Name::Function, :instruction_args
 
-      def self.builtins
-        @builtins ||= []
+        rule %r/[\r\n]+/, Text
       end
 
-      start { push :expr_bol }
-
-      state :expr_bol do
-        mixin :inline_whitespace
-        rule(//) { pop! }
-      end
+      state :instruction_args do
+			  rule %r/"(\\\\"|[^"\\n])*"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`/, Str
+        rule %r/(?:0x[\da-f]+|$0[\da-f]*|\d+[\da-f]*h)/i, Num::Hex
+        rule %r/[0-7]+q/i, Num::Oct
+        rule %r/[01]+b/i, Num::Bin
+        rule %r/\d+\.e?\d+/i, Num::Float
+        rule %r/\d+/, Num::Integer
 
-      state :inline_whitespace do
-        rule %r/[ \t\r]+/, Text
-      end
+        mixin :punctuation
 
-      state :whitespace do
-        rule %r/\n+/m, Text, :expr_bol
-        rule %r(//(\\.|.)*?\n), Comment::Single, :expr_bol
-        mixin :inline_whitespace
-      end
+        rule %r/r\d[0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]/i, Name::Builtin
+        rule %r/[a-z$._?][\w$.?#@~]*/i, Name::Variable
+        rule %r/[\r\n]+/, Text, :pop!
 
-      state :expr_whitespace do
-        rule %r/\n+/m, Text, :expr_bol
         mixin :whitespace
       end
 
-      state :root do
-        mixin :expr_whitespace
-        rule(//) { push :statement }
-        rule %r/^%[a-zA-Z0-9]+/, Comment::Preproc, :statement
-
-        rule(
-          %r(&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]),
-          Operator
-        )
-        rule %r/;.*/, Comment, :statement
-        rule %r/^[a-zA-Z]+[a-zA-Z0-9]*:/, Name::Function
-        rule %r/;.*/, Comment
+      state :preproc do
+        rule %r/[^;\n]+/, Comment::Preproc
+        rule %r/;.*?\n/, Comment::Single, :pop!
+        rule %r/\n/, Comment::Preproc, :pop!
       end
 
-      state :statement do
-        mixin :expr_whitespace
-        mixin :statements
-        rule %r/;.*/, Comment
-        rule %r/^%[a-zA-Z0-9]+/, Comment::Preproc
-        rule %r/[a-zA-Z]+%[0-9]+:/, Name::Function
-      end
-
-      state :statements do
-        mixin :whitespace
-        rule %r/L?"/, Str, :string
-        rule %r/[a-zA-Z]+%[0-9]+:/, Name::Function  #labels/subroutines/functions
-        rule %r(L?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
-        rule %r/0x[0-9a-f]+[lu]*/i, Num::Hex
-        rule %r/\d+[lu]*/i, Num::Integer
-        rule %r(\*/), Error
-        rule %r([~&*+=\|?:<>/-]), Operator
-        rule %r/[(),.]/, Punctuation
-        rule %r/\[[a-zA-Z0-9]*\]/, Punctuation
-        rule %r/%[0-9]+/, Keyword::Reserved
-        rule %r/[a-zA-Z]+%[0-9]+/, Name::Function  #labels/subroutines/functions
-
-        #rule %r/(?<!\.)#{id}/ do |m|
-        rule id do |m|
-          name = m[0]
-
-          if self.class.keywords.include? name
-            token Keyword
-          elsif self.class.keywords_type.include? name
-            token Keyword::Type
-          elsif self.class.reserved.include? name
-            token Keyword::Reserved
-          elsif self.class.builtins.include? name
-            token Name::Builtin
-          else
-            token Name
-          end
-        end
+      state :whitespace do
+        rule %r/\n/, Text
+        rule %r/[ \t]+/, Text
+        rule %r/;.*/, Comment::Single
       end
 
-      state :string do
-        rule %r/"/, Str, :pop!
-        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
-        rule %r/[^\\"\n]+/, Str
-        rule %r/\\\n/, Str
-        rule %r/\\/, Str # stray backslash
+      state :punctuation do
+        rule %r/[,():\[\]]+/, Punctuation
+        rule %r/[&|^<>+*\/%~-]+/, Operator
+        rule %r/\$+/, Keyword::Constant
+        rule %r/seg|wrt|strict/i, Operator::Word
+        rule %r/byte|[dq]?word/i, Keyword::Type
       end
     end
   end

data/lib/rouge/lexers/ruby.rb

@@ -170,8 +170,11 @@ module Rouge
         rule %r/0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
         rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
         rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
-        rule %r/\d+\.\d+(e[\+\-]?\d+)?/, Num::Float
-        rule %r/[\d]+(?:_\d+)*/, Num::Integer
+
+        decimal = %r/[\d]+(?:_\d+)*/
+        exp = %r/e[+-]?\d+/i
+        rule %r/#{decimal}(?:\.#{decimal}#{exp}?|#{exp})/, Num::Float
+        rule decimal, Num::Integer
 
         # names
         rule %r/@@[a-z_]\w*/i, Name::Variable::Class

data/lib/rouge/lexers/scala.rb

@@ -40,7 +40,7 @@ module Rouge
           groups Keyword, Text
           push :class
         end
-        rule %r/'#{idrest}[^']/, Str::Symbol
+        rule %r/'#{idrest}(?!')/, Str::Symbol
         rule %r/[^\S\n]+/, Text
 
         rule %r(//.*), Comment::Single

data/lib/rouge/lexers/varnish.rb

@@ -4,16 +4,14 @@
 module Rouge
   module Lexers
     class Varnish < RegexLexer
-      title 'Varnish'
-      desc 'The Varnish (high-performance web accelerator) configuration language'
+      title 'VCL: Varnish Configuration Language'
+      desc 'The configuration language for Varnish HTTP Cache (varnish-cache.org)'
 
-      tag 'varnish'
-      aliases 'varnishconf', 'VCL'
+      tag 'vcl'
+      aliases 'varnishconf', 'varnish'
       filenames '*.vcl'
-      mimetypes 'text/x-varnish'
+      mimetypes 'text/x-varnish', 'text/x-vcl'
 
-      LNUM = '[0-9]+'
-      DNUM = '([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)'
       SPACE = '[ \f\n\r\t\v]+'
 
       # backend acl
@@ -21,6 +19,9 @@ module Rouge
         @keywords ||= Set.new %w[
           vcl set unset include import if else elseif elif elsif director probe
           backend acl
+
+          declare local
+          BOOL FLOAT INTEGER IP RTIME STRING TIME
         ]
       end
 
@@ -65,6 +66,9 @@ module Rouge
         # long strings ({" ... "})
         rule %r/\{".*?"}/m, Str::Single
 
+        # heredoc style long strings ({xyz"..."xyz})
+        rule %r/\{(\w+)".*?"(\1)\}/m, Str::Single
+
         # comments
         rule %r'/\*.*?\*/'m, Comment::Multiline
         rule %r'(?://|#).*', Comment::Single
@@ -72,7 +76,13 @@ module Rouge
         rule %r/true|false/, Keyword::Constant
 
         # "wildcard variables"
-        rule %r/(?:(?:be)?re(?:sp|q)|obj)\.http\.[\w.-]+/ do
+        var_prefix = Regexp.union(%w(beresp bereq resp req obj))
+        rule %r/(?:#{var_prefix})\.http\.[\w.-]+/ do
+          token Name::Variable
+        end
+
+        # local variables (var.*)
+        rule %r/(?:var)\.[\w.-]+/ do
           token Name::Variable
         end
 
@@ -86,20 +96,47 @@ module Rouge
           push :inline_c
         end
 
-        rule %r/[a-z_.-]+/i do |m|
+        rule %r/\.?[a-z_][\w.-]*/i do |m|
           next token Keyword if self.class.keywords.include? m[0]
           next token Name::Function if self.class.functions.include? m[0]
           next token Name::Variable if self.class.variables.include? m[0]
           token Text
         end
 
-        # duration
-        rule %r/(?:#{LNUM}|#{DNUM})(?:ms|[smhdwy])/, Num::Other
-        # size in bytes
-        rule %r/#{LNUM}[KMGT]?B/, Num::Other
-        # literal numeric values (integer/float)
-        rule %r/#{LNUM}/, Num::Integer
-        rule %r/#{DNUM}/, Num::Float
+        ## for number literals
+
+        decimal = %r/[0-9]+/
+        hex = %r/[0-9a-f]+/i
+
+        numeric = %r{
+          (?:
+            0x#{hex}
+            (?:\.#{hex})?
+            (?:p[+-]?#{hex})?
+          )
+          |
+          (?:
+            #{decimal}
+            (?:\.#{decimal})?
+            (?:e[+-]?#{decimal})?
+          )
+        }xi
+
+        # duration literals
+        duration_suffix = Regexp.union(%w(ms s m h d w y))
+        rule %r/#{numeric}#{duration_suffix}/, Num::Other
+
+        # numeric literals (integer / float)
+        rule numeric do |m|
+            case m[0]
+            when /^#{decimal}$/
+              token Num::Integer
+            when /^0x#{hex}$/
+              token Num::Integer
+            else
+              token Num::Float
+            end
+        end
 
         # standard strings
         rule %r/"/, Str::Double, :string

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.16.0"
+    "3.17.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.16.0
+  version: 3.17.0
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-11 00:00:00.000000000 Z
+date: 2020-03-10 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -63,6 +63,7 @@ files:
 - lib/rouge/demos/digdag
 - lib/rouge/demos/docker
 - lib/rouge/demos/dot
+- lib/rouge/demos/ecl
 - lib/rouge/demos/eex
 - lib/rouge/demos/eiffel
 - lib/rouge/demos/elixir
@@ -193,8 +194,8 @@ files:
 - lib/rouge/demos/twig
 - lib/rouge/demos/typescript
 - lib/rouge/demos/vala
-- lib/rouge/demos/varnish
 - lib/rouge/demos/vb
+- lib/rouge/demos/vcl
 - lib/rouge/demos/verilog
 - lib/rouge/demos/vhdl
 - lib/rouge/demos/viml
@@ -267,6 +268,7 @@ files:
 - lib/rouge/lexers/digdag.rb
 - lib/rouge/lexers/docker.rb
 - lib/rouge/lexers/dot.rb
+- lib/rouge/lexers/ecl.rb
 - lib/rouge/lexers/eex.rb
 - lib/rouge/lexers/eiffel.rb
 - lib/rouge/lexers/elixir.rb

data/lib/rouge/demos/varnish

@@ -1,55 +0,0 @@
-vcl 4.0;
-
-backend server1 {
-      .host = "server1.example.com";
-      .probe = {
-              .url = "/";
-              .timeout = 1s;
-              .interval = 5s;
-              .window = 5;
-              .threshold = 3;
-      }
-}
-
-sub vcl_hit {
-    # Called when a cache lookup is successful.
-
-    if (obj.ttl >= 0s) {
-        # A pure unadultered hit, deliver it
-        return (deliver);
-    }
-
-    # https://www.varnish-cache.org/docs/trunk/users-guide/vcl-grace.html
-    # When several clients are requesting the same page Varnish will send one request to the backend and place the others on hold while fetching one copy from the backend. In some products this is called request coalescing and Varnish does this automatically.
-    # If you are serving thousands of hits per second the queue of waiting requests can get huge. There are two potential problems - one is a thundering herd problem - suddenly releasing a thousand threads to serve content might send the load sky high. Secondly - nobody likes to wait. To deal with this we can instruct Varnish to keep the objects in cache beyond their TTL and to serve the waiting requests somewhat stale content.
-
-# if (!std.healthy(req.backend_hint) && (obj.ttl + obj.grace > 0s)) {
-#     return (deliver);
-# } else {
-#     return (fetch);
-# }
-
-    # We have no fresh fish. Lets look at the stale ones.
-    if (std.healthy(req.backend_hint)) {
-        # Backend is healthy. Limit age to 10s.
-        if (obj.ttl + 10s > 0s) {
-            #set req.http.grace = "normal(limited)";
-            return (deliver);
-        } else {
-            # No candidate for grace. Fetch a fresh object.
-            return(fetch);
-        }
-    } else {
-        # backend is sick - use full grace
-            if (obj.ttl + obj.grace > 0s) {
-            #set req.http.grace = "full";
-            return (deliver);
-        } else {
-            # no graced object.
-            return (fetch);
-        }
-    }
-
-    # fetch & deliver once we get the result
-    return (fetch); # Dead code, keep as a safeguard
-}