aspera-cli 4.24.0 → 4.24.1

data/lib/aspera/cli/main.rb

@@ -378,7 +378,7 @@ module Aspera
           :invalid_characters, 'Replacement character and invalid filename characters',
           handler: {o: Environment.instance, m: :file_illegal_characters}
         )
-        @context.options.declare(:log_level, 'Log level', values: Log.levels, handler: {o: Log.instance, m: :level})
+        @context.options.declare(:log_level, 'Log level', values: Log::LEVELS, handler: {o: Log.instance, m: :level})
         @context.options.declare(:log_format, 'Log formatter', types: [Proc, Logger::Formatter, String], handler: {o: Log.instance, m: :formatter})
         @context.options.declare(:logger, 'Logging method', values: Log::LOG_TYPES, handler: {o: Log.instance, m: :logger_type})
         @context.options.declare(:lock_port, 'Prevent dual execution of a command, e.g. in cron', coerce: Integer, types: Integer)

data/lib/aspera/cli/plugins/config.rb

@@ -473,6 +473,19 @@ module Aspera
           return result
         end
 
+        def defaults_set(plugin_name, preset_name, preset_values, option_default, option_override)
+          @config_presets[CONF_PRESET_DEFAULTS] ||= {}
+          raise Cli::Error, "A default configuration already exists for plugin '#{plugin_name}' (use --override=yes or --default=no)" \
+            if !option_override && option_default && @config_presets[CONF_PRESET_DEFAULTS].key?(plugin_name)
+          raise Cli::Error, "Preset already exists: #{preset_name}  (use --override=yes or provide alternate name on command line)" \
+            if !option_override && @config_presets.key?(preset_name)
+          if option_default
+            formatter.display_status("Setting config preset as default for #{plugin_name}")
+            @config_presets[CONF_PRESET_DEFAULTS][plugin_name.to_s] = preset_name
+          end
+          @config_presets[preset_name] = preset_values
+        end
+
         def set_preset_key(preset, param_name, param_value)
           Aspera.assert_values(param_name.class, [String, Symbol]){'parameter'}
           param_name = param_name.to_s
@@ -505,9 +518,9 @@ module Aspera
         attr_reader :gem_url
         attr_accessor :option_config_file
 
-        # @return the hash from name (also expands possible includes)
         # @param config_name name of the preset in config file
         # @param include_path used to detect and avoid include loops
+        # @return copy of the hash from name (also expands possible includes)
         def preset_by_name(config_name, include_path = [])
           raise Cli::Error, 'loop in include' if include_path.include?(config_name)
           include_path = include_path.clone # avoid messing up if there are multiple branches

data/lib/aspera/cli/plugins/faspex5.rb

@@ -113,13 +113,13 @@ module Aspera
             raise "Username shall be an email in Faspex: #{wiz_username}" if !(wiz_username =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i)
             if options.get_option(:client_id).nil? || options.get_option(:client_secret).nil?
               formatter.display_status('Ask the ascli client id and secret to your Administrator.'.red)
-              formatter.display_status("Admin should login to: #{instance_url}")
+              formatter.display_status("Log in as an admin user at: #{instance_url}")
               Environment.instance.open_uri(instance_url)
               formatter.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
               formatter.display_status('Create an API client with:')
               formatter.display_status('- name: ascli')
               formatter.display_status('- JWT: enabled')
-              formatter.display_status("Then, logged in as #{wiz_username.red} go to your profile:")
+              formatter.display_status("Log in as user #{wiz_username.red}. Navigate to your profile:")
               formatter.display_status('👤 → Account Settings → Preferences → Public Key in PEM:')
               formatter.display_status(pub_key_pem)
               formatter.display_status('Once set, fill in the parameters:')

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # for beta add extension : .beta1
     # for dev version add extension : .pre
-    VERSION = '4.24.0'
+    VERSION = '4.24.1'
   end
 end

data/lib/aspera/cli/wizard.rb

@@ -28,6 +28,10 @@ module Aspera
         @parent.formatter
       end
 
+      def config
+        @parent.config
+      end
+
       # Find a plugin, and issue the "require"
       # @return [Hash] plugin info: { product:, name:, url:, version: }
       def identify_plugins_for_url
@@ -68,6 +72,8 @@ module Aspera
         return found_apps
       end
 
+      # Wizard function, creates configuration
+      # @param apps [Array] list of detected apps
       def find(apps)
         identification = if apps.length.eql?(1)
           Log.log.debug{"Detected: #{identification}"}
@@ -101,7 +107,7 @@ module Aspera
           private_key_path = options.get_option(:key_path)
           # give a chance to provide
           if private_key_path.nil?
-            formatter.display_status('Please provide the path to your private RSA key, or nothing to generate one:')
+            formatter.display_status('Path to private RSA key (leave empty to generate):')
             private_key_path = options.get_option(:key_path, mandatory: true).to_s
           end
           # else generate path
@@ -138,20 +144,11 @@ module Aspera
         # Write configuration file
         formatter.display_status("Preparing preset: #{wiz_preset_name}")
         # init defaults if necessary
-        @config_presets[CONF_PRESET_DEFAULTS] ||= {}
         option_override = options.get_option(:override, mandatory: true)
-        raise Cli::Error, "A default configuration already exists for plugin '#{identification[:product]}' (use --override=yes or --default=no)" \
-          if !option_override && options.get_option(:default, mandatory: true) && @config_presets[CONF_PRESET_DEFAULTS].key?(identification[:product])
-        raise Cli::Error, "Preset already exists: #{wiz_preset_name}  (use --override=yes or --id=<name>)" \
-          if !option_override && @config_presets.key?(wiz_preset_name)
-        @config_presets[wiz_preset_name] = wizard_result[:preset_value].stringify_keys
+        option_default = options.get_option(:default, mandatory: true)
+        config.defaults_set(identification[:product], wiz_preset_name, wizard_result[:preset_value].stringify_keys, option_default, option_override)
         test_args = wizard_result[:test_args]
-        if options.get_option(:default, mandatory: true)
-          formatter.display_status("Setting config preset as default for #{identification[:product]}")
-          @config_presets[CONF_PRESET_DEFAULTS][identification[:product].to_s] = wiz_preset_name
-        else
-          test_args = "-P#{wiz_preset_name} #{test_args}"
-        end
+        test_args = "-P#{wiz_preset_name} #{test_args}" unless option_default
         # TODO: actually test the command
         return Main.result_status("You can test with:\n#{Info::CMD_NAME} #{identification[:product]} #{test_args}")
       end

data/lib/aspera/environment.rb

@@ -311,11 +311,12 @@ module Aspera
     # @return [String] A file name safe to use on file system
     def sanitized_filename(filename)
       safe_char = safe_filename_character
-      # Windows does not allow file name ending with space or dot
-      # nor control characters anywhere.
+      # Windows does not allow file name:
+      # - with control characters anywhere
+      # - ending with space or dot
       filename = filename
-        .gsub(/[\. ]+$/, safe_char)
         .gsub(/[\x00-\x1F\x7F]/, safe_char)
+        .sub(/[. ]+\z/, safe_char)
       if @file_illegal_characters&.size.to_i >= 2
         # replace all illegal characters with safe_char
         filename = filename.tr(@file_illegal_characters[1..-1], safe_char)

data/lib/aspera/log.rb

@@ -17,12 +17,17 @@ $VERBOSE = nil
 class Logger
   # Two additionnal trace levels
   TRACE_MAX = 2
+
   # Add custom level to logger severity, below debug level
   module Severity
     1.upto(TRACE_MAX).each{ |level| const_set(:"TRACE#{level}", - level)}
   end
-  # Quick access to label
+
+  # Hash : key: log level int, value: uppercase log level label
   SEVERITY_LABEL = Severity.constants.each_with_object({}){ |name, hash| hash[Severity.const_get(name)] = name}
+
+  # @param severity [Integer] Log severity as int
+  # @return [String] Log severity upper case label
   def format_severity(severity)
     SEVERITY_LABEL[severity] || 'ANY'
   end
@@ -51,34 +56,23 @@ module Aspera
 
     # Where logs are sent to
     LOG_TYPES = %i[stderr stdout syslog].freeze
