Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package rubygem-rouge for openSUSE:Factory checked in at 2022-08-09 15:26:50 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-rouge (Old) and /work/SRC/openSUSE:Factory/.rubygem-rouge.new.1521 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-rouge" Tue Aug 9 15:26:50 2022 rev:19 rq:993517 version:3.30.0 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-rouge/rubygem-rouge.changes 2022-06-17 21:23:25.866803248 +0200 +++ /work/SRC/openSUSE:Factory/.rubygem-rouge.new.1521/rubygem-rouge.changes 2022-08-09 15:27:06.573412122 +0200 @@ -1,0 +2,6 @@ +Thu Aug 4 13:26:09 UTC 2022 - Stephan Kulow <[email protected]> + +updated to version 3.30.0 + no changelog found + +------------------------------------------------------------------- Old: ---- rouge-3.29.0.gem New: ---- rouge-3.30.0.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-rouge.spec ++++++ --- /var/tmp/diff_new_pack.gFOnUE/_old 2022-08-09 15:27:07.057413505 +0200 +++ /var/tmp/diff_new_pack.gFOnUE/_new 2022-08-09 15:27:07.065413528 +0200 @@ -24,7 +24,7 @@ # Name: rubygem-rouge -Version: 3.29.0 +Version: 3.30.0 Release: 0 %define mod_name rouge %define mod_full_name %{mod_name}-%{version} ++++++ rouge-3.29.0.gem -> rouge-3.30.0.gem ++++++ Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/cli.rb new/lib/rouge/cli.rb --- old/lib/rouge/cli.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/cli.rb 2022-07-30 06:58:28.000000000 +0200 @@ -174,35 +174,38 @@ 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, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/demos/isabelle new/lib/rouge/demos/isabelle --- old/lib/rouge/demos/isabelle 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/demos/isabelle 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/demos/meson new/lib/rouge/demos/meson --- old/lib/rouge/demos/meson 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/demos/meson 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/demos/nial new/lib/rouge/demos/nial --- old/lib/rouge/demos/nial 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/demos/nial 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/guessers/disambiguation.rb new/lib/rouge/guessers/disambiguation.rb --- old/lib/rouge/guessers/disambiguation.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/guessers/disambiguation.rb 2022-07-30 06:58:28.000000000 +0200 @@ -131,6 +131,13 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/apple_script.rb new/lib/rouge/lexers/apple_script.rb --- old/lib/rouge/lexers/apple_script.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/apple_script.rb 2022-07-30 06:58:28.000000000 +0200 @@ -5,7 +5,7 @@ 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' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/cpp.rb new/lib/rouge/lexers/cpp.rb --- old/lib/rouge/lexers/cpp.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/cpp.rb 2022-07-30 06:58:28.000000000 +0200 @@ -71,6 +71,7 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/dart.rb new/lib/rouge/lexers/dart.rb --- old/lib/rouge/lexers/dart.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/dart.rb 2022-07-30 06:58:28.000000000 +0200 @@ -61,7 +61,8 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/groovy.rb new/lib/rouge/lexers/groovy.rb --- old/lib/rouge/lexers/groovy.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/groovy.rb 2022-07-30 06:58:28.000000000 +0200 @@ -7,7 +7,7 @@ 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) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/isabelle.rb new/lib/rouge/lexers/isabelle.rb --- old/lib/rouge/lexers/isabelle.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/lexers/isabelle.rb 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/javascript.rb new/lib/rouge/lexers/javascript.rb --- old/lib/rouge/lexers/javascript.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/javascript.rb 2022-07-30 06:58:28.000000000 +0200 @@ -149,7 +149,7 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/meson.rb new/lib/rouge/lexers/meson.rb --- old/lib/rouge/lexers/meson.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/lexers/meson.rb 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/nial.rb new/lib/rouge/lexers/nial.rb --- old/lib/rouge/lexers/nial.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/rouge/lexers/nial.rb 2022-07-30 06:58:28.000000000 +0200 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/pascal.rb new/lib/rouge/lexers/pascal.rb --- old/lib/rouge/lexers/pascal.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/pascal.rb 2022-07-30 06:58:28.000000000 +0200 @@ -7,7 +7,7 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/php.rb new/lib/rouge/lexers/php.rb --- old/lib/rouge/lexers/php.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/php.rb 2022-07-30 06:58:28.000000000 +0200 @@ -39,12 +39,12 @@ 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 @@ 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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/lexers/toml.rb new/lib/rouge/lexers/toml.rb --- old/lib/rouge/lexers/toml.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/lexers/toml.rb 2022-07-30 06:58:28.000000000 +0200 @@ -28,9 +28,14 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/rouge/version.rb new/lib/rouge/version.rb --- old/lib/rouge/version.rb 2022-06-01 08:42:07.000000000 +0200 +++ new/lib/rouge/version.rb 2022-07-30 06:58:28.000000000 +0200 @@ -3,6 +3,6 @@ module Rouge def self.version - "3.29.0" + "3.30.0" end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2022-06-01 08:42:07.000000000 +0200 +++ new/metadata 2022-07-30 06:58:28.000000000 +0200 @@ -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 @@ - 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 @@ - 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 @@ - 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 @@ - 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 @@ - 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 @@ - 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 @@ 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 @@ 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: []
