timerage 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '07846226e71bd754087bd3b54c49d85a70e9d2f9b809d678351fbd685546fcb4'
-  data.tar.gz: e3be843301a7d7a7ea7cec902c2f4fd8152314a5cbbf4e74d8aad65ede5196ec
+  metadata.gz: d21955bc8e1453cafb40e1de151e67835964f857728eaa1cf001a7c70a79a1fb
+  data.tar.gz: efc6d71d6fbc442b2fc3fa2066657cc51bc669549ad52a576ef09f14d29aa171
 SHA512:
-  metadata.gz: 76acc33ddaa358897021f20b82c4f3faffb1867469e410da6566480880c78c9524a84e39edb6c3468bfd5d49cba4d72dfe526dbd749ad6ecff66be839fcb6bc0
-  data.tar.gz: 96e281a1b857a002653629b4289574f4488068609f40f74b85832966a402311c88ea16f9db91080a74566ac502a7bd1468d496bb73b5095dcfbe572d09f2ec06
+  metadata.gz: 58064fee1d615adf865a0de63f0db64d7757af8b837c475d9ccf43018fd25574305250ef6ee525931ef9a7d5cdd1a69e203a13b4de22511ec9cafbc4e07a13e2
+  data.tar.gz: 836ed39bef1dd174aa19e90a9f049a5bff4c88a79419aaf810470a698cdee2fb44aa41f17624a95fb440ee7ed31fad4aa1fdc53ed7fad8bef20e5c00cba8bf15

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
@@ -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
 

data/lib/timerage/version.rb

@@ -1,3 +1,3 @@
 module Timerage
-  VERSION = "2.2.0"
+  VERSION = "2.3.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,10 +6,16 @@ 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
@@ -86,12 +92,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 +165,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 +193,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 +236,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timerage
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Peter Williams
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-10 00:00:00.000000000 Z
+date: 2024-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Simple refinement to Range to allow Time or Date as arguments