-    DEFAULT_FORMATTER = ->(s, _d, _p, m){"#{Log.color_level(s)} #{m}\n"}
-    FORMATTERS = {
-      standard: Logger::Formatter.new,
-      default:  DEFAULT_FORMATTER
-    }.freeze
+
+    # Levels are :trace2,:trace1,:debug,:info,:warn,:error,fatal,:unknown
+    LEVELS = Logger::Severity.constants.sort{ |a, b| Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{ |c| c.downcase.to_sym}.freeze
+
     # Class methods
     class << self
-      def color_level(level)
-        case level
-        when :TRACE2 then 'TR2'.dim
-        when :TRACE1 then 'TR1'.blue
-        when :DEBUG then 'DBG'.cyan
-        when :INFO  then 'INF'.green
-        when :WARN  then 'WRN'.bg_brown.black
-        when :ERROR then 'ERR'.bg_red.blink
-        when :FATAL then 'FTL'.magenta
-        when :UNKNOWN then 'UKN'.blink
-        else Aspera.error_unexpected_value(level){'log level'}
-        end
+      # Applies the provided list of string decoration (colors) to the value.
+      # @param value [String]         Value to enhance.
+      # @param colors [Array(Symbol)] List of decorations
+      def apply_colors(value, colors)
+        colors.inject(value){ |s, c| s.send(c)}
       end
 
-      # levels are :debug,:info,:warn,:error,fatal,:unknown
-      def levels; Logger::Severity.constants.sort{ |a, b| Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{ |c| c.downcase.to_sym}; end
-
-      # get the logger object of singleton
+      # Get the logger object of singleton
       def log; instance.logger; end
 
-      # Dump object (`Hash`) using specified level
+      # Dump object (`Hash`) to log using specified level
       #
       # @param name   [String, Symbol]  Name of object dumped
       # @param object [Hash, nil]       Data to dump
@@ -90,14 +84,16 @@ module Aspera
         instance.logger.send(level, obj_dump(name, object))
       end
 
+      # @return [String] Dump of object
       def obj_dump(name, object)
-        dump_text = case instance.dump_format
-        when :json
-          JSON.pretty_generate(object) rescue PP.pp(object, +'')
-        when :ruby
-          PP.pp(object, +'')
-        else error_unexpected_value(instance.dump_format){'dump format'}
-        end
+        dump_text =
+          case instance.dump_format
+          when :json
+            JSON.pretty_generate(object) rescue PP.pp(object, +'')
+          when :ruby
+            PP.pp(object, +'')
+          else error_unexpected_value(instance.dump_format){'dump format'}
+          end
         "#{name.to_s.green} (#{instance.dump_format})=\n#{dump_text}"
       end
 
@@ -121,6 +117,7 @@ module Aspera
     end
 
     # Set log level of underlying logger given symbol level
+    # @param new_level [Symbol] One of LEVELS
     def level=(new_level)
       @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
     end
@@ -141,6 +138,7 @@ module Aspera
     end
 
     # Get symbol of debug level of underlying logger
+    # @return [Symbol] One of LEVELS
     def level
       Logger::Severity.constants.each do |name|
         return name.downcase.to_sym if @logger.level.eql?(Logger::Severity.const_get(name))
@@ -188,5 +186,30 @@ module Aspera
       # This sets @logger and @logger_type (self needed to call method instead of local var)
       self.logger_type = @logger_type
     end
+
+    # Define decoration of levels
+    LVL_DECO = {
+      TRACE2:  %i{dim},
+      TRACE1:  %i{blue},
+      DEBUG:   %i{cyan},
+      INFO:    %i{green},
+      WARN:    %i{bg_brown black},
+      ERROR:   %i{bg_red blink},
+      FATAL:   %i{magenta},
+      UNKNOWN: %i{blink}
+    }.freeze
+
+    # Short levels with color
+    LVL_COLOR = LVL_DECO.map{ |k, v| [k, apply_colors("#{k[..2]}#{k[-1]}", v)]}.to_h.freeze
+
+    DEFAULT_FORMATTER = ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{m}\n"}
+
+    # pre-defined formatters
+    FORMATTERS = {
+      standard: Logger::Formatter.new,
+      default:  DEFAULT_FORMATTER
+    }.freeze
+
+    private_constant :LVL_DECO, :LVL_COLOR, :DEFAULT_FORMATTER, :FORMATTERS
   end
 end

data/lib/aspera/sync/operations.rb

@@ -25,19 +25,19 @@ module Aspera
 
       class << self
         # Set `remote_dir` in sync parameters based on transfer spec
-        # @param params [Hash] sync parameters, old or new format
+        # @param params [Hash] Sync parameters, old or new format
         # @param remote_dir_key [String] key to update in above hash
         # @param transfer_spec [Hash] transfer spec
-        def update_remote_dir(sync_params, remote_dir_key, transfer_spec)
+        def update_remote_dir(params, remote_dir_key, transfer_spec)
           if transfer_spec.dig(*%w[tags aspera node file_id])
             # in AoC, use gen4
-            sync_params[remote_dir_key] = '/'
+            params[remote_dir_key] = '/'
           elsif transfer_spec['cookie']&.start_with?('aspera.shares2')
             # TODO : something more generic, independent of Shares
             # in Shares, the actual folder on remote end is not always the same as the name of the share
             remote_key = transfer_spec['direction'].eql?('send') ? 'destination' : 'source'
             actual_remote = transfer_spec['paths']&.first&.[](remote_key)
-            sync_params[remote_dir_key] = actual_remote if actual_remote
+            params[remote_dir_key] = actual_remote if actual_remote
           end
           nil
         end
@@ -70,34 +70,36 @@ module Aspera
         end
 
         # Get symbol of sync direction, defaulting to :push
-        # @param params [Hash] sync parameters, old or new format
+        # @param params [Hash] Sync parameters, old or new format
         # @return [Symbol] direction symbol, one of :push, :pull, :bidi
         def direction_sym(params)
           (params['direction'] || DEFAULT_DIRECTION).to_sym
         end
 
         # Start the sync process
-        # @param sync_params [Hash] sync parameters, old or new format
+        # @param params [Hash] Sync parameters, old or new format
+        # @param opt_ts [Hash] Optional transfer spec
         # @param &block [nil, Proc] block to generate transfer spec, takes: direction (one of DIRECTIONS), local_dir, remote_dir
-        def start(sync_params, opt_ts = nil)
-          Log.dump(:sync_params_initial, sync_params)
-          Aspera.assert_type(sync_params, Hash)
+        def start(params, opt_ts = nil)
+          Log.dump(:sync_params_initial, params)
+          Aspera.assert_type(params, Hash)
+          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
           env_args = {
             args: [],
             env:  {}
           }
-          if sync_params.key?('local')
+          if params.key?('local')
             # "conf" format
-            Aspera.assert_type(sync_params['local'], Hash){'local'}
-            remote = sync_params['remote']
+            Aspera.assert_type(params['local'], Hash){'local'}
+            remote = params['remote']
             Aspera.assert_type(remote, Hash){'remote'}
             Aspera.assert_type(remote['path'], String){'remote path'}
             # get transfer spec if possible, and feed back to new structure
             if block_given?
-              transfer_spec = yield(direction_sym(sync_params), sync_params['local']['path'], remote['path'])
+              transfer_spec = yield(direction_sym(params), params['local']['path'], remote['path'])
               Log.dump(:auth_ts, transfer_spec)
               transfer_spec.deep_merge!(opt_ts) unless opt_ts.nil?
-              tspec_to_sync_info(transfer_spec, sync_params, CONF_SCHEMA)
+              tspec_to_sync_info(transfer_spec, params, CONF_SCHEMA)
               update_remote_dir(remote, 'path', transfer_spec)
             end
             remote['connect_mode'] ||= transfer_spec['wss_enabled'] ? 'ws' : 'ssh'
@@ -107,18 +109,18 @@ module Aspera
               remote['private_key_paths'].concat(add_certificates)
             end
             # '--exclusive-mgmt-port=12345', '--arg-err-path=-',
-            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(sync_params))}"]
-            Log.dump(:sync_conf, sync_params)
+            env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(params))}"]
+            Log.dump(:sync_conf, params)
             agent = Agent::Direct.new
             agent.start_and_monitor_process(session: {}, name: :async, **env_args)
-          elsif sync_params.key?('sessions')
+          else
             # "args" format
             raise StandardError, "Only 'sessions', and optionally 'instance' keys are allowed" unless
-              sync_params.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
-            Aspera.assert_type(sync_params['sessions'], Array)
-            Aspera.assert_type(sync_params['sessions'].first, Hash)
+              params.keys.push('instance').uniq.sort.eql?(CMDLINE_PARAMS_KEYS)
+            Aspera.assert_type(params['sessions'], Array)
+            Aspera.assert_type(params['sessions'].first, Hash)
             if block_given?
-              sync_params['sessions'].each do |session|
+              params['sessions'].each do |session|
                 Aspera.assert_type(session['local_dir'], String){'local_dir'}
                 Aspera.assert_type(session['remote_dir'], String){'remote_dir'}
                 transfer_spec = yield(direction_sym(session), session['local_dir'], session['remote_dir'])
@@ -129,13 +131,13 @@ module Aspera
                 update_remote_dir(session, 'remote_dir', transfer_spec)
               end
             end
-            if sync_params.key?('instance')
-              Aspera.assert_type(sync_params['instance'], Hash)
-              instance_builder = CommandLineBuilder.new(sync_params['instance'], INSTANCE_SCHEMA, CommandLineConverter)
+            if params.key?('instance')
+              Aspera.assert_type(params['instance'], Hash)
+              instance_builder = CommandLineBuilder.new(params['instance'], INSTANCE_SCHEMA, CommandLineConverter)
               instance_builder.process_params
               instance_builder.add_env_args(env_args)
             end
