delta_t 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.idea/
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in delta_t.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tim 'S.D.Eagle' Zeitz
+
+MIT License
+
+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.md

@@ -0,0 +1,90 @@
+# DeltaT
+
+DeltaT provides an interface to represent time differences and make duration calculations nice and easy.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'delta_t'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install delta_t
+
+## Usage
+
+DeltaT hooks into the Time class and overrides the - operator.
+
+    diff = (Time.now - 2.days.ago)
+    diff.class # => TimeDiff
+
+The TimeDiff class provides accessors for Years, Months, Days, Hours, Minutes and Seconds
+
+    diff.days # => 2
+
+The differences will always be normalized - you will never get something like 48 hours.
+For the total amount of something
+
+    diff.total_hours # => 48
+
+Furthermore either all time amounts will be positive or negative
+
+    diff = Time.new(2012, 2) - Time.new(2011, 11)
+    diff.years # => 0
+    diff.months # => 3
+
+    diff = Time.new(2011, 11) - Time.new(2012, 2)
+    diff.years # => 0
+    diff.months # => -3
+
+You can create TimeDiffs with the differences of two times or with a hash
+
+    diff = TimeDiff.new(hours: 1, seconds: 5)
+    diff.seconds # => 5
+    diff.total_seconds # => 3605
+
+and you can a hash back out of the TimeDiff
+
+    diff.to_hash # => {years: 0, months: 0, days: 0, hours: 1, minutes: 0, seconds: 5}
+
+You can do calculations with TimeDiffs
+
+    diff = TimeDiff.new(days: 2) + TimeDiff.new(months: 3)
+    diff.days # => 2
+    diff.months # => 3
+
+    diff - TimeDiff.new(days: 2).days # => 0
+
+    diff * -1 == -diff # => true
+
+When calculating a TimeDiff from two Time the day - month foobar will be handled correctly
+
+    (Time.new(2012,4,2) - Time.new(2012,3,31)).days # => 2
+
+but if you do any further calculations since the concrete month is unknown a month will always have 30 days.
+
+You can apply TimeDiffs to Time objects
+
+    Time.new(2012, 4, 5) + TimeDiff.new(days: 30) == Time.new(2012, 4, 5) + 30.days # => true
+
+Concluding: the following equation should always be true
+
+    (sometime - othertime) + othertime == sometime # => true
+
+
+The TimeDiff class is in the DeltaT Module so normally you would have to use DeltaT::TimeDiff
+For further examples have a look into the tests
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/delta_t.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/delta_t/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tim 'S.D.Eagle' Zeitz"]
+  gem.email         = ["dev.tim.zeitz@gmail.com"]
+  gem.description   = %q{Making time difference calculations fun}
+  gem.summary       = %q{Provides a class to represent time differences and make duration calculations nice and easy}
+  gem.homepage      = "https://github.com/SDEagle/delta_t"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "delta_t"
+  gem.require_paths = ["lib"]
+  gem.version       = DeltaT::VERSION
+
+  gem.add_development_dependency 'rake'
+
+  gem.add_runtime_dependency 'activesupport'
+end

data/lib/delta_t.rb

@@ -0,0 +1,7 @@
+require 'active_support/all'
+require 'delta_t/version'
+require 'delta_t/time_diff'
+require 'delta_t/time'
+
+module DeltaT
+end

data/lib/delta_t/time.rb

@@ -0,0 +1,22 @@
+class Time
+  old_plus = instance_method :+
+  old_minus = instance_method :-
+
+  define_method :+  do |other|
+    if other.class == DeltaT::TimeDiff
+      other + self
+    else
+      old_plus.bind(self).(other)
+    end
+  end
+
+  define_method :-  do |other|
+    if other.class == DeltaT::TimeDiff
+      (other*-1) + self
+    elsif other.respond_to? :to_time
+      DeltaT::TimeDiff.new self, other
+    else
+      old_minus.bind(self).(other)
+    end
+  end
+end

data/lib/delta_t/time_diff.rb

