rduration 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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.3@duration_gem

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-duration.gemspec
+gemspec
+
+# Guard & Devtools
+gem 'guard', '~> 0.8.8'
+# MacOS notifications:
+gem 'rb-fsevent', :require => ('rb-fsevent' if RUBY_PLATFORM =~ /darwin/i)
+gem 'growl', :require => ('growl' if RUBY_PLATFORM =~ /darwin/i)
+gem 'guard-bundler'
+gem 'guard-rspec'

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :version => 2, :cli => '--color --format nested', :all_on_start => true, :all_after_pass => true do
+  watch('spec/spec_helper.rb')                        { "spec" }
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Matt Wilson
+
+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,95 @@
+# Duration
+
+Provides simple (somewhat naive) Duration parsing from strings. Allows you to compare and modify durations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rduration', :require => 'duration'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rduration
+
+## Usage
+
+`duration_spec.rb` has more details about the types of strings this can handle, but here's brief overview:
+
+```ruby
+a = Duration.new("01:46:00")
+b = Duration.new("25 minutes 17 seconds")
+a > b # => true
+a - b # => #<Duration:2164349940 @raw="4843">
+[b, a].sort # => [a, b]
+
+b.to_clock_format # => "25:17"
+```
+
+If you require 'duration/string_ext' then strings gain a new method: `#to_duration`
+
+```ruby
+"35m 5s".to_duration # => NoMethodError: undefined method `to_duration' for "35m 5s":String
+
+require 'duration/string_ext'
+"35m 5s".to_duration # => #<Duration:2151903540 @raw="35m 5s">
+
+# once you've done this, the arithmetic and comparison stuff works too
+"35m 5s".to_duration > "10m" # => true
+"35m 5s".to_duration > "50m" # => false
+"35m 5s".to_duration + "10m" # => #<Duration:2156162420 @raw="2705">
+```
+
+### Formats
+
+Here's a list of formats that will parse:
+
+```
+Duration
+  #parse
+    parses "0" as 0 seconds
+    parses "00:00" as 0 seconds
+    parses "0 seconds" as 0 seconds
+    parses nil as 0 seconds
+    parses "45s" as 45 seconds
+    parses "45 seconds" as 45 seconds
+    parses "00:00:45" as 45 seconds
+    parses "45" as 45 seconds
+    parses "137s" as 137 seconds
+    parses "2m17s" as 137 seconds
+    parses "2 minutes 17 seconds" as 137 seconds
+    parses "02:17" as 137 seconds
+    parses "2:17" as 137 seconds
+    parses "1h32m07s" as 5527 seconds
+    parses "1:32:07" as 5527 seconds
+    parses "92 minutes and 7 seconds" as 5527 seconds
+    parses "3d10h15m" as 296100 seconds
+    parses "3:10:15:00" as 296100 seconds
+    parses "82 hours 15 minutes" as 296100 seconds
+```
+
+### Interesting Methods
+
+* `#to_clock_format` leverages `#to_s`'s newfound proc handling powers to format the output. Speaking of...
+* `#to_s` takes a proc, and yields the duration in seconds to it. This is useful for output.
+
+## CHANGELOG
+
+* **v0.0.1 Hello World**
+  * Handles all of my use cases. Could be better at everything, though :).
+
+## 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
+
+## Copyright
+
+Copyright (c) 2012 Matt Wilson. See LICENSE for details, but it's MIT.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/duration/arithmatic.rb

@@ -0,0 +1,15 @@
+class Duration
+  module Arithmatic
+    def + other_duration
+      raise StandardError.new("Cannot add #{other_duration.class} to #{self}") unless other_duration.respond_to?(:to_i)
+      other_duration = other_duration.to_duration if other_duration.respond_to?(:to_duration)
+      Duration.new(self.to_i + other_duration.to_i)
+    end
+
+    def - other_duration
+      raise StandardError.new("Cannot subtract #{other_duration.class} from #{self}") unless other_duration.respond_to?(:to_i)
+      other_duration = other_duration.to_duration if other_duration.respond_to?(:to_duration)
+      Duration.new(self.to_i - other_duration.to_i)
+    end
+  end
+end

data/lib/duration/string_ext.rb

@@ -0,0 +1,5 @@
+class String
+  def to_duration
+    Duration.new(self)
+  end
+end

