timeframe 0.0.11 → 0.1.0

data/.document

@@ -1,5 +1,5 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2009 Andy Rossmeissl
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2009 Andy Rossmeissl
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -10,6 +10,8 @@ http://rdoc.info/projects/rossmeissl/timeframe
 
 The good parts of Timeframe all came from the gentlemen at Fingertips[http://fngtps.com].
 
+Thanks to @artemk for https://github.com/rossmeissl/timeframe/pull/5
+
 == Copyright
 
 Copyright (c) 2010 Andy Rossmeissl.

data/Rakefile

@@ -6,26 +6,21 @@ end
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+require 'rake/testtask'
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+Rake::TestTask.new do |t|
+  t.libs.push 'lib'
+  t.test_files = FileList['spec/**/*spec.rb']
+  t.verbose = true
 end
 
-task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+task :default => :test
 
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "timeframe #{version}"
+  rdoc.title = "timeframe"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/lib/timeframe.rb

@@ -1,16 +1,7 @@
 require 'date'
+require 'multi_json'
 require 'active_support/version'
-%w{
-  active_support/core_ext/hash
-  active_support/core_ext/array/extract_options
-  active_support/core_ext/string/conversions
-  active_support/core_ext/date/conversions
-  active_support/core_ext/integer/time
-  active_support/core_ext/numeric/time
-  active_support/json
-}.each do |active_support_3_requirement|
-  require active_support_3_requirement
-end if ActiveSupport::VERSION::MAJOR == 3
+require 'active_support/core_ext' if ActiveSupport::VERSION::MAJOR >= 3
 
 # Encapsulates a timeframe between two dates. The dates provided to the class are always until the last date. That means
 # that the last date is excluded.
@@ -20,7 +11,90 @@ end if ActiveSupport::VERSION::MAJOR == 3
 #   # and holds 31 days
 #   Timeframe.new(Date(2007,10,1), Date(2007,11,1)).days #=> 31
 class Timeframe
-  attr_accessor :from, :to
+  class << self    
+    # Shortcut method to return the Timeframe representing the current year (as defined by Time.now)
+    def this_year
+      new :year => Time.now.year
+    end
+    
+    # Construct a new Timeframe, but constrain it by another
+    def constrained_new(start_date, end_date, constraint)
+      start_date, end_date = make_dates start_date, end_date
+      raise ArgumentError, 'Constraint must be a Timeframe' unless constraint.is_a? Timeframe
+      raise ArgumentError, "Start date #{start_date} should be earlier than end date #{end_date}" if start_date > end_date
+      if end_date <= constraint.start_date or start_date >= constraint.end_date
+        new constraint.start_date, constraint.start_date
+      elsif start_date.year == end_date.yesterday.year
+        new(start_date, end_date) & constraint
+      elsif start_date.year < constraint.start_date.year and constraint.start_date.year < end_date.yesterday.year
+        constraint
+      else
+        new [constraint.start_date, start_date].max, [constraint.end_date, end_date].min
+      end
+    end
+    
+    # Create a timeframe +/- number of years around today
+    def mid(number)
+      start_date = Time.now.today - number.years
+      end_date = Time.now.today + number.years
+      new start_date, end_date
+    end
+    
+    # Construct a new Timeframe by parsing an ISO 8601 time interval string
+    # http://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+    def from_iso8601(str)
+      raise ArgumentError, 'Intervals should be specified according to ISO 8601, method 1, eliding times' unless str =~ /^\d\d\d\d-\d\d-\d\d\/\d\d\d\d-\d\d-\d\d$/
+      new *str.split('/')
+    end
+    
+    # Construct a new Timeframe from a hash with keys startDate and endDate    
+    def from_hash(hsh)
+      hsh = hsh.symbolize_keys
+      new hsh[:startDate], hsh[:endDate]
+    end
+    
+    # Construct a new Timeframe from a year.
+    def from_year(year)
+      new :year => year.to_i
+    end
+    
+    # Automagically parse a Timeframe from either a String or a Hash
+    def parse(input)
+      case input
+      when ::Integer
+        from_year input
+      when ::Hash
+        from_hash input
+      when ::String
+        str = input.strip
+        if str.start_with?('{')
+          from_hash ::MultiJson.decode(str)
+        elsif input =~ /\A\d\d\d\d\z/
+          from_year input
+        else
+          from_iso8601 str
+        end
+      else
+        raise ::ArgumentError, "Must be String or Hash"
+      end
+    end
+    alias :interval :parse
+    alias :from_json :parse
+    
+    # Deprecated
+    def multiyear(*args) # :nodoc:
+      new *args
+    end
+
+    private
+    
+    def make_dates(start_date, end_date)
+      [start_date.to_date, end_date.to_date]
+    end
+  end
+
+  attr_reader :start_date
+  attr_reader :end_date
 
   # Creates a new instance of Timeframe. You can either pass a start and end Date or a Hash with named arguments,
   # with the following options:
@@ -30,9 +104,6 @@ class Timeframe
   #   <tt>:year</tt>: Start date becomes the first day of this year, and the end date becomes the first day of the
   #   next year.
   #
-  # By default, Timeframe.new will die if the resulting Timeframe would cross year boundaries. This can be overridden
-  # by setting the <tt>:skip_year_boundary_crossing_check</tt> option.
-  #
   # Examples:
   #
   #   Timeframe.new Date.new(2007, 2, 1), Date.new(2007, 4, 1) # February and March
@@ -45,263 +116,182 @@ class Timeframe
     if month = options[:month]
       month = Date.parse(month).month if month.is_a? String
       year = options[:year] || Date.today.year
-      from = Date.new(year, month, 1)
-      to   = from.next_month
+      start_date = Date.new(year, month, 1)
+      end_date   = start_date.next_month
     elsif year = options[:year]
-      from = Date.new(year, 1, 1)
-      to   = Date.new(year+1, 1, 1)
+      start_date = Date.new(year, 1, 1)
+      end_date   = Date.new(year+1, 1, 1)
     end
 
-    from = args.shift.to_date if from.nil? and args.any?
-    to = args.shift.to_date if to.nil? and args.any?
+    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?
 
-    raise ArgumentError, "Please supply a start and end date, `#{args.map(&:inspect).to_sentence}' is not enough" if from.nil? or to.nil?
-    raise ArgumentError, "Start date #{from} should be earlier than end date #{to}" if from > to
-    raise ArgumentError, 'Timeframes that cross year boundaries are dangerous' unless options[:skip_year_boundary_crossing_check] or from.year == to.yesterday.year or from == to
+    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
 
-    @from, @to = from, to
+    @start_date, @end_date = start_date, end_date
   end
-  
+
   def inspect # :nodoc:
-    "<Timeframe(#{object_id}) #{days} days starting #{from} ending #{to}>"
+    "<Timeframe(#{object_id}) #{days} days starting #{start_date} ending #{end_date}>"
   end
-
+    
   # The number of days in the timeframe
   #
   #   Timeframe.new(Date.new(2007, 11, 1), Date.new(2007, 12, 1)).days #=> 30
   #   Timeframe.new(:month => 1).days #=> 31
   #   Timeframe.new(:year => 2004).days #=> 366
   def days
-    (to - from).to_i
+    (end_date - start_date).to_i
   end
-  
+
   # Returns true when a Date or other Timeframe is included in this Timeframe
   def include?(obj)
-    # puts "checking to see if #{date} is between #{from} and #{to}" if Emitter::DEBUG
+    # puts "checking to see if #{date} is between #{start_date} and #{end_date}" if Emitter::DEBUG
     case obj
     when Date
-      (from...to).include?(obj)
+      (start_date...end_date).include?(obj)
     when Time
-      # (from...to).include?(obj.to_date)
+      # (start_date...end_date).include?(obj.to_date)
       raise "this wasn't previously supported, but it could be"
     when Timeframe
-      from <= obj.from and to >= obj.to
+      start_date <= obj.start_date and end_date >= obj.end_date
     end
   end
-  
+
   # Returns true when the parameter Timeframe is properly included in the Timeframe
   def proper_include?(other_timeframe)
     raise ArgumentError, 'Proper inclusion only makes sense when testing other Timeframes' unless other_timeframe.is_a? Timeframe
-    (from < other_timeframe.from) and (to > other_timeframe.to)
+    (start_date < other_timeframe.start_date) and (end_date > other_timeframe.end_date)
   end
-  
+
   # Returns true when this timeframe is equal to the other timeframe
   def ==(other)
     # puts "checking to see if #{self} is equal to #{other}" if Emitter::DEBUG
     return false unless other.is_a?(Timeframe)
-    from == other.from and to == other.to
+    start_date == other.start_date and end_date == other.end_date
   end
   alias :eql? :==
-    
+
   # Calculates a hash value for the Timeframe, used for equality checking and Hash lookups.
-  #--
-  # This needs to be an integer or else it won't use #eql?
   def hash
-    from.hash + to.hash
-  end
-  
-  # Returns an array of month-long subtimeframes
-  #--
-  # TODO: rename to month_subtimeframes
-  def months
-    raise ArgumentError, "Please only provide whole-month timeframes to Timeframe#months" unless from.day == 1 and to.day == 1
-    raise ArgumentError, 'Timeframes that cross year boundaries are dangerous during Timeframe#months' unless from.year == to.yesterday.year
-    year = from.year # therefore this only works in the from year
-    (from.month..to.yesterday.month).map { |m| Timeframe.new :month => m, :year => year }
+    start_date.hash + end_date.hash
   end
-  
+
   # Returns the relevant year as a Timeframe
   def year
-    raise ArgumentError, 'Timeframes that cross year boundaries are dangerous during Timeframe#year' unless from.year == to.yesterday.year
-    Timeframe.new :year => from.year
-  end
-  
-  # Divides a Timeframe into component parts, each no more than a month long.
-  #--
-  # multiyear safe
-  def month_subtimeframes
-    (from.year..to.yesterday.year).map do |year|
-      (1..12).map do |month|
-        Timeframe.new(:year => year, :month => month) & self
-      end
-    end.flatten.compact
-  end
-  
-  # Like #month_subtimeframes, but will discard partial months
-  # multiyear safe
-  def full_month_subtimeframes
-    month_subtimeframes.map { |st| Timeframe.new(:year => st.from.year, :month => st.from.month) }
-  end
-  
-  # Divides a Timeframe into component parts, each no more than a year long.
-  #--
-  # multiyear safe
-  def year_subtimeframes
-    (from.year..to.yesterday.year).map do |year|
-      Timeframe.new(:year => year) & self
-    end
+    raise ArgumentError, 'Timeframes that cross year boundaries are dangerous during Timeframe#year' unless start_date.year == end_date.yesterday.year
+    Timeframe.new :year => start_date.year
   end
-  
-  # Like #year_subtimeframes, but will discard partial years
-  #--
-  # multiyear safe
-  def full_year_subtimeframes
-    (from.year..to.yesterday.year).map do |year|
-      Timeframe.new :year => year
+
+  # Returns an Array of month-long Timeframes. Partial months are **not** included by default.
+  # http://stackoverflow.com/questions/1724639/iterate-every-month-with-date-objects
+  def months
+    memo = []
+    ptr = start_date
+    while ptr <= end_date do
+      memo.push(Timeframe.new(:year => ptr.year, :month => ptr.month) & self)
+      ptr = ptr >> 1
     end
+    memo.flatten.compact
   end
-  
+
   # Crop a Timeframe to end no later than the provided date.
-  #--
-  # multiyear safe  
   def ending_no_later_than(date)
-    if to < date
+    if end_date < date
       self
-    elsif from >= date
+    elsif start_date >= date
       nil
     else
-      Timeframe.multiyear from, date
+      Timeframe.new start_date, date
     end
   end
-    
+
   # Returns a timeframe representing the intersection of the given timeframes
   def &(other_timeframe)
     this_timeframe = self
     if other_timeframe == this_timeframe
       this_timeframe
-    elsif this_timeframe.from > other_timeframe.from and this_timeframe.to < other_timeframe.to
+    elsif this_timeframe.start_date > other_timeframe.start_date and this_timeframe.end_date < other_timeframe.end_date
       this_timeframe
-    elsif other_timeframe.from > this_timeframe.from and other_timeframe.to < this_timeframe.to
+    elsif other_timeframe.start_date > this_timeframe.start_date and other_timeframe.end_date < this_timeframe.end_date
       other_timeframe
-    elsif this_timeframe.from >= other_timeframe.to or this_timeframe.to <= other_timeframe.from
+    elsif this_timeframe.start_date >= other_timeframe.end_date or this_timeframe.end_date <= other_timeframe.start_date
       nil
     else
-      Timeframe.new [this_timeframe.from, other_timeframe.from].max, [this_timeframe.to, other_timeframe.to].min, :skip_year_boundary_crossing_check => true
+      Timeframe.new [this_timeframe.start_date, other_timeframe.start_date].max, [this_timeframe.end_date, other_timeframe.end_date].min
     end
   end
-  
+
   # Returns the fraction (as a Float) of another Timeframe that this Timeframe represents
   def /(other_timeframe)
     raise ArgumentError, 'You can only divide a Timeframe by another Timeframe' unless other_timeframe.is_a? Timeframe
     self.days.to_f / other_timeframe.days.to_f
   end
-  
+
   # Crop a Timeframe by another Timeframe
   def crop(container)
     raise ArgumentError, 'You can only crop a timeframe by another timeframe' unless container.is_a? Timeframe
-    self.class.new [from, container.from].max, [to, container.to].min
+    self.class.new [start_date, container.start_date].max, [end_date, container.end_date].min
   end
-  
+
   # Returns an array of Timeframes representing the gaps left in the Timeframe after removing all given Timeframes
   def gaps_left_by(*timeframes)
     # remove extraneous timeframes
-    timeframes.reject! { |t| t.to <= from }
-    timeframes.reject! { |t| t.from >= to }
+    timeframes.reject! { |t| t.end_date <= start_date }
+    timeframes.reject! { |t| t.start_date >= end_date }
     
     # crop timeframes
     timeframes.map! { |t| t.crop self }
-    
+
     # remove proper subtimeframes
     timeframes.reject! { |t| timeframes.detect { |u| u.proper_include? t } }
-    
+
     # escape
     return [self] if  timeframes.empty?
 
-    timeframes.sort! { |x, y| x.from <=> y.from }
+    timeframes.sort! { |x, y| x.start_date <=> y.start_date }
     
-    a = [ from ] + timeframes.collect(&:to)
-    b = timeframes.collect(&:from) + [ to ]
+    a = [ start_date ] + timeframes.collect(&:end_date)
+    b = timeframes.collect(&:start_date) + [ end_date ]
 
     a.zip(b).map do |gap|
-      Timeframe.new(*gap) if gap[1] > gap[0]
+      Timeframe.new(*gap, :skip_year_boundary_crossing_check => true) if gap[1] > gap[0]
     end.compact
   end
-  
+
   # Returns true if the union of the given Timeframes includes the Timeframe
   def covered_by?(*timeframes)
     gaps_left_by(*timeframes).empty?
   end
-  
+
   # Returns the same Timeframe, only a year earlier
   def last_year
-    self.class.new((from - 1.year), (to - 1.year))
-  end
-    
-  def as_json(*)
-    to_param
+    self.class.new((start_date - 1.year), (end_date - 1.year))
   end
   
-  # overriding this so that as_json is not used
   def to_json(*)
-    to_param
+    %({"startDate":"#{start_date.iso8601}","endDate":"#{end_date.iso8601}"})
   end
   
+  def as_json(*)
+    { :startDate => start_date.iso8601, :endDate => end_date.iso8601 }
+  end
+    
   # An ISO 8601 "time interval" like YYYY-MM-DD/YYYY-MM-DD
-  def to_param
-    "#{from}/#{to}"
+  def iso8601
+    "#{start_date.iso8601}/#{end_date.iso8601}"
   end
-  
-  # The String representation is equivalent to its ISO 8601 form
-  def to_s
-    to_param
+  alias :to_s :iso8601
+  alias :to_param :iso8601
+
+  # Deprecated
+  def from # :nodoc:
+    @start_date
   end
   
-  class << self
-    def make_dates(from, to) # :nodoc:
-      return from.to_date, to.to_date
-    end
-    
-    # Shortcut method to return the Timeframe representing the current year (as defined by Time.now)
-    def this_year
-      new :year => Time.now.year
-    end
-    
-    # Construct a new Timeframe, but constrain it by another
-    def constrained_new(from, to, constraint)
-      from, to = make_dates from, to
-      raise ArgumentError, 'Constraint must be a Timeframe' unless constraint.is_a? Timeframe
-      raise ArgumentError, "Start date #{from} should be earlier than end date #{to}" if from > to
-      if to <= constraint.from or from >= constraint.to
-        new constraint.from, constraint.from
-      elsif from.year == to.yesterday.year
-        new(from, to) & constraint
-      elsif from.year < constraint.from.year and constraint.from.year < to.yesterday.year
-        constraint
-      else
-        new [constraint.from, from].max, [constraint.to, to].min
-      end
-    end
-    
-    # Shortcut for #new that automatically skips year boundary crossing checks
-    def multiyear(from, to)
-      from, to = make_dates from, to
-      new from, to, :skip_year_boundary_crossing_check => true
-    end
-    
-    # Create a multiyear timeframe +/- number of years around today
-    def mid(number)
-      from = Time.zone.today - number.years
-      to = Time.zone.today + number.years
-      multiyear from, to
-    end
-    
-    # Construct a new Timeframe by parsing an ISO 8601 time interval string
-    # http://en.wikipedia.org/wiki/ISO_8601#Time_intervals
-    def interval(str)
-      raise ArgumentError, 'Intervals should be specified as a string' unless str.is_a? String
-      raise ArgumentError, 'Intervals should be specified according to ISO 8601, method 1, eliding times' unless str =~ /^\d\d\d\d-\d\d-\d\d\/\d\d\d\d-\d\d-\d\d$/
-      multiyear *str.split('/')
-    end
-    alias :from_json :interval
+  # Deprecated
+  def to # :nodoc:
+    @end_date
   end
 end

data/lib/timeframe/core_ext/array.rb

@@ -0,0 +1,9 @@
+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/lib/timeframe/version.rb

@@ -1,3 +1,3 @@
 class Timeframe
-  VERSION = '0.0.11'
+  VERSION = '0.1.0'
 end

data/spec/spec_helper.rb

@@ -1,12 +1,9 @@
 require 'rubygems'
 require 'bundler'
 Bundler.setup
-require 'spec'
-require 'spec/autorun'
+require 'minitest/spec'
+require 'minitest/autorun'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'timeframe'
-
-Spec::Runner.configure do |config|
-  
-end
+require File.expand_path('../../lib/timeframe.rb', __FILE__)
+require File.expand_path('../../lib/timeframe/core_ext/array.rb', __FILE__)

data/spec/timeframe_spec.rb

@@ -1,58 +1,52 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path('../spec_helper', __FILE__)
 
 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.should == Date.parse('2008-02-14')
-      tf.to.should == Date.parse('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.should == start
-      tf.to.should == finish
+      tf.from.must_equal start
+      tf.to.must_equal finish
     end
     it "should accept months" do
       timeframe = Timeframe.new(:month => 1)
-      timeframe.from.should == Date.today.change(:month => 1, :day => 1)
-      timeframe.to.should == Date.today.change(:month => 2, :day => 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.should == Date.today.change(:month => 2, :day => 1)
-      timeframe.to.should == Date.today.change(:month => 3, :day => 1)
+      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.should == Date.new(2004, 1, 1)
-      timeframe.to.should == Date.new(2005, 1, 1)
+      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.should == Date.new(2005, 5, 1)
-      timeframe.to.should == Date.new(2005, 6, 1)
+      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)
-      }.should raise_error(ArgumentError, /supply/)
+      }.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)
-      }.should raise_error(ArgumentError, /earlier/)
+      }.must_raise(ArgumentError, /earlier/)
     end
