hms 0.0.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+
+rvm:
+  - 1.9.3

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Nicholas E. Rabenau
+
+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,40 @@
+# HMS
+
+Models construction, parsing and formatting durations in hh::mm::ss format.
+
+This is an extraction from the [cre-stats](http://github.com/nerab/cre-stats) project.
+
+[![Build Status](https://secure.travis-ci.org/nerab/hms.png?branch=master)](http://travis-ci.org/nerab/hms)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hms'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hms
+
+## Usage
+
+    d = HMS::Duration.new(42)
+    puts "Podcast episode length is #{d}." # 42
+
+    d = HMS::Duration.new('32:16:08')
+    puts "#{d} equals to #{d.to_i} seconds" # 116168
+
+See [tests](/nerab/hms/blob/master/test/unit) for advanced usage.
+
+## 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,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'lib' << 'test' << 'test/unit'
+  test.pattern = 'test/unit/test_*.rb'
+end
+
+task :default => :test

data/hms.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hms/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Nicholas E. Rabenau"]
+  gem.email         = ["nerab@gmx.net"]
+  gem.description   = %q{Models construction, parsing and formatting durations in hh::mm::ss format}
+  gem.summary       = %q{Durations in hh::mm::ss format}
+  gem.homepage      = "https://github.com/nerab/hms"
+
+  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          = "hms"
+  gem.require_paths = ["lib"]
+  gem.version       = HMS::VERSION
+
+  gem.add_development_dependency 'rake'
+end

data/lib/hms/duration.rb

@@ -0,0 +1,136 @@
+require 'forwardable'
+
+module HMS
+  #
+  # Represents durations in hh:mm:ss format
+  #
+  # Parts taken from https://gist.github.com/309694
+  #
+  class Duration < Numeric
+    def initialize(val = 0)
+      case val
+      when String
+        @seconds = parse_string(val)
+      when Numeric
+        @seconds = val.to_i
+      when nil
+        @seconds = 0
+      else
+        raise ArgumentError, "Cannot convert #{val} to Duration"
+      end
+    end
+
+    def coerce(other)
+      [Duration.new(other.to_i), self]
+    end
+
+    #
+    # returns the total duration in seconds
+    #
+    def to_i
+      @seconds
+    end
+
+    #
+    # returns the hours part of the total duration
+    #
+    def hours
+      @seconds.abs / 60 / 60  * (@seconds < 0 ? -1 : 1)
+    end
+
+    #
+    # returns the hours part of the total duration
+    #
+    def minutes
+      (@seconds.abs / 60) % 60 * (@seconds < 0 ? -1 : 1)
+    end
+
+    #
+    # Returns the seconds part of the total duration. For the total in seconds
+    # use #to_i.
+    #
+    def seconds
+      @seconds.abs % 60 * (@seconds < 0 ? -1 : 1)
+    end
+
+    def to_s
+      "#{'-' if @seconds < 0}#{'%02d' % hours.abs}:#{'%02d' % minutes.abs}:#{'%02d' % seconds.abs}"
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) && @seconds == other.to_i
+    end
+
+    def ==(other)
+      @seconds == other.to_i
+    end
+
+    # delegate to seconds
+    extend Forwardable
+    def_delegators :@seconds, :hash, :zero?, :nonzero?, :between?
+
+    include Comparable
+
+    def <=>(other)
+      case other
+      when Duration
+        @seconds <=> other.to_i
+      when Numeric
+        @seconds <=> other
+      else
+        a, b = other.coerce(self)
+        a <=> b
+      end rescue nil
+    end
+
+    def +@
+      self
+    end
+
+    def -@
+      Duration.new(-@seconds)
+    end
+
+    def +(other)
+      op(:+, other)
+    end
+
+    def -(other)
+      op(:-, other)
+    end
+
+    def *(other)
+      op(:*, other)
+    end
+
+    def /(other)
+      op(:/, other)
+    end
+
+    private
+
+    DURATION_REGEXP = /([0-9]+):([0-5][0-9]):([0-5][0-9])/
+
+    #
+    # Loads a duration (seconds) from hh:mm:ss string
+    #
+    def parse_string(str)
+      hms = DURATION_REGEXP.match(str)
+      raise ArgumentError, "The duration #{str} does not match the expected format #{DURATION_REGEXP}" if hms.nil?
+      hms.captures[0].to_i * 60 * 60 + hms.captures[1].to_i * 60 + hms.captures[2].to_i
+    end
+
+    # generic operator implementation
+    def op(sym, o)
+      case o
+      when Duration
+        Duration.new(@seconds.send(sym, o.to_i))
+      when Numeric
+        Duration.new(@seconds.send(sym, o))
+      else
+        a, b = o.coerce(self)
+        a.send(sym, b)
+      end
+    end
+  end
+end

data/lib/hms/version.rb

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

data/lib/hms.rb

@@ -0,0 +1,6 @@
+require "hms/version"
+require "hms/duration"
+
+module HMS
+  # Your code goes here...
+end

data/test/helper.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require 'hms'
+
+class MiniTest::Unit::TestCase
+  # extensions go here
+end
+
+#
+# Allow some better expressiveness
+#
+class Fixnum
+  def hour
+    minute * 60
+  end
+  alias hours hour
+
+  def minute
+    to_i * 60
+  end
+  alias minutes minute
+
+  alias second to_i
+  alias seconds second
+end

data/test/unit/test_duration.rb

@@ -0,0 +1,296 @@
+require 'helper'
+
+class TestDuration < MiniTest::Unit::TestCase
+  include HMS
+
+  def test_initial
+    d = Duration.new
+    assert_equal(0, d.to_i)
+    assert_equal('00:00:00', d.to_s)
+  end
+
+  def test_invalid_strings
+    assert_raises(ArgumentError){Duration.new('')}
+    assert_raises(ArgumentError){Duration.new('foo')}
+
+    assert(Duration.new('00:00:59'))
+    assert_raises(ArgumentError){Duration.new('00:00:60')}
+    assert(Duration.new('00:01:00'))
+
+    assert(Duration.new('00:59:00'))
+    assert_raises(ArgumentError){Duration.new('00:60:00')}
+    assert(Duration.new('99:00:00'))
+  end
+
+  def test_zero
+    sec = 0
+    assert_construction('00:00:00', sec)
+    assert_parts(0, 0, 0, sec)
+  end
+
+  def test_1_sec
+    sec = 1.second
+    assert_construction('00:00:01', sec)
+    assert_parts(0, 0, 1, sec)
+  end
+
+  def test_59_sec
+    sec = 59.seconds
+    assert_construction('00:00:59', sec)
+    assert_parts(0, 0, 59, sec)
+  end
+
+  def test_60_sec
+    sec = 1.minute
+    assert_construction('00:01:00', sec)
+    assert_parts(0, 1, 0, sec)
+  end
+
+  def test_61_sec
+    sec = 1.minute + 1.seconds
+    assert_construction('00:01:01', sec)
+    assert_parts(0, 1, 1, sec)
+  end
+
+  def test_3_min_59_sec
+    sec = 3.minutes + 59.seconds
+    assert_construction('00:03:59', sec)
+    assert_parts(0, 3, 59, sec)
+  end
+
+  def test_3_min_60_sec
+    sec = 3.minutes + 60.seconds
+    assert_construction('00:04:00', sec)
+    assert_parts(0, 4, 0, sec)
+  end
+
+  def test_3_min_61_sec
+    sec = 3.minutes + 61.seconds
+    assert_construction('00:04:01', sec)
+    assert_parts(0, 4, 1, sec)
+  end
+
+  def test_59_min_59_sec
+    sec = 59.minutes + 59.seconds
+    assert_construction('00:59:59', sec)
+    assert_parts(0, 59, 59, sec)
+  end
+
+  def test_59_min_60_sec
+    sec = 59.minutes + 60.seconds
+    assert_construction('01:00:00', sec)
+    assert_parts(1, 0, 0, sec)
+  end
+
+  def test_59_min_61_sec
+    sec = 59.minutes + 61.seconds
+    assert_construction('01:00:01', sec)
+    assert_parts(1, 0, 1, sec)
+  end
+
+  def test_1_hr_59_sec
+    sec = 1.hour + 59.seconds
+    assert_construction('01:00:59', sec)
+    assert_parts(1, 0, 59, sec)
+  end
+
+  def test_1_hr_60_sec
+    sec = 1.hour + 60.seconds
+    assert_construction('01:01:00', sec)
+    assert_parts(1, 1, 0, sec)
+  end
+
+  def test_1_hr_61_sec
+    sec = 1.hour + 61.seconds
+    assert_construction('01:01:01', sec)
+    assert_parts(1, 1, 1, sec)
+  end
+
+  def test_1_hr_59_min_59_sec
+    sec = 1.hour + 59.minutes + 59.seconds
+    assert_construction('01:59:59', sec)
+    assert_parts(1, 59, 59, sec)
+  end
+
+  def test_1_hr_59_min_60_sec
+    sec = 1.hour + 59.minutes + 60.seconds
+    assert_construction('02:00:00', sec)
+    assert_parts(2, 0, 0, sec)
+  end
+
+  def test_1_hr_59_min_61_sec
+    sec = 1.hour + 59.minutes + 61.seconds
+    assert_construction('02:00:01', sec)
+    assert_parts(2, 0, 1, sec)
+  end
+
+  def test_23_hr_59_min_59_sec
+    sec = 23.hours + 59.minutes + 59.seconds
+    assert_construction('23:59:59', sec)
+    assert_parts(23, 59, 59, sec)
+  end
+
+  # we don't overflow to days
+  def test_23_hr_59_min_60_sec
+    sec = 23.hours + 59.minutes + 60.seconds
+    assert_construction('24:00:00', sec)
+    assert_parts(24, 0, 0, sec)
+  end
+
+  def test_23_hr_59_min_61_sec
+    sec = 23.hours + 59.minutes + 61.seconds
+    assert_construction('24:00:01', sec)
+    assert_parts(24, 0, 1, sec)
+  end
+
+  def test_99_hr_59_min_59_sec
+    sec = 99.hours + 59.minutes + 59.seconds
+    assert_construction('99:59:59', sec)
+    assert_parts(99, 59, 59, sec)
+  end
+
+  def test_99_hr_59_min_60_sec
+    sec = 99.hours + 59.minutes + 60.seconds
+    assert_construction('100:00:00', sec)
+    assert_parts(100, 0, 0, sec)
+  end
+
+  def test_99_hr_59_min_61_sec
+    sec = 99.hours + 59.minutes + 61.seconds
+    assert_construction('100:00:01', sec)
+    assert_parts(100, 0, 1, sec)
+  end
+
+  def test_plus_zero
+    assert_equal(0, Duration.new + Duration.new)
+    assert_equal(0, Duration.new + 0)
+    assert_equal(0, 0 + Duration.new)
+  end
+
+  def test_plus_two
+    assert_equal(4, Duration.new(2) + Duration.new(2))
+    assert_equal(4, Duration.new(2) + 2)
+    assert_equal(4, 2 + Duration.new(2))
+  end
+
+  def test_minus_zero
+    assert_equal(0, Duration.new(2) - Duration.new(2))
+    assert_equal(0, Duration.new(2) - 2)
+    assert_equal(0, 2 - Duration.new(2))
+    assert_equal('00:00:00', (2 - Duration.new(2)).to_s)
+  end
+
+  def test_minus_positive
+    assert_equal(2, Duration.new(5) - Duration.new(3))
+    assert_equal(2, Duration.new(5) - 3)
+    assert_equal(2, 5 - Duration.new(3))
+    assert_equal('00:00:02', (5 - Duration.new(3)).to_s)
+  end
+
+  def test_minus_negative
+    assert_equal(-2, Duration.new(5) - Duration.new(7))
+    assert_equal(-2, Duration.new(5) - 7)
+    assert_equal(-2, 5 - Duration.new(7))
+
+    minus2 = (5 - Duration.new(7))
+    assert_parts(0, 0, -2, minus2)
+    assert_equal('-00:00:02', minus2.to_s)
+  end
+
+  def test_negative_to_s
+    assert_equal('-00:00:59', Duration.new(-1.minute + 1.second).to_s)
+    assert_equal('-00:01:00', Duration.new(-1.minute).to_s)
+    assert_equal('-00:01:08', Duration.new(-1.minute - 8.seconds).to_s)
+  end
+
+  def test_compare_zero
+    assert_equal(Duration.new, Duration.new)
+    assert_equal(0, Duration.new)
+    assert_equal(Duration.new, 0)
+  end
+
+  def test_compare_positive
+    assert_equal(Duration.new(42), Duration.new(42))
+    assert_equal(42, Duration.new(42))
+    assert_equal(Duration.new(42), 42)
+  end
+
+  def test_compare_negative
+    assert_equal(Duration.new(-23), Duration.new(-23))
+    assert_equal(-23, Duration.new(-23))
+    assert_equal(Duration.new(-23), -23)
+  end
+
+  def test_equals_zero
+    assert(Duration.new == Duration.new)
+    assert(0 == Duration.new)
+    assert(Duration.new == 0)
+  end
+
+  def test_equals_positive
+    assert(Duration.new(42) == Duration.new(42))
+    assert(42 == Duration.new(42))
+    assert(Duration.new(42) == 42)
+  end
+
+  def test_equals_negative
+    assert(Duration.new(-23) == Duration.new(-23))
+    assert(-23 == Duration.new(-23))
+    assert(Duration.new(-23) == -23)
+  end
+
+  def test_compare_same
+    assert_equal(0, Duration.new <=> Duration.new)
+    assert_compare_same(0)
+    assert_compare_same(42)
+    assert_compare_same(-11)
+  end
+
+  def test_compare_shorter
+    assert_compare_shorter(23, 42)
+    assert_compare_shorter(-42, 23)
+  end
+
+  def test_compare_longer
+    assert_compare_longer(42, 23)
+    assert_compare_longer(-23, -42)
+  end
+
+  private
+
+  def assert_construction(str, int)
+    d = Duration.new(int)
+    assert_equal(int, d.to_i)
+    assert_equal(str, d.to_s)
+    assert_equal(int, Duration.new(str).to_i)
+    assert_equal(str, Duration.new(str).to_s)
+  end
+
+  def assert_parts(hours, minutes, seconds, int)
+    d = Duration.new(int)
+
+    assert_equal(hours, d.hours, 'Wrong hours')
+    assert_equal(minutes, d.minutes, 'Wrong minutes')
+    assert_equal(seconds, d.seconds, 'Wrong seconds')
+  end
+
+  def assert_compare_same(number)
+    assert_equal(0, Duration.new(number) <=> Duration.new(number))
+    assert_equal(0, number <=> Duration.new(number))
+    assert_equal(0, Duration.new(number) <=> number)
+  end
+
+  def assert_compare_shorter(left, right)
+    assert(left < right)
+    assert(0 > (Duration.new(left) <=> Duration.new(right)))
+    assert(0 > (left <=> Duration.new(right)))
+    assert(0 > (Duration.new(left) <=> right))
+  end
+
+  def assert_compare_longer(left, right)
+    assert(left > right)
+    assert(0 < (Duration.new(left) <=> Duration.new(right)))
+    assert(0 < (left <=> Duration.new(right)))
+    assert(0 < (Duration.new(left) <=> right))
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: hms
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nicholas E. Rabenau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-07 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'
+description: Models construction, parsing and formatting durations in hh::mm::ss format
+email:
+- nerab@gmx.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hms.gemspec
+- lib/hms.rb
+- lib/hms/duration.rb
+- lib/hms/version.rb
+- test/helper.rb
+- test/unit/test_duration.rb
+homepage: https://github.com/nerab/hms
+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: Durations in hh::mm::ss format
+test_files:
+- test/helper.rb
+- test/unit/test_duration.rb