timespan 0.1.4 → 0.2.0

data/lib/timespan/compare.rb

@@ -0,0 +1,59 @@
+class Timespan
+  class TimeDuration
+    include Timespan::Units
+
+    attr_reader :duration, :reverse
+
+    def initialize duration, options = {}
+      @duration = ::Duration.new(duration)
+      @reverse = options[:reverse] || (@duration.total < 0)
+    end
+
+    def total
+      reverse ? -(duration.total.abs) : duration.total
+    end
+
+    def self.create_reverse duration
+      self.new duration, :reverse => true
+    end
+  end
+
+  module Compare
+
+  	include Comparable
+
+    def time_left time = nil
+      time_compare = time || Time.now
+      diff = end_time - time_compare
+      Timespan::TimeDuration.new(diff)
+    end
+
+    def expired?
+      time_left.total <= 0
+    end
+
+    def <=> time
+    	raise ArgumentError, "Not a valid argument for Timespan comparison, was #{time}" unless valid_compare?(time)
+    	case time
+    	when Timespan
+    		seconds <=> time.seconds
+    	when Time  		
+      	seconds <=> time.to_i
+      when Date, DateTime
+      	time.to_time.to_i
+      when Integer
+      	seconds <=> time
+      when ActiveSupport::Duration
+        seconds <=> time.to_i
+      end
+    end
+
+    def valid_compare? time
+      valid_compare_types.any? {|type| time.kind_of? type }
+    end
+
+    def valid_compare_types
+      [Timespan, Time, Date, DateTime, Integer]
+    end    
+  end
+end

data/lib/timespan/mongoid.rb

@@ -0,0 +1,31 @@
+require "timespan"
+require "mongoid/fields"
+
+# Mongoid serialization support for Timespan type.
+module Mongoid
+  module Fields
+    class Timespan
+      include Mongoid::Fields::Serializable
+    
+      # Deserialize a Timespan given the hash stored by Mongodb
+      #
+      # @param [Hash] Timespan as hash
+      # @return [Timespan] deserialized Timespan
+      def deserialize(timespan_hash)
+        return if !timespan_hash
+        ::Timespan.new(:from => timespan_hash[:from], :to => timespan_hash[:to])
+      end
+
+      # Serialize a Timespan or a Hash (with Timespan units) or a Duration in some form to
+      # a BSON serializable type.
+      #
+      # @param [Timespan, Hash, Integer, String] value
+      # @return [Hash] Timespan in seconds
+      def serialize(value)
+        return if value.blank?
+        timespan = ::Timespan.new(value)
+        {:from => time_span.start_time, :to => time_span.end_time, :Timespan => time_span.Timespan}
+      end
+    end
+  end
+end

data/lib/timespan/printer.rb

@@ -0,0 +1,71 @@
+require 'i18n'
+
+class Timespan
+	class << self
+		attr_writer :time_format
+
+		def time_format
+			@time_format ||= "%d %b %Y"
+		end
+	end
+
+	module Printer
+		# locale-dependent terminology
+		# %~s, %~m, %~h, %~d and %~w
+		#
+		# %td  => total days
+  	# %th  => total hours
+  	# %tm  => total minutes
+  	# %ts  => total seconds
+		def to_s mode = :full
+			meth = "print_#{mode}"
+			raise ArgumentError, "Print mode not supported, was: #{mode}" unless respond_to?(meth)
+			send(meth)
+		end
+
+		def print_dates
+			"#{i18n_t 'from'} #{print :start_time} #{i18n_t 'to'} #{print :end_time}"
+		end
+
+		def print_duration
+			print :duration
+		end
+
+		def print_full
+			 [print_dates, i18n_t('lasting'), print_duration].join(' ')
+		end
+
+		protected
+
+		def i18n_t label
+			I18n.t(label, :scope => :timespan, :default => label.to_s)
+		end
+
+		def print type
+			return duration.format(duration_format) if type == :duration
+			raise ArgumentError, "Not a valid print type, was: #{type}" unless valid_print_type? type
+			send(type).strftime(time_format)
+		end
+	
+		def valid_print_type? type
+			%w{start_time end_time}.include? type.to_s
+		end
+
+		def time_format
+			Timespan.time_format
+		end
+
+		def duration_format
+			identifiers = []
+			identifiers << 'y' if (duration.years > 0)
+			identifiers << 'o' if (duration.months > 0)
+			identifiers << 'w' if (duration.weeks > 0)
+			identifiers << 'd' if (duration.days > 0)
+			identifiers << 'h' if (duration.hours > 0)
+			identifiers << 'm' if (duration.minutes > 0)
+			identifiers << 's' if (duration.seconds > 0)
+
+			identifiers.map {|id| "%#{id} %~#{id}" }.join(' ')
+		end
+	end
+end