-            sync_params['sessions'].each do |session_params|
+            params['sessions'].each do |session_params|
               Aspera.assert_type(session_params, Hash)
               Aspera.assert(session_params.key?('name')){'session must contain at least: name'}
               session_builder = CommandLineBuilder.new(session_params, SESSION_SCHEMA, CommandLineConverter)
@@ -143,8 +145,6 @@ module Aspera
               session_builder.add_env_args(env_args)
             end
             Environment.secure_execute(exec: Ascp::Installation.instance.path(:async), **env_args)
-          else
-            raise Error, 'At least one of `local` or `sessions` must be present in async parameters'
           end
           return
         end
@@ -168,23 +168,24 @@ module Aspera
         end
 
         # Run `asyncadmin` to get status of sync session
-        # @param sync_params [Hash] sync parameters in conf or args format
+        # @param params [Hash] sync parameters in conf or args format
         # @return [Hash] parsed output of asyncadmin
-        def admin_status(sync_params)
+        def admin_status(params)
+          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
           arguments = ['--quiet']
-          if sync_params.key?('local')
+          if params.key?('local')
             # "conf" format
-            arguments.push("--name=#{sync_params['name']}")
-            if sync_params.key?('local_db_dir')
-              arguments.push("--local-db-dir=#{sync_params['local_db_dir']}")
-            elsif sync_params.dig('local', 'path')
-              arguments.push("--local-dir=#{sync_params.dig('local', 'path')}")
+            arguments.push("--name=#{params['name']}")
+            if params.key?('local_db_dir')
+              arguments.push("--local-db-dir=#{params['local_db_dir']}")
+            elsif params.dig('local', 'path')
+              arguments.push("--local-dir=#{params.dig('local', 'path')}")
             else
               raise Error, 'Missing either local_db_dir or local.path'
             end
-          elsif sync_params.key?('sessions')
+          else
             # "args" format
-            session = sync_params['sessions'].first
+            session = params['sessions'].first
             arguments.push("--name=#{session['name']}")
             if session.key?('local_db_dir')
               arguments.push("--local-db-dir=#{session['local_db_dir']}")
@@ -193,30 +194,28 @@ module Aspera
             else
               raise Error, 'Missing either local_db_dir or local_dir'
             end
-          else
-            raise Error, 'At least one of `local` or `sessions` must be present in async parameters'
           end
           stdout = Environment.secure_capture(exec: ASYNC_ADMIN_EXECUTABLE, args: arguments)
           return parse_status(stdout)
         end
 
-        # Find the local database folder based on sync_params
-        # @param sync_params [Hash] sync parameters in conf or args format
-        # @param exception [Bool] Raise exception in case of problem, else return nil
+        # Find the local database folder based on params
+        # @param params [Hash] sync parameters in conf or args format
         # @return [String, nil] path to "local DB dir", i.e. folder that contains folders that contain snap.db
-        def local_db_folder(sync_params, exception: true)
-          if sync_params.key?('local')
+        def local_db_folder(params)
+          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if params.key?('local')
             # "conf" format
-            if sync_params.key?('local_db_dir')
-              return sync_params['local_db_dir']
-            elsif (local_path = sync_params.dig('local', 'path'))
+            if params.key?('local_db_dir')
+              return params['local_db_dir']
+            elsif (local_path = params.dig('local', 'path'))
               return local_path
             elsif exception
               raise Error, 'Missing either local_db_dir or local.path'
             end
-          elsif sync_params.key?('sessions')
+          else
             # "args" format
-            session = sync_params['sessions'].first
+            session = params['sessions'].first
             if session.key?('local_db_dir')
               return session['local_db_dir']
             elsif session.key?('local_dir')
@@ -224,26 +223,23 @@ module Aspera
             elsif exception
               raise Error, 'Missing either local_db_dir or local_dir'
             end
-          elsif exception
-            raise Error, 'At least one of `local` or `sessions` must be present in async parameters'
           end
           nil
         end
 
-        def session_name(sync_params)
-          if sync_params.key?('local')
+        def session_name(params)
+          Aspera.assert(PARAM_KEYS.any?{ |k| params.key?(k)}, type: Error){'At least one of `local` or `sessions` must be present in async parameters'}
+          if params.key?('local')
             # "conf" format
-            return sync_params['name']
-          elsif sync_params.key?('sessions')
-            # "args" format
-            return sync_params['sessions'].first['name']
+            return params['name']
           else
-            raise Error, 'At least one of `local` or `sessions` must be present in async parameters'
+            # "args" format
+            return params['sessions'].first['name']
           end
         end
 
-        def session_db_file(sync_params)
-          db_file = File.join(local_db_folder(sync_params), PRIVATE_FOLDER, session_name(sync_params), ASYNC_DB)
+        def session_db_file(params)
+          db_file = File.join(local_db_folder(params), PRIVATE_FOLDER, session_name(params), ASYNC_DB)
           Aspera.assert(File.exist?(db_file)){"Database file #{db_file} does not exist"}
           db_file
         end
@@ -292,8 +288,9 @@ module Aspera
       ASYNC_ADMIN_EXECUTABLE = 'asyncadmin'
       PRIVATE_FOLDER = '.private-asp'
       ASYNC_DB = 'snap.db'
+      PARAM_KEYS = %w[local sessions].freeze
 
-      private_constant :INSTANCE_SCHEMA, :SESSION_SCHEMA, :CONF_SCHEMA, :CMDLINE_PARAMS_KEYS, :ASYNC_ADMIN_EXECUTABLE, :PRIVATE_FOLDER, :ASYNC_DB
+      private_constant :INSTANCE_SCHEMA, :SESSION_SCHEMA, :CONF_SCHEMA, :CMDLINE_PARAMS_KEYS, :ASYNC_ADMIN_EXECUTABLE, :PRIVATE_FOLDER, :ASYNC_DB, :PARAM_KEYS
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspera-cli
 version: !ruby/object:Gem::Version
-  version: 4.24.0
+  version: 4.24.1
 platform: ruby
 authors:
 - Laurent Martin
@@ -37,7 +37,7 @@ cert_chain:
   eTf9kxhVM40wGQOECVNA8UsEEZHD48eF+csUYZtAJOF5oxTI8UyV9T/o6CgO0c9/
   Gzz+Qm5ULOUcPiJLjSpaiTrkiIVYiDGnqNSr6R1Hb1c=
   -----END CERTIFICATE-----
-date: 2025-09-30 00:00:00.000000000 Z
+date: 2025-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blankslate