@@ -0,0 +1,163 @@
+module DeltaT
+  class TimeDiff
+    UNITS = [:n_secs, :seconds, :minutes, :hours, :days, :months, :years]
+
+    ##
+    # Create a new TimeDiff either by two Time like objects or an hash with values for the time units (keys: seconds, minutes, hours, days, months, years)
+    def initialize *args
+      if args.size == 1 && args[0].class == Hash
+        @diff = [0,0,0,0,0,0,0]
+        add_array [0, args[0][:seconds], args[0][:minutes], args[0][:hours], args[0][:days], args[0][:months], args[0][:years]]
+      elsif args.size == 2 && args[0].respond_to?(:to_time) && args[1].respond_to?(:to_time)
+        apply_time_diff args[0].to_time, args[1].to_time
+      else
+        raise ArgumentError, "Arguments neither two times nor a hash", caller
+      end
+    end
+
+    UNITS.each_index do |index|
+      define_method UNITS[index] do
+        @diff[index]
+      end
+    end
+
+    UNITS.each_index do |index|
+      unless index == 0
+        define_method ("total_" + UNITS[index].to_s).to_sym do
+          sum = 0
+          i = index
+          while i < UNITS.length
+            sum += @diff[i].send UNITS[i]
+            i += 1
+          end
+          sum / 1.send(UNITS[index])
+        end
+      end
+    end
+
+    ##
+    # checks if two TimeDiffs are equal
+    def == other
+      eql = true
+      UNITS.each do |unit|
+        eql &= send(unit) == other.send(unit)
+      end
+      eql
+    end
+
+    ##
+    # Either adds two TimeDiffs together or advances a time by this TimeDiff
+    def + other
+      if other.class == TimeDiff
+        TimeDiff.new(other.to_hash).add_array @diff
+      elsif other.respond_to? :to_time
+        other.to_time.advance self.to_hash
+      else
+        raise ArgumentError, "Addition only defined for TimeDiff and time like classes", caller
+      end
+    end
+
+    ##
+    # Subtracts the other TimeDiff from this one
+    def - other
+      if other.class == TimeDiff
+        self + (-other)
+      else
+        raise ArgumentError, "Only subtraction of TimeDiffs possible", caller
+      end
+    end
+
+    ##
+    # multiplies the duration of this TimeDiff with the given scalar. Must be an integer
+    def * scalar
+      unless scalar.integer?
+        raise ArgumentError, "Only integer calculations possible", caller
+      end
+      h = to_hash
+      h.each { |k, v| h[k] = v * scalar }
+      result = TimeDiff.new h
+      result.normalize!
+    end
+
+    ##
+    # Equivalent to *-1
+    def -@
+      self * -1
+    end
+
+    ##
+    # Returns an integer representing this TimeDiff - the total number of seconds
+    def to_i
+      total_seconds
+    end
+
+    ##
+    # Returns an float representing this TimeDiff - the total number of seconds with smaller units as decimals
+    def to_f
+      to_i.to_f + @diff[0] * 0.000000001
+    end
+
+    def coerce other
+      return other, self.to_f
+    end
+
+    ##
+    # Returns an hash with all different time durations with each ones value
+    def to_hash
+      h = {}
+      UNITS.each do |unit|
+        h[unit] = send(unit)
+      end
+      h
+    end
+
+    protected
+
+    def apply_time_diff ending, start
+      @diff = [ending.nsec - start.nsec, ending.sec - start.sec, ending.min - start.min, ending.hour - start.hour, ending.day - start.day, ending.month - start.month, ending.year - start.year]
+      normalize! start
+    end
+
+    def add_array array
+      array.each_index do |i|
+        @diff[i] += array[i] unless array[i].nil?
+      end
+      normalize!
+    end
+
+    def normalize! base_date=nil, recalculate=false
+      if base_date && recalculate
+        ending = base_date + self
+        apply_time_diff ending, base_date
+      else
+        switched = false
+        if total_seconds < 0
+          @diff.collect! { |t| t * -1 }
+          switched = true
+        end
+
+        @diff.each_index do |index|
+          (index+1...UNITS.length).to_a.each do |unit|
+            base = TimeDiff.get_ratio UNITS[unit], UNITS[index], base_date
+            @diff[unit] += @diff[index] / base
+            @diff[index] %= base
+          end
+        end
+
+        @diff.collect! { |t| t * -1 } if switched
+        self
+      end
+    end
+
+    def self.get_ratio numerator_unit, denominator_unit, base_date=nil
+      if base_date && numerator_unit == :months && denominator_unit == :days
+        Time.days_in_month base_date.month, base_date.year
+      elsif denominator_unit == :n_secs
+        (1.send(numerator_unit) * 1000000000).round
+      else
+        (1.send(numerator_unit) / 1.send(denominator_unit)).round
+      end
+    end
+
+  end
+end

data/lib/delta_t/version.rb

@@ -0,0 +1,3 @@
+module DeltaT
+  VERSION = "0.0.1"
+end