-    it "should not accept timeframes that cross year boundaries" do
-      lambda {
-        timeframe = Timeframe.new Date.new(2007, 1, 1), Date.new(2008, 1, 2)
-      }.should raise_error(ArgumentError, /cross/)
-    end
-    it "should optionally accept timeframes that cross year boundaries" do
-      lambda {
-        timeframe = Timeframe.new Date.new(2007, 1, 1), Date.new(2008, 1, 2), :skip_year_boundary_crossing_check => true
-      }.should_not raise_error
+    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
 
@@ -61,7 +55,7 @@ describe Timeframe do
       start = Date.parse('2008-02-14')
       finish = Date.parse('2008-05-10')
       tf = Timeframe.new(start, finish)
-      tf.inspect.should =~ /<Timeframe\(-?\d+\) 86 days starting 2008-02-14 ending 2008-05-10>/
+      tf.inspect.must_match %r{<Timeframe\(-?\d+\) 86 days starting 2008-02-14 ending 2008-05-10>}
     end
   end
 
@@ -76,60 +70,60 @@ describe Timeframe 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).should == may
-      Timeframe.constrained_new(Date.new(2007,1,1), Date.new(2010,1,1), constraint).should == constraint
-      Timeframe.constrained_new(Date.new(2007,11,1), Date.new(2008,2,1), constraint).should == january
+      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.should == start
-      tf.to.should == finish
+      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.should == start
-      tf.to.should == finish
+      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.should == constraint_start
-      tf.to.should == finish
+      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.should == start
-      tf.to.should == constraint_finish
+      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.should == 0
+      timeframe.days.must_equal 0
     end
   end
 
   describe '.this_year' do
     it "should return the current year" do
-      Timeframe.this_year.should == Timeframe.new(:year => Time.now.year)
+      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.should == 365
-      Timeframe.new(Date.new(2008, 1, 1), Date.new(2009, 1, 1)).days.should == 366 #leap year
-      Timeframe.new(Date.new(2007, 11, 1), Date.new(2007, 12, 1)).days.should == 30
-      Timeframe.new(Date.new(2007, 11, 1), Date.new(2008, 1, 1)).days.should == 61
-      Timeframe.new(Date.new(2007, 2, 1), Date.new(2007, 3, 1)).days.should == 28
-      Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 3, 1)).days.should == 29
-      Timeframe.new(Date.new(2008, 2, 1), Date.new(2008, 2, 1)).days.should == 0
+      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
 
@@ -142,69 +136,61 @@ describe Timeframe do
         Date.new(2008, 2, 5),
         Date.new(2008, 2, 29)
       ].each do |date|
-        timeframe.include?(date).should == true
+        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).should == false
+        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).should == Timeframe.new(:year => 2007)
-      Timeframe.new(:year => 2004, :month => 1).should == Timeframe.new(:year => 2004, :month => 1)
+      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.should == Timeframe.new(:year => 2007).hash
-      Timeframe.new(:year => 2004, :month => 1).hash.should == Timeframe.new(:year => 2004, :month => 1).hash
+      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.should == 12
-    end
-    it "should not return an array of month-long subtimeframes if provided an inappropriate range" do
-      lambda { 
-        Timeframe.new(Date.new(2009, 3, 2), Date.new(2009, 3, 5)).months
-      }.should raise_error(ArgumentError, /whole/)
-      lambda {
-        Timeframe.new(Date.new(2009, 1, 1), Date.new(2012, 1, 1), :skip_year_boundary_crossing_check => true).months
-      }.should raise_error(ArgumentError, /dangerous during/)
+      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.should == Timeframe.new(:year => 2009)
+      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), :skip_year_boundary_crossing_check => true).year
-      }.should raise_error(ArgumentError, /dangerous during/)
+        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)).should be_nil
-      (Timeframe.new(:month => 4) & Timeframe.new(:month => 5)).should be_nil
-      (Timeframe.new(:month => 4) & Timeframe.new(:month => 4)).should == Timeframe.new(:month => 4)
-      (Timeframe.new(:year => Time.now.year) & Timeframe.new(:month => 4)).should == 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))).should == Timeframe.new(Date.new(2009, 4, 1), Date.new(2009, 6, 1))
+      (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)).should == (30.0 / 365.0)
+      (Timeframe.new(:month => 4, :year => 2009) / Timeframe.new(:year => 2009)).must_equal (30.0 / 365.0)
     end
   end
 
