timerage 2.2.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '07846226e71bd754087bd3b54c49d85a70e9d2f9b809d678351fbd685546fcb4'
-  data.tar.gz: e3be843301a7d7a7ea7cec902c2f4fd8152314a5cbbf4e74d8aad65ede5196ec
+  metadata.gz: dd5297580375d5da0f4f8e0c5565cbe0b5e87bb27e01a3f6ab7b53e322f0836b
+  data.tar.gz: 1095aa363d5652855d905dfeeecc74291cdb4399c5769ac115c2bed2ad889043
 SHA512:
-  metadata.gz: 76acc33ddaa358897021f20b82c4f3faffb1867469e410da6566480880c78c9524a84e39edb6c3468bfd5d49cba4d72dfe526dbd749ad6ecff66be839fcb6bc0
-  data.tar.gz: 96e281a1b857a002653629b4289574f4488068609f40f74b85832966a402311c88ea16f9db91080a74566ac502a7bd1468d496bb73b5095dcfbe572d09f2ec06
+  metadata.gz: c8114be85281560a2d7c08fad17ab9db72809b3a992cf2fff1433e6e4fe3e04673e9fa53bfa93070c4c1b3643bad913c550ca68d11f1ff2f04c2c4b04a9f8188
+  data.tar.gz: 701cd90ba28da27218c23f0346bc15d33c63646bf0a96d8f79ff39dc6a8fe55974fc848b5bca7266bfdf4fe6709fc70448242930e6ffd284f9519b04e40da4bf

data/lib/timerage/time_interval.rb

@@ -5,11 +5,34 @@ module Timerage
   class TimeInterval < Range
 
     class << self
+      # Returns a new TimeInterval
+      #
+      # start_time - the beginning of the interval
+      # end_time   - the end of the interval
+      # exclude_end - whether the end time is excluded from the interval
       def new(*args)
-        args = [args.first.begin, args.first.end, args.first.exclude_end?] if args.first.respond_to?(:exclude_end?)
-        new_obj = allocate
-        new_obj.send(:initialize, *args)
-        new_obj
+        return from_range(*args) if args.first.respond_to?(:exclude_end?)
+
+        super
+      end
+
+      # Returns a new TimeInterval
+      #
+      # time - the beginning or end of the interval
+      # duration - the duration of the interval, if negative the
+      #   interval will start before`time`
+      # exclude_end - whether the end time is excluded from the interval
+      def from_time_and_duration(time, duration, exclude_end: true)
+        if duration >= 0
+          new(time, time + duration, exclude_end)
+        else
+          new(time + duration, time, exclude_end)
+        end
+      end 
+
+      # Returns a new TimeInterval based on the specified range 
+      def from_range(range)
+        new(range.begin, range.end, range.exclude_end?)
       end
     end
 
@@ -32,12 +55,12 @@ module Timerage
       end
     end
 
-    def slice(seconds)
-      time_enumerator(seconds)
-        .map{|t|
-          end_time = [t+seconds, self.end].min
-          inclusive = (t == end_time || t+seconds > self.end) && !exclude_end?
-          TimeInterval.new(t, end_time, !inclusive) }
+    def slice(duration)
+      time_enumerator(duration)
+        .each_cons(2).map { |s_begin, s_end| TimeInterval.new(s_begin, s_end, exclusive_end_slice?(s_end)) }
+        .then do |slices|
+          slices << TimeInterval.new(slices.last.end, self.end, exclusive_end_slice?(slices.last.end + duration)) if slices.present?
+        end
     end
 
     # Return new TimeInterval that is the concatenation of self and
@@ -54,7 +77,7 @@ module Timerage
     # Returns an ISO8601 interval representation of self
     # Takes same args as Time#iso8601
     def iso8601(*args)
-      "#{self.begin.iso8601(*args)}/#{self.end.iso8601(*args)}"
+      "#{self.begin&.iso8601(*args) || ".."}/#{self.end&.iso8601(*args) || ".."}"
     end
 
     def getutc
@@ -134,6 +157,10 @@ module Timerage
         an_obj.respond_to?(:end)
     end
 
+    def exclusive_end_slice?(slice_end)
+      !((slice_end > self.end) && !exclude_end?)
+    end
+
     def time_enumerator(step)
       next_offset = step * 0
 
@@ -155,7 +182,17 @@ module Timerage
     #
     # Currently this only supports `<begin>/<end>` style time intervals.
     def self.iso8601(str, exclusive_end: true)
-      new *str.split("/", 2).map{|s| Time.iso8601(s)}, exclusive_end
+      str
+        .split("/", 2)
+        .tap { |it| fail ArgumentError, "Invalid iso8601 interval: #{str.inspect}" unless it.size == 2 }
+        .map {|s|
+          if s.strip == ".."
+            nil
+          else
+            Time.iso8601(s)
+          end
+        }
+        .then { |b, e| new(b, e, exclusive_end) }
 
     rescue ArgumentError
       raise ArgumentError, "Invalid iso8601 interval: #{str.inspect}"

data/lib/timerage/version.rb

@@ -1,3 +1,3 @@
 module Timerage
-  VERSION = "2.2.0"
+  VERSION = "2.4.0"
 end

data/lib/timerage.rb

@@ -16,17 +16,30 @@ module Timerage
     Time.iso8601(str)
   end
 
+  # Returns a new TimeInterval from a time and duration or two times.
+  #
+  # signature:
+  #  Interval(begin_time, end_time, exclude_end: true)
+  #  Interval(begin_or_end_time, duration, exclude_end: true)
+  def self.Interval(begin_or_end_time, end_time_or_duration, exclude_end: true)
+    if end_time_or_duration.respond_to?(:since)
+      TimeInterval.from_time_and_duration(begin_or_end_time, end_time_or_duration, exclude_end: exclude_end)
+    else
+      TimeInterval.new(begin_or_end_time, end_time_or_duration, exclude_end)
+    end
+  end
+
   refine Range do
     def step(n, &blk)
       if self.begin.kind_of?(Time) || self.begin.kind_of?(Date)
-        Timerage::TimeInterval.new(self).step(n, &blk)
+        Timerage::TimeInterval.from_range(self).step(n, &blk)
       else
         super
       end
     end
 
     def to_time_interval
-      Timerage::TimeInterval.new(self)
+      Timerage::TimeInterval.from_range(self)
     end
   end
 end
@@ -40,7 +53,7 @@ module Kernel
       thing
 
     when ->(x) { x.respond_to? :exclude_end? }
-      Timerage::TimeInterval.new(thing)
+      Timerage::TimeInterval.from_range(thing)
 
     when ->(x) { x.respond_to? :to_str }
       Timerage.parse_iso8601(thing.to_str)

data/spec/timerage/time_interval_spec.rb

@@ -6,18 +6,64 @@ describe Timerage::TimeInterval do
   let(:duration) { 3600 }
 
   describe "creation" do
-    specify { expect(described_class.new(now-1..now)).to be_kind_of described_class }
-    specify { expect(described_class.new(now-1, now)).to be_kind_of described_class }
-    specify { expect(described_class.new(now-1, now, true)).to be_kind_of described_class }
-    specify { expect(described_class.new(now-1, now, false )).to be_kind_of described_class }
+    specify { expect(described_class.new(now-1.day, now))
+      .to be_kind_of(described_class).and eq now-1.day..now }
+    specify { expect(described_class.new(now-1.day, now, true))
+      .to be_kind_of(described_class).and eq now-1.day...now }
+    specify { expect(described_class.new(now-1.day, now, false ))
+      .to be_kind_of(described_class).and eq now-1.day..now }
+
+    it "support new(range) for backwards compatibility" do
+      expect(described_class.new((now-1.day)..now)).to eq (now-1.day)..now 
+    end
   end
 
-  describe ".iso8601" do
-    specify { expect(described_class
-                      .iso8601("2001-01-01T00:00:00Z/2001-01-02T00:00:00-06:00"))
-                .to be_kind_of described_class }
-    specify { expect{described_class.iso8601("2001-01-01T00:00:00Z")}
-                .to raise_error ArgumentError }
+  describe ".iso8601" do 
+    specify do
+      expect(described_class.iso8601("2001-01-01T00:00:00Z/2001-01-02T00:00:00-06:00"))
+        .to be_kind_of described_class 
+    end
+
+    specify do
+      expect{described_class.iso8601("2001-01-01T00:00:00Z")}
+        .to raise_error ArgumentError
+    end
+
+    specify do
+      expect(described_class.iso8601("2001-01-01T00:00:00Z/.."))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: Time.parse("2001-01-01T00:00:00Z"), end: nil))
+    end
+
+    specify do
+      expect(described_class.iso8601("\t2001-01-01T00:00:00Z/..\t"))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: Time.parse("2001-01-01T00:00:00Z"), end: nil))
+    end
+
+    specify do
+      expect(described_class.iso8601(" 2001-01-01T00:00:00Z/.. "))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: Time.parse("2001-01-01T00:00:00Z"), end: nil))
+    end
+
+    specify do
+      expect(described_class.iso8601("../2001-01-01T00:00:00Z"))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: nil, end: Time.parse("2001-01-01T00:00:00Z")))
+    end
+
+    specify do
+      expect(described_class.iso8601("\t../2001-01-01T00:00:00Z\t"))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: nil, end: Time.parse("2001-01-01T00:00:00Z")))
+    end
+
+    specify do
+      expect(described_class.iso8601(" ../2001-01-01T00:00:00Z "))
+        .to (be_kind_of described_class)
+          .and (have_attributes(begin: nil, end: Time.parse("2001-01-01T00:00:00Z")))
+    end
   end
 
   describe "#getutc" do
@@ -60,6 +106,18 @@ describe Timerage::TimeInterval do
             .to eq "#{interval.begin.iso8601(3)}/#{interval.end.iso8601(3)}" }
   specify { expect( interval.duration).to eq duration  }
 
+  context "open-ended intervals" do
+    subject(:interval) { described_class.new(now-duration, nil) }
+    specify { expect(interval.iso8601).to eq "#{interval.begin.iso8601}/.." }
+    specify { expect(interval.iso8601(3)).to eq "#{interval.begin.iso8601(3)}/.." }
+  end
+
+  context "open-start intervals" do
+    subject(:interval) { described_class.new(nil, now) }
+    specify { expect(interval.iso8601).to eq "../#{interval.end.iso8601}" }
+    specify { expect(interval.iso8601(3)).to eq "../#{interval.end.iso8601(3)}" }
+  end
+
   specify { expect(interval.cover? interval.begin+1..interval.end-1).to be_truthy }
   specify { expect(interval.cover? interval.begin...interval.end).to be_truthy }
   specify { expect(interval.cover? interval.begin-1..interval.end-1).to be_falsy }
@@ -86,12 +144,12 @@ describe Timerage::TimeInterval do
     specify { expect( interval & (interval.begin...interval.end) ).to eq interval.begin...interval.end }
     specify { expect( interval & (interval.begin...interval.end-1) )
               .to eq interval.begin...interval.end-1 }
-    specify { expect( described_class.new(interval.begin...interval.end-1) & interval )
-              .to eq described_class.new(interval.begin...interval.end-1) }
+    specify { expect( described_class.new(interval.begin, interval.end-1) & interval )
+              .to eq described_class.new(interval.begin,interval.end-1) }
   end
 
   describe "==" do
-    specify { expect( described_class.new(interval) == interval ).to be true }
+    specify { expect( described_class.from_range(interval) == interval ).to be true }
     specify { expect( described_class.new(interval.begin, interval.end) == interval ).to be true }
   end
 
@@ -159,7 +217,7 @@ describe Timerage::TimeInterval do
   end
 
   context "exclusive end" do
-    subject(:interval) { described_class.new(now-duration...now) }
+    subject(:interval) { described_class.from_range(now-duration...now) }
 
     specify { expect(interval.exclude_end?).to be true }
     specify { expect(interval.cover? now).to be false }