data/lib/timespan/rails/engine.rb

@@ -0,0 +1,9 @@
+module Timespan
+	module Rails
+		class Engine < ::Rails::Engine
+			initializer 'Timespan setup' do
+				I18n.load_path << Dir[Rails.root.join('config', 'locales', 'timespan', '*.yml')]
+			end
+		end
+	end
+end

data/lib/timespan/span.rb

@@ -0,0 +1,43 @@
+class Timespan
+	class DurationParseError < StandardError; end
+
+	module Span
+		attr_reader :duration
+
+		def duration= duration
+			@duration = case duration
+			when Duration
+				duration
+			when Numeric, Hash
+				Duration.new duration
+			when String
+				Duration.new parse_duration(duration)
+			else
+				raise ArgumentError, "Unsupported duration type: #{duration}"
+			end	
+			unless is_new?
+				add_dirty :duration
+				refresh!
+				calculate!
+			end
+		end
+
+		protected
+
+		def parse_duration text
+			spanner_parse text
+		rescue Spanner::ParseError => e
+			chronic_parse text
+		rescue ChronicDuration::DurationParseError => e
+			raise Timespan::DurationParseError, "Internal error: neither Spanner or ChronicDuration could parse '#{duration}'"
+		end
+
+		def spanner_parse text
+			Spanner.parse(text.gsub /and/, '')
+		end
+
+		def chronic_parse text
+			ChronicDuration.parse text
+		end
+	end
+end

data/lib/timespan/units.rb

@@ -0,0 +1,92 @@
+class Timespan
+	module Units
+		def to_milliseconds
+			@to_seconds ||= (seconds * 1000.0).round
+		end
+		alias_method :to_mils, 	 			:to_milliseconds
+		alias_method :millis, 	 			:to_mils
+		alias_method :milliseconds, 	:to_mils
+
+		def seconds
+			@seconds 	||= duration.total
+		end
+			
+		alias_method :to_secs, 		:seconds
+		alias_method :to_seconds, :seconds
+
+		def to_minutes
+			@to_minutes ||= (to_seconds / 60.0).round
+		end
+		alias_method :to_m, 		:to_minutes
+		alias_method :to_mins, 	:to_minutes
+		alias_method :minutes, 	:to_minutes
+
+		def to_hours
+			@to_hours ||= (to_minutes / 60.0).round
+		end
+		alias_method :to_h, 	:to_hours
+		alias_method :hrs, 		:to_hours
+		alias_method :hours, 	:to_hours
+
+		def to_days
+			@to_days ||= (to_hours / 24.0).round
+		end	
+		alias_method :to_d, :to_days
+		alias_method :days, :to_days
+
+		def to_weeks
+			@to_weeks ||= (to_days / 7.0).round
+		end	
+		alias_method :to_w, 	:to_weeks
+		alias_method :weeks, 	:to_days
+
+		def to_months
+			@to_months ||= (to_days / 30.0).round
+		end	
+		alias_method :to_mon, :to_months
+		alias_method :months, :to_months
+
+		def to_years
+			@to_years ||= (to_days.to_f / 365.25).round
+		end	
+		alias_method :to_y, 	:to_years
+		alias_method :years, 	:to_years
+
+		def to_decades
+			@to_decades ||= (to_years / 10.0).round
+		end	
+		alias_method :decades, 	:to_decades
+
+		def to_centuries
+			@to_centuries ||= (to_decades / 10.0).round
+		end	
+		alias_method :centuries, 	:to_centuries
+
+		def self.duration_units
+			%w{seconds minutes hours days weeks months years}
+		end
+
+		def self.units
+			duration_units + %w{decades centuries}
+		end
+
+		def units
+			Timespan::Units.units
+		end
+
+		duration_units.each do |unit|
+			define_method :"#{unit}=" do |number|
+				raise ArgumentError, "Must be a Numeric, was: #{number.inspect}" unless number.kind_of? Numeric
+				self.duration = Duration.new(unit.to_sym => number)
+			end
+		end
+
+		def decades= number
+			self.years = number * 10
+		end
+
+		def centuries= number
+			self.decades = number * 10
+		end
+	end
+end

data/spec/timespan/compare_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "Timespan" do
+	subject { timespan }
+
+  context 'From and To with 1 day apart' do
+  	let(:timespan) { Timespan.new :from => from, :to => to}
+
+  	let(:from) { Chronic.parse("1 day ago") }
+  	let(:to)   { Time.now }
+
+    describe '.compare == ' do  
+    	specify do 
+    		(subject == 1.day).should be_true
+    	end  
+    end
+
+    describe '.compare < ' do    
+    	specify do 
+    		(subject < 1.day).should be_false
+    	end
+    end    
+
+    describe '.compare > ' do    
+    	specify do 
+    		(subject > 1.day).should be_false
+    	end
+    end    
+  end
+
+  context 'From 2 days ago until today' do
+    let(:timespan) { Timespan.new :from => "2 days ago", :to => "1 hour ago" }    
+
+    describe '.time_left' do
+      it 'should have 0 days left' do
+        timespan.time_left.days.should == 0
+      end
+
+      it 'should have 1 hour left' do
+        timespan.time_left.hrs.should == -1
+      end
+    end  
+
+    describe '.expired?' do
+      it 'should have 0 days left' do
+        timespan.expired?.should be_true
+      end
+    end 
+  end  
+end

data/spec/timespan/locales/duration_da.yml

@@ -0,0 +1,20 @@
+da:
+  timespan:
+    from: fra
+    to: til
+    lasting: der varer ialt
+  ruby_duration:
+    second: sekond
+    seconds: sekonder
+    minute: minut
+    minutes: minutter
+    hour: time
+    hours: timer
+    day: dag
+    days: dage
+    week: uge
+    weeks: uges
+    month: måned
+    months: måneder
+    year: år
+    years: år

data/spec/timespan/printer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'i18n'
+
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales', 'duration_da.yml')
+
+describe Timespan::Span do
+  subject { timespan }
+
+  let(:from) { Chronic.parse("1 day ago") }
+  let(:to)   { Time.now }
+
+  before do
+  	I18n.locale = :da
+  end
+
+  describe 'print in danish - multiple modes' do
+    let(:timespan) { Timespan.new :from => from, :to => to }    
+
+    its(:to_s) { should == 'fra 03 May 2012 til 04 May 2012 der varer ialt 1 dag' }
+
+    specify { subject.to_s(:dates).should == 'fra 03 May 2012 til 04 May 2012' }
+    specify { subject.to_s(:duration).should == '1 dag' }
+  end
+end

data/spec/timespan/span_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Timespan::Span do
+  subject { timespan }
+
+  let(:from) { Chronic.parse("1 day ago") }
+  let(:to)   { Time.now }
+
+  describe 'set seconds to new' do
+    let(:timespan) { Timespan.new :from => from, :to => to }    
+
+    before :each do
+      @old_timespan = timespan.clone
+      @new_timespan = timespan.clone
+      @new_timespan.seconds = 120
+    end
+
+    its(:duration) { should be_a Duration }
+    specify { subject.send(:dirty).should be_empty }
+
+    it 'should have diff durations' do
+      @old_timespan.duration.should_not == @new_timespan.duration
+    end
+
+    it 'should have diff timespans in minutes' do
+      @old_timespan.minutes.should_not == @new_timespan.minutes
+    end    
+  end
+
+  describe 'set minutes to new' do
+    let(:timespan) { Timespan.new :from => from, :to => to }    
+
+    before :each do
+      @old_timespan = timespan.clone
+      @new_timespan = timespan.clone
+      @new_timespan.minutes = 50
+    end
+
+    its(:duration) { should be_a Duration }
+    specify { subject.send(:dirty).should be_empty }
+
+    it 'should have diff durations' do
+      @old_timespan.duration.should_not == @new_timespan.duration
+    end
+
+    it 'should have diff timespans in minutes' do
+      @old_timespan.minutes.should_not == @new_timespan.minutes
+    end    
+  end
+
+  describe 'set duration to new' do
+    let(:timespan) { Timespan.new :from => from, :to => to }    
+
+    before :each do
+      @old_timespan = timespan.clone
+      @new_timespan = timespan.clone
+      @new_timespan.duration = "7 days"
+    end
+
+    its(:duration) { should be_a Duration }
+    specify { subject.send(:dirty).should be_empty }
+
+    it 'should have diff timespans' do
+      @old_timespan.days.should_not == @new_timespan.days
+    end
+  end
+end