@@ -215,67 +201,96 @@ describe Timeframe do
         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))
-      ).should == 
+      ).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)) ]
+          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(:month => 1, :year => 2009),
         Timeframe.new(Date.new(2009, 2, 1), Date.new(2010, 1, 1))
-      ).should be_true
+      ).must_equal(true)
     end
   end
 
   describe '#last_year' do
     it "should return its predecessor in a previous year" do
-      Timeframe.this_year.last_year.should ==
-        Timeframe.new(Date.new(Date.today.year - 1, 1, 1), Date.new(Date.today.year, 1, 1))
-    end
-  end
-  
-  describe 'Timeframe:class#interval' do
-    it 'should parse ISO 8601 interval format' do
-      Timeframe.interval('2009-01-01/2010-01-01').should == Timeframe.new(:year => 2009)
-    end
-    it 'should skip year boundary checking' do
-      lambda {
-        Timeframe.interval '2009-01-01/2011-01-01'
-      }.should_not raise_error
-    end
-    it 'should understand its own #to_param' do
-      t = Timeframe.new(:year => 2009)
-      Timeframe.interval(t.to_param).should == t
+      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 'Timeframe:class#from_json' do
-    it 'should understand its own #to_json' do
-      t = Timeframe.new(:year => 2009)
-      Timeframe.from_json(t.to_json).should == t
+  describe '.parse' do
+    it 'understands ISO8601' do
+      Timeframe.parse('2009-01-01/2010-01-01').must_equal Timeframe.new(:year => 2009)
+    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
+      {"startDate":"2009-05-01", "endDate":"2009-06-01"}
+EOS
+      Timeframe.parse(json).must_equal Timeframe.new(:year => 2009, :month => 5)
+    end
+    it 'understands a Ruby hash' 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 '#to_json' do
     it 'should generate JSON (test fails on ruby 1.8)' do
-      Timeframe.new(:year => 2009).to_json.should == "2009-01-01/2010-01-01"
+      Timeframe.new(:year => 2009).to_json.must_equal %({"startDate":"2009-01-01","endDate":"2010-01-01"})
+    end
+    it 'understands its own #to_json' do
+      t = Timeframe.new(:year => 2009, :month => 5)
+      Timeframe.from_json(t.to_json).must_equal t
     end
   end
-  
+
   describe '#to_param' do
     it 'should generate a URL-friendly parameter' do
-      Timeframe.new(:year => 2009).to_param.should == "2009-01-01/2010-01-01"
+      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.multiyear(Date.parse('2008-01-01'), Date.parse('2010-01-01')).to_s.should == "2008-01-01/2010-01-01"
+      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 "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

data/timeframe.gemspec

@@ -19,8 +19,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_development_dependency "rspec", "~> 1"
+  s.add_development_dependency "minitest"
   s.add_development_dependency 'home_run'
-  s.add_dependency 'activesupport', '>=2.3.5'
-  s.add_dependency 'i18n'
+  s.add_development_dependency 'rake'
+  s.add_runtime_dependency 'activesupport', '>=2.3.5'
+  s.add_runtime_dependency 'i18n'
+  s.add_runtime_dependency 'multi_json'
 end