@@ -187,29 +245,29 @@ describe Timerage::TimeInterval do
   end
 
   context "exclusive 0 length interval" do
-    subject(:interval) { described_class.new(now...now) }
+    subject(:interval) { described_class.from_range(now...now) }
     specify { expect{ |b| subject.step(1, &b) }.not_to yield_control }
   end
 
   context "inclusive 0 length interval" do
-    subject(:interval) { described_class.new(now..now) }
+    subject(:interval) { described_class.from_range(now..now) }
     specify { expect{ |b| subject.step(1, &b) }.to yield_control.once }
   end
 
   context "includes leap day" do
-    subject(:interval) { described_class.new(before_leap_day..after_leap_day) }
+    subject(:interval) { described_class.new(before_leap_day, after_leap_day) }
     specify { expect{ |b| subject.step(1.day, &b) }.to yield_control.exactly(3).times }
     specify { expect{ |b| subject.step(86_400, &b) }.to yield_control.exactly(3).times }
   end
 
   context "transition into dst with explicit time zone" do
-    subject(:interval) { described_class.new(before_dst..after_dst) }
+    subject(:interval) { described_class.new(before_dst, after_dst) }
     specify { expect{ |b| subject.step(1.hour, &b) }.to yield_control.exactly(2).times }
     specify { expect{ |b| subject.step(3_600, &b) }.to yield_control.exactly(2).times }
   end
 
   context "transition into dst without explicit time zone" do
-    subject(:interval) { described_class.new(before_dst..(before_dst + 1.hour)) }
+    subject(:interval) { described_class.new(before_dst, (before_dst + 1.hour)) }
     specify { expect{ |b| subject.step(1.hour, &b) }.to yield_control.exactly(2).times }
     specify { expect{ |b| subject.step(3_600, &b) }.to yield_control.exactly(2).times }
   end
@@ -230,6 +288,14 @@ describe Timerage::TimeInterval do
     end
   end
 
+  context "produces complete slices" do
+    it "slices a range into intervals without missing any time inbetween" do
+      range = Timerage(Time.parse("2023-10-31T00:00:00+00:00")...Time.parse("2024-06-30 00:00:00 UTC"))
+      slices = range.slice(1.month)
+      expect(slices.map(&:duration).sum).to eq range.duration
+    end
+  end
+
   let(:leap_day) { Time.parse("2016-02-29 12:00:00 UTC") }
   let(:before_leap_day) { leap_day - 1.day }
   let(:after_leap_day) { leap_day + 1.day}

data/spec/timerage_spec.rb

@@ -17,6 +17,22 @@ describe Timerage do
                 .to be_kind_of Time }
     end
 
+    describe ".Interval" do
+      let(:t) { Time.now }
+      let(:one_day) { 1.day }
+
+      specify { expect(described_class.Interval(t, 1.day)).to eq t...(t+1.day) }
+      specify { expect(described_class.Interval(t, 1.day, exclude_end: false)).to eq(t..(t+1.day)) }
+
+      specify { expect(described_class.Interval(t, -1.day)).to eq((t-1.day)...t) }
+      specify { expect(described_class.Interval(t, -1.day, exclude_end: false)).to eq((t+-1.day)..t) }
+
+      specify { expect{ described_class.Interval(t, (t+1.day)).to eq(t...(t+1.day)) } }
+      specify { expect{ described_class.Interval(t, (t+1.day), exclude_end: false).to eq(t..(t+1.day)) } }
+
+      specify { expect{ described_class.Interval(t..(t+1.day)).to eq(t..(t+1.day)) } }
+    end 
+
     context "interval include end" do
       specify { expect{|b| range.step(1200, &b) }
           .to yield_successive_args now-duration, now-(duration-1200), now-(duration-2400), now }

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timerage
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Peter Williams
 - Chris Schneider
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,7 +95,6 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Simple refinement to Range to allow Time or Date as arguments
 test_files: