timeframe 0.2.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5c448bfd96b67234ea8986d23f6c9f668ffacb9
+  data.tar.gz: 0b348d4217d82035a8247f6a23546ce223af3e3f
+SHA512:
+  metadata.gz: c9fca9bff28ef6ea8cf6de692f79509a7200fe85efedc9c871f538c4e72402a329fc4e69d6737aa45064744b1bad35933c401920b3094a2de865c6d820fc4445
+  data.tar.gz: e65458296129a65a665f0cfd4357cd9fa34ee023613d4414887f951cc1199153542bf77c2d0c0ba1aa97c0c98006b19026efc71f3891a00d8450f4b86bdc4120

data/CHANGELOG

@@ -1,3 +1,14 @@
+1.0.0 / 2017-06-22
+
+* Breaking changes
+
+  * No more Array#multiple_timeframes_gaps_left_by (who knows what that was for)
+
+* Enhancements
+
+  * Only uses active_support/core_ext/date
+  * Convert to rspec, modernize
+
 0.2.1 / 2012-04-24
 
 * Bug fixes

data/Gemfile

@@ -1,9 +1,3 @@
 source :rubygems
 
 gemspec
-
-# development dependencies
-gem 'yard'
-gem 'rake'
-gem 'minitest'
-gem 'minitest-reporters'

data/Rakefile

@@ -1,15 +1,6 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-require 'rake'
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
-
-require 'yard'
-YARD::Rake::YardocTask.new
+task :default => :spec

data/lib/timeframe.rb

@@ -1,7 +1,7 @@
 require 'date'
 require 'multi_json'
-require 'active_support/version'
-require 'active_support/core_ext' if ActiveSupport::VERSION::MAJOR >= 3
+require 'active_support'
+require 'active_support/core_ext/date'
 
 require 'timeframe/iso_8601'
 
@@ -94,10 +94,23 @@ class Timeframe
       new *args
     end
 
+    def to_date(v)
+      case v
+      when NilClass
+        nil
+      when Date
+        v
+      when Time
+        v.to_date
+      else
+        Date.parse v
+      end
+    end
+
     private
     
     def make_dates(start_date, end_date)
-      [start_date.to_date, end_date.to_date]
+      [to_date(start_date), to_date(end_date)]
     end
   end
 
@@ -131,8 +144,8 @@ class Timeframe
       end_date   = Date.new(year+1, 1, 1)
     end
 
-    start_date = args.shift.to_date if start_date.nil? and args.any?
-    end_date = args.shift.to_date if end_date.nil? and args.any?
+    start_date ||= Timeframe.to_date(args[0])
+    end_date ||= Timeframe.to_date(args[1])
 
     raise ArgumentError, "Please supply a start and end date, `#{args.map(&:inspect).to_sentence}' is not enough" if start_date.nil? or end_date.nil?
     raise ArgumentError, "Start date #{start_date} should be earlier than end date #{end_date}" if start_date > end_date
@@ -160,7 +173,7 @@ class Timeframe
     when Date
       (start_date...end_date).include?(obj)
     when Time
-      # (start_date...end_date).include?(obj.to_date)
+      # (start_date...end_date).include?(Date.parse(obj))
       raise "this wasn't previously supported, but it could be"
     when Timeframe
       start_date <= obj.start_date and end_date >= obj.end_date
@@ -275,7 +288,10 @@ class Timeframe
 
   # Returns the same Timeframe, only a year earlier
   def last_year
-    self.class.new((start_date - 1.year), (end_date - 1.year))
+    self.class.new(
+      Date.new(start_date.year - 1, start_date.month, start_date.day),
+      Date.new(end_date.year - 1, end_date.month, end_date.day)
+    )
   end
   
   def as_json(*)

data/lib/timeframe/version.rb

@@ -1,3 +1,3 @@
 class Timeframe
-  VERSION = '0.2.1'
+  VERSION = '1.0.0'
 end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'timeframe'
+
+RSpec.configure do |config|
+end

data/spec/timeframe_spec.rb

@@ -0,0 +1,332 @@
+require_relative 'spec_helper'
+
+describe Timeframe do
+  describe 'initialization' do
+    it 'should create a timeframe using date strings' do
+      tf = Timeframe.new('2008-02-14', '2008-05-10')
+      expect(tf.from).to eq(Date.parse('2008-02-14'))
+      expect(tf.to).to eq(Date.parse('2008-05-10'))
+    end
+    it 'should create a timeframe using date objects' do
+      start = Date.parse('2008-02-14')
+      finish = Date.parse('2008-05-10')
+      tf = Timeframe.new(start, finish)
+      expect(tf.from).to eq(start)
+      expect(tf.to).to eq(finish)
+    end
+    it "should accept months" do
+      timeframe = Timeframe.new(:month => 1)
+      expect(timeframe.from).to eq(Date.today.change(:month => 1, :day => 1))
+      expect(timeframe.to).to eq(Date.today.change(:month => 2, :day => 1))
+    end
+    it "should accept month names" do
+      timeframe = Timeframe.new(:month => 'february')
+      expect(timeframe.from).to eq(Date.today.change(:month => 2, :day => 1))
+      expect(timeframe.to).to eq(Date.today.change(:month => 3, :day => 1))
+    end
+    it "should accept years" do
+      timeframe = Timeframe.new(:year => 2004)
+      expect(timeframe.from).to eq(Date.new(2004, 1, 1))
+      expect(timeframe.to).to eq(Date.new(2005, 1, 1))
+    end
+    it "should accept years and months" do
+      timeframe = Timeframe.new(:year => 2005, :month => 5)
+      expect(timeframe.from).to eq(Date.new(2005, 5, 1))
+      expect(timeframe.to).to eq(Date.new(2005, 6, 1))
+    end
+    it "should not accept just one date argument" do
+      expect {
+        Timeframe.new Date.new(2007, 2, 1)
+      }.to raise_error(ArgumentError, /supply/)
+    end
+    it "should not accept end date that is earlier than start date" do
+      expect {
+        timeframe = Timeframe.new Date.new(2008, 1, 1), Date.new(2007, 1, 1)
+      }.to raise_error(ArgumentError, /earlier/)
+    end
+    it "should always accept timeframes that cross year boundaries" do
+      timeframe = Timeframe.new Date.new(2007, 1, 1), Date.new(2008, 1, 2)
+      expect(timeframe.start_date).to eq(Date.new(2007, 1, 1))
+    end
+  end
+
+  describe '#inspect' do
+    it 'should return the time frame in readable text' do
+      start = Date.parse('2008-02-14')
+      finish = Date.parse('2008-05-10')
+      tf = Timeframe.new(start, finish)
+      expect(tf.inspect).to match(%r{<Timeframe\(-?\d+\) 86 days starting 2008-02-14 ending 2008-05-10>})
+    end
+  end
+
+  describe :constrained_new do
+    let(:start) { Date.parse('2008-02-14') }
+    let(:finish) { Date.parse('2008-05-10') }
+    let(:constraint_start) { Date.parse('2008-01-01') }
+    let(:constraint_finish) { Date.parse('2008-12-01') }
+    let(:constraint) { Timeframe.new(constraint_start, constraint_finish) }
+
+    it "should allow for constrained creation" do
+      constraint = Timeframe.new :year => 2008
+      may = Timeframe.new Date.new(2008,5,1), Date.new(2008,6,1)
+      january = Timeframe.new Date.new(2008,1,1), Date.new(2008,2,1)
+      expect(Timeframe.constrained_new(may.from, may.to, constraint)).to eq(may)
+      expect(Timeframe.constrained_new(Date.new(2007,1,1), Date.new(2010,1,1), constraint)).to eq(constraint)
+      expect(Timeframe.constrained_new(Date.new(2007,11,1), Date.new(2008,2,1), constraint)).to eq(january)
+    end
+    it 'should return a timeframe spanning start and end date if within constraint' do
+      tf = Timeframe.constrained_new(start, finish, constraint)
+      expect(tf.from).to eq(start)
+      expect(tf.to).to eq(finish)
+    end
+    it 'should return a timeframe spanning constraint start and end date if outside constraint' do
+      constraint = Timeframe.new(start, finish)
+      tf = Timeframe.constrained_new(constraint_start, constraint_finish, constraint)
+      expect(tf.from).to eq(start)
+      expect(tf.to).to eq(finish)
+    end
+    it 'should return a timeframe starting at constraint start' do
+      start = Date.parse('2008-01-01')
+      constraint_start = Date.parse('2008-01-14')
+      constraint = Timeframe.new(constraint_start, constraint_finish)
+      tf = Timeframe.constrained_new(start, finish, constraint)
+      expect(tf.from).to eq(constraint_start)
+      expect(tf.to).to eq(finish)
+    end
+    it 'should return a timeframe ending at constraint end' do
+      constraint_finish = Date.parse('2008-04-14')
+      constraint = Timeframe.new(constraint_start, constraint_finish)
+      tf = Timeframe.constrained_new(start, finish, constraint)
+      expect(tf.from).to eq(start)
+      expect(tf.to).to eq(constraint_finish)
+    end
+    it "should return a 0-length timeframe when constraining a timeframe by a disjoint timeframe" do
+      constraint = Timeframe.new :year => 2010
+      timeframe = Timeframe.constrained_new(
+        Date.new(2009,1,1), Date.new(2010,1,1), constraint)
+      expect(timeframe.days).to eq(0)
+    end
+  end
+
+  describe :this_year do
+    it "should return the current year" do
+      expect(Timeframe.this_year).to eq(Timeframe.new(:year => Time.now.year))
+    end
+  end
+
+  describe '#days' do
+    it "should return them number of days included" do
+      #TODO: make these separate "it" blocks, per best practices
+      expect(Timeframe.new(Date.new(2007, 1, 1), Date.new(2008, 1, 1)).days).to eq(365)
+      expect(Timeframe.new(Date.new(2008, 1, 1), Date.new(2009, 1, 1)).days).to eq(366) # leap year
+      expect(Timeframe.new(Date.new(2007, 11, 1), Date.new(2007, 12, 1)).days).to eq(30)
+      expect(Timeframe.new(Date.new(2007, 11, 1), Date.new(2008, 1, 1)).days).to eq(61)
+      expect(Timeframe.new(Date.new(2007, 2, 1), Date.new(2007, 3, 1)).days).to eq(28)
+      expect(Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 3, 1)).days).to eq(29)
+      expect(Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 2, 1)).days).to eq(0)
+    end
+  end
+
+  describe '#include?' do
+    it "should know if a certain date is included in the Timeframe" do
+      #TODO: make these separate "it" blocks, per best practices
+      timeframe = Timeframe.new :year => 2008, :month => 2
+      [
+        Date.new(2008, 2, 1),
+        Date.new(2008, 2, 5),
+        Date.new(2008, 2, 29)
+      ].each do |date|
+        expect(timeframe.include?(date)).to eq(true)
+      end
+      [
+        Date.new(2008, 1, 1),
+        Date.new(2007, 2, 1),
+        Date.new(2008, 3, 1)
+      ].each do |date|
+        expect(timeframe.include?(date)).to eq(false)
+      end
+    end
+  end
+
+  describe '#==' do
+    it "should be able to know if it's equal to another Timeframe object" do
+      expect(Timeframe.new(:year => 2007)).to eq(Timeframe.new(:year => 2007))
+      expect(Timeframe.new(:year => 2004, :month => 1)).to eq(Timeframe.new(:year => 2004, :month => 1))
+    end
+
+    it "should hash equal hash values when the timeframe is equal" do
+      expect(Timeframe.new(:year => 2007).hash).to eq(Timeframe.new(:year => 2007).hash)
+      expect(Timeframe.new(:year => 2004, :month => 1).hash).to eq(Timeframe.new(:year => 2004, :month => 1).hash)
+    end
+  end
+
+  describe '#months' do
+    it "should return an array of month-long subtimeframes" do
+      expect(Timeframe.new(:year => 2009).months.length).to eq(12)
+    end
+  end
+
+  describe '#year' do
+    it "should return the relevant year of a timeframe" do
+      expect(Timeframe.new(Date.new(2009, 2, 1), Date.new(2009, 4, 1)).year).to eq(Timeframe.new(:year => 2009))
+    end
+    it "should not return the relevant year of a timeframe if provided an inappropriate range" do
+      expect {
+        Timeframe.new(Date.new(2009, 1, 1), Date.new(2012, 1, 1)).year
+      }.to raise_error(ArgumentError, /dangerous during/)
+    end
+  end
+
+  describe '#&' do
+    it "should return its intersection with another timeframe" do
+      #TODO: make these separate "it" blocks, per best practices
+      expect(Timeframe.new(:month => 4) & Timeframe.new(:month => 6)).to be_nil
+      expect(Timeframe.new(:month => 4) & Timeframe.new(:month => 5)).to be_nil
+      expect((Timeframe.new(:month => 4) & Timeframe.new(:month => 4))).to eq(Timeframe.new(:month => 4))
+      expect((Timeframe.new(:year => Time.now.year) & Timeframe.new(:month => 4))).to eq(Timeframe.new(:month => 4))
+      expect((Timeframe.new(Date.new(2009, 2, 1), Date.new(2009, 6, 1)) & Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 8, 1)))).to eq(Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 6, 1)))
+    end
+  end
+
+  describe '#/' do
+    it "should return a fraction of another timeframe" do 
+      expect(Timeframe.new(:month => 4, :year => 2009) / Timeframe.new(:year => 2009)).to eq(30.0 / 365.0)
+    end
+  end
+
+  describe '#gaps_left_by' do
+    it "should be able to ascertain gaps left by a list of other Timeframes" do
+      expect(Timeframe.new(:year => 2009).gaps_left_by(
+        Timeframe.new(:year => 2009, :month => 3),
+        Timeframe.new(:year => 2009, :month => 5),
+        Timeframe.new(Date.new(2009, 8, 1), Date.new(2009, 11, 1)),
+        Timeframe.new(Date.new(2009, 9, 1), Date.new(2009, 10, 1))
+      )).to eq(
+        [ Timeframe.new(Date.new(2009, 1, 1), Date.new(2009, 3, 1)),
+          Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 5, 1)),
+          Timeframe.new(Date.new(2009, 6, 1), Date.new(2009, 8, 1)),
+          Timeframe.new(Date.new(2009, 11, 1), Date.new(2010, 1, 1)) ])
+    end
+  end
+
+  describe '#covered_by?' do
+    it "should be able to ascertain gaps left by a list of other Timeframes" do
+      expect(Timeframe.new(:year => 2009).covered_by?(
+        Timeframe.new(:month => 1, :year => 2009),
+        Timeframe.new(Date.new(2009, 2, 1), Date.new(2010, 1, 1))
+      )).to eq(true)
+    end
+  end
+
+  describe '#last_year' do
+    it "should return its predecessor in a previous year" do
+      expect(Timeframe.this_year.last_year).to eq(Timeframe.new(Date.new(Date.today.year - 1, 1, 1), Date.new(Date.today.year, 1, 1)))
+    end
+  end
+  
+  describe :parse do
+    describe 'ISO 8601 <start>/<end>' do
+      it 'works without time' do
+        expect(Timeframe.parse('2007-03-01/2008-05-11')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('2007-03-01--2008-05-11')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+      end
+      it 'works with time' do
+        expect(Timeframe.parse('2007-03-01T13:00:00Z/2008-05-11T15:30:00Z')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('2007-03-01T13:00:00Z--2008-05-11T15:30:00Z')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+      end
+      it 'takes shorthand' do
+        expect(Timeframe.parse('2007-11-13/15')).to eq(Timeframe.new(Date.new(2007, 11, 13), Date.new(2007, 11, 15))) # "2007-11-13/15", i.e. from any time on 2007-11-13 to any time on 2007-11-15
+        expect(Timeframe.parse("2008-02-15/03-14")).to eq(Timeframe.new(Date.new(2008, 2, 15), Date.new(2008, 3, 14))) # "2008-02-15/2008-03-14"
+        expect(Timeframe.parse("2007-12-14T13:30/15:30")).to eq(Timeframe.new(Date.new(2007, 12, 14), Date.new(2007, 12, 14))) # "2007-12-14T13:30/2007-12-14T15:30".. imprecise!
+      end
+    end
+
+    describe 'ISO 8601 <start>/<duration>' do
+      it 'works without time' do
+        expect(Timeframe.parse('2007-03-01/P1Y2M10DT2H30M')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('2007-03-01--P1Y2M10DT2H30M')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+      end
+      it 'works with time' do
+        expect(Timeframe.parse('2007-03-01T13:00:00Z/P1Y2M10DT2H30M')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('2007-03-01T13:00:00Z--P1Y2M10DT2H30M')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11)))
+      end
+    end
+    
+    # note that 2008 was a leap year
+    describe 'ISO 8601 <duration>/<end>' do
+      it 'works with leap years' do
+        expect(Timeframe.parse('2007-02-28--P1Y')).to eq(Timeframe.new(Date.new(2007, 2, 28), Date.new(2008, 2, 29)))
+        expect(Timeframe.parse('P1Y--2008-02-29')).to eq(Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 2, 29)))
+      end
+      it 'works without time' do
+        expect(Timeframe.parse('P1Y2M10DT2H30M/2008-05-11')).to eq(Timeframe.new(Date.new(2007, 3, 2), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('P1Y2M10DT2H30M--2008-05-11')).to eq(Timeframe.new(Date.new(2007, 3, 2), Date.new(2008, 5, 11)))
+      end
+      it 'works with time' do
+        expect(Timeframe.parse('P1Y2M10DT2H30M/2008-05-11T15:30:00Z')).to eq(Timeframe.new(Date.new(2007, 3, 3), Date.new(2008, 5, 11)))
+        expect(Timeframe.parse('P1Y2M10DT2H30M--2008-05-11T15:30:00Z')).to eq(Timeframe.new(Date.new(2007, 3, 3), Date.new(2008, 5, 11)))
+      end
+    end
+
+    it 'understands plain year' do
+      plain_year = 2009
+      expect(Timeframe.parse(plain_year)).to eq(Timeframe.new(:year => plain_year))
+      expect(Timeframe.parse(plain_year.to_s)).to eq(Timeframe.new(:year => plain_year))
+    end
+    it 'understands JSON' do
+      json =<<-EOS
+      "2009-05-01/2009-06-01"
+EOS
+      expect(Timeframe.parse(json)).to eq(Timeframe.new(:year => 2009, :month => 5))
+    end
+    it 'understands a particular style of Ruby hash we used to emit (deprecated)' do
+      hsh = { :startDate => '2009-05-01', :endDate => '2009-06-01' }
+      expect(Timeframe.parse(hsh)).to eq(Timeframe.new(:year => 2009, :month => 5))
+      expect(Timeframe.parse(hsh.stringify_keys)).to eq(Timeframe.new(:year => 2009, :month => 5))
+    end
+  end
+
+  describe '#as_json' do
+    it 'should generate JSON (test fails on ruby 1.8)' do
+      expect(Timeframe.new(:year => 2009).as_json).to eq(%{2009-01-01/2010-01-01})
+      expect(MultiJson.dump(Timeframe.new(:year => 2009))).to eq(Timeframe.new(:year => 2009).as_json.inspect)
+    end
+    it 'understands its own JSON' do
+      t = Timeframe.new(:year => 2009, :month => 5)
+      expect(Timeframe.from_json(MultiJson.dump(t))).to eq(t)
+    end
+  end
+
+  describe '#to_param' do
+    it 'should generate a URL-friendly parameter' do
+      expect(Timeframe.new(:year => 2009).to_param).to eq("2009-01-01/2010-01-01")
+    end
+    it 'understands its own #to_param' do
+      t = Timeframe.new(:year => 2009, :month => 5)
+      expect(Timeframe.parse(t.to_param)).to eq(t)
+    end
+  end
+
+  describe '#to_s' do
+    it 'should not only look at month numbers when describing multi-year timeframes' do
+      expect(Timeframe.new(Date.parse('2008-01-01'), Date.parse('2010-01-01')).to_s).to eq("2008-01-01/2010-01-01")
+    end
+  end
+  
+  describe '#dates' do
+    it "should enumerate all dates between start and end" do
+      dates = Timeframe.new(:year => 2008).dates
+      expect(dates.min).to eq(Date.new(2008,1,1))
+      expect(dates.max).to eq(Date.new(2008,12,31))
+      expect(dates.uniq.length).to eq(366)
+      expect(dates.select { |d| d.month == 2 }.length).to eq(29)
+    end
+  end
+  
+  describe '#first_days_of_months' do
+    it "should enumerate all the first days of included months" do
+      dates = Timeframe.parse('2011-05-01/2012-02-01').first_days_of_months
+      expect(dates).to eq([Date.new(2011,5,1), Date.new(2011,6,1), Date.new(2011,7,1), Date.new(2011,8,1), Date.new(2011,9,1), Date.new(2011,10,1), Date.new(2011,11,1), Date.new(2011,12,1), Date.new(2012,1,1)])
+    end
+  end
+end

data/timeframe.gemspec

@@ -21,5 +21,8 @@ Gem::Specification.new do |s|
   
   s.add_runtime_dependency 'activesupport', '>=2.3.5'
   s.add_runtime_dependency 'i18n'
-  s.add_runtime_dependency 'multi_json'
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timeframe
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Andy Rossmeissl
@@ -11,54 +10,76 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-24 00:00:00.000000000 Z
+date: 2017-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.5
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A Ruby class for describing and interacting with timeframes.
@@ -68,44 +89,41 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGELOG
 - Gemfile
 - LICENSE
 - README.markdown
 - Rakefile
 - lib/timeframe.rb
-- lib/timeframe/core_ext/array.rb
 - lib/timeframe/iso_8601.rb
 - lib/timeframe/version.rb
-- test/helper.rb
-- test/test_timeframe.rb
+- spec/spec_helper.rb
+- spec/timeframe_spec.rb
 - timeframe.gemspec
 homepage: http://github.com/rossmeissl/timeframe
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: timeframe
-rubygems_version: 1.8.21
+rubygems_version: 2.6.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Date intervals
 test_files:
-- test/helper.rb
-- test/test_timeframe.rb
-has_rdoc: 
+- spec/spec_helper.rb
+- spec/timeframe_spec.rb

data/lib/timeframe/core_ext/array.rb

@@ -1,9 +0,0 @@
-class Array
-  # Constructs an array of timeframes representing the "gaps" left by the given array of timeframes.
-  #
-  # To use this feature, you must explicitly require 'timeframe/core_ext/array'
-  def multiple_timeframes_gaps_left_by(*time_frames)
-    raise ArgumentError.new 'You can only use timeframe for this operation' unless [self + time_frames].flatten.all?{|el| el.is_a?(Timeframe)}
-    self.inject([]){|a,b| a << b.gaps_left_by(*time_frames)}.flatten
-  end
-end

data/test/helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/reporters'
-MiniTest::Unit.runner = MiniTest::SuiteRunner.new
-MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new
-
-require 'timeframe'
-require 'timeframe/core_ext/array'

data/test/test_timeframe.rb

@@ -1,354 +0,0 @@
-require 'helper'
-
-describe Timeframe do
-  describe 'initialization' do
-    it 'should create a timeframe using date strings' do
-      tf = Timeframe.new('2008-02-14', '2008-05-10')
-      tf.from.must_equal Date.parse('2008-02-14')
-      tf.to.must_equal Date.parse('2008-05-10')
-    end
-    it 'should create a timeframe using date objects' do
-      start = Date.parse('2008-02-14')
-      finish = Date.parse('2008-05-10')
-      tf = Timeframe.new(start, finish)
-      tf.from.must_equal start
-      tf.to.must_equal finish
-    end
-    it "should accept months" do
-      timeframe = Timeframe.new(:month => 1)
-      timeframe.from.must_equal Date.today.change(:month => 1, :day => 1)
-      timeframe.to.must_equal Date.today.change(:month => 2, :day => 1)
-    end
-    it "should accept month names" do
-      timeframe = Timeframe.new(:month => 'february')
-      timeframe.from.must_equal Date.today.change(:month => 2, :day => 1)
-      timeframe.to.must_equal Date.today.change(:month => 3, :day => 1)
-    end
-    it "should accept years" do
-      timeframe = Timeframe.new(:year => 2004)
-      timeframe.from.must_equal Date.new(2004, 1, 1)
-      timeframe.to.must_equal Date.new(2005, 1, 1)
-    end
-    it "should accept years and months" do
-      timeframe = Timeframe.new(:year => 2005, :month => 5)
-      timeframe.from.must_equal Date.new(2005, 5, 1)
-      timeframe.to.must_equal Date.new(2005, 6, 1)
-    end
-    it "should not accept just one date argument" do
-      lambda {
-        Timeframe.new Date.new(2007, 2, 1)
-      }.must_raise(ArgumentError, /supply/)
-    end
-    it "should not accept end date that is earlier than start date" do
-      lambda {
-        timeframe = Timeframe.new Date.new(2008, 1, 1), Date.new(2007, 1, 1)
-      }.must_raise(ArgumentError, /earlier/)
-    end
-    it "should always accept timeframes that cross year boundaries" do
-      timeframe = Timeframe.new Date.new(2007, 1, 1), Date.new(2008, 1, 2)
-      timeframe.start_date.must_equal Date.new(2007, 1, 1)
-    end
-  end
-
-  describe '#inspect' do
-    it 'should return the time frame in readable text' do
-      start = Date.parse('2008-02-14')
-      finish = Date.parse('2008-05-10')
-      tf = Timeframe.new(start, finish)
-      tf.inspect.must_match %r{<Timeframe\(-?\d+\) 86 days starting 2008-02-14 ending 2008-05-10>}
-    end
-  end
-
-  describe :constrained_new do
-    let(:start) { Date.parse('2008-02-14') }
-    let(:finish) { Date.parse('2008-05-10') }
-    let(:constraint_start) { Date.parse('2008-01-01') }
-    let(:constraint_finish) { Date.parse('2008-12-01') }
-    let(:constraint) { Timeframe.new(constraint_start, constraint_finish) }
-
-    it "should allow for constrained creation" do
-      constraint = Timeframe.new :year => 2008
-      may = Timeframe.new Date.new(2008,5,1), Date.new(2008,6,1)
-      january = Timeframe.new Date.new(2008,1,1), Date.new(2008,2,1)
-      Timeframe.constrained_new(may.from, may.to, constraint).must_equal may
-      Timeframe.constrained_new(Date.new(2007,1,1), Date.new(2010,1,1), constraint).must_equal constraint
-      Timeframe.constrained_new(Date.new(2007,11,1), Date.new(2008,2,1), constraint).must_equal january
-    end
-    it 'should return a timeframe spanning start and end date if within constraint' do
-      tf = Timeframe.constrained_new(start, finish, constraint)
-      tf.from.must_equal start
-      tf.to.must_equal finish
-    end
-    it 'should return a timeframe spanning constraint start and end date if outside constraint' do
-      constraint = Timeframe.new(start, finish)
-      tf = Timeframe.constrained_new(constraint_start, constraint_finish, constraint)
-      tf.from.must_equal start
-      tf.to.must_equal finish
-    end
-    it 'should return a timeframe starting at constraint start' do
-      start = Date.parse('2008-01-01')
-      constraint_start = Date.parse('2008-01-14')
-      constraint = Timeframe.new(constraint_start, constraint_finish)
-      tf = Timeframe.constrained_new(start, finish, constraint)
-      tf.from.must_equal constraint_start
-      tf.to.must_equal finish
-    end
-    it 'should return a timeframe ending at constraint end' do
-      constraint_finish = Date.parse('2008-04-14')
-      constraint = Timeframe.new(constraint_start, constraint_finish)
-      tf = Timeframe.constrained_new(start, finish, constraint)
-      tf.from.must_equal start
-      tf.to.must_equal constraint_finish
-    end
-    it "should return a 0-length timeframe when constraining a timeframe by a disjoint timeframe" do
-      constraint = Timeframe.new :year => 2010
-      timeframe = Timeframe.constrained_new(
-        Date.new(2009,1,1), Date.new(2010,1,1), constraint)
-      timeframe.days.must_equal 0
-    end
-  end
-
-  describe :this_year do
-    it "should return the current year" do
-      Timeframe.this_year.must_equal Timeframe.new(:year => Time.now.year)
-    end
-  end
-
-  describe '#days' do
-    it "should return them number of days included" do
-      #TODO: make these separate "it" blocks, per best practices
-      Timeframe.new(Date.new(2007, 1, 1), Date.new(2008, 1, 1)).days.must_equal 365
-      Timeframe.new(Date.new(2008, 1, 1), Date.new(2009, 1, 1)).days.must_equal 366 #leap year
-      Timeframe.new(Date.new(2007, 11, 1), Date.new(2007, 12, 1)).days.must_equal 30
-      Timeframe.new(Date.new(2007, 11, 1), Date.new(2008, 1, 1)).days.must_equal 61
-      Timeframe.new(Date.new(2007, 2, 1), Date.new(2007, 3, 1)).days.must_equal 28
-      Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 3, 1)).days.must_equal 29
-      Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 2, 1)).days.must_equal 0
-    end
-  end
-
-  describe '#include?' do
-    it "should know if a certain date is included in the Timeframe" do
-      #TODO: make these separate "it" blocks, per best practices
-      timeframe = Timeframe.new :year => 2008, :month => 2
-      [
-        Date.new(2008, 2, 1),
-        Date.new(2008, 2, 5),
-        Date.new(2008, 2, 29)
-      ].each do |date|
-        timeframe.include?(date).must_equal true
-      end
-      [
-        Date.new(2008, 1, 1),
-        Date.new(2007, 2, 1),
-        Date.new(2008, 3, 1)
-      ].each do |date|
-        timeframe.include?(date).must_equal false
-      end
-    end
-  end
-
-  describe '#==' do
-    it "should be able to know if it's equal to another Timeframe object" do
-      Timeframe.new(:year => 2007).must_equal Timeframe.new(:year => 2007)
-      Timeframe.new(:year => 2004, :month => 1).must_equal Timeframe.new(:year => 2004, :month => 1)
-    end
-
-    it "should hash equal hash values when the timeframe is equal" do
-      Timeframe.new(:year => 2007).hash.must_equal Timeframe.new(:year => 2007).hash
-      Timeframe.new(:year => 2004, :month => 1).hash.must_equal Timeframe.new(:year => 2004, :month => 1).hash
-    end
-  end
-
-  describe '#months' do
-    it "should return an array of month-long subtimeframes" do
-      Timeframe.new(:year => 2009).months.length.must_equal 12
-    end
-  end
-
-  describe '#year' do
-    it "should return the relevant year of a timeframe" do
-      Timeframe.new(Date.new(2009, 2, 1), Date.new(2009, 4, 1)).year.must_equal Timeframe.new(:year => 2009)
-    end
-    it "should not return the relevant year of a timeframe if provided an inappropriate range" do
-      lambda {
-        Timeframe.new(Date.new(2009, 1, 1), Date.new(2012, 1, 1)).year
-      }.must_raise(ArgumentError, /dangerous during/)
-    end
-  end
-
-  describe '#&' do
-    it "should return its intersection with another timeframe" do
-      #TODO: make these separate "it" blocks, per best practices
-      (Timeframe.new(:month => 4) & Timeframe.new(:month => 6)).must_be_nil
-      (Timeframe.new(:month => 4) & Timeframe.new(:month => 5)).must_be_nil
-      (Timeframe.new(:month => 4) & Timeframe.new(:month => 4)).must_equal Timeframe.new(:month => 4)
-      (Timeframe.new(:year => Time.now.year) & Timeframe.new(:month => 4)).must_equal Timeframe.new(:month => 4)
-      (Timeframe.new(Date.new(2009, 2, 1), Date.new(2009, 6, 1)) & Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 8, 1))).must_equal Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 6, 1))
-    end
-  end
-
-  describe '#/' do
-    it "should return a fraction of another timeframe" do 
-      (Timeframe.new(:month => 4, :year => 2009) / Timeframe.new(:year => 2009)).must_equal(30.0 / 365.0)
-    end
-  end
-
-  describe '#gaps_left_by' do
-    it "should be able to ascertain gaps left by a list of other Timeframes" do
-      Timeframe.new(:year => 2009).gaps_left_by(
-        Timeframe.new(:year => 2009, :month => 3),
-        Timeframe.new(:year => 2009, :month => 5),
-        Timeframe.new(Date.new(2009, 8, 1), Date.new(2009, 11, 1)),
-        Timeframe.new(Date.new(2009, 9, 1), Date.new(2009, 10, 1))
-      ).must_equal(
-        [ Timeframe.new(Date.new(2009, 1, 1), Date.new(2009, 3, 1)),
-          Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 5, 1)),
-          Timeframe.new(Date.new(2009, 6, 1), Date.new(2009, 8, 1)),
-          Timeframe.new(Date.new(2009, 11, 1), Date.new(2010, 1, 1)) ])
-    end
-  end
-
-  describe '#covered_by?' do
-    it "should be able to ascertain gaps left by a list of other Timeframes" do
-      Timeframe.new(:year => 2009).covered_by?(
-        Timeframe.new(:month => 1, :year => 2009),
-        Timeframe.new(Date.new(2009, 2, 1), Date.new(2010, 1, 1))
-      ).must_equal(true)
-    end
-  end
-
-  describe '#last_year' do
-    it "should return its predecessor in a previous year" do
-      Timeframe.this_year.last_year.must_equal Timeframe.new(Date.new(Date.today.year - 1, 1, 1), Date.new(Date.today.year, 1, 1))
-    end
-  end
-  
-  describe :parse do
-    describe 'ISO 8601 <start>/<end>' do
-      it 'works without time' do
-        Timeframe.parse('2007-03-01/2008-05-11').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-        Timeframe.parse('2007-03-01--2008-05-11').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-      end
-      it 'works with time' do
-        Timeframe.parse('2007-03-01T13:00:00Z/2008-05-11T15:30:00Z').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-        Timeframe.parse('2007-03-01T13:00:00Z--2008-05-11T15:30:00Z').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-      end
-      it 'takes shorthand' do
-        Timeframe.parse('2007-11-13/15').must_equal Timeframe.new(Date.new(2007, 11, 13), Date.new(2007, 11, 15)) # "2007-11-13/15", i.e. from any time on 2007-11-13 to any time on 2007-11-15
-        Timeframe.parse("2008-02-15/03-14").must_equal Timeframe.new(Date.new(2008, 2, 15), Date.new(2008, 3, 14)) # "2008-02-15/2008-03-14"
-        Timeframe.parse("2007-12-14T13:30/15:30").must_equal Timeframe.new(Date.new(2007, 12, 14), Date.new(2007, 12, 14)) # "2007-12-14T13:30/2007-12-14T15:30".. imprecise!
-      end
-    end
-
-    describe 'ISO 8601 <start>/<duration>' do
-      it 'works without time' do
-        Timeframe.parse('2007-03-01/P1Y2M10DT2H30M').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-        Timeframe.parse('2007-03-01--P1Y2M10DT2H30M').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-      end
-      it 'works with time' do
-        Timeframe.parse('2007-03-01T13:00:00Z/P1Y2M10DT2H30M').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-        Timeframe.parse('2007-03-01T13:00:00Z--P1Y2M10DT2H30M').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 5, 11))
-      end
-    end
-    
-    # note that 2008 was a leap year
-    describe 'ISO 8601 <duration>/<end>' do
-      it 'works with leap years' do
-        Timeframe.parse('2007-02-28--P1Y').must_equal Timeframe.new(Date.new(2007, 2, 28), Date.new(2008, 2, 29))
-        Timeframe.parse('P1Y--2008-02-29').must_equal Timeframe.new(Date.new(2007, 3, 1), Date.new(2008, 2, 29))
-      end
-      it 'works without time' do
-        Timeframe.parse('P1Y2M10DT2H30M/2008-05-11').must_equal Timeframe.new(Date.new(2007, 3, 2), Date.new(2008, 5, 11))
-        Timeframe.parse('P1Y2M10DT2H30M--2008-05-11').must_equal Timeframe.new(Date.new(2007, 3, 2), Date.new(2008, 5, 11))
-      end
-      it 'works with time' do
-        Timeframe.parse('P1Y2M10DT2H30M/2008-05-11T15:30:00Z').must_equal Timeframe.new(Date.new(2007, 3, 3), Date.new(2008, 5, 11))
-        Timeframe.parse('P1Y2M10DT2H30M--2008-05-11T15:30:00Z').must_equal Timeframe.new(Date.new(2007, 3, 3), Date.new(2008, 5, 11))
-      end
-    end
-
-    it 'understands plain year' do
-      plain_year = 2009
-      Timeframe.parse(plain_year).must_equal Timeframe.new(:year => plain_year)
-      Timeframe.parse(plain_year.to_s).must_equal Timeframe.new(:year => plain_year)
-    end
-    it 'understands JSON' do
-      json =<<-EOS
-      "2009-05-01/2009-06-01"
-EOS
-      Timeframe.parse(json).must_equal Timeframe.new(:year => 2009, :month => 5)
-    end
-    it 'understands a particular style of Ruby hash we used to emit (deprecated)' do
-      hsh = { :startDate => '2009-05-01', :endDate => '2009-06-01' }
-      Timeframe.parse(hsh).must_equal Timeframe.new(:year => 2009, :month => 5)
-      Timeframe.parse(hsh.stringify_keys).must_equal Timeframe.new(:year => 2009, :month => 5)
-    end
-  end
-
-  describe '#as_json' do
-    it 'should generate JSON (test fails on ruby 1.8)' do
-      Timeframe.new(:year => 2009).as_json.must_equal %{2009-01-01/2010-01-01}
-      MultiJson.dump(Timeframe.new(:year => 2009)).must_equal Timeframe.new(:year => 2009).as_json.inspect
-    end
-    it 'understands its own JSON' do
-      t = Timeframe.new(:year => 2009, :month => 5)
-      Timeframe.from_json(MultiJson.dump(t)).must_equal t
-    end
-  end
-
-  describe '#to_param' do
-    it 'should generate a URL-friendly parameter' do
-      Timeframe.new(:year => 2009).to_param.must_equal "2009-01-01/2010-01-01"
-    end
-    it 'understands its own #to_param' do
-      t = Timeframe.new(:year => 2009, :month => 5)
-      Timeframe.parse(t.to_param).must_equal t
-    end
-  end
-
-  describe '#to_s' do
-    it 'should not only look at month numbers when describing multi-year timeframes' do
-      Timeframe.new(Date.parse('2008-01-01'), Date.parse('2010-01-01')).to_s.must_equal "2008-01-01/2010-01-01"
-    end
-  end
-  
-  describe '#dates' do
-    it "should enumerate all dates between start and end" do
-      dates = Timeframe.new(:year => 2008).dates
-      dates.min.must_equal Date.new(2008,1,1)
-      dates.max.must_equal Date.new(2008,12,31)
-      dates.uniq.length.must_equal 366
-      dates.select { |d| d.month == 2 }.length.must_equal 29
-    end
-  end
-  
-  describe '#first_days_of_months' do
-    it "should enumerate all the first days of included months" do
-      dates = Timeframe.parse('2011-05-01/2012-02-01').first_days_of_months
-      dates.must_equal [Date.new(2011,5,1), Date.new(2011,6,1), Date.new(2011,7,1), Date.new(2011,8,1), Date.new(2011,9,1), Date.new(2011,10,1), Date.new(2011,11,1), Date.new(2011,12,1), Date.new(2012,1,1)]
-    end
-  end
-
-  describe "Array#multiple_timeframes_gaps_left_by" do
-    it "should raise error if not a Timeframes are going to be merged" do
-      lambda {
-        [Timeframe.new(Date.parse('2011-10-10'), Date.parse('2011-10-28'))].multiple_timeframes_gaps_left_by(1,2)
-      }.must_raise(ArgumentError, /only use timeframe/)
-    end
-
-    it "should properly work with multiple timeframes" do
-      t1 = Timeframe.new(Date.parse('2011-10-10'), Date.parse('2011-10-28'))
-      t2 = Timeframe.new(Date.parse('2011-11-01'), Date.parse('2011-11-12'))
-
-      t3 = Timeframe.new(Date.parse('2011-10-11'), Date.parse('2011-10-15'))
-      t4 = Timeframe.new(Date.parse('2011-11-01'), Date.parse('2011-11-08'))
-
-      [t1, t2].multiple_timeframes_gaps_left_by(t3, t4).must_equal(
-      [ Timeframe.new(Date.parse('2011-10-10'), Date.parse('2011-10-11')),
-        Timeframe.new(Date.parse('2011-10-15'), Date.parse('2011-10-28')),
-        Timeframe.new(Date.parse('2011-11-08'), Date.parse('2011-11-12'))
-      ])
-    end
-  end
-end