l43_time 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bada7ae04b6b801708365b0538c92057a380c8c75982b9f4bd09582e2a1e53d5
-  data.tar.gz: 0b7308732b154084de0e2ffd4cd3a4b70853e501aace43481d598d0f8dcbf78c
+  metadata.gz: 6598feb4c3eb9c20748aed065de3fbbc0ee9305fb86e70cd2ea1aaa01c4a9da4
+  data.tar.gz: 8b2c428ab4e6373694004b6815c99028ce7739eebf3aa81266bc6b0207768f09
 SHA512:
-  metadata.gz: f64ac006a10b5836ee7d3a16b9c40e04b11635d82ae3a882e053d7c58e04e34890edda29632265afc0358ca73ea6b45e974de1a04da2efa58931ce5ca3bdba82
-  data.tar.gz: 6d74b612cb85ecc8a5f8cb160f9510eed7284504aeea51ff6d1f53e979be4df05b546cd9d1b7c56c82d20503ba6b12450dbfd5dd94e44b4e8dbc622d61f22916
+  metadata.gz: fae438b6f985aa098b8c78289af8626030d11d85771582f49c70f8c0914d9bbcf7ab012924dce18c6069e0fb71fa9edc46be9cceabd880b72c340cc5f8faa7e5
+  data.tar.gz: 886f8f5a043e5dc8c892bac66197bdc09450540d35e426026fdfafcf2fcd994ffa78cbbdf2d48c5e833c0c014f21438de6871de6a5f2bba763137e4e0578b56e

data/lib/l43/time/enumerable_extension.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    module EnumerableExtension
+      def find_value(enum, &blk)
+        enum.each do |ele|
+          result = blk.(ele)
+          next if result.nil?
+          return result
+        end
+        nil
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/errors.rb

@@ -3,6 +3,7 @@
 module L43
   module Time
     BadFormat = Class.new RuntimeError