data/lib/duration/version.rb

@@ -0,0 +1,3 @@
+class Duration
+  VERSION = "0.0.1"
+end

data/lib/duration.rb

@@ -0,0 +1,99 @@
+require "duration/version"
+require "duration/arithmatic"
+
+class Duration
+  attr_accessor :raw
+
+  include Comparable
+  include Arithmatic
+
+  def initialize input
+    self.raw = input.to_s
+  end
+
+  def parse
+    @parsed ||= count normalize_input
+  end
+  alias_method :to_i, :parse
+
+  def normalize_input input = raw.dup
+    input = condense_duration_tokens input # => '92 m and 7 s'
+    input = strip_useless_words input # => '92 m 7 s'
+    input = intelligently_space input # => '92m 7s'
+    convert_to_normal_form input # '92:07' => '92m 7s'
+  end
+
+  def condense_duration_tokens input = raw.dup
+    input.gsub(/(#{DURATIONS.keys.join("|")})/, DURATIONS)
+  end
+
+  def strip_useless_words input = raw.dup
+    input.gsub(/[[:alpha:]]{2,}/, "").gsub(/[^\ddhms:]/, " ").squeeze(" ")
+  end
+
+  def intelligently_space input = raw.dup
+    input.gsub(/\s/, "").gsub(/([[:alpha:]])(?=[[:digit:]])/, '\1 ')
+  end
+
+  def convert_to_normal_form input = raw.dup
+    return input unless input =~ /:/ || input !~ /[[:alpha:]]/
+    split = input.split(":").reverse
+    split.zip(UNITS).reverse.map { |unit| unit.join("") }.join(" ")
+  end
+
+  def hashify string
+    string.split(" ").inject({}) do |accum, token|
+      _, amount, type = token.split(/([[:digit:]]+)(?=[[:alpha:]])/)
+      accum[type] = amount.to_i
+      accum
+    end
+  end
+
+  def count input = normalize_input
+    hashify(input).inject(0) do |accum, (unit, how_many)|
+      accum += how_many * STANDARD_CONVERSION[unit]
+      accum
+    end
+  end
+
+  def to_clock_format
+    to_s proc { |s|
+      a = STANDARD_CONVERSION.values.dup
+      [(s / a[3]), (s % a[3] / a[2]), (s % a[2] / a[1]), (s % a[1])].
+        each_with_index.
+        reject { |value, index| index < 2 && value == 0 }.
+        map { |value| "%02d" % value }.
+        join(":")
+    }
+  end
+
+  def to_s formatter = nil
+    formatter ? formatter.call(parse) : "#<Duration:#{self.object_id} @raw=#{raw.inspect} @clock=#{to_clock_format.inspect}>"
+  end
+
+  UNITS = ['s', 'm', 'h', 'd']
+
+  DURATIONS = {
+    'seconds' => 's',
+    'minutes' => 'm',
+    'hours'   => 'h',
+    'days'    => 'd',
+    'sec'     => 's',
+    'hrs'     => 'h',
+    'mins'    => 'm'
+  }
+  DURATIONS.default_proc = proc { |hash, key| hash[key] = "" }
+
+  STANDARD_CONVERSION = {
+    's' => 1,
+    'm' => 60,
+    'h' => 3600,
+    'd' => 86_400
+  }
+
+  # Comparable Protocol:
+  def <=> other_thing
+    other_thing = other_thing.to_duration if other_thing.respond_to?(:to_duration)
+    self.to_i <=> other_thing.to_i
+  end
+end

data/rduration.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/duration/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors       = ["Matt Wilson"]
+  s.email         = ["mhw@hypomodern.com"]
+  s.description   = %q{Simple utility for parsing durations from strings and comparing them. Basic math is also supported.}
+  s.summary       = %q{Parse durations from strings and manipulate them.}
+  s.homepage      = "https://github.com/hypomodern/rduration"
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.name          = "rduration"
+  s.require_paths = ["lib"]
+  s.version       = Duration::VERSION
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/spec/duration/string_ext_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'duration/string_ext'
+
+describe String do
+  describe "#to_duration" do
+    it "returns a duration object" do
+      duration = "2 hours 5 minutes".to_duration
+      duration.should be_a_kind_of(Duration)
+    end
+  end
+
+end

data/spec/duration_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe Duration do
+  describe "#initialize" do
+    it "stores the raw input string in an attribute called #raw" do
+      d = Duration.new("00:01")
+      d.raw.should == "00:01"
+    end
+    it "coerces the input to a string" do
+      d = Duration.new(nil)
+      d.raw.should == ""
+    end
+  end
+
+  describe "#parse" do
+    expected_second_values_and_their_strings = {
+      0       => [ '0', '00:00', '0 seconds', nil ],
+      45      => [ '45s', '45 seconds', '00:00:45', '45' ],
+      137     => [ '137s', '2m17s', '2 minutes 17 seconds', '02:17', '2:17' ],
+      5_527   => [ '1h32m07s', '1:32:07', '92 minutes and 7 seconds' ],
+      296_100 => [  '3d10h15m', '3:10:15:00', '82 hours 15 minutes' ]
+    }
+    expected_second_values_and_their_strings.each do |(expected, inputs)|
+      inputs.each do |possible_input|
+        it "parses #{possible_input.inspect} as #{expected} seconds" do
+          Duration.new(possible_input).parse.should == expected
+        end
+      end
+    end
+  end
+
+  describe "#to_i" do
+    it "is an alias for #parse" do
+      Duration.new('45s').to_i.should == 45
+    end
+  end
+
+  describe "#normalize_input" do
+    normal_form_and_variants = {
+      '45s'            => [ '45s', '45 seconds', '45' ],
+      '00h 00m 45s'    => ['00:00:45'],
+      '2m 17s'         => [ '2m17s', '2 minutes 17 seconds', '2:17','2m 17s' ],
+      '137s'           => ['137s'],
+      '1h 32m 07s'     => [ '1h32m07s', '1:32:07', '1h 32m 07s'  ],
+      '3d 10h 15m 00s' => [ '3d10h15m00s', '3:10:15:00', '3d 10h 15m 00s' ],
+      '82h 15m'        => ['82 hours, 15 minutes'],
+      '92m 7s'         => ['92 minutes and 7 seconds']
+    }
+    normal_form_and_variants.each do |(expected, inputs)|
+      inputs.each do |input|
+        it "normalizes #{input.inspect} to #{expected.inspect}" do
+          Duration.new(input).normalize_input.should == expected
+        end
+      end
+    end
+    it "doesn't modify the #raw attibute" do
+      input = '92 minutes and 7 seconds'
+      Duration.new(input).tap { |s| s.normalize_input }.raw.should == input
+    end
+  end
+
+  describe "#condense_duration_tokens" do
+    forms_to_condense = {
+      '2 minutes 17 seconds' => '2 m 17 s',
+      '3 days 10 hours 15 minutes' => '3 d 10 h 15 m',
+      '2:17' => '2:17'
+    }
+    forms_to_condense.each do |(input, expectation)|
+      it "converts #{input.inspect} into #{expectation.inspect}" do
+        Duration.new(input).condense_duration_tokens.should == expectation
+      end
+    end
+  end
+
+  describe "#strip_useless_words" do
+    forms_with_useless_words = {
+      '92 m and 7 s' => '92 m 7 s',
+      '3 d, 8 h, and 11 m' => '3 d 8 h 11 m',
+      '3m + 18s' => '3m 18s',
+      '2:17' => '2:17'
+    }
+    forms_with_useless_words.each do |(input, expectation)|
+      it "converts #{input.inspect} to #{expectation.inspect}" do
+        Duration.new(input).strip_useless_words.should == expectation
+      end
+    end
+  end
+
+  describe "#intelligently_space" do
+    spaced_out_forms = {
+      '1h32m07s' => '1h 32m 07s',
+      '92 m 7 s' => '92m 7s',
+      '3 d 8 h 11 m' => '3d 8h 11m',
+      '3m 18s' => '3m 18s',
+      '2:17' => '2:17'
+    }
+    spaced_out_forms.each do |(input, expectation)|
+      it "converts #{input.inspect} to #{expectation.inspect}" do
+        Duration.new(input).intelligently_space.should == expectation
+      end
+    end
+  end
+
+  describe "#convert_to_normal_form" do
+    clock_forms = {
+      '1:32:07'     => '1h 32m 07s',
+      '92:07'       => '92m 07s',
+      '03:08:11:00' => '03d 08h 11m 00s',
+      '03:00'       => '03m 00s',
+      '2m 17s'      => '2m 17s',
+      '45'          => '45s'
+    }
+    clock_forms.each do |(input, expectation)|
+      it "converts #{input.inspect} to #{expectation.inspect}" do
+        Duration.new(input).convert_to_normal_form.should == expectation
+      end
+    end
+  end
+
+  describe "#hashify" do
+    it "maps a string to an easily-countable hash form" do
+      Duration.new("42m 3s").hashify("42m 3s").should == {
+        "m" => 42,
+        "s" => 3
+      }
+    end
+    normalized_inputs = {
+      '1h 32m 07s'      => { 'h' => 1, 'm' => 32, 's' => 7 },
+      '03d 08h 11m 00s' => { 'd' => 3, 'h' => 8, 'm' => 11, 's' => 0 },
+    }
+    normalized_inputs.each do |(input, expectation)|
+      it "converts #{input.inspect} to #{expectation.inspect}" do
+        Duration.new(input).hashify(input).should == expectation
+      end
+    end
+  end
+
+  describe "#to_clock_format" do
+    clocks = {
+      0       => '00:00',
+      45      => '00:45',
+      137     => '02:17',
+      5_527   => '01:32:07',
+      296_100 => '03:10:15:00'
+    }
+    clocks.each do |seconds, formatted|
+      it "outputs #{formatted.inspect} given #{seconds} seconds" do
+        Duration.new(seconds).to_clock_format.should == formatted
+      end
+    end
+  end
+
+  describe "#to_s" do
+    context "but with a formatter proc/lambda" do
+      it "calls the formatter, yielding the current number of seconds" do
+        formatted = Duration.new(500).to_s proc { |s| "Mein formatt sagt #{s}" }
+        formatted.should == "Mein formatt sagt 500"
+      end
+    end
+    it "just returns something like #to_s normally does" do
+      d = Duration.new(500)
+      d.to_s.should == "#<Duration:#{d.object_id} @raw=\"500\" @clock=\"08:20\">"
+    end
+  end
+
+  describe "Comparable compatibility" do
+    describe "#<=>" do
+      it "compares Durations based on their #to_i values" do
+        ( Duration.new("01:04:55") > Duration.new("55m 3s") ).should be_true
+        ( Duration.new("55m 3s") > Duration.new("30 minutes and 14 seconds") ).should be_true
+        ( Duration.new("04:22") > Duration.new("75") ).should be_true
+      end
+    end
+  end
+
+  describe "basic maths" do
+    let(:a) { Duration.new("55 seconds") }
+    let(:b) { Duration.new("1m 10s") }
+    describe "#+" do
+      it "returns a new Duration..." do
+        added = a + b
+        added.should be_a_kind_of(Duration)
+        [a.object_id, b.object_id].should_not include(added.object_id)
+      end
+      it "sums the two Durations by seconds" do
+        added = a+b
+        added.to_i.should == 125
+        added.to_clock_format.should == "02:05"
+      end
+    end
+    describe "#-" do
+      it "returns a new Duration..." do
+        difference = b - a
+        difference.should be_a_kind_of(Duration)
+        [a.object_id, b.object_id].should_not include(difference.object_id)
+      end
+      it "subtracts the two Durations by seconds" do
+        difference = b - a
+        difference.to_i.should == 15
+        difference.to_clock_format.should == "00:15"
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'duration' # and any other gems you need
+
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: rduration
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2156379680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156379680
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156379180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156379180
+description: Simple utility for parsing durations from strings and comparing them.
+  Basic math is also supported.
+email:
+- mhw@hypomodern.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/duration.rb
+- lib/duration/arithmatic.rb
+- lib/duration/string_ext.rb
+- lib/duration/version.rb
+- rduration.gemspec
+- spec/duration/string_ext_spec.rb
+- spec/duration_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/hypomodern/rduration
+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.17
+signing_key: 
+specification_version: 3
+summary: Parse durations from strings and manipulate them.
+test_files:
+- spec/duration/string_ext_spec.rb
+- spec/duration_spec.rb
+- spec/spec_helper.rb