time_only 1.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+.rbenv-version

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - jruby-18mode
+  - rbx-18mode
+  - ree
+  - 1.9.2
+  - jruby-19mode
+  - rbx-19mode
+  - 1.9.3

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 OrgSync and Aaron Lasseigne
+
+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,59 @@
+# TimeOnly
+
+A simple class for handling time and only time. No dates, no time zones, just good old time of day.
+At the moment, `TimeOnly` only supports resolution to 1 second.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'time_only'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install time_only
+
+## Usage
+
+`TimeOnly` attempts to implement the same functionality as `Time` where it makes sense to do so.
+
+    require 'time_only'
+    
+    time = TimeOnly.new(8, 0, 2)
+    # => '08:00:02'
+    
+    time.hour
+    # => 8
+    
+    time.min
+    # => 0
+    
+    time.sec
+    # => 2
+    
+    time.strftime('The time is %-l:%M:%S %P.')
+    # => 'The time is 1:03:56 pm.'
+    
+    # adding times rolls the time forward and returns a new TimeOnly
+    TimeOnly.new(23, 59, 59) + 3
+    # => '00:00:02'
+        
+    morning_flights, afternoon_flights = departure_times.partition(&:am?)
+    
+    current_time = TimeOnly.now
+    
+    # and many more...
+    
+Method documentation can be found in the source.
+    
+## 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,8 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new

data/lib/time_only.rb

@@ -0,0 +1,260 @@
+class TimeOnly
+  include Comparable
+
+  SECONDS_PER_MIN  = 60
+  SECONDS_PER_HOUR = 60 * SECONDS_PER_MIN
+  SECONDS_PER_DAY  = 24 * SECONDS_PER_HOUR
+
+  # Public: Initialize a TimeOnly.
+  #
+  # seconds - The Integer number of seconds since midnight.
+  #
+  # Examples
+  #
+  #   TimeOnly.at(4)
+  #   # => '00:00:04'
+  def self.at(seconds)
+    new(seconds)
+  end
+
+  def self.now
+    time = Time.now
+
+    new(time.hour, time.min, time.sec)
+  end
+
+  # Public: Initialize a TimeOnly.
+  #
+  # seconds - The Integer number of seconds since midnight.
+  #   OR
+  # hours   - The Integer number of hours.
+  # minutes - The Integer number of minutes.
+  # seconds - The Integer number of seconds.
+  #
+  # Examples
+  #
+  #   TimeOnly.new(4)
+  #   # => '00:00:04'
+  #
+  #   TimeOnly.new(13, 24, 56)
+  #   # => '13:24:56'
+  def initialize(*args)
+    seconds = case args.size
+      when 1
+        args.first
+      when 3
+        hours, minutes, seconds = args
+
+        raise ArgumentError, 'hours must be between 0 and 23'   if hours   < 0 || hours   > 23
+        raise ArgumentError, 'minutes must be between 0 and 59' if minutes < 0 || minutes > 59
+        raise ArgumentError, 'seconds must be between 0 and 59' if seconds < 0 || seconds > 59
+
+        (hours * SECONDS_PER_HOUR) + (minutes * SECONDS_PER_MIN) + seconds
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1 or 3)"
+      end
+
+    @seconds_since_midnight = mod_by_day(seconds)
+  end
+
+  # Public: Add seconds to the time and return that as a new value. If the value
+  # exceeds the number of seconds in a day the time will roll forwardd.
+  #
+  # seconds - The Integer number of seconds.
+  #
+  # Examples
+  #
+  #   TimeOnly.new(4) + 3
+  #   # => '00:00:07'
+  #
+  #   TimeOnly.new(23, 59, 59) + 3
+  #   # => '00:00:02'
+  #
+  # Returns a new TimeOnly.
+  def +(seconds)
+    self.class.new(mod_by_day(@seconds_since_midnight + seconds))
+  end
+
+  # Public: Subtract seconds from the time and return that as a new value. If the
+  # value is less than zero seconds in a day the time will roll backwards.
+  #
+  # seconds - The Integer number of seconds.
+  #
+  # Examples
+  #
+  #   TimeOnly.new(4) - 3
+  #   # => '00:00:01'
+  #
+  #   TimeOnly.new(0, 0, 0) - 3
+  #   # => '23:59:57'
+  #
+  # Returns a new TimeOnly.
+  def -(seconds)
+    self + (seconds * -1)
+  end
+
+  def ==(other)
+    to_i == other.to_i
+  end
+  alias_method :eql?, :==
+
+  def <=>(other)
+    to_i <=> other.to_i
+  end
+
+  def am?
+    hour < 12
+  end
+
+  def hour
+    @hour ||= @seconds_since_midnight / SECONDS_PER_HOUR
+  end
+
+  def min
+    @min ||= (@seconds_since_midnight % SECONDS_PER_HOUR) / SECONDS_PER_MIN
+  end
+
+  def pm?
+    !am?
+  end
+
+  def sec
+    @sec ||= @seconds_since_midnight % SECONDS_PER_MIN
+  end
+
+  # Public: Formats time according to the directives in the given format string.
+  # The directives begins with a percent (%) character. Any text not listed as a
+  # directive will be passed through to the output string.)
+  #
+  # The directive consists of a percent (%) character, zero or more flags and a 
+  # conversion specifier as follows.
+  #
+  #   %<flags><conversion>
+  #
+  #  Flags:
+  #    - don't pad a numerical output
+  #
+  #  Directives:
+  #    %H - Hour of the day, 24-hour clock, zero-padded (00..23)
+  #    %k - Hour of the day, 24-hour clock, blank-padded ( 0..23)
+  #    %I - Hour of the day, 12-hour clock, zero-padded (01..12)
+  #    %l - Hour of the day, 12-hour clock, blank-padded ( 1..12)
+  #    %P - Meridian indicator, lowercase (``am' or ``pm')
+  #    %p - Meridian indicator, uppercase (``AM' or ``PM')
+  #    %M - Minute of the hour (00..59)
+  #    %S - Second of the minute (00..60)
+  #
+  #  Literal strings:
+  #    %n - Newline character (\n)
+  #    %t - Tab character (\t)
+  #    %% - Literal ``%'' character)
+  #
+  #  Combinations:
+  #    %X - Same as %T
+  #    %r - 12-hour time (%I:%M:%S %p)
+  #    %R - 24-hour time (%H:%M)
+  #    %T - 24-hour time (%H:%M:%S)
+  #
+  # format - The String containing directives.
+  #
+  # Examples
+  #
+  #   TimeOnly.new(12, 34, 56).strftime('%r')
+  #   # => '12:34:56 PM'
+  #
+  #   TimeOnly.new(1, 3, 56).strftime('The time is %-l:%M:%S %P.')
+  #   # => 'The time is 1:03:56 pm.'
+  #
+  # Returns the formatted String.
+  def strftime(format)
+    format = format.dup
+
+    format.gsub!(/%[rRTX]/) do |token|
+      case token
+      when '%r'
+        '%I:%M:%S %p'
+      when '%R'
+        '%H:%M'
+      when '%T', '%X'
+        '%H:%M:%S'
+      end
+    end
+
+    format.gsub(/%-?[HkIlPpMSnt%]/) do |token|
+      case token
+      when '%H'
+        zero_pad(hour)
+      when '%k'
+        blank_pad(hour)
+      when '%-H', '%-k'
+        hour
+      when '%I'
+        zero_pad(twelve_hour)
+      when '%l'
+        blank_pad(twelve_hour)
+      when '%-I', '%-l'
+        twelve_hour
+      when '%P'
+        am? ? 'am' : 'pm'
+      when '%p'
+        am? ? 'AM' : 'PM'
+      when '%M'
+        zero_pad(min)
+      when '%-M'
+        min
+      when '%S'
+        zero_pad(sec)
+      when '%-S'
+        sec
+      when '%n'
+        "\n"
+      when '%t'
+        "\t"
+      when '%%'
+        '%'
+      end
+    end
+  end
+
+  def succ
+    self + 1
+  end
+
+  def to_a
+    [hour, min, sec]
+  end
+
+  def to_f
+    @seconds_since_midnight.to_f
+  end
+
+  def to_i
+    @seconds_since_midnight
+  end
+  alias_method :tv_sec, :to_i
+
+  def to_s
+    strftime('%T')
+  end
+  alias_method :asctime, :to_s
+  alias_method :ctime,   :to_s
+  alias_method :inspect, :to_s
+
+  private
+
+  def mod_by_day(seconds)
+    seconds % SECONDS_PER_DAY
+  end
+
+  def twelve_hour
+    hour > 12 ? hour % 12 : hour
+  end
+
+  def zero_pad(number)
+    number < 10 ? "0#{number}" : number
+  end
+
+  def blank_pad(number)
+    number < 10 ? " #{number}" : number
+  end
+end

data/lib/time_only/version.rb