+    SyntaxError = Class.new RuntimeError
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/arg_parser.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'l43/rgx/all'
+require_relative 'time_methods'
+require_relative '../wrapper'
+require_relative '../enumerable_extension'
+module L43
+  module Time
+    module TimeCalc
+      class ArgParser
+        include EnumerableExtension
+
+        MethodNames = %w[ 
+          midnight 
+          tomorrow
+          yesterday
+        ].freeze
+
+        MethodLiterals = MethodNames.map { ".#{it}" }.freeze
+
+        SecsPerUnit = {
+          "s" => 1,
+          "m" => 60,
+          "h" => 3600,
+          "d" => 86400,
+        }.freeze
+
+        attr_reader :now
+
+        def parse(args)
+          if args.empty?
+            [:time, now]
+          else
+            case _time_expr_parser.parse(args.join(" "))
+            in nil
+              [:error, "bad format"] 
+            in ast, ""
+              ast
+              # TODO:
+            in [:time, time], rest
+              _parse_methods(time, rest)
+            in _, rest
+              [:error, "unexpected suffix #{rest.inspect}"]
+            end
+          end
+        end
+
+
+        private
+        def initialize(now)
+          @now = now
+        end
+
+        def _date_in_century_parser
+          R.new([:digit, 2], [:digit, 2], [:digit, 2], :end) { |*date| time_wrapper.with_year(*date) }
+        end
+
+        def _date_in_month_parser
+          R.new([:digit, 2], :end).map_first { time_wrapper.with_day(it) }
+        end
+
+        def _date_in_year_parser
+          R.new([:digit, 2], [:digit, 2], :end) { |*md| time_wrapper.with_month(*md) }
+        end
+
+        def _make_unit_offset(sign, parts)
+          seconds = parts
+            .each_slice(2)
+            .inject(0) do |secs, (n, u)|
+              secs + _unit_to_secs(n.to_i, u)
+            end
+          sign == "-" ? -seconds : seconds
+        end
+
+        def _method_parser(time=nil)
+          time ||= now
+          _one_method_parser.reduce(time) do |time, method, *a|
+            TimeMethods.send(method[1..], time)
+          end
+        end
+
+        def _one_method_parser
+          R.literals(*MethodLiterals, name: "method parser").flattened
+        end
+
+        def _offset_float_seconds_parser
+          R.new([_sign, :digits, "\\.", :digits], :end, escape_strings: false, name: "float_seconds").joined(&:to_f)
+        end
+
+        def _offset_in_seconds_parser
+          _offset_float_seconds_parser.or(_offset_int_seconds_parser)
+        end
+
+        def _offset_int_seconds_parser
+          R.new([_sign, :digits], :end, escape_strings: false, name: "int_seconds").joined(&:to_i)
+        end
+
+        def _offset_parser
+          _offset_in_seconds_parser.or(_offset_with_units_parser).map(name: "adding offset") { [:offset, it] }
+        end
+
+        def _offset_with_units_parser 
+          R.and(_opt_sign, _unit).flattened { |sign, *parts| _make_unit_offset(sign, parts) }
+        end
+
+        def _opt_sign = R.from_regexp("[-+]?")
+
+        def _parse_methods(time, rest)
+          case _tagged_method_parser(time).parse(rest)
+          in nil
+            [:error, "unexpected suffix #{rest.inspect}"]
+          in ast, ""
+            ast
+          in _, rest
+            [:error, "unexpected suffix #{rest.inspect}"]
+          end
+        end
+      
+        def _sign = "[-+]"
+
+        def _simple_time_parser
+          R.or(_date_in_century_parser, _date_in_year_parser, _date_in_month_parser)
+        end
+
+        def _tagged_method_parser(time=nil)
+          _method_parser(time).map { [:time, it] }
+        end
+
+        def _time_parser
+          R.or(
+            _simple_time_parser,
+            _timestamp_parser,
+            _method_parser) { [:time, it] }
+        end
+
+        def _time_expr_parser
+          _offset_parser
+            .or(_time_parser)
+        end
+
+        def _timestamp_float_parser
+          R.new(:digits, [".", :digits]).joined(&:to_f) 
+        end
+
+        def _timestamp_int_parser
+          R.new(:digits, &:to_i)
+        end
+
+        def _timestamp_parser
+          R.or(_timestamp_float_parser, _timestamp_int_parser) { Wrapper.from_ts(it) }  
+        end
+
+        def _unit = R.and(R.new(:digits, "([dhms])", escape_strings: false).many, R.end)
+
+        def _unit_to_secs(n, u)
+          n * SecsPerUnit.fetch(u)
+        end
+
+        def _time_method_parser
+          R.fail
+        end
+
+        def _time_op_parser
+          R.fail
+        end
+
+        def time_wrapper =  @__time_wrapper__ ||= L43::Time::Wrapper.new
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/calculate.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../wrapper'
+require_relative 'arg_parser'
+module L43
+  module Time
+    module TimeCalc
+      module Calculate
+
+        private
+
+        def _calc_time
+          case _parse_head(args.first)
+          in :error, msg
+            [:error, msg]
+          in :ok, result
+            _parse_rest(result)
+          end
+        end
+
+        def _calculate_and_print(now)
+          arg_parser = ArgParser.new(Wrapper.new)
+          case arg_parser.parse(args)
+          in :time, time
+            puts format_time!(format, time: time.time)
+          in :offset, offset
+            puts format_time!(format, time: now.time + offset)
+          in :error, msg, expr
+            putcol(_make_error(msg, expr), to: $stderr)
+          in x
+            putcol(_make_error("unexpected parse result: ", x.inspect), to: $stderr)
+          end
+        end
+
+        # if args.empty?
+        #   puts format_time!(format)
+        # else
+        #   case _calc_time
+        #   in :ok, time
+        #     puts format_time!(format, time:)
+        #   in :error, message
+        #     putcol(message, to: $stderr)
+        #   end
+        # end
+        # end
+
+        def _current_century = (::Time.now.year / 100) * 100
+
+        def _make_error(msg, time_expr) = [
+          :red, :bold, "ERROR: ", :yellow, msg, " ", :blue, time_expr, :reset, " use flag ",
+          :cyan, :bold, ":help_time_expression|:hts", :reset, " for more info"
+        ]
+
+          def _parse_head(time_expr)
+            result = 
+              case time_expr
+              when /\A\d{2}\z/
+                Wrapper.new(::Time.now).with_day(time_expr.to_i).time
+              when /\A(\d{2})(\d{2})\z/
+                month_day = Regexp.last_match.captures.map(&:to_i)
+                Wrapper.new(::Time.now).with_month(*month_day).time
+              when /\A(\d{2})(\d{2})(\d{2})\z/
+                Regexp.last_match.captures.map(&:to_i) => y, m, d
+                ::Time.new(_current_century + y, m, d)
+              when /\A\d+\z/
+                ::Time.at(time_expr.to_i)
+              when /\A\d+\.\d+\z/
+                ::Time.at(time_expr.to_f)
+              else
+              end
+            [:ok, result]
+          end
+
+          def _parse_rest(result)
+            rest = args.drop(1)
+            return [:ok, result] if rest.empty?
+
+            result = Wrapper.new(result)
+          end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/cli/arguments.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    module TimeCalc
+      class Cli
+        module Arguments extend self
+          BadFormat = Class.new(RuntimeError)
+          def define_arguments(arg_parser)
+            define_flags(arg_parser)
+            define_kwds(arg_parser)
+          end
+
+          private
+          def define_flags(arg_parser)
+            arg_parser
+              .def_flag(:version, :v, desc: ["print version information to ", :green, "stdout", :reset, " and exit"])
+              .def_flag(:help_time_expression, desc: ["prints help about the syntax of ", :blue, :bold, " <time-expr> ", :reset, "syntax"])
+              .def_alias(:hts, for_flag: :help_time_expression)
+              .def_flag(:help_fmt, desc: ["prints help about the available values of the ", :cyan, :bold, "fmt:|f:", :reset, " option"])
+              .def_alias(:hfmt, for_flag: :help_fmt)
+          end
+
+          def define_kwds(arg_parser)
+            arg_parser
+              .def_kwd(:fmt, :f, desc: ["defines the format of result ", :bold, "use the ", :cyan, ":help_fmt|:hfmt", :reset, " flag for details"], default: nil)
+              .add_desc(4, "if not provided the envionment variable ", :bold, "TIME_CALC_FMT", :reset, " will be read")
+              .add_desc(4, "and if the environment variable is not set the format defaults to milliseconds in base 36 (", :dim, :cyan, "zms", :reset, ")")
+          end
+
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/cli/help.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    module TimeCalc
+      class Cli
+        module Help extend self
+          include L43::Color::Output
+
+          def help_format = _output(_help_formats)
+
+          def help_time_expression = _output(_help_time_expressions)
+
+          def additional_help_information
+            [
+              ["prints the result of the calculations indicated by ", *_options("options"), " to ", :blue, "stdout"],
+              ["the result is a time which is formatted according to the ", *_options("fmt:|f:"), " keyword"],
+              [nil, 3, "the ", :bold, :blue, "<time-expr>", :reset, " positional arguments default to ", :bold, :magenta, "Time.now"],
+            ].map { |line| [3, *line, :reset] }
+          end
+
+          private
+          def _help_formats
+            [
+              ["The following values are legal for the ", :bold, :cyan, "fmt:|f:", :reset, " option"],
+              ["   ", :bold, :cyan, "ds", :reset, " decimal seconds", :reset],
+              ["   ", :bold, :cyan, "dms", :reset, " decimal milliseconds", :reset],
+              ["   ", :bold, :cyan, "dmcs", :reset, " decimal microseconds", :reset],
+              ["   ", :bold, :cyan, "dμs", :reset, " decimal microseconds", :reset],
+              ["   ", :bold, :cyan, "xs", :reset, " hex seconds", :reset],
+              ["   ", :bold, :cyan, "xms", :reset, " hex milliseconds", :reset],
+              ["   ", :bold, :cyan, "xmcs", :reset, " hex microseconds", :reset],
+              ["   ", :bold, :cyan, "xμs", :reset, " hex microseconds", :reset],
+              ["   ", :bold, :cyan, "zs", :reset, " base36 seconds", :reset],
+              ["   ", :bold, :cyan, "zms", :reset, " base36 milliseconds", :reset],
+              ["   ", :bold, :cyan, "zmcs", :reset, " base36 microseconds", :reset],
+              ["   ", :bold, :cyan, "zμs", :reset, " base36 microseconds", :reset],
+              ["   ", :bold, :cyan, "date", :reset, " date", :reset],
+              ["   ", :bold, :cyan, "long", :reset, " long", :reset],
+              ["   ", :bold, :cyan, "iso", :reset, " iso", :reset],
+              ["   ", :bold, :cyan, "time", :reset, " time", :reset],
+            ]
+          end
+
+
+          def _help_time_expressions
+            [
+              ["Time expressions are of the following syntax:"],
+              [""],
+              ["    ", *_kwd("<time>"), " [", :bold, :magenta, " <op> ", *_kwd("<offset>"), " ]  |  [",
+               :bold, :blue, "<time>", :reset, "][.", :bold, :magenta, "<method>...",
+               :reset, "]  |  ", *_kwd("<offset>")
+              ],
+              [""],
+              ["  ", :bold, :blue, "<time>", :reset, ":"],
+              ["    ", "if not directed by any option ", *_kwd("<time>"), " is parsed heuristically"],
+              ["      6 digits to a date in the 21st century"],
+              ["      4 digits to a month and day in the current year"],
+              ["      2 digits to a day in the current month"],
+              ["      an unsigned number, interpreted as seconds from epoch "],
+              [:bold, :yellow, "         N.B.: ", :reset, "must contain a decimal point if the number format conflicts with the formats above"],
+              [""],
+              ["  ", :bold, :blue, "<offset>", :reset, ":"],
+              ["      a signed number, interpreted as offsets in seconds"],
+              ["      a unit offset, which is a sequence of ", :blue, :bold, "<int><unit>", :reset, " where ", :blue, :bold, "<unit>",
+               :reset, " is one of: ", :green, "dhms"],
+               [""],
+              ["  ", :bold, :magenta, "<method>", :reset, ":"],
+              ["     [", :bold, :blue, "<time>", :reset, "]", :bold, :green, ".midnight", :reset, " time 0h0m0s of ", :bold, :blue, "<time>.", :reset],
+              ["     [", :bold, :blue, "<time>", :reset, "]", :bold, :green, ".tomorrow", :reset, " 1 day after ", :bold, :blue, "<time>.", :reset],
+              ["     [", :bold, :blue, "<time>", :reset, "]", :bold, :green, ".yesterday", :reset, " 1 day before ", :bold, :blue, "<time>.", :reset],
+            ]
+          end
+
+          def _kwd(*kwds) = [:bold, :blue, *kwds, :reset].freeze
+
+          def _options(name) =  [:cyan, :bold, name, :reset].freeze
+
+          def _output(lines)
+            lines.each do |line|
+              putcol(line, to: $stderr)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/cli.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'l43/xargs'
+require 'l43/rgx/all'
+require 'l43/rgx/result'
+
+require_relative 'cli/arguments'
+require_relative 'cli/help'
+require_relative 'calculate'
+require_relative 'arg_parser'
+require_relative '../format_time'
+require_relative '../wrapper'
+module L43
+  module Time
+    module TimeCalc
+      class Cli
+        include Calculate
+        include Color::Output
+        include FormatTime
+
+        attr_reader :arg_parser, :args,
+          :format,
+          :kwds
+
+        def run(argv)
+          result = arg_parser.parse(argv)
+          case result
+          in true, args, [], kwds
+            @args = args
+            @kwds = kwds
+            _run
+          in false, _, errors, _
+            errors.each do |error|
+              putcol(error, to: $stderr)
+            end
+          end
+        end
+
+        private
+        def initialize
+          @arg_parser = Xargs.new(program_name: "time_calc", autohelp: true, no_posix_short: true, usage: [:options, "<time-expr>..."])
+          Arguments.define_arguments(arg_parser) 
+        end
+
+        def _checks!
+          legal_fmts = FormatTime::LegalFormats.keys 
+          @format = (fmt || ENV["TIME_CALC_FMT"] || "zms").to_sym
+          return true if legal_fmts.member?(format)
+          putcol(
+            [:bold, :red, "ERROR: ", :reset, :yellow, "#{format.inspect} is not a legal format. Use the script with ", :bold, :green, ":help_fmt|:hfmt"],
+            to: $stderr)
+          false
+        end
+
+        def _run
+          arg_parser.forward_to_kwds!(self)
+          if help
+            arg_parser.print_help([nil, *Help.additional_help_information])
+          elsif version
+            require_relative '../version'
+            putcol([:bold, :white, arg_parser.program_name, :green, " v", L43::Time::VERSION], to: $stderr)
+          elsif help_time_expression
+            Help.help_time_expression
+          elsif help_fmt
+            Help.help_format
+          else
+            _calculate_and_print(Wrapper.new) if _checks!
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_calc/time_methods.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../wrapper'
+module L43
+  module Time
+    module TimeCalc
+      module TimeMethods extend self
+        def midnight(time)
+          time.with_time
+        end
+
+        def tomorrow(time)
+          time + 86400
+        end
+        
+
+        def yesterday(time)
+          time - 86400
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/version.rb

@@ -2,7 +2,7 @@
 
 module L43
   module Time
-    VERSION = '0.1.9'
+    VERSION = '0.2.0'
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/wrapper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    class Wrapper
+      attr_reader :time
+
+      class << self
+        def from_ts(ts) = new(::Time.at(ts))
+      end
+
+      def deconstruct(*)
+        [
+          time.year, time.month, time.day, time.hour, time.min, time.sec, seconds_since_epoch, microseconds
+        ]
+      end
+
+      def ==(other) 
+        return false unless self.class === other 
+        other.time == time
+      end
+
+      def +(ts)
+        self.class.from_ts(time + ts)
+      end
+
+      def -(ts)
+        self.class.from_ts(time - ts)
+      end
+
+      def to_f = time.to_f
+
+      def to_i = time.to_i
+
+      def microseconds =  @__microseconds__ ||= ((time.to_f - seconds_since_epoch) * 1_000_000).to_i 
+      def seconds_since_epoch =  @__seconds_since_epoch__ ||= time.to_i
+
+      def with_day(day, hour=0, min=0, sec=0)
+        self => [y, m, *]
+        self.class.new(y, m, day, hour, min, sec)
+      end
+
+      def with_month(month, day=1, hour=0, min=0, sec=0)
+        self.class.new(time.year, month, day, hour, min, sec)
+      end
+
+      def with_time(hour=0, min=0, sec=0)
+        self => [year, month, day, *]
+        self.class.new(year, month, day, hour, min, sec)
+      end
+
+      def with_year(year, month, day=1, hour=0, min=0, sec=0)
+        year = Integer(year)
+        year += 2000 if year < 1000
+        self.class.new(year, month, day, hour, min, sec)
+      end
+
+      private
+      def initialize(time=::Time.now, *parts)
+        case time
+        when ::Time
+          raise ArgumentError, "parts not allowed if first part is an instance of Time" unless parts.empty?
+          @time = time
+        else
+          @time = ::Time.new(time, *parts)
+        end
+        @time.freeze
+      end
+        
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,30 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: l43_time
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
-date: 2026-08-17 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ostruct
+  name: l43_color
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.3
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.3
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
-  name: l43_color
+  name: l43_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+- !ruby/object:Gem::Dependency
+  name: l43_open_object
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -38,33 +52,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.0
 - !ruby/object:Gem::Dependency
-  name: l43_core
+  name: l43_xargs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.7
+        version: 0.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.7
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
-  name: l43_open_object
+  name: l43_rgx
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.2.0
 description: 'Time related tools
 
   '
@@ -78,10 +92,17 @@ files:
 - lib/l43/time.rb
 - lib/l43/time/consts.rb
 - lib/l43/time/delta.rb
+- lib/l43/time/enumerable_extension.rb
 - lib/l43/time/errors.rb
 - lib/l43/time/format_time.rb
 - lib/l43/time/parser.rb
 - lib/l43/time/range.rb
+- lib/l43/time/time_calc/arg_parser.rb
+- lib/l43/time/time_calc/calculate.rb
+- lib/l43/time/time_calc/cli.rb
+- lib/l43/time/time_calc/cli/arguments.rb
+- lib/l43/time/time_calc/cli/help.rb
+- lib/l43/time/time_calc/time_methods.rb
 - lib/l43/time/time_range.rb
 - lib/l43/time/to_time.rb
 - lib/l43/time/tools/format_ts.rb
@@ -89,6 +110,7 @@ files:
 - lib/l43/time/tools/scanner.rb
 - lib/l43/time/ts.rb
 - lib/l43/time/version.rb
+- lib/l43/time/wrapper.rb
 homepage: https://codeberg.org/lab419/l43_time
 licenses:
 - AGPL-3.0-or-later
@@ -107,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Time related tools
 test_files: []