data/test/delta_t_test.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/helper'
+
+class DeltaT::TimeDiff
+  # exposing internals for better testing
+  # nano secs are ignored cause they are just implemented for compatibility with old play time diff
+  # current implementation: [y,m,d,h,m,s]
+  def diff
+    @diff.reverse[0..-2]
+  end
+end
+
+class DeltaTTest < Test::Unit::TestCase
+
+  # caution - depends on current time so if buggy non deterministic
+  def test_simple_difference
+    now = Time.now
+    dif = DeltaT::TimeDiff.new(now, now - (1.days + 3.hours))
+    assert_equal 0, dif.years
+    assert_equal 0, dif.months
+    assert_equal 1, dif.days
+    assert_equal 3, dif.hours
+    assert_equal 0, dif.minutes
+    assert_equal 0, dif.seconds
+  end
+
+  def test_overlapping_difference
+    assert_equal [0,0,0,0,0,2], DeltaT::TimeDiff.new(Time.new(2000, 1, 1, 0, 1 , 1), Time.new(2000, 1, 1, 0, 0, 59)).diff
+    assert_equal [0,0,2,0,0,0], DeltaT::TimeDiff.new(Time.new(2000, 2, 1), Time.new(2000, 1, 30)).diff
+  end
+
+  def test_negative_difference
+    assert_equal [1, 2, 10, 0, 3, 2], DeltaT::TimeDiff.new(Time.new(2001, 6, 15, 10, 4, 1), Time.new(2000, 4, 5, 10, 0, 59)).diff
+    assert_equal [-1, -2, -10, 0, -3, -2], DeltaT::TimeDiff.new(Time.new(2000, 4, 5, 10, 0, 59), Time.new(2001, 6, 15, 10, 4, 1)).diff
+  end
+
+  def test_init
+    assert_equal [1,2,3,4,5,6], DeltaT::TimeDiff.new(years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6).diff
+    assert_equal [1,0,3,0,0,0], DeltaT::TimeDiff.new(years: 1, days: 3).diff
+    assert_equal [1,0,0,0,0,0], DeltaT::TimeDiff.new(years: 1).diff
+  end
+
+  def test_equals
+    t = DeltaT::TimeDiff.new(years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6)
+    assert t == t
+    assert t != -t
+  end
+
+  def test_total
+    assert_equal 48, DeltaT::TimeDiff.new(days: 2).total_hours
+    assert_equal 62, DeltaT::TimeDiff.new(months: 2, days: 2).total_days
+    dif = DeltaT::TimeDiff.new(months: 2, days: 2, hours: 5, minutes: 7, seconds: 1)
+    assert_equal 62, dif.total_days
+    assert_equal 5375221, dif.total_seconds
+  end
+
+  def test_normalization
+    assert_equal [0,1,21,0,0,0], DeltaT::TimeDiff.new(days: 51).diff
+    assert_equal [0,1,10,18,5,0], DeltaT::TimeDiff.new(minutes: 60*24*40 + 60*18 + 5).diff
+    assert_equal [0,-1,-10,-18,-5,0], DeltaT::TimeDiff.new(minutes: -(60*24*40 + 60*18 + 5)).diff
+  end
+
+  def test_to_hash
+    h = {years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6, n_secs: 0}
+    assert_equal h, DeltaT::TimeDiff.new(h).to_hash
+  end
+
+  def test_operators
+    assert_equal [1,3,0,0,0,0], (DeltaT::TimeDiff.new(months: 11) + DeltaT::TimeDiff.new(months: 4)).diff
+    assert_equal [0,7,0,0,0,0], (DeltaT::TimeDiff.new(months: 11) - DeltaT::TimeDiff.new(months: 4)).diff
+    assert_equal [2,9,0,0,0,0], (DeltaT::TimeDiff.new(months: 11) * 3).diff
+  end
+
+  def test_time_operators
+    before = Time.new 2001, 4, 3, 12, 23, 55
+    after = Time.new 2012, 12, 21, 0, 0, 0
+    assert_equal after, before + DeltaT::TimeDiff.new(after, before)
+    assert_equal after, DeltaT::TimeDiff.new(after, before) + before
+    assert_equal before, after - DeltaT::TimeDiff.new(after, before)
+    assert_equal before, -DeltaT::TimeDiff.new(after, before) + after
+
+    assert_equal after, before + (after - before)
+    assert_equal after, after - before + before
+    assert_equal before, after - (after - before)
+    assert_equal before, -(after - before) + after
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'delta_t'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: delta_t
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tim 'S.D.Eagle' Zeitz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    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'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
+description: Making time difference calculations fun
+email:
+- dev.tim.zeitz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- delta_t.gemspec
+- lib/delta_t.rb
+- lib/delta_t/time.rb
+- lib/delta_t/time_diff.rb
+- lib/delta_t/version.rb
+- test/delta_t_test.rb
+- test/helper.rb
+homepage: https://github.com/SDEagle/delta_t
+licenses: []
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides a class to represent time differences and make duration calculations
+  nice and easy
+test_files:
+- test/delta_t_test.rb
+- test/helper.rb