metadata

@@ -1,69 +1,120 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: timeframe
-version: !ruby/object:Gem::Version
-  version: 0.0.11
+version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
-authors:
+authors: 
 - Andy Rossmeissl
 - Seamus Abshere
 - Derek Kastner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-05 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &2162728480 !ruby/object:Gem::Requirement
+
+date: 2012-01-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *2162728480
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: home_run
-  requirement: &2162728060 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: *2162728060
-- !ruby/object:Gem::Dependency
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &2162727520 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
         version: 2.3.5
   type: :runtime
-  prerelease: false
-  version_requirements: *2162727520
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: i18n
-  requirement: &2162727100 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: multi_json
   prerelease: false
-  version_requirements: *2162727100
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
 description: A Ruby class for describing and interacting with timeframes.
-email:
+email: 
 - andy@rossmeissl.net
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .document
 - .gitignore
 - Gemfile
@@ -71,36 +122,44 @@ files:
 - README.rdoc
 - Rakefile
 - lib/timeframe.rb
+- lib/timeframe/core_ext/array.rb
 - lib/timeframe/version.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/timeframe_spec.rb
 - timeframe.gemspec
 homepage: http://github.com/rossmeissl/timeframe
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: timeframe
-rubygems_version: 1.8.5
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: Date intervals
-test_files:
-- spec/spec.opts
-- spec/spec_helper.rb
-- spec/timeframe_spec.rb
+test_files: []
+
+has_rdoc: 

data/spec/spec.opts

@@ -1 +0,0 @@
---color