@@ -0,0 +1,3 @@
+class TimeOnly
+  VERSION = '1.0.0'
+end

data/spec/time_only_spec.rb

@@ -0,0 +1,391 @@
+require 'rspec'
+require 'timecop'
+require 'time_only'
+
+describe TimeOnly do
+  describe '.new(args)' do
+    context 'one arg' do
+      it 'creates as the seconds since midnight' do
+        expect(described_class.new(45296).to_i).to eq(45296)
+      end
+
+      it "rolls over seconds that are greater than #{described_class::SECONDS_PER_DAY}" do
+        expect(described_class.new(described_class::SECONDS_PER_DAY * 2 + 1).to_i).to eq(1)
+      end
+
+      it 'handles negative seconds which rolls back' do
+        expect(described_class.new(-10).to_i).to eq(described_class::SECONDS_PER_DAY - 10)
+      end
+    end
+
+    context 'three argss' do
+      it 'creates based on hours, minutes and seconds' do
+        expect(described_class.new(12, 34, 56).to_i).to eq(45296)
+      end
+
+      it 'raises an error when the hours arg is outside of 0 - 23' do
+        expect{ described_class.new(24, 0, 0) }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an error when the minutes arg is outside of 0 - 59' do
+        expect{ described_class.new(0, 60, 0) }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an error when the seconds arg is outside of 0 - 59' do
+        expect{ described_class.new(0, 0, 60) }.to raise_error(ArgumentError)
+      end
+    end
+
+    it 'raises an error when the wrong number of arguments is passed' do
+      expect{ described_class.new(1, 2) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '.at(seconds)' do
+    it 'creates a time based on the number of seconds since midnight' do
+      expect(described_class.at(300).to_i).to eq(300)
+    end
+
+    it "rolls over seconds that are greater than #{described_class::SECONDS_PER_DAY}" do
+      expect(described_class.at(described_class::SECONDS_PER_DAY * 2 + 1).to_i).to eq(1)
+    end
+
+    it 'handles negative seconds which rolls back' do
+      expect(described_class.at(-10).to_i).to eq(described_class::SECONDS_PER_DAY - 10)
+    end
+  end
+
+  describe '.now' do
+    it "returns a #{described_class} object for the current system time" do
+      hour, min, sec = 12, 34, 56
+
+      Timecop.freeze(Time.local(2012, 11, 30, hour, min, sec)) do
+        expect(described_class.now.to_s).to eq("#{hour}:#{min}:#{sec}")
+      end
+    end
+  end
+
+  describe '#+(seconds)' do
+    it "returns a new #{described_class} object with n seconds added to it" do
+      current_time = described_class.new(0)
+      new_time = current_time + 1
+
+      expect(current_time).not_to equal(new_time)
+      expect(new_time).to eq(described_class.new(1))
+    end
+
+    it 'rolls over time when greater than 23:59:59' do
+      expect(described_class.new(23, 59, 59) + 2).to eq(described_class.new(0, 0, 1))
+    end
+  end
+
+  describe '#-(seconds)' do
+    it "returns a new #{described_class} object with n seconds subtracted from it" do
+      current_time = described_class.new(1)
+      new_time = current_time - 1
+
+      expect(current_time).not_to equal(new_time)
+      expect(new_time).to eq(described_class.new(0))
+    end
+
+    it 'rolls back time when less than 00:00:00' do
+      expect(described_class.new(00, 00, 01) - 2).to eq(described_class.new(23, 59, 59))
+    end
+  end
+
+  describe '#==(other)' do # aliases: eql?
+    it 'returns true when the times are the same' do
+      expect(described_class.new(12, 34, 56) == described_class.new(12, 34, 56)).to be_true
+    end
+
+    it 'returns false when the times are not the same' do
+      expect(described_class.new(12, 34, 56) == described_class.new(0, 0, 0)).to be_false
+    end
+  end
+
+  describe '#<=>(other)' do
+    it 'returns 0 when the times are equal' do
+      other = described_class.new(0)
+
+      expect(described_class.new(0) <=> other).to eq(0)
+    end
+
+    it 'returns -1 when the times are equal' do
+      other = described_class.new(1)
+
+      expect(described_class.new(0) <=> other).to eq(-1)
+    end
+    
+    it 'returns 1 when the times are equal' do
+      other = described_class.new(0)
+
+      expect(described_class.new(1) <=> other).to eq(1)
+    end
+  end
+
+  describe '#am?' do
+    context 'time is before noon' do
+      subject { described_class.new(2, 4, 6) }
+
+      its(:am?) { should be_true }
+    end
+
+    context 'time is after noon' do
+      subject { described_class.new(12, 4, 6) }
+
+      its(:am?) { should be_false }
+    end
+  end
+
+  describe '#hour' do
+    subject { described_class.new(2, 4, 6) }
+
+    its(:hour) { should be 2 }
+  end
+
+  describe '#min' do
+    subject { described_class.new(2, 4, 6) }
+
+    its(:min) { should be 4 }
+  end
+
+  describe '#pm?' do
+    context 'time is before noon' do
+      subject { described_class.new(2, 4, 6) }
+
+      its(:pm?) { should be_false }
+    end
+
+    context 'time is after noon' do
+      subject { described_class.new(12, 4, 6) }
+
+      its(:pm?) { should be_true }
+    end
+  end
+
+  describe '#sec' do
+    subject { described_class.new(2, 4, 6) }
+
+    its(:sec) { should be 6 }
+  end
+
+  describe '#strftime' do
+    context 'flags' do
+      context "- don't pad a numerical output" do
+        context 'hour' do
+          %w(H k I l).each do |directive|
+            context "using %#{directive}" do
+              it 'hour is one digit' do
+                expect(described_class.new(8, 0, 0).strftime("%-#{directive}")).to eq('8')
+              end
+
+              it 'hour is two digits' do
+                if directive == 'I' || directive == 'l'
+                  hour, hour_s = 13, '1'
+                else
+                  hour, hour_s = 12, '12'
+                end
+
+                expect(described_class.new(hour, 0, 0).strftime("%-#{directive}")).to eq(hour_s)
+              end
+            end
+          end
+        end
+
+        context 'min' do
+          it 'min is one digit' do
+            expect(described_class.new(0, 8, 0).strftime('%-M')).to eq('8')
+          end
+
+          it 'min is two digits' do
+            expect(described_class.new(0, 12, 0).strftime('%-M')).to eq('12')
+          end
+        end
+
+        context 'sec' do
+          it 'sec is one digit' do
+            expect(described_class.new(0, 0, 8).strftime('%-S')).to eq('8')
+          end
+
+          it 'sec is two digits' do
+            expect(described_class.new(0, 0, 12).strftime('%-S')).to eq('12')
+          end
+        end
+      end
+    end
+
+    context 'directives' do
+      context '%H - Hour of the day, 24-hour clock, zero-padded (00..23)' do
+        it 'hour is one digit' do
+          expect(described_class.new(8, 0, 0).strftime('%H')).to eq('08')
+        end
+
+        it 'hour is two digits' do
+          expect(described_class.new(12, 0, 0).strftime('%H')).to eq('12')
+        end
+      end
+
+      context '%k - Hour of the day, 24-hour clock, blank-padded ( 0..23)' do
+        it 'hour is one digit' do
+          expect(described_class.new(8, 0, 0).strftime('%k')).to eq(' 8')
+        end
+
+        it 'hour is two digits' do
+          expect(described_class.new(12, 0, 0).strftime('%k')).to eq('12')
+        end
+      end
+
+      context '%I - Hour of the day, 12-hour clock, zero-padded (01..12)' do
+        context 'before 1pm' do
+          it 'hour is one digit' do
+            expect(described_class.new(8, 0, 0).strftime('%I')).to eq('08')
+          end
+
+          it 'hour is two digits' do
+            expect(described_class.new(12, 0, 0).strftime('%I')).to eq('12')
+          end
+        end
+
+        context 'after or equal to 1pm' do
+          it 'hour is one digit' do
+            expect(described_class.new(13, 0, 0).strftime('%I')).to eq('01')
+          end
+
+          it 'hour is two digits' do
+            expect(described_class.new(22, 0, 0).strftime('%I')).to eq('10')
+          end
+        end
+      end
+
+      context '%l - Hour of the day, 12-hour clock, blank-padded ( 1..12)' do
+        context 'before 1pm' do
+          it 'hour is one digit' do
+            expect(described_class.new(8, 0, 0).strftime('%l')).to eq(' 8')
+          end
+
+          it 'hour is two digits' do
+            expect(described_class.new(12, 0, 0).strftime('%l')).to eq('12')
+          end
+        end
+
+        context 'after or equal to 1pm' do
+          it 'hour is one digit' do
+            expect(described_class.new(13, 0, 0).strftime('%l')).to eq(' 1')
+          end
+
+          it 'hour is two digits' do
+            expect(described_class.new(22, 0, 0).strftime('%l')).to eq('10')
+          end
+        end
+      end
+
+      context '%P - Meridian indicator, lowercase ("am" or "pm")' do
+        it 'hours are before noon' do
+          expect(described_class.new(8, 0, 0).strftime('%P')).to eq('am')
+        end
+
+        it 'hours are after noon' do
+          expect(described_class.new(13, 0, 0).strftime('%P')).to eq('pm')
+        end
+      end
+
+      context '%p - Meridian indicator, uppercase ("AM" or "PM")' do
+        it 'hours are before noon' do
+          expect(described_class.new(8, 0, 0).strftime('%p')).to eq('AM')
+        end
+
+        it 'hours are after noon' do
+          expect(described_class.new(13, 0, 0).strftime('%p')).to eq('PM')
+        end
+      end
+
+      context '%M - Minute of the hour (00..59)' do
+        it 'min is one digit' do
+          expect(described_class.new(0, 8, 0).strftime('%M')).to eq('08')
+        end
+
+        it 'min is two digits' do
+          expect(described_class.new(0, 12, 0).strftime('%M')).to eq('12')
+        end
+      end
+
+      context '%S - Second of the minute (00..60)' do
+        it 'sec is one digit' do
+          expect(described_class.new(0, 0, 8).strftime('%S')).to eq('08')
+        end
+
+        it 'sec is two digits' do
+          expect(described_class.new(0, 0, 12).strftime('%S')).to eq('12')
+        end
+      end
+    end
+
+    context 'literals' do
+      it '%n - Newline character (\n)' do
+        expect(described_class.at(0).strftime('%n')).to eq("\n")
+      end
+
+      it '%t - Tab character (\t)' do
+        expect(described_class.at(0).strftime('%t')).to eq("\t")
+      end
+
+      it '%% - Literal "%" character' do
+        expect(described_class.at(0).strftime('%%')).to eq('%')
+      end
+    end
+
+    context 'combinations' do
+      it '%r - 12-hour time (%I:%M:%S %p)' do
+        expect(described_class.new(1, 0, 12).strftime('%r')).to eq('01:00:12 AM')
+      end
+
+      it '%R - 24-hour time (%H:%M)' do
+        expect(described_class.new(1, 0, 12).strftime('%R')).to eq('01:00')
+      end
+
+      %w(X T).each do |combination|
+        it "%#{combination} - 24-hour time (%H:%M:%S)" do
+          expect(described_class.new(1, 0, 12).strftime("%#{combination}")).to eq('01:00:12')
+        end
+      end
+    end
+  end
+
+  describe '#succ' do
+    it "returns a new #{described_class} object, one second later than the original" do
+      current_time = described_class.new(0)
+      new_time = current_time.succ
+
+      expect(current_time).not_to equal(new_time)
+      expect(new_time).to eq(described_class.new(1))
+    end
+
+    it 'rolls over time when greater than 23:59:59' do
+      expect(described_class.new(23, 59, 59).succ).to eq(described_class.new(0, 0, 0))
+    end
+  end
+
+  describe '#to_a' do
+    subject { described_class.new(2, 3, 4) }
+
+    its(:to_a) { should == [2, 3, 4] }
+  end
+
+  describe '#to_f' do
+    subject { described_class.new(300) }
+
+    its(:to_f) { should == 300.0 }
+  end
+
+  describe '#to_i' do # aliases: tv_sec
+    subject { described_class.new(300) }
+
+    its(:to_i) { should == 300 }
+  end
+
+  describe '#to_s' do # aliases: asctime, ctime, inspect
+    subject { described_class.new(2, 4, 6) }
+
+    its(:to_s) { should == '02:04:06' }
+  end
+end

data/time_only.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/time_only/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'time_only'
+  gem.version       = TimeOnly::VERSION
+  gem.summary       = 'A simple class for handling time and only time.'
+  gem.description   = "#{gem.summary} No dates, no time zones, just good old time of day."
+
+  gem.authors       = ['Aaron Lasseigne']
+  gem.email         = ['aaron@orgsync.com']
+
+  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.require_paths = ['lib']
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'timecop'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: time_only
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Aaron Lasseigne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-04 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id003
+  prerelease: false
+description: A simple class for handling time and only time. No dates, no time zones, just good old time of day.
+email: 
+- aaron@orgsync.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/time_only.rb
+- lib/time_only/version.rb
+- spec/time_only_spec.rb
+- time_only.gemspec
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A simple class for handling time and only time.
+test_files: 
+- spec/time_only_spec.rb