timerage 2.1.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2b0e89fc0f24f9a2d8216d867b9d7d8f9477c4b449bc43c9d5287c4e24057c7
-  data.tar.gz: b6a3376136ad56501316b735da77c3ba8667803fd80f3a8812e941cf0f8dbbc3
+  metadata.gz: d21955bc8e1453cafb40e1de151e67835964f857728eaa1cf001a7c70a79a1fb
+  data.tar.gz: efc6d71d6fbc442b2fc3fa2066657cc51bc669549ad52a576ef09f14d29aa171
 SHA512:
-  metadata.gz: 157b9c3a249183f8e8b4247332b5be02578899bf1c6d67e84853d161950bd09894d87098676eed4f71ced7a1e23d33e0c27168fdc27570a020e2774110664e75
-  data.tar.gz: 131e7dbf90167eeaf21935d246327283da94371ffa40c27ee36577317daf7a92d91049acde3a4bfe6f48eaa87cdebf2cd596889e68983523fd6992a03e6d1ae9
+  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,8 +157,12 @@ 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 = 0.seconds
+      next_offset = step * 0
 
       Enumerator.new do |y|
         while self.cover?(self.begin + next_offset)

data/lib/timerage/version.rb

@@ -1,3 +1,3 @@
 module Timerage
-  VERSION = "2.1.1"
+  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,33 +193,57 @@ 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
 
+  context "When given date range" do
+    it "returns date objects when stepping through the range with a day duration" do
+      date_range = Date.new(2020, 1, 1)..Date.new(2020,1,3)
+      described_class.new(date_range).step(1.day) do |date|
+        expect(date).to be_kind_of Date
+      end
+    end
+
+    it "returns Time objects when stepping through the range with an hour duration" do
+      date_range = Date.new(2020, 1, 1)..Date.new(2020,1,2)
+      described_class.new(date_range).step(6.hours) do |date|
+        expect(date).to be_kind_of Time
+      end
+    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,15 @@
 --- !ruby/object:Gem::Specification
 name: timerage
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.3.0
 platform: ruby
 authors:
 - Peter Williams
 - Chris Schneider
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-08 00:00:00.000000000 Z
+date: 2024-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,7 +96,7 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +111,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Simple refinement to Range to allow Time or Date as arguments
 test_files: