l43_time 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e00494e65d3ddd6c92edf5c8a7afe23b051f9d1e5f2a7290b4262e2ba97f467
+  data.tar.gz: 0ef11ca9be18c6843c7bfb36a72f67a7d37cfdb430571a95e92e33735bc0e06c
+SHA512:
+  metadata.gz: f2436b9759c0afdb3c9ead2ed7505732d8093a4d3c4efa5e55f35407a83ceb1ac7ad67dafc3b12e2803f72299944a43fb79e40f46eb9ad4f87003a830ddf7f12
+  data.tar.gz: 60bd5b65ebbf69c2292f35b4cebe1c2eaad95848256a5e3de917210e40eff0c34249242404ad31e267f03c90a7f323e54db752f7a49a56c4a4aeb935f1cde1b1

data/lib/l43/time/consts.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    SPERM = 60
+    SPERH = 60*SPERM
+    SPERD = 24*SPERH
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/delta.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'parser'
+
+module L43
+  module Time
+    module Delta
+      include Parser 
+
+      def after(duration, from: nil, format: :to_f) = _delta(duration, from:, format:)
+      def before(duration, from: nil, format: :to_f) = _delta(duration, from:, format:, factor: -1)
+
+      def after!(duration, from: nil, format: :to_f)
+        case after(duration, from:, format:)
+        in :ok, result
+          result
+        in :error, error
+          raise BadFormat, error
+        end
+      end
+
+      def before!(duration, from: nil, format: :to_f)
+        case before(duration, from:, format:)
+        in :ok, result
+          result
+        in :error, error
+          raise BadFormat, error
+        end
+      end
+        
+      private
+      def _delta(duration, from: nil, format: :to_f, factor: 1)
+        from ||= ::Time.now
+        case parse_or_duration(duration)
+        in :ok, result
+          _format_date(from + factor * result.to_f, format:)
+        in error
+          error
+        end
+      end
+
+      def _format_date(date, format:)
+        case format
+        in Symbol => sym
+          date.send(sym).to_s
+        else
+          raise ArgumentError, 'only symbols are supported for the format: argument'
+        end
+      rescue NoMethodError
+        raise ArgumentError, 'only symbols representing instance methods of the class Time are supported for the format: argument'
+      end
+    end
+  end
+end
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    BadFormat = Class.new RuntimeError
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/parser.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'consts'
+require_relative 'errors'
+require_relative 'tools/scanner'
+require_relative 'ts'
+
+module L43
+  module Time
+    module Parser
+      include Ts
+
+      Prefix =
+        %r{
+          (?<unit>[[:lower:]]+) [[:space:]]*:[[:space:]]* (?<value>[[:digit:]]+ (?:\.[[:digit:]]+)? )
+        }x
+
+      Suffix =
+        %r{
+          (?<value>[[:digit:]]+ (?:\.[[:digit:]]+)?) [[:space:]]* (?<unit>[[:lower:]]+)
+        }x
+
+        def parse_duration!(str)
+          case parse_duration(str)
+          in :ok, value
+            value
+          in :error, msg
+            raise BadFormat, msg
+          end
+        end
+
+        def parse_duration(str)
+          if str[Prefix]
+            Helper.parse_prefix(str)
+          else
+            Helper.parse_suffix(str)
+          end
+        end
+
+        def parse_or_duration!(str)
+          case parse_or_duration(str)
+          in :ok, value
+            value
+          in :error, msg
+            raise BadFormat, msg
+          end
+        end
+
+        def parse_or_duration(str)
+          case duration_as_string(str)
+          in :ok, value
+            [:ok, value]
+          else
+            parse_duration(str)
+          end
+        end
+
+        module Helper extend self
+          Units = {
+            's' => [1, 'seconds'],
+            'second' => [1, 'seconds'],
+            'seconds' => [1, 'seconds'],
+
+            'm' => [60, 'minutes'],
+            'minute' => [60, 'minutes'],
+            'minutes' => [60, 'minutes'],
+
+            'h' => [3600, 'hours'],
+            'hour' => [3600, 'hours'],
+            'hours' => [3600, 'hours'],
+
+            'd' => [86400, 'days'],
+            'day' => [86400, 'days'],
+            'days' => [86400, 'days'],
+          }
+
+          def parse_prefix(str) = _parse_with(str, rgx: Prefix)
+          def parse_suffix(str) = _parse_with(str, rgx: Suffix)
+
+          private
+          def _parse_with(str, rgx:)
+            sign = ""
+            if str.start_with?("-")
+              sign = "-"
+              str = str[1..]
+            end
+
+            parsed = Tools::Scanner.scan_with_captures(str:, rgx:)
+              .inject([Set.new, 0, nil]) { |(used, result, error), captures| _update_duration(used:, result:, error:, unit: captures.unit, value: captures.value) }
+
+            case parsed
+            in [_, result, nil]
+              [:ok, sign + result.to_s]
+            in [_, _, error]
+              [:error, error]
+            end
+          end
+
+          def _seconds(unit:, used:, value:)
+            case Units.fetch(unit, :not_found)
+            in :not_found
+              [:error, "#{unit} is not supported, use d(ays?), h(ours?), m(inutes), s(econds?) only"]
+            in factor, name
+              if used.member?(name)
+                [:error, "#{name} already used"]
+              else
+                used << name
+                [:ok, factor * value.to_f]
+              end
+            end
+          end
+
+          def _update_duration(used:, result:, error:, unit:, value:)
+            return [used, result, error] if error 
+            case _seconds(unit:, used:, value:)
+            in :error, error
+              [used, result, error]
+            in :ok, value
+              [used, result+value, nil]
+            end
+          end
+        end
+    end
+  end
+end
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/range.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+module L43
+  module Time
+    class Range
+      extend L43::OpenObject
+
+      attributes from: nil, to: nil
+      def ===(other)
+        other = _time(other)
+        return false if from&.> other
+        return false if to&.< other
+        true
+      end
+
+      private
+      def initialize(from: nil, to: nil)
+        raise ArgumentError, "need at least one of: from:, to:" unless from || to
+        @from = _time(from)
+        @to = _time(to)
+      end
+
+      def _time(str_or_time)
+        return Time.str_to_time(str_or_time) if String === str_or_time
+        str_or_time
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/time_range.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'range'
+module L43
+  module Time
+    module TimeRange
+      def str_to_range(str)
+        case str.split("..")
+        in from, to
+          time_range(from:, to:)
+        else
+          raise ArgumentError, "must use a str of format '<time>..<time>'"
+        end
+      end
+
+      def time_range(from: nil, to: nil)
+        Range.new(from:, to:)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/to_time.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'parser'
+module L43
+  module Time
+    module Duration
+      extend Parser
+    end
+
+    module ToTime
+      T = ::Time
+      def str_to_time(str)
+        case str
+        when /\A\d{14}\z/
+          T.strptime(str, "%Y%m%d%H%M%S")
+        when /\A\d{12}\z/
+          T.strptime(str, "%y%m%d%H%M%S")
+        when /\A\d{6}\z/
+          T.strptime(str, "%y%m%d")
+        when /\A\d{4}\z/
+          T.strptime(str, "%m%d")
+        when /\A\d{2}\z/
+          T.strptime(str, "%d")
+        else
+          parse_symbolic_or_duration(str)
+        end
+      end
+
+      private
+      def parse_symbolic_or_duration(str)
+        case symbolic_time(str)
+        in :ok, time
+          time
+        else
+          d = Duration.parse_duration!(str).to_f
+          T.now + d 
+        end
+      end
+
+      def sym_today = T.strptime(format("%02d", T.now.day), "%d")
+      def sym_yesterday = T.strptime(format("%02d", T.now.day), "%d") - SPERD
+
+      SymbolicTimes = {
+        "today" => :sym_today,
+        "yesterday" => :sym_yesterday,
+        "yd" => :sym_yesterday,
+      }
+
+      def symbolic_time(str) 
+        # TODO: Use &"sym...".to_sym
+        map_ok(exception: KeyError) {
+          send SymbolicTimes.fetch(str)
+        }
+      end
+
+      def map_ok(exception: RuntimeError, &blk)
+        [:ok, blk.()]
+      rescue exception => e
+        [:error, e.message]
+      end
+
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/tools/scanner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+module L43
+  module Time
+    module Tools
+      module Scanner extend self
+        def scan_with_captures(str:, rgx:, names: :keys)
+          result = []
+          str
+            .scan(rgx) { |*| result << _extract(from: Regexp.last_match, names:) }
+          result
+        end
+
+        private
+        def _extract(from:, names:)
+          case names
+          in :keys
+            OpenStruct.new(from.named_captures).freeze
+          in :all
+            from.captures.freeze
+          else
+            OpenStruct.new(from.named_captures.slice(names.map(&:to_s))).freeze
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/ts.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'consts'
+require_relative 'errors'
+
+module L43
+  module Time
+    module Ts
+      DecimalPart = %r{\A(.*)\.(\d+)\z}
+      Seperators =
+        Regexp.compile(%w[. : _ -].map { Regexp.escape(it) }.join('|'))
+
+      def duration_as_string!(str)
+        case duration_as_string(str)
+        in :ok, value
+          value
+        in :error, msg
+          raise BadFormat, msg
+        end
+      end
+      alias_method :duration_s!, :duration_as_string!
+
+      def duration_as_string(str)
+        header = ''
+        if str.start_with?('+')
+          str = str[1..]
+        elsif str.start_with?('-')
+          str = str[1..]
+          header = '-'
+        end
+
+        if DecimalPart === str
+          Helper.duration_as_string($1, $2, header)
+        else
+          Helper.duration_as_string(str, "0", header)
+        end
+      end
+      alias_method :duration_s, :duration_as_string
+
+      module Helper extend self
+
+        def duration_as_string(secs, millisecs, header)
+          case _duration_as_string(secs)
+          in :ok, value
+            [:ok, [header, value, '.', millisecs].join]
+          in error
+            error
+          end
+        end
+
+        private
+        def _compute(parts)
+          [:ok, 
+           parts
+            .reverse
+            .zip([1, SPERM, SPERH, SPERD])
+            .inject(0) { |s, (v,f)| s + f * Integer(v) } 
+          ]
+        rescue ArgumentError
+          [:error, "Only digits or seperators are allowed in a duration string"]
+        end
+
+        def _duration_as_string(secs)
+          case secs.split(Seperators)
+          in [m, _, _, _, _, *]
+            [:error, "Must not specify more than day values, got leading #{m}"]
+          in parts
+            _compute(parts)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module L43
+  module Time
+    VERSION = '0.1.0'
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative 'time/delta'
+require_relative 'time/time_range'
+require_relative 'time/to_time'
+require_relative 'time/version'
+module L43
+  module Time
+
+    extend Delta
+    include ToTime
+    include TimeRange
+
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: l43_time
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Dober
+bindir: bin
+cert_chain: []
+date: 2026-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: l43_open_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+description: 'Time related tools
+
+  '
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/l43/time.rb
+- lib/l43/time/consts.rb
+- lib/l43/time/delta.rb
+- lib/l43/time/errors.rb
+- lib/l43/time/parser.rb
+- lib/l43/time/range.rb
+- lib/l43/time/time_range.rb
+- lib/l43/time/to_time.rb
+- lib/l43/time/tools/scanner.rb
+- lib/l43/time/ts.rb
+- lib/l43/time/version.rb
+homepage: https://codeberg.org/lab419/l43_time
+licenses:
+- AGPL-3.0-or-later
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: Time related tools
+test_files: []