rouge 3.26.0 → 3.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b4023b528780340984bedccbe7068091fe13e092ec69c43972849924928eaf0
-  data.tar.gz: 20d90c29a74768ad39ffd84202396ba17be6c67c4d91daef83c7aa11b8bf55a2
+  metadata.gz: 396c335066b8bb01574b5d81b25d43a98b58dd1bad1d3d9588b7a35c573e2209
+  data.tar.gz: d899fb3968d38a1a93415c21c62e332f1a8ba230952c0a33adda5c4755c4c8f3
 SHA512:
-  metadata.gz: 5ce0c09ee43cf473c4e86dcc74fa84c735cc045080a47fc46e31a40553e8e0e106069b1f8cc2c23bcf76f80a5ba9749717e47a8385e970456b035bdb9ea626aa
-  data.tar.gz: 1a54b8b602cc6bca9b1f04c9eebc5353962f6476866f04b48092ffde45511408c6fbfb096fe0b450aa55bf8922ccbb62dd61363e4d71ef198651f49a6a0dac95
+  metadata.gz: c1fed00ea4906f18e1939675dff9c02508cddef4b1878622422d66b3cbee6d07111ab434cb83314d5d3077f3b86375424d4af05f2fce46cb105a9ecef698aec9
+  data.tar.gz: 7764c52128ef376d3af7e2c5d1a958a62bddffadc4b2d8c868161fd786a9af63827d143a8b85d6d5251d65f8adefc6a405e2fef5d29e6c7d73bc00f041d8c024

data/Gemfile

@@ -8,6 +8,7 @@ gem 'rake'
 
 gem 'minitest', '>= 5.0'
 gem 'minitest-power_assert'
+gem 'power_assert', '~> 1.2'
 
 gem 'parallel', '~> 1.13.0' if RUBY_VERSION < '2.2.0'
 gem 'rubocop', '~> 0.49.1'

data/lib/rouge/demos/dafny

@@ -0,0 +1,16 @@
+module A {
+  const i: int := 56_78
+}
+
+method m(b: bool, s: string) {
+  var x: string;
+  var i: int;
+  if b then i := 1; else i := 2;
+  i := if b 1 else 2;
+  assert b;
+  assume b;
+  print s;
+  expect b;
+}
+
+function f(i: int): int { i + 1 }

data/lib/rouge/formatter.rb

@@ -42,8 +42,8 @@ module Rouge
     end
 
     # Format a token stream.  Delegates to {#format}.
-    def self.format(tokens, *a, &b)
-      new(*a).format(tokens, &b)
+    def self.format(tokens, *args, **kwargs, &b)
+      new(*args, **kwargs).format(tokens, &b)
     end
 
     def initialize(opts={})

data/lib/rouge/lexers/ceylon.rb

@@ -51,8 +51,8 @@ module Rouge
 
         rule %r("(\\\\|\\"|[^"])*"), Literal::String
         rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
-        rule %r(".*``.*``.*"', String::Interpol
-        rule %r(\.)([a-z_]\w*)) do
+        rule %r("[^`]*``[^`]*``[^`]*"), Literal::String::Interpol
+        rule %r((\.)([a-z_]\w*)) do
           groups Operator, Name::Attribute
         end
         rule %r([a-zA-Z_]\w*:), Name::Label

data/lib/rouge/lexers/cpp.rb

@@ -59,7 +59,7 @@ module Rouge
       prepend :statements do
         rule %r/(class|struct)\b/, Keyword, :classname
         rule %r/template\b/, Keyword, :template
-        rule %r/\d+(\.\d+)?(?:h|(?:min)|s|(?:ms)|(?:us)|(?:ns))/, Num::Other
+        rule %r/#{dq}(\.#{dq})?(?:y|d|h|(?:min)|s|(?:ms)|(?:us)|(?:ns)|i|(?:if)|(?:il))\b/, Num::Other
         rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
         rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
         rule %r/0x\h('?\h)*[lu]*/i, Num::Hex

data/lib/rouge/lexers/dafny.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dafny < RegexLexer
+      title "Dafny"
+      desc "The Dafny programming language (github.com/dafny-lang/dafny)"
+      tag "dafny"
+      filenames "*.dfy"
+      mimetypes "text/x-dafny"
+
+      keywords = %w(
+        abstract allocated assert assume
+        break by
+        calc case class codatatype const constructor
+        datatype decreases downto
+        else ensures exists expect export extends
+        false for forall fresh function
+        ghost greatest
+        if import include invariant iterator
+        label least lemma
+        match method modifies modify module
+        nameonly new newtype null
+        old opened
+        predicate print provides
+        reads refines requires return returns reveal reveals
+        static
+        then this to trait true twostate type
+        unchanged
+        var
+        while witness
+        yield yields
+      )
+
+      literals = %w{ true false null }
+
+      textOperators = %w{ as is in }
+
+      types = %w(bool char int real string nat
+                 array array? object object? ORDINAL
+                 seq set iset map imap multiset )
+
+      idstart = /[0-9a-zA-Z?]/
+      idchar = /[0-9a-zA-Z_'?]/
+      id = /#{idstart}#{idchar}*/
+
+      arrayType = /array(?:1[0-9]+|[2-9][0-9]*)\??(?!#{idchar})/
+      bvType = /bv(?:0|[1-9][0-9]*)(?!#{idchar})/
+
+      digit = /\d/
+      digits = /#{digit}+(?:_#{digit}+)*/
+      bin_digits = /[01]+(?:_[01]+)*/
+      hex_digit = /(?:[0-9a-fA-F])/
+      hex_digits = /#{hex_digit}+(?:_#{hex_digit}+)*/
+
+      cchar = /(?:[^\\'\n\r]|\\["'ntr\\0])/
+      schar = /(?:[^\\"\n\r]|\\["'ntr\\0])/
+      uchar = /(?:\\u#{hex_digit}{4})/
+
+      ## IMPORTANT: Rules are ordered, which allows later rules to be 
+      ## simpler than they would otherwise be
+      state :root do
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(//.*?$), Comment::Single
+        rule %r(\*/), Error          # should not have closing comment in :root
+                                     # is an improperly nested comment
+
+        rule %r/'#{cchar}'/, Str::Char           # standard or escape char
+        rule %r/'#{uchar}'/, Str::Char           # unicode char
+        rule %r/'[^'\n\r]*'/, Error              # bad any other enclosed char
+        rule %r/'[^'\n\r]*$/, Error              # bad unclosed char
+
+        rule %r/"(?:#{schar}|#{uchar})*"/, Str::Double        # valid string
+        rule %r/".*"/, Error                     # anything else that is closed
+        rule %r/".*$/, Error                     # bad unclosed string
+
+        rule %r/@"([^"]|"")*"/, Str::Other     # valid verbatim string
+        rule %r/@".*/m, Error             # anything else , multiline unclosed
+
+
+        rule %r/#{digits}\.#{digits}(?!#{idchar})/, Num::Float
+        rule %r/0b#{bin_digits}(?!#{idchar})/, Num::Bin
+        rule %r/0b#{idchar}*/, Error
+        rule %r/0x#{hex_digits}(?!#{idchar})/, Num::Hex
+        rule %r/0x#{idchar}*/, Error
+        rule %r/#{digits}(?!#{idchar})/, Num::Integer
+        rule %r/_(?!#{idchar})/, Name
+        rule %r/_[0-9_]+[_]?(?!#{idchar})/, Error
+        rule %r/[0-9_]+_(?!#{idchar})/, Error
+        rule %r/[0-9]#{idchar}+/, Error
+
+        rule %r/#{arrayType}/, Keyword::Type
+        rule %r/#{bvType}/, Keyword::Type
+
+        rule id do |m|
+          if types.include?(m[0])
+            token Keyword::Type
+          elsif literals.include?(m[0])
+            token Keyword::Constant
+          elsif textOperators.include?(m[0])
+            token Operator::Word
+          elsif keywords.include?(m[0])
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        rule %r/\.\./, Operator
+        rule %r/[*!%&<>\|^+=:.\/-]/, Operator
+        rule %r/[\[\](){},;`]/, Punctuation
+
+        rule %r/[^\S\n]+/, Text
+        rule %r/\n/, Text
+        rule %r/./, Error # Catchall
+      end
+
+      state :comment do
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r([^*/]+), Comment::Multiline
+        rule %r(.), Comment::Multiline
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/eex.rb

@@ -7,9 +7,9 @@ module Rouge
       desc "Embedded Elixir"
 
       tag 'eex'
-      aliases 'leex'
+      aliases 'leex', 'heex'
 
-      filenames '*.eex', '*.leex'
+      filenames '*.eex', '*.leex', '*.heex'
 
       def initialize(opts={})
         @elixir_lexer = Elixir.new(opts)

data/lib/rouge/lexers/factor.rb

@@ -243,8 +243,8 @@ module Rouge
         end
 
         # strings
-        rule %r/"""\s+.*?\s+"""/, Str
-        rule %r/"(\\.|[^\\])*?"/, Str
+        rule %r/"(?:\\\\|\\"|[^"])*"/, Str
+        rule %r/\S+"\s+(?:\\\\|\\"|[^"])*"/, Str
         rule %r/(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
 
         # comments

data/lib/rouge/lexers/ghc_core.rb

@@ -17,7 +17,7 @@ module Rouge
         rule %r/^=====.*=====$/, Generic::Heading
         # timestamps
         rule %r/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ UTC$/, Comment::Single
-        rule %r/^Result size of .+\s*.*}/, Comment::Multiline
+        rule %r/^Result size of .+\n.+{[^}]*}/, Comment::Multiline
         rule %r/--.*$/, Comment::Single
 
         rule %r/\[/, Comment::Special, :annotation

data/lib/rouge/lexers/jsl.rb

@@ -14,24 +14,23 @@ module Rouge
         rule %r/\s+/m, Text::Whitespace
 
         rule %r(//.*?$), Comment::Single
-        rule %r'/[*].*', Comment::Multiline, :comment
+        rule %r'/[*].*?', Comment::Multiline, :comment # multiline block comment
 
         # messages
         rule %r/<</, Operator, :message
 
         # covers built-in and custom functions
-        rule %r/([a-z_][\w\s'%.\\]*)(\()/i do |m|
-          groups Keyword, Punctuation
+        rule %r/(::|:)?([a-z_][\w\s'%.\\]*)(\()/i do |m|
+          groups Punctuation, Keyword, Punctuation
         end
 
         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/-?(?:[0-9]+(?:[.][0-9]+)?|[.][0-9]*)(?:e[+-]?[0-9]+)?i?/i, Num
 
-        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/(::|:)?([a-z_][\w\s'%.\\]*|"(?:\\!"|[^"])*?"n)/i do |m|
+          groups Punctuation, Name::Variable
+        end
 
         rule %r/(")(\\\[)(.*?)(\]\\)(")/m do
           groups Str::Double, Str::Escape, Str::Double, Str::Escape, Str::Double  # escaped string

data/lib/rouge/lexers/rust.rb

@@ -22,10 +22,10 @@ module Rouge
 
       def self.keywords
         @keywords ||= %w(
-          as assert async await break const continue copy do drop else enum extern
-          fail false fn for if impl let log loop match mod move mut priv pub pure
-          ref return self static struct true trait type unsafe use where
-          while box
+          as assert async await break crate const continue copy do drop dyn else enum extern
+          fail false fn for if impl let log loop macro match mod move mut priv pub pure
+          ref return self Self static struct super true try trait type union unsafe use
+          where while yield box
         )
       end
 
@@ -40,6 +40,9 @@ module Rouge
           Right Send Shl Shr size_t Some ssize_t str Sub Success time_t
           u16 u32 u64 u8 usize uint uintptr_t
           Box Vec String Gc Rc Arc
+          u128 i128 Result Sync Pin Unpin Sized Drop drop Fn FnMut FnOnce
+          Clone PartialEq PartialOrd AsMut AsRef From Into Default
+          DoubleEndedIterator ExactSizeIterator Extend IntoIterator Iterator
         )
       end
 
@@ -54,12 +57,12 @@ module Rouge
 
       delim_map = { '[' => ']', '(' => ')', '{' => '}' }
 
-      id = /[a-z_]\w*/i
+      id = /[\p{XID_Start}_]\p{XID_Continue}*/
       hex = /[0-9a-f]/i
       escapes = %r(
-        \\ ([nrt'"\\0] | x#{hex}{2} | u#{hex}{4} | U#{hex}{8})
+        \\ ([nrt'"\\0] | x#{hex}{2} | u\{(#{hex}_*){1,6}\})
       )x
-      size = /8|16|32|64/
+      size = /8|16|32|64|128|size/
 
       # Although not officially part of Rust, the rustdoc tool allows code in
       # comments to begin with `#`. Code like this will be evaluated but not
@@ -82,8 +85,62 @@ module Rouge
 
       state :whitespace do
         rule %r/\s+/, Text
-        rule %r(//[^\n]*), Comment
-        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        mixin :comments
+      end
+
+      state :comments do
+        # Only 3 slashes are doc comments, `////` and beyond become normal
+        # comments again (for some reason), so match this before the
+        # doc line comments rather than figure out a
+        rule %r(////+[^\n]*), Comment::Single
+        # doc line comments — either inner (`//!`), or outer (`///`).
+        rule %r(//[/!][^\n]*), Comment::Doc
+        # otherwise, `//` is just a plain line comme
+        rule %r(//[^\n]*), Comment::Single
+        # /**/ and /***/ are self-closing block comments, not doc. Because this
+        # is self-closing, it doesn't enter the states for nested comments
+        rule %r(/\*\*\*?/), Comment::Multiline
+        # 3+ stars and it's a normal non-doc block comment.
+        rule %r(/\*\*\*+), Comment::Multiline, :nested_plain_block
+        # `/*!` and `/**` begin doc comments. These nest and can have internal
+        # block/doc comments, but they're still part of the documentation
+        # inside.
+        rule %r(/[*][*!]), Comment::Doc, :nested_doc_block
+        # any other /* is a plain multiline comment
+        rule %r(/[*]), Comment::Multiline, :nested_plain_block
+      end
+
+      # Multiline/block comments fully nest. This is true for ones that are
+      # marked as documentation too. The behavior here is:
+      #
+      # - Anything inside a block doc comment is still included in the
+      #   documentation, even if it's a nested non-doc block comment. For
+      #   example: `/** /* still docs */ */`
+      # - Anything inside of a block non-doc comment is still just a normal
+      #   comment, even if it's a nested block documentation comment. For
+      #   example: `/* /** not docs */ */`
+      #
+      # This basically means: if (on the outermost level) the comment starts as
+      # one kind of block comment (either doc/non-doc), then everything inside
+      # of it, including nested block comments of the opposite type, needs to
+      # stay that type.
+      #
+      # Also note that single line comments do nothing anywhere inside of block
+      # comments, thankfully.
+      #
+      # We just define this as two states, because this seems easier than
+      # tracking it with instance vars.
+      [
+        [:nested_plain_block, Comment::Multiline],
+        [:nested_doc_block, Comment::Doc]
+      ].each do |state_name, comment_token|
+        state state_name do
+          rule %r(\*/), comment_token, :pop!
+          rule %r(/\*), comment_token, state_name
+          # We only want to eat at most one `[*/]` at a time,
+          # but we can skip past non-`[*/]` in bulk.
+          rule %r([^*/]+|[*/]), comment_token
+        end
       end
 
       state :root do
@@ -110,6 +167,7 @@ module Rouge
         rule %r/\bmacro_rules!/, Name::Decorator, :macro_rules
         rule %r/#{id}!/, Name::Decorator, :macro
 
+        rule %r/'static\b/, Keyword
         rule %r/'#{id}/, Name::Variable
         rule %r/#{id}/ do |m|
           name = m[0]
@@ -155,32 +213,33 @@ module Rouge
       state :has_literals do
         # constants
         rule %r/\b(?:true|false|nil)\b/, Keyword::Constant
-        # characters
+        # characters/bytes
         rule %r(
-          ' (?: #{escapes} | [^\\] ) '
+          b?' (?: #{escapes} | [^\\] ) '
         )x, Str::Char
 
-        rule %r/"/, Str, :string
-        rule %r/r(#*)".*?"\1/m, Str
+        rule %r/b?"/, Str, :string
+        rule %r/b?r(#*)".*?"\1/m, Str
 
         # numbers
-        dot = /[.][0-9_]+/
-        exp = /e[-+]?[0-9_]+/
+        dot = /[.][0-9][0-9_]*/
+        exp = /[eE][-+]?[0-9_]+/
         flt = /f32|f64/
 
         rule %r(
-          [0-9_]+
+          [0-9][0-9_]*
           (#{dot}  #{exp}? #{flt}?
           |#{dot}? #{exp}  #{flt}?
           |#{dot}? #{exp}? #{flt}
+          |[.](?![._\p{XID_Start}])
           )
         )x, Num::Float
 
         rule %r(
           ( 0b[10_]+
           | 0x[0-9a-fA-F_]+
-          | 0o[0-7]+
-          | [0-9_]+
+          | 0o[0-7_]+
+          | [0-9][0-9_]*
           ) (u#{size}?|i#{size})?
         )x, Num::Integer
 

data/lib/rouge/lexers/sql.rb

@@ -38,8 +38,8 @@ module Rouge
           DYNAMIC DYNAMIC_FUNCTION DYNAMIC_FUNCTION_CODE EACH ELSE
           ENCODING ENCRYPTED END END-EXEC EQUALS ESCAPE EVERY EXCEPT
           ESCEPTION EXCLUDING EXCLUSIVE EXEC EXECUTE EXISTING EXISTS
-          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOR FORCE
-          FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
+          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOLLOWING FOR
+          FORCE FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
           G GENERAL GENERATED GET GLOBAL GO GOTO GRANT GRANTED GROUP
           GROUPING HANDLER HAVING HIERARCHY HOLD HOST IDENTITY IGNORE
           ILIKE IMMEDIATE IMMUTABLE IMPLEMENTATION IMPLICIT IN INCLUDING
@@ -58,10 +58,10 @@ module Rouge
           ORDINALITY OUT OUTER OUTPUT OVERLAPS OVERLAY OVERRIDING
           OWNER PAD PARAMETER PARAMETERS PARAMETER_MODE PARAMATER_NAME
           PARAMATER_ORDINAL_POSITION PARAMETER_SPECIFIC_CATALOG
-          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PASCAL
-          PENDANT PLACING PLI POSITION POSTFIX PREFIX PREORDER
+          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PARTITION
+          PASCAL PENDANT PLACING PLI POSITION POSTFIX PREFIX PRECEDING PREORDER
           PREPARE PRESERVE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
-          PUBLIC READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
+          PUBLIC RANGE READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
           REINDEX RELATIVE RENAME REPEATABLE REPLACE RESET RESTART
           RESTRICT RESULT RETURN RETURNED_LENGTH RETURNED_OCTET_LENGTH
           RETURNED_SQLSTATE RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
@@ -84,7 +84,7 @@ module Rouge
           USAGE USER USER_DEFINED_TYPE_CATALOG USER_DEFINED_TYPE_NAME
           USER_DEFINED_TYPE_SCHEMA USING VACUUM VALID VALIDATOR VALUES
           VARIABLE VERBOSE VERSION VIEW VOLATILE WHEN WHENEVER WHERE
-          WITH WITHOUT WORK WRITE ZONE
+          WINDOW WITH WITHOUT WORK WRITE ZONE
         )
       end
 
@@ -126,7 +126,7 @@ module Rouge
         end
 
         rule %r([+*/<>=~!@#%&|?^-]), Operator
-        rule %r/[;:()\[\],.]/, Punctuation
+        rule %r/[;:()\[\]\{\},.]/, Punctuation
       end
 
       state :multiline_comments do

data/lib/rouge/lexers/swift.rb

@@ -15,17 +15,17 @@ module Rouge
       id = /#{id_head}#{id_rest}*/
 
       keywords = Set.new %w(
-        break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
+        await break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
 
         as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
 
-        associativity didSet get infix inout mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
+        associativity async didSet get infix inout isolated mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
 
         #available #colorLiteral #column #else #elseif #endif #error #file #fileLiteral #function #if #imageLiteral #line #selector #sourceLocation #warning
       )
 
       declarations = Set.new %w(
-        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
+        actor class deinit enum convenience extension final func import init internal lazy let nonisolated optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate some
       )
 
       constants = Set.new %w(

data/lib/rouge/lexers/yaml.rb

@@ -175,7 +175,7 @@ module Rouge
 
       state :block_nodes do
         # implicit key
-        rule %r/((?:[\p{L}\p{Nl}\p{Nd}_][\p{L}\p{Nl}\p{Nd}\p{Blank}_-]*)?)(:)(?=\s|$)/ do |m|
+        rule %r/([^#,:?\[\]{}"'\n]+)(:)(?=\s|$)/ do |m|
           groups Name::Attribute, Punctuation::Indicator
           set_indent m[0], :implicit => true
         end

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.26.0"
+    "3.27.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.26.0
+  version: 3.27.0
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-08 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -62,6 +62,7 @@ files:
 - lib/rouge/demos/cypher
 - lib/rouge/demos/cython
 - lib/rouge/demos/d
+- lib/rouge/demos/dafny
 - lib/rouge/demos/dart
 - lib/rouge/demos/datastudio
 - lib/rouge/demos/diff
@@ -290,6 +291,7 @@ files:
 - lib/rouge/lexers/cypher.rb
 - lib/rouge/lexers/cython.rb
 - lib/rouge/lexers/d.rb
+- lib/rouge/lexers/dafny.rb
 - lib/rouge/lexers/dart.rb
 - lib/rouge/lexers/datastudio.rb
 - lib/rouge/lexers/diff.rb
@@ -517,7 +519,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A pure-ruby colorizer based on pygments