rouge 3.29.0 → 3.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15e78361e4f2dde8ae802ffcd36cc0b1e8e9124c2bbe0d3182a767244047a9e0
-  data.tar.gz: 661838ffd5b8c6ff8ac894312293aa6c46b36abed76ccc8f0932358e6478c8b1
+  metadata.gz: acc37e14414bcaa3f67dda77f1b746f8035cfc972dc807610b4a1ef4fcffe848
+  data.tar.gz: 2380291e01345a7251f229dddf858d612f64d89f7ef93d7b75b2c44fa9a093a6
 SHA512:
-  metadata.gz: 21f210c421a0a0137d57f2c7fd3b3d931a1b481a276e6fe6eb296a5e1572ccb7ffd3912a8455e98c362b863ab52773b27c7d9135e2cddaa7b75b5fa324f4036e
-  data.tar.gz: 9bb3d495c856a8e790cc38736afb4e187b5b34fa8d1f0c1b99ff60af63cec60a9312ee4a69a642e31938dd4586647e224f311afdde6d343bcafa35b64110f2a3
+  metadata.gz: a4d60e1f37e66b4991b040ff82db8cc59983f37923a7f8b41a44a149407167467b443cd6ac8bb47f8800588e82301be1d58c14175bb1513a728952be21144ed8
+  data.tar.gz: 6f0e6ab3786ac315f0a2d658d02091bb3b8a0b6cd75ef3aac6dc2a116eee9dd5a45b1a4c9ef11f40f0f6338ae50d7c0f0b219e9ab20de950e4ae865f3824e002

data/lib/rouge/cli.rb

@@ -174,35 +174,38 @@ module Rouge
         yield %[usage: rougify highlight <filename> [options...]]
         yield %[       rougify highlight [options...]]
         yield %[]
-        yield %[--input-file|-i <filename>  specify a file to read, or - to use stdin]
+        yield %[--input-file|-i <filename>   specify a file to read, or - to use stdin]
         yield %[]
-        yield %[--lexer|-l <lexer>          specify the lexer to use.]
-        yield %[                            If not provided, rougify will try to guess]
-        yield %[                            based on --mimetype, the filename, and the]
-        yield %[                            file contents.]
+        yield %[--lexer|-l <lexer>           specify the lexer to use.]
+        yield %[                             If not provided, rougify will try to guess]
+        yield %[                             based on --mimetype, the filename, and the]
+        yield %[                             file contents.]
         yield %[]
-        yield %[--formatter|-f <opts>       specify the output formatter to use.]
-        yield %[                            If not provided, rougify will default to]
-        yield %[                            terminal256.]
+        yield %[--formatter-preset|-f <opts> specify the output formatter to use.]
+        yield %[                             If not provided, rougify will default to]
+        yield %[                             terminal256. options are: terminal256,]
+        yield %[                             terminal-truecolor, html, html-pygments,]
+        yield %[                             html-inline, html-line-table, html-table,]
+        yield %[                             null/raw/tokens, or tex.]
         yield %[]
-        yield %[--theme|-t <theme>          specify the theme to use for highlighting]
-        yield %[                            the file. (only applies to some formatters)]
+        yield %[--theme|-t <theme>           specify the theme to use for highlighting]
+        yield %[                             the file. (only applies to some formatters)]
         yield %[]
-        yield %[--mimetype|-m <mimetype>    specify a mimetype for lexer guessing]
+        yield %[--mimetype|-m <mimetype>     specify a mimetype for lexer guessing]
         yield %[]
-        yield %[--lexer-opts|-L <opts>      specify lexer options in CGI format]
-        yield %[                            (opt1=val1&opt2=val2)]
+        yield %[--lexer-opts|-L <opts>       specify lexer options in CGI format]
+        yield %[                             (opt1=val1&opt2=val2)]
         yield %[]
-        yield %[--formatter-opts|-F <opts>  specify formatter options in CGI format]
-        yield %[                            (opt1=val1&opt2=val2)]
+        yield %[--formatter-opts|-F <opts>   specify formatter options in CGI format]
+        yield %[                             (opt1=val1&opt2=val2)]
         yield %[]
-        yield %[--require|-r <filename>     require a filename or library before]
-        yield %[                            highlighting]
+        yield %[--require|-r <filename>      require a filename or library before]
+        yield %[                             highlighting]
         yield %[]
-        yield %[--escape                    allow the use of escapes between <! and !>]
+        yield %[--escape                     allow the use of escapes between <! and !>]
         yield %[]
-        yield %[--escape-with <l> <r>       allow the use of escapes between custom]
-        yield %[                            delimiters. implies --escape]
+        yield %[--escape-with <l> <r>        allow the use of escapes between custom]
+        yield %[                             delimiters. implies --escape]
       end
 
       # There is no consistent way to do this, but this is used elsewhere,

data/lib/rouge/demos/isabelle

@@ -0,0 +1,16 @@
+theory demo imports Main begin
+
+section ‹Inductive predicates for lists›
+
+datatype 'a list = Nil ("[]") | Cons 'a "'a list" ("_ # _")
+
+fun length :: "'a list ⇒ nat" where
+  "length [] = 0" | "length (x # xs) = 1 + length xs"
+
+inductive ζ :: "'a list ⇒ nat ⇒ bool" where
+Nil[intro!]:  "ζ [] 0" |
+Cons[intro]: "ζ xs l ⟹ ζ (x # xs) (1 + l)"
+
+(* Not the answer? *)
+lemma "ζ xs 42"
+  oops

data/lib/rouge/demos/meson

@@ -0,0 +1,10 @@
+project('tutorial', 'c', version: '0.2.3')
+executable('demo', 'main.c')
+
+version_array = meson.project_version().split('.')
+api_version = '@0@.@1@'.format(version_array[0], version_array[1])
+
+d = dependency('foo', required : get_option('myfeature'))
+if d.found()
+  app = executable('app', 'app.c', dependencies : [d])
+endif

data/lib/rouge/demos/nial

@@ -0,0 +1,35 @@
+% Functional Recursion: ;
+fact IS RECUR [ 0 =, 1 first, pass, product, -1 +] % from wikipedia; 
+ 
+% Product of a range: ; 
+fact IS * count;
+
+% Plain recursion: ;
+fact IS OPERATION x {
+  if x = 0 then 1 else x * fact (x - 1) endif
+  };
+
+% While loop: ;
+fact IS OPERATION x {
+prod := 1;
+  WHILE x > 0 DO
+      prod := prod * x;
+      x := x - 1;
+  ENDWHILE;
+  prod
+}
+
+     % A basic divide by zero error: ;
+     1 / 0
+# OUTPUT:
+?div
+
+     % Errors are also values called faults, giving you their location: ;
+     5 / 5 10 0 8
+# OUTPUT:
+1. 0.5 ?div 0.625
+
+     % You can also define custom faults using 'fault': ;
+     fault 'this is an error'
+# OUTPUT:
+this is an error

data/lib/rouge/guessers/disambiguation.rb

@@ -131,6 +131,13 @@ module Rouge
         next TeX if matches?(/\A\s*(?:\\|%)/)
         next Apex
       end
+
+      disambiguate '*.pp' do
+        next Pascal if matches?(/\b(function|begin|var)\b/)
+        next Pascal if matches?(/\b(end(;|\.))/)
+
+        Puppet
+      end
     end
   end
 end

data/lib/rouge/lexers/apple_script.rb

@@ -5,7 +5,7 @@ module Rouge
   module Lexers
     class AppleScript < RegexLexer
       title "AppleScript"
-      desc "The AppleScript scripting language by Apple Inc. (http://developer.apple.com/applescript/)"
+      desc "The AppleScript scripting language by Apple Inc. (https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html)"
 
       tag 'applescript'
       aliases 'applescript'

data/lib/rouge/lexers/cpp.rb

@@ -71,6 +71,7 @@ module Rouge
         rule %r/\bnullptr\b/, Name::Builtin
         rule %r/(?:u8|u|U|L)?R"([a-zA-Z0-9_{}\[\]#<>%:;.?*\+\-\/\^&|~!=,"']{,16})\(.*?\)\1"/m, Str
         rule %r/(::|<=>)/, Operator
+        rule %r/[{}]/, Punctuation
       end
 
       state :classname do

data/lib/rouge/lexers/dart.rb

@@ -61,7 +61,8 @@ module Rouge
 
         rule %r/#{id}:/, Name::Label
         rule %r/\$?#{id}/, Name
-        rule %r/[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule %r/[~^*!%&\|+=:\/?-]/, Operator
+        rule %r/[\[\](){}<>\.,;]/, Punctuation
         rule %r/\d*\.\d+([eE]\-?\d+)?/, Num::Float
         rule %r/0x[\da-fA-F]+/, Num::Hex
         rule %r/\d+L?/, Num::Integer

data/lib/rouge/lexers/groovy.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Groovy"
       desc 'The Groovy programming language (http://www.groovy-lang.org/)'
       tag 'groovy'
-      filenames '*.groovy', 'Jenkinsfile'
+      filenames '*.groovy', 'Jenkinsfile', '*.Jenkinsfile'
       mimetypes 'text/x-groovy'
 
       def self.detect?(text)

data/lib/rouge/lexers/isabelle.rb

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+# Lexer adapted from https://github.com/pygments/pygments/blob/ad55974ce83b85dbb333ab57764415ab84169461/pygments/lexers/theorem.py
+
+module Rouge
+  module Lexers
+    class Isabelle < RegexLexer
+      title "Isabelle"
+      desc 'Isabelle theories (isabelle.in.tum.de)'
+      tag 'isabelle'
+      aliases 'isa', 'Isabelle'
+      filenames '*.thy'
+      mimetypes 'text/x-isabelle'
+
+      def self.keyword_minor
+        @keyword_minor ||= Set.new %w(
+          and assumes attach avoids binder checking
+          class_instance class_relation code_module congs
+          constant constrains datatypes defines file fixes
+          for functions hints identifier if imports in
+          includes infix infixl infixr is keywords lazy
+          module_name monos morphisms no_discs_sels notes
+          obtains open output overloaded parametric permissive
+          pervasive rep_compat shows structure type_class
+          type_constructor unchecked unsafe where
+        )
+      end
+
+      def self.keyword_diag
+        @keyword_diag ||= Set.new %w(
+          ML_command ML_val class_deps code_deps code_thms
+          display_drafts find_consts find_theorems find_unused_assms
+          full_prf help locale_deps nitpick pr prf
+          print_abbrevs print_antiquotations print_attributes
+          print_binds print_bnfs print_bundles
+          print_case_translations print_cases print_claset
+          print_classes print_codeproc print_codesetup
+          print_coercions print_commands print_context
+          print_defn_rules print_dependencies print_facts
+          print_induct_rules print_inductives print_interps
+          print_locale print_locales print_methods print_options
+          print_orders print_quot_maps print_quotconsts
+          print_quotients print_quotientsQ3 print_quotmapsQ3
+          print_rules print_simpset print_state print_statement
+          print_syntax print_theorems print_theory print_trans_rules
+          prop pwd quickcheck refute sledgehammer smt_status
+          solve_direct spark_status term thm thm_deps thy_deps
+          try try0 typ unused_thms value values welcome
+          print_ML_antiquotations print_term_bindings values_prolog
+        )
+      end
+
+      def self.keyword_thy
+        @keyword_thy ||= Set.new %w(theory begin end)
+      end
+
+      def self.keyword_section
+        @keyword_section ||= Set.new %w(header chapter)
+      end
+
+      def self.keyword_subsection
+        @keyword_subsection ||= Set.new %w(section subsection subsubsection sect subsect subsubsect)
+      end
+
+      def self.keyword_theory_decl
+        @keyword_theory_decl ||= Set.new %w(
+          ML ML_file abbreviation adhoc_overloading arities
+          atom_decl attribute_setup axiomatization bundle
+          case_of_simps class classes classrel codatatype
+          code_abort code_class code_const code_datatype
+          code_identifier code_include code_instance code_modulename
+          code_monad code_printing code_reflect code_reserved
+          code_type coinductive coinductive_set consts context
+          datatype datatype_new datatype_new_compat declaration
+          declare default_sort defer_recdef definition defs
+          domain domain_isomorphism domaindef equivariance
+          export_code extract extract_type fixrec fun
+          fun_cases hide_class hide_const hide_fact hide_type
+          import_const_map import_file import_tptp import_type_map
+          inductive inductive_set instantiation judgment lemmas
+          lifting_forget lifting_update local_setup locale
+          method_setup nitpick_params no_adhoc_overloading
+          no_notation no_syntax no_translations no_type_notation
+          nominal_datatype nonterminal notation notepad oracle
+          overloading parse_ast_translation parse_translation
+          partial_function primcorec primrec primrec_new
+          print_ast_translation print_translation quickcheck_generator
+          quickcheck_params realizability realizers recdef record
+          refute_params setup setup_lifting simproc_setup
+          simps_of_case sledgehammer_params spark_end spark_open
+          spark_open_siv spark_open_vcg spark_proof_functions
+          spark_types statespace syntax syntax_declaration text
+          text_raw theorems translations type_notation
+          type_synonym typed_print_translation typedecl hoarestate
+          install_C_file install_C_types wpc_setup c_defs c_types
+          memsafe SML_export SML_file SML_import approximate
+          bnf_axiomatization cartouche datatype_compat
+          free_constructors functor nominal_function
+          nominal_termination permanent_interpretation
+          binds defining smt2_status term_cartouche
+          boogie_file text_cartouche
+        )
+      end
+
+      def self.keyword_theory_script
+        @keyword_theory_script ||= Set.new %w(inductive_cases inductive_simps)
+      end
+
+      def self.keyword_theory_goal
+        @keyword_theory_goal ||= Set.new %w(
+          ax_specification bnf code_pred corollary cpodef
+          crunch crunch_ignore
+          enriched_type function instance interpretation lemma
+          lift_definition nominal_inductive nominal_inductive2
+          nominal_primrec pcpodef primcorecursive
+          quotient_definition quotient_type recdef_tc rep_datatype
+          schematic_corollary schematic_lemma schematic_theorem
+          spark_vc specification subclass sublocale termination
+          theorem typedef wrap_free_constructors
+        )
+      end
+
+      def self.keyword_qed
+        @keyword_qed ||= Set.new %w(by done qed)
+      end
+
+      def self.keyword_abandon_proof
+        @keyword_abandon_proof ||= Set.new %w(sorry oops)
+      end
+
+      def self.keyword_proof_goal
+        @keyword_proof_goal ||= Set.new %w(have hence interpret)
+      end
+
+      def self.keyword_proof_block
+        @keyword_proof_block ||= Set.new %w(next proof)
+      end
+
+      def self.keyword_proof_chain
+        @keyword_proof_chain ||= Set.new %w(finally from then ultimately with)
+      end
+
+      def self.keyword_proof_decl
+        @keyword_proof_decl ||= Set.new %w(
+          ML_prf also include including let moreover note
+          txt txt_raw unfolding using write
+        )
+      end
+
+      def self.keyword_proof_asm
+        @keyword_proof_asm ||= Set.new %w(assume case def fix presume)
+      end
+
+      def self.keyword_proof_asm_goal
+        @keyword_proof_asm_goal ||= Set.new %w(guess obtain show thus)
+      end
+
+      def self.keyword_proof_script
+        @keyword_proof_script ||= Set.new %w(apply apply_end apply_trace back defer prefer)
+      end
+
+      state :root do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\{\*|‹/, Text, :text
+
+        rule %r/::|\[|\]|-|[:()_=,|+!?]/, Operator
+        rule %r/[{}.]|\.\./, Operator::Word
+
+        def word(keywords)
+          return %r/\b(#{keywords.join('|')})\b/
+        end
+
+        rule %r/[a-zA-Z]\w*/ do |m|
+          sym = m[0]
+
+          if self.class.keyword_minor.include?(sym) ||
+            self.class.keyword_proof_script.include?(sym)
+            token Keyword::Pseudo
+          elsif self.class.keyword_diag.include?(sym)
+            token Keyword::Type
+          elsif self.class.keyword_thy.include?(sym) ||
+            self.class.keyword_theory_decl.include?(sym) ||
+            self.class.keyword_qed.include?(sym) ||
+            self.class.keyword_proof_goal.include?(sym) ||
+            self.class.keyword_proof_block.include?(sym) ||
+            self.class.keyword_proof_decl.include?(sym) ||
+            self.class.keyword_proof_chain.include?(sym) ||
+            self.class.keyword_proof_asm.include?(sym) ||
+            self.class.keyword_proof_asm_goal.include?(sym)
+            token Keyword
+          elsif self.class.keyword_section.include?(sym)
+            token Generic::Heading
+          elsif self.class.keyword_subsection.include?(sym)
+            token Generic::Subheading
+          elsif self.class.keyword_theory_goal.include?(sym) ||
+            self.class.keyword_theory_script.include?(sym)
+            token Keyword::Namespace
+          elsif self.class.keyword_abandon_proof.include?(sym)
+            token Generic::Error
+          else
+            token Name
+          end
+        end
+
+        rule %r/\\<\w*>/, Str::Symbol
+
+        rule %r/'[^\W\d][.\w']*/, Name::Variable
+
+        rule %r/0[xX][\da-fA-F][\da-fA-F_]*/, Num::Hex
+        rule %r/0[oO][0-7][0-7_]*/, Num::Oct
+        rule %r/0[bB][01][01_]*/, Num::Bin
+
+        rule %r/"/, Str, :string
+        rule %r/`/, Str::Other, :fact
+        # Everything except for (most) operators whitespaces may be name
+        rule %r/[^\s:|\[\]\-()=,+!?{}._][^\s:|\[\]\-()=,+!?{}]*/, Name
+      end
+
+      state :comment do
+        rule %r/[^(*)]+/, Comment
+        rule %r/\(\*/, Comment, :comment
+        rule %r/\*\)/, Comment, :pop!
+        rule %r/[(*)]/, Comment
+      end
+
+      state :text do
+        rule %r/[^{*}‹›]+/, Text
+        rule %r/\{\*|‹/, Text, :text
+        rule %r/\*\}|›/, Text, :pop!
+        rule %r/[{*}]/, Text
+      end
+
+      state :string do
+        rule %r/[^"\\]+/, Str
+        rule %r/\\<\w*>/, Str::Symbol
+        rule %r/\\"/, Str
+        rule %r/\\/, Str
+        rule %r/"/, Str, :pop!
+      end
+
+      state :fact do
+        rule %r/[^`\\]+/, Str::Other
+        rule %r/\\<\w*>/, Str::Symbol
+        rule %r/\\`/, Str::Other
+        rule %r/\\/, Str::Other
+        rule %r/`/, Str::Other, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/javascript.rb

@@ -149,7 +149,7 @@ module Rouge
         rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
         rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
         mixin :comments_and_whitespace
-        rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
+        rule %r(\+\+ | -- | ~ | \?\?=? | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
           Operator, :expr_start
         rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start

data/lib/rouge/lexers/meson.rb

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Meson < RegexLexer
+      title "Meson"
+      desc "Meson's specification language (mesonbuild.com)"
+      tag 'meson'
+      filenames 'meson.build', 'meson_options.txt'
+      mimetypes 'text/x-meson'
+
+      def self.keywords
+        @keywords ||= %w(
+          continue break elif else endif
+          if true false foreach endforeach
+        )
+      end
+
+      def self.builtin_variables
+        @builtin_variables ||= %w(
+          meson host_machine build_machine target_machine
+        )
+      end
+    
+      def self.builtin_functions
+        @builtin_functions ||= %w(
+          add_global_arguments add_project_arguments
+          add_global_link_arguments add_project_link_arguments add_test_setup add_languages
+          alias_target assert benchmark both_libraries build_target configuration_data configure_file
+          custom_target declare_dependency dependency disabler environment error executable
+          generator gettext get_option get_variable files find_library find_program
+          include_directories import install_data install_headers install_man install_subdir
+          is_disabler is_variable jar join_paths library message option project
+          run_target run_command set_variable subdir subdir_done
+          subproject summary shared_library shared_module static_library test vcs_tag warning
+        )
+      end
+
+      identifier =        /[[:alpha:]_][[:alnum:]_]*/
+      dotted_identifier = /[[:alpha:]_.][[:alnum:]_.]*/
+
+      def current_string
+        @current_string ||= StringRegister.new
+      end
+
+      state :root do
+        rule %r/\n+/m, Text
+
+        rule %r/[^\S\n]+/, Text
+        rule %r(#(.*)?\n?), Comment::Single
+        rule %r/[\[\]{}:(),;.]/, Punctuation
+        rule %r/\\\n/, Text
+        rule %r/\\/, Text
+
+        rule %r/(in|and|or|not)\b/, Operator::Word
+        rule %r/[-+\/*%=<>]=?|!=/, Operator
+
+        rule %r/([f]?)('''|['])/i do |m|
+          groups Str::Affix, Str
+          current_string.register type: m[1].downcase, delim: m[2]
+          push :generic_string
+        end
+
+        rule %r/(?<!\.)#{identifier}\b\s*(?=\()/ do  |m|
+          if self.class.builtin_functions.include? m[0]
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule %r/(?<!\.)#{identifier}(?!\s*?:)/ do |m|
+          if self.class.builtin_variables.include? m[0]
+            token Name::Builtin
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+
+        rule %r/0b(_?[0-1])+/i, Num::Bin
+        rule %r/0o(_?[0-7])+/i, Num::Oct
+        rule %r/0x(_?[a-f0-9])+/i, Num::Hex
+        rule %r/([1-9](_?[0-9])*|0(_?0)*)/, Num::Integer
+      end
+
+      state :generic_string do
+        rule %r/[^'\\\@]+/, Str
+
+        rule %r/'''|[']/ do |m|
+          token Str
+          if current_string.delim? m[0]
+            current_string.remove
+            pop!
+          end
+        end
+
+        rule %r/(?=\\)/, Str, :generic_escape
+
+        rule %r/\@/ do |m|
+          if current_string.type? "f"
+            token Str::Interpol
+            push :generic_interpol
+          else
+            token Str
+          end
+        end
+      end
+
+      state :generic_escape do
+        rule %r(\\
+          ( [\\abfnrtv']
+          | N{[a-zA-Z][a-zA-Z ]+[a-zA-Z]}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x do
+          token(Str::Escape)
+          pop!
+        end
+
+        rule %r/\\./, Str, :pop!
+      end
+
+      state :generic_interpol do
+        rule %r/[^\@]+/ do |m|
+          recurse m[0]
+        end
+        rule %r/\@/, Str::Interpol, :pop!
+      end
+
+      class StringRegister < Array
+        def delim?(delim)
+          self.last[1] == delim
+        end
+
+        def register(type: "u", delim: "'")
+          self.push [type, delim]
+        end
+
+        def remove
+          self.pop
+        end
+
+        def type?(type)
+          self.last[0].include? type
+        end
+      end
+
+      private_constant :StringRegister
+    end
+  end
+end

data/lib/rouge/lexers/nial.rb

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Nial < RegexLexer
+      title 'Nial'
+      desc 'The Nial programming language (nial-array-language.org)'
+      tag 'nial'
+      filenames '*.ndf', '*.nlg'
+      
+      def self.keywords
+        @keywords ||= Set.new ["is", "gets", "op", "tr", ";",
+                     "if", "then", "elseif", "else",
+                     "endif", "case", "from", "endcase",
+                     "begin", "end", "for", "with",
+                     "endfor", "while", "do", "endwhile",
+                     "repeat", "until", "endrepeat"]
+      end
+
+      def self.operators
+        @operators||= Set.new [".",  "!", "#", "+", "*", "-", "<<",
+                 "/", "<", ">>", "<=", ">", "=", ">=", "@", "|", "~="]
+      end
+
+      def self.punctuations
+        @punctuations ||= Set.new [ "{", "}", "[", "]", ",", "(", ")", ":=", ":", ";"]
+      end
+
+      def self.transformers
+        @transformers ||= Set.new ["accumulate", "across",
+        "bycols", "bykey",  "byrows",
+        "converse",  "down",
+        "eachboth", "eachall", "each",
+        "eachleft", "eachright",
+        "filter", "fold", "fork",
+        "grade",  "inner", "iterate",
+        "leaf",  "no_tr", "outer",
+        "partition", "rank", "recur",
+        "reduce", "reducecols", "reducerows",
+        "sort", "team", "timeit", "twig"]
+      end
+      
+      def self.funcs
+        @funcs ||= Set.new ["operation", "expression", "and", "abs",
+                  "allbools", "allints", "allchars", "allin",
+                  "allreals", "allnumeric", "append",
+                  "arcsin", "arccos", "appendfile", "apply",
+                  "arctan", "atomic", "assign", "atversion",
+                  "axes", "cart", "break", "blend", "breaklist",
+                  "breakin", "bye", "callstack", "choose", "char",
+                  "ceiling", "catenate", "charrep", "check_socket",
+                  "cos", "content", "close", "clearws",
+                  "clearprofile", "cols", "continue", "copyright",
+                  "cosh", "cull", "count", "diverse", "deepplace",
+                  "cutall", "cut", "display", "deparse",
+                  "deepupdate", "descan", "depth", "diagram",
+                  "div", "divide", "drop", "dropright", "edit",
+                  "empty", "expression", "exit", "except", "erase",
+                  "equal", "eval", "eraserecord", "execute", "exp",
+                  "external", "exprs", "findall", "find", 
+                  "fault", "falsehood", "filestatus", "filelength",
+                  "filepath", "filetally", "floor", "first",
+                  "flip", "fuse", "fromraw", "front",
+                  "gage", "getfile", "getdef", "getcommandline",
+                  "getenv", "getname", "hitch", "grid", "getsyms",
+                  "gradeup", "gt", "gte", "host", "in", "inverse",
+                  "innerproduct", "inv", "ip", "ln", "link", "isboolean",
+                  "isinteger", "ischar", "isfault", "isreal", "isphrase",
+                  "isstring", "istruthvalue", "last", "laminate",
+                  "like", "libpath", "library", "list", "load",
+                  "loaddefs", "nonlocal", "max", "match", "log",
+                  "lt", "lower", "lte", "mate", "min", "maxlength",
+                  "mod", "mix", "minus", "nialroot", "mold", "not",
+                  "numeric", "no_op", "no_expr", "notin",
+                  "operation", "open", "or", "opposite", "opp",
+                  "operators", "plus", "pick", "pack", "pass", "pair", "parse",
+                  "paste", "phrase", "place", "picture", "placeall",
+                  "power", "positions", "post", "quotient", "putfile",
+                  "profile", "prod", "product", "profiletree",
+                  "profiletable", "quiet_fault", "raise", "reach",
+                  "random", "reciprocal", "read", "readfile",
+                  "readchar", "readarray", "readfield",
+                  "readscreen", "readrecord", "recip", "reshape",
+                  "seek", "second", "rest", "reverse", "restart",
+                  "return_status", "scan", "save", "rows", "rotate",
+                  "seed", "see", "sublist", "sin", "simple", "shape",
+                  "setformat", "setdeftrace", "set", "seeusercalls",
+                  "seeprimcalls", "separator", "setwidth", "settrigger",
+                  "setmessages", "setlogname", "setinterrupts",
+                  "setprompt", "setprofile", "sinh", "single",
+                  "sqrt", "solitary", "sketch", "sleep",
+                  "socket_listen", "socket_accept", "socket_close",
+                  "socket_bind", "socket_connect", "socket_getline",
+                  "socket_receive", "socket_peek", "socket_read",
+                  "socket_send", "socket_write", "solve", "split",
+                  "sortup", "string", "status", "take", "symbols",
+                  "sum", "system", "tan", "tally", "takeright",
+                  "tanh", "tell", "tr", "times", "third", "time",
+                  "toupper", "tolower", "timestamp", "tonumber",
+                  "toraw", "toplevel", "transformer", "type",
+                  "transpose", "trs", "truth", "unequal",
+                  "variable", "valence", "up", "updateall",
+                  "update", "vacate", "value", "version", "vars",
+                  "void", "watch", "watchlist", "write", "writechars",
+                  "writearray", "writefile", "writefield",
+                  "writescreen", "writerecord"]
+      end
+
+      def self.consts
+        @consts ||= Set.new %w(false null pi true)
+      end
+
+      state :root do
+        rule %r/'/, Str::Single, :str
+        rule %r/\b[lo]+\b/, Num::Bin
+        rule %r/-?\d+((\.\d*)?[eE][+-]?\d|\.)\d*/, Num::Float
+        rule %r/\-?\d+/, Num::Integer
+        rule %r/`./, Str::Char
+        rule %r/"[^\s()\[\]{}#,;]*/, Str::Symbol
+        rule %r/\?[^\s()\[\]{}#,;]*/, Generic::Error
+        rule %r/%[^;]+;/, Comment::Multiline
+        rule %r/^#(.+\n)+\n/, Comment::Multiline
+        rule %r/:=|[\{\}\[\]\(\),:;]/ do |m|
+          if self.class.punctuations.include?(m[0])
+            token Punctuation
+          else
+            token Text
+          end
+        end
+        # [".",  "!", "#", "+", "*", "-", "<<",
+        #   "/", "<", ">>", "<=", ">", "=", ">=", "@", "|", "~="]
+        rule %r'>>|>=|<=|~=|[\.!#+*\-=></|@]' do |m|
+          if self.class.operators.include?(m[0])
+            token Operator
+          else
+            token Text
+          end
+        end
+        
+        rule %r/\b[_A-Za-z]\w*\b/ do |m|
+          lower = m[0].downcase
+          if self.class.keywords.include?(lower)
+            token Keyword
+          elsif self.class.funcs.include?(lower)
+            token Keyword::Pseudo
+          elsif self.class.transformers.include?(lower)
+            token Name::Builtin
+          elsif self.class.consts.include?(lower)
+            token Keyword::Constant
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r/\s+/, Text
+      end
+      
+      state :str do
+        rule %r/''/, Str::Escape
+        rule %r/[^']+/, Str::Single
+        rule %r/'|$/, Str::Single, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/pascal.rb

@@ -7,7 +7,7 @@ module Rouge
       tag 'pascal'
       title "Pascal"
       desc 'a procedural programming language commonly used as a teaching language.'
-      filenames '*.pas', '*.lpr'
+      filenames '*.pas', '*.lpr', '*.pp'
 
       mimetypes 'text/x-pascal'
 
@@ -55,6 +55,7 @@ module Rouge
         mixin :whitespace
 
         rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
+        rule %r/\$[0-9A-Fa-f]+/, Num::Hex
         rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
         rule %r{'([^']|'')*'}, Str
         rule %r/(true|false|nil)\b/i, Name::Builtin

data/lib/rouge/lexers/php.rb

@@ -39,12 +39,12 @@ module Rouge
           old_function cfunction
           __class__ __dir__ __file__ __function__ __halt_compiler __line__
           __method__ __namespace__ __trait__ abstract and array as break case
-          catch clone continue declare default die do echo else elseif
+          catch clone continue declare default die do echo else elseif empty
           enddeclare endfor endforeach endif endswitch endwhile eval exit
           extends final finally fn for foreach global goto if implements
-          include include_once instanceof insteadof isset list new or parent
-          print private protected public require require_once return self
-          static switch throw try var while xor yield
+          include include_once instanceof insteadof isset list match new or
+          parent print private protected public readonly require require_once
+          return self static switch throw try unset var while xor yield
         )
       end
 
@@ -305,6 +305,7 @@ module Rouge
         rule %r/,/, Punctuation
         rule %r/[.]{3}/, Punctuation
         rule %r/=/, Operator, :in_assign
+        rule %r/\b(?:public|protected|private|readonly)\b/i, Keyword
         rule %r/\??#{id}/, Keyword::Type, :in_assign
         mixin :escape
         mixin :whitespace
@@ -366,7 +367,8 @@ module Rouge
       end
 
       state :in_visibility do
-        rule %r/(?=(abstract|const|function|static)\b)/i, Keyword, :pop!
+        rule %r/\b(?:readonly|static)\b/i, Keyword
+        rule %r/(?=(abstract|const|function)\b)/i, Keyword, :pop!
         rule %r/\??#{id}/, Keyword::Type, :pop!
         mixin :escape
         mixin :whitespace

data/lib/rouge/lexers/toml.rb

@@ -28,9 +28,14 @@ module Rouge
 
         rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
 
-        rule %r/(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?/, Num::Float
-        rule %r/\d+[eE][+-]?[0-9]+j?/, Num::Float
-        rule %r/\-?\d+/, Num::Integer
+        rule %r/[+-]?\d+(?:_\d+)*\.\d+(?:_\d+)*(?:[eE][+-]?\d+(?:_\d+)*)?/, Num::Float
+        rule %r/[+-]?\d+(?:_\d+)*[eE][+-]?\d+(?:_\d+)*/, Num::Float
+        rule %r/[+-]?(?:nan|inf)/, Num::Float
+
+        rule %r/0x\h+(?:_\h+)*/, Num::Hex
+        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r/[+-]?\d+(?:_\d+)*/, Num::Integer
       end
 
       state :root do

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.29.0"
+    "3.30.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.29.0
+  version: 3.30.0
 platform: ruby
 authors:
 - Jeanine Adkisson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-07-30 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -112,6 +112,7 @@ files:
 - lib/rouge/demos/io
 - lib/rouge/demos/irb
 - lib/rouge/demos/irb_output
+- lib/rouge/demos/isabelle
 - lib/rouge/demos/isbl
 - lib/rouge/demos/j
 - lib/rouge/demos/janet
@@ -143,6 +144,7 @@ files:
 - lib/rouge/demos/mason
 - lib/rouge/demos/mathematica
 - lib/rouge/demos/matlab
+- lib/rouge/demos/meson
 - lib/rouge/demos/minizinc
 - lib/rouge/demos/moonscript
 - lib/rouge/demos/mosel
@@ -151,6 +153,7 @@ files:
 - lib/rouge/demos/nasm
 - lib/rouge/demos/nesasm
 - lib/rouge/demos/nginx
+- lib/rouge/demos/nial
 - lib/rouge/demos/nim
 - lib/rouge/demos/nix
 - lib/rouge/demos/objective_c
@@ -349,6 +352,7 @@ files:
 - lib/rouge/lexers/ini.rb
 - lib/rouge/lexers/io.rb
 - lib/rouge/lexers/irb.rb
+- lib/rouge/lexers/isabelle.rb
 - lib/rouge/lexers/isbl.rb
 - lib/rouge/lexers/isbl/builtins.rb
 - lib/rouge/lexers/j.rb
@@ -387,6 +391,7 @@ files:
 - lib/rouge/lexers/matlab.rb
 - lib/rouge/lexers/matlab/builtins.rb
 - lib/rouge/lexers/matlab/keywords.rb
+- lib/rouge/lexers/meson.rb
 - lib/rouge/lexers/minizinc.rb
 - lib/rouge/lexers/moonscript.rb
 - lib/rouge/lexers/mosel.rb
@@ -395,6 +400,7 @@ files:
 - lib/rouge/lexers/nasm.rb
 - lib/rouge/lexers/nesasm.rb
 - lib/rouge/lexers/nginx.rb
+- lib/rouge/lexers/nial.rb
 - lib/rouge/lexers/nim.rb
 - lib/rouge/lexers/nix.rb
 - lib/rouge/lexers/objective_c.rb
@@ -520,7 +526,7 @@ metadata:
   changelog_uri: https://github.com/rouge-ruby/rouge/blob/master/CHANGELOG.md
   documentation_uri: https://rouge-ruby.github.io/docs/
   source_code_uri: https://github.com/rouge-ruby/rouge
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -536,7 +542,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A pure-ruby colorizer based on pygments
 test_files: []