iso8601 0.12.2 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63fc30058203b81b163c0e43e6752493988e104a76b2fcd6c52eba5905cd5ec3
-  data.tar.gz: 990d117c3c06599abf7306da203fa23efadc1215d40eebf0f9a54da8dd30cf97
+  metadata.gz: b974875d177ceceff7f8d892867990e27f46718e57d7a8bb0119b8ccbddd77eb
+  data.tar.gz: 0b4e786f4abde832af5f5ceefb53c2478cffa0c3e8d9e997762ca54787fbf70a
 SHA512:
-  metadata.gz: b84622859b9da1598fe29879aff66aeed4aaa560af9ecade7d48fbf4ae6e40a0668dadd528690f0c1039317f726925f3656414a6a4ac38658509edfbf8c793b3
-  data.tar.gz: 9719addba3e3536ecec660b791f65203332610eed991db6ca97cabf25ae186569ee82bb5ca63fc52ee76de15cd2e76c27bc403af0a1844978c377194b06c3907
+  metadata.gz: e295765af84738b2bc1dc80ad2509a7e8bc065e61e32151ad979eb332cb5afe9b0042dd7072674be8259d985684616e8a0c9890c88cc29eefee9391ffd248924
+  data.tar.gz: 5ef627990b4f2c1ec2bcb98ec4caddc23928612a6b2895080cdcc84fd8a9295e7ce8564c04303d37b3c3ab934922cf9b1cdf8ced23571777f8c57ab2067a6ac5

data/docs/date-time.md

@@ -0,0 +1,86 @@
+# Date Time, Date, Time
+
+
+## Interface with core classes
+
+ISO8601 classes provide a method `to_*` to convert to its core equivalent:
+
+```ruby
+ISO8601::DateTime#to_datetime # => #<DateTime: ...>
+ISO8601::Date#to_date # => #<Date: ...>
+ISO8601::Time#to_time # => #<Time: ...>
+```
+
+## Differences with core Date, Time and DateTime
+
+### Reduced precision
+
+Core `Date.parse` and `DateTime.parse` don't allow reduced precision. For
+example:
+
+```ruby
+DateTime.parse('2014-05') # => ArgumentError: invalid date
+```
+
+But the standard covers this situation assuming any missing token as its lower
+value:
+
+```ruby
+ISO8601::DateTime.new('2014-05').to_s # => "2014-05-01T00:00:00+00:00"
+ISO8601::DateTime.new('2014').to_s # => "2014-01-01T00:00:00+00:00"
+```
+
+The same assumption happens in core classes with `.new`:
+
+```ruby
+DateTime.new(2014,5) # => #<DateTime: 2014-05-01T00:00:00+00:00 ((2456779j,0s,0n),+0s,2299161j)>
+DateTime.new(2014) # => #<DateTime: 2014-01-01T00:00:00+00:00 ((2456659j,0s,0n),+0s,2299161j)>
+```
+
+### Unmatched precision
+
+Unmatched precison is handled strongly. Notice the time fragment is lost in
+`DateTime.parse` with no warning only if the loose precision is in the time
+component.
+
+```ruby
+ISO8601::DateTime.new('2014-05-06T101112')  # => ISO8601::Errors::UnknownPattern
+DateTime.parse('2014-05-06T101112')  # => #<DateTime: 2014-05-06T00:00:00+00:00 ((2456784j,0s,0n),+0s,2299161j)>
+
+ISO8601::DateTime.new('20140506T10:11:12')  # => ISO8601::Errors::UnknownPattern
+DateTime.parse('20140506T10:11:12')  # => #<DateTime: 2014-05-06T10:11:12+00:00 ((2456784j,0s,0n),+0s,2299161j)>
+```
+
+### Strong pattern matching
+
+Week dates raise an error when two digit days provied instead of return monday:
+
+```ruby
+ISO8601::DateTime.new('2014-W15-02') # => ISO8601::Errors::UnknownPattern
+DateTime.new('2014-W15-02')  # => #<Date: 2014-04-07 ((2456755j,0s,0n),+0s,2299161j)>
+```
+
+
+## Atomization
+
+`DateTime#to_a` allows decomposing to an array of atoms:
+
+```ruby
+atoms = ISO8601::DateTime.new('2014-05-31T10:11:12Z').to_a # => [2014, 5, 31, 10, 11, 12, '+00:00']
+dt = DateTime.new(*atoms)
+```
+
+## Sign
+
+Ordinal dates keep the sign. `2014-001` is not the same as `-2014-001`.
+
+
+## Fractional seconds precision
+
+Fractional seconds for `ISO8601::DateTime` and `ISO8601::Time` are rounded to
+one decimal.
+
+```ruby
+ISO8601::DateTime.new('2015-02-03T10:11:12.12').second #=> 12.1
+ISO8601::Time.new('T10:11:12.16').second #=> 12.2
+```

data/docs/duration.md

@@ -0,0 +1,76 @@
+# Duration
+
+> Durations are a component of time intervals and define the amount of
+> intervening time in a time interval. Source: [Wikipedia ISO8601](https://en.wikipedia.org/wiki/ISO_8601#Durations)
+
+See [Time Interval](time-interval.md) for working with specific intervals of
+time.
+
+## Supported patterns
+
+```
+PnYnMnDTnHnMnS
+PnW
+```
+
+`P<date>T<time>` will not be implemented.
+
+
+## Usage
+
+Some times using durations might be more convenient than using time intervals:
+
+```ruby
+duration = ISO8601::Duration.new('PT10H')
+duration.to_seconds # => 36000.0
+```
+
+You can reuse the duration with a time interval:
+
+```ruby
+start_time = ISO8601::DateTime.new('2015-01-01T10:11:12Z')
+time_interval = ISO8601::TimeInterval.from_duration(start_time, duration)
+time_interval.size # => 36000.0
+end_time = ISO8601::DateTime.new('2015-01-01T10:11:12Z')
+time_interval = ISO8601::TimeInterval.from_duration(duration, end_time)
+```
+
+Or use an ad-hoc base:
+
+```ruby
+base = ISO8601::DateTime.new('2015-01-01T10:11:12Z')
+duration = ISO8601::Duration.new('PT10H')
+duration.to_seconds(base) # => 36000.0
+```
+
+**Warning**: When using durations without base, the result of `#to_seconds` is
+an _average_.  See the atoms' implementation for details.
+
+
+# Operate with durations
+
+The `ISO8601::Duration` has the concept of sign to be able to represent negative
+values:
+
+```ruby
+(ISO8601::Duration.new('PT10S') - ISO8601::Duration.new('PT12S')).to_s  #=> '-PT2S'
+(ISO8601::Duration.new('-PT10S') + ISO8601::Duration.new('PT12S')).to_s #=> 'PT2S'
+```
+
+You can also inspect a duration by atom:
+
+```
+duration = ISO8601::Duration.new('P2Y1MT2H')
+duration.years   # => #<ISO8601::Years ... @atom=2.0>
+duration.months  # => #<ISO8601::Months ... @atom=1.0>
+duration.days    # => #<ISO8601::Days ... @atom=0>
+duration.hours   # => #<ISO8601::Hours ... @atom=2.0>
+duration.minutes # => #<ISO8601::Hours ... @atom=0.0>
+duration.seconds # => #<ISO8601::Hours ... @atom=0.0>
+```
+
+Or get back the pattern:
+
+```ruby
+duration.to_s # => 'P2Y1MT2H'
+```

data/docs/time-interval.md

@@ -0,0 +1,120 @@
+# Time Interval
+
+> A time interval is the intervening time between two time points.
+Source: [Wikipedia ISO8601](https://en.wikipedia.org/wiki/ISO_8601#Time_intervals)
+
+This library implements the Time Interval type via [`ISO8601::TimeInterval`](../lib/iso8601/time_interval.rb)
+with the following constructors:
+
+* `TimeInterval.new(String)` (or `TimeInterval.parse(String)`)
+* `TimeInterval.from_duration(Duration, Hash<DateTime>)`
+* `TimeInterval.from_datetime(DateTime, DateTime)`
+
+
+## Supported patterns
+
+```
+<start>/<end>
+<start>/<duration>
+<duration>/<end>
+```
+
+Where `<start>` and `<end>` are points in time and `<duration>` is an amount of
+time.
+
+The pattern `<duration>` is not implemented; instead, you can use
+[`TimeInterval.from_duration`](../lib/iso8601/time_interval.rb#L70).
+
+
+## Usage
+
+### `<start>/<end>`
+
+The resulting time interval will have a starting point based on the provided
+`<start>` pattern and an ending point based on the provided `<end>` pattern.
+
+```ruby
+ti = ISO8601::TimeInterval.parse('2015-12-12T19:53:00Z/2015-12-13T19:53:00Z')
+ti.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti.size             # => 86_400.0
+```
+
+### `<start>/<duration>`
+
+The resulting time interval will have a starting point based on the provided
+`<start>` pattern and an ending point result of `<start> + <duration>`.
+
+```ruby
+ti = ISO8601::TimeInterval.parse('2015-12-12T19:53:00Z/P1D')
+ti.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti.size             # => 86_400.0
+```
+
+### `<duration>/<end>`
+
+The resulting time interval will have a starting point result of
+`<end> - <duration>` and an ending point based on the provided `<end>` pattern.
+
+```ruby
+ti = ISO8601::TimeInterval.parse('P1D/2015-12-13T19:53:00Z')
+ti.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti.size             # => 86_400.0
+```
+
+
+### `TimeInterval.from_duration`
+
+```ruby
+duration = ISO8601::Duration.new('P1D`)
+start_time = ISO8601::DateTime.new('2015-12-12T19:53:00Z')
+ti = ISO8601::TimeInterval.from_duration(start_time, duration)
+ti.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti.size             # => 86_400.0
+
+
+end_time = ISO8601::DateTime.new('2015-12-13T19:53:00Z')
+ti2 = ISO8601::TimeInterval.from_duration(duration, end_time)
+ti2.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti2.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti2.size             # => 86_400.0
+```
+
+### `TimeInterval.from_datetime`
+
+This constructor is an alternative way to `<start>/<end>` via Ruby objects.
+
+```ruby
+start_time = ISO8601::DateTime.new('2015-12-12T19:53:00Z')
+end_time = ISO8601::DateTime.new('2015-12-13T19:53:00Z')
+ti2 = ISO8601::TimeInterval.from_duration(start_time, end_time)
+ti2.start_time.to_s  # => '2015-12-12T19:53:00Z'
+ti2.end_time.to_s    # => '2015-12-13T19:53:00Z'
+ti2.size             # => 86_400.0
+```
+
+## Operate with time intervals
+
+`TimeInterval` is `Comparable`, so you can use the usual `<`, `>`, `<=`, `>=`,
+`==` to compare against another `TimeInterval`.  Is equivalent to get the
+amount of seconds via `#to_f` and compare the resulting numbers.
+
+A time interval can be viewed as an ordered set of datetime elements:
+
+* `#empty?` checks if an interval is empty.
+* `#include?` checks if a `DateTime` is part of the time interval.
+* `#intersect?` checks if two time intervals overlap.
+* `#intersection` returns the intersected time interval if the two intervals intersect.
+* `#disjoint?` checks if two time intervals don't intersect.
+* `#subset?` checks if a time interval is included in another one.
+* `#superset?` checks if a time interval is included in another one.
+* `#first` is the lower bound.
+* `#last` is the upper bound.
+* `#size` is the total amount of seconds.
+
+
+You can convert a time interval into a string with `#to_s` or into a float via
+`#to_f`.

data/lib/iso8601/version.rb

@@ -1,5 +1,5 @@
 module ISO8601
   ##
   # The gem version
-  VERSION = '0.12.2'.freeze
+  VERSION = '0.12.3'.freeze
 end

data/spec/iso8601/date_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe ISO8601::Date do
+  it "should raise an error for any unknown pattern" do
+    expect { ISO8601::Date.new('') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('20') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('201') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2010-') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2010-') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('20-05') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2010-0') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2010-0-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2010-1-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('201001-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('201-0109') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::Date.new('2014-W15-02') }.to raise_error(ISO8601::Errors::UnknownPattern)
+  end
+
+  it "should raise an error for a correct pattern but an invalid date" do
+    expect { ISO8601::Date.new('2010-01-32') }.to raise_error(ISO8601::Errors::RangeError)
+    expect { ISO8601::Date.new('2010-02-30') }.to raise_error(ISO8601::Errors::RangeError)
+    expect { ISO8601::Date.new('2010-13-30') }.to raise_error(ISO8601::Errors::RangeError)
+  end
+
+  it "should parse any allowed pattern" do
+    expect { ISO8601::Date.new('2010') }.to_not raise_error
+    expect { ISO8601::Date.new('2010-05') }.to_not raise_error
+    expect { ISO8601::Date.new('2010-05-09') }.to_not raise_error
+    expect { ISO8601::Date.new('2014-001') }.to_not raise_error
+    expect { ISO8601::Date.new('2014121') }.to_not raise_error
+    expect { ISO8601::Date.new('2014-W15') }.to_not raise_error
+    expect { ISO8601::Date.new('2014-W15-2') }.to_not raise_error
+    expect { ISO8601::Date.new('2014W15') }.to_not raise_error
+    expect { ISO8601::Date.new('2014W152') }.to_not raise_error
+  end
+
+  context 'reduced patterns' do
+    it "should parse correctly reduced dates" do
+      reduced_date = ISO8601::Date.new('20100509')
+      expect(reduced_date.year).to eq(2010)
+      expect(reduced_date.month).to eq(5)
+      expect(reduced_date.day).to eq(9)
+    end
+  end
+
+  it "should return the right sign for the given year" do
+    expect(ISO8601::Date.new('-2014-05-31').year).to eq(-2014)
+    expect(ISO8601::Date.new('+2014-05-31').year).to eq(2014)
+  end
+
+  it "should respond to delegated casting methods" do
+    expect(ISO8601::Date.new('2014-12-11')).to respond_to(:to_s, :to_time, :to_date, :to_datetime)
+  end
+
+  describe '#+' do
+    it "should return the result of the addition of a number" do
+      expect((ISO8601::Date.new('2012-07-07') + 7).to_s).to eq('2012-07-14')
+    end
+  end
+
+  describe '#-' do
+    it "should return the result of the subtraction" do
+      expect((ISO8601::Date.new('2012-07-07') - 7).to_s).to eq('2012-06-30')
+    end
+  end
+
+  describe '#to_a' do
+    it "should return an array of atoms" do
+      expect(ISO8601::Date.new('2014-05-31').to_a).to eq([2014, 5, 31])
+    end
+  end
+
+  describe '#atoms' do
+    it "should return an array of original atoms" do
+      expect(ISO8601::Date.new('2014-05-02').atoms).to eq([2014, 5, 2])
+      expect(ISO8601::Date.new('2014-05').atoms).to eq([2014, 5])
+      expect(ISO8601::Date.new('2014').atoms).to eq([2014])
+    end
+  end
+
+  describe '#hash' do
+    it "should return the date hash" do
+      subject = ISO8601::Date.new('2014-08-16')
+      contrast = ISO8601::Date.new('2014-08-16')
+
+      expect(subject).to respond_to(:hash)
+      expect(subject.hash).to eq(contrast.hash)
+    end
+  end
+end

data/spec/iso8601/date_time_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe ISO8601::DateTime do
+  it "should raise a ISO8601::Errors::UnknownPattern for any unknown pattern" do
+    expect { ISO8601::DateTime.new('') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('20') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('201') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('20-05') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-0') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-0-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-1-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('201001-09') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('201-0109') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-05-09T103012+0400') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('20100509T10:30:12+04:00') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010-05T10:30:12Z') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2010T10:30:12Z') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    expect { ISO8601::DateTime.new('2014-W15-02T10:11:12Z') }.to raise_error(ISO8601::Errors::UnknownPattern)
+  end
+
+  it "should raise a RangeError for a correct pattern but an invalid date" do
+    expect { ISO8601::DateTime.new('2010-01-32') }.to raise_error(ISO8601::Errors::RangeError)
+    expect { ISO8601::DateTime.new('2010-02-30') }.to raise_error(ISO8601::Errors::RangeError)
+    expect { ISO8601::DateTime.new('2010-13-30') }.to raise_error(ISO8601::Errors::RangeError)
+    expect { ISO8601::DateTime.new('2010-12-30T25:00:00') }.to raise_error(ISO8601::Errors::RangeError)
+  end
+
+  it "should parse any allowed pattern" do
+    expect { ISO8601::DateTime.new('2010') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12+04') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12+04:00') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12-04:00') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2010-05-09T10:30:12-00:00') }.to_not raise_error
+    expect { ISO8601::DateTime.new('-2014-05-31T16:26:00Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2014-05-31T16:26:10.5Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2014-05-31T16:26:10,5Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('T10:30:12Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2014-001') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2014121') }.to_not raise_error
+    expect { ISO8601::DateTime.new('2014-121T10:11:12Z') }.to_not raise_error
+    expect { ISO8601::DateTime.new('20100509T103012+0400') }.to_not raise_error
+    expect { ISO8601::DateTime.new('20100509') }.to_not raise_error
+    expect { ISO8601::DateTime.new('T103012+0400') }.to_not raise_error
+    expect { ISO8601::DateTime.new('T103012+04') }.to_not raise_error
+    expect { ISO8601::DateTime.new('T103012+04') }.to_not raise_error
+  end
+
+  context 'reduced patterns' do
+    it "should parse correctly reduced dates" do
+      reduced_date = ISO8601::DateTime.new('20100509')
+      expect(reduced_date.year).to eq(2010)
+      expect(reduced_date.month).to eq(5)
+      expect(reduced_date.day).to eq(9)
+    end
+    it "should parse correctly reduced times" do
+      reduced_time = ISO8601::DateTime.new('T101112Z')
+      expect(reduced_time.hour).to eq(10)
+      expect(reduced_time.minute).to eq(11)
+      expect(reduced_time.second).to eq(12)
+    end
+    it "should parse correctly reduced date times" do
+      reduced_datetime = ISO8601::DateTime.new('20140531T101112Z')
+      expect(reduced_datetime.year).to eq(2014)
+      expect(reduced_datetime.month).to eq(5)
+      expect(reduced_datetime.day).to eq(31)
+      expect(reduced_datetime.hour).to eq(10)
+      expect(reduced_datetime.minute).to eq(11)
+      expect(reduced_datetime.second).to eq(12)
+    end
+  end
+
+  it "should return each atomic value" do
+    dt = ISO8601::DateTime.new('2010-05-09T12:02:01+04:00')
+    expect(dt.year).to eq(2010)
+    expect(dt.month).to eq(5)
+    expect(dt.day).to eq(9)
+    expect(dt.hour).to eq(12)
+    expect(dt.minute).to eq(2)
+    expect(dt.second).to eq(1)
+    expect(dt.zone).to eq('+04:00')
+  end
+
+  it "should return the right sign for the given year" do
+    expect(ISO8601::DateTime.new('-2014-05-31T16:26:00Z').year).to eq(-2014)
+    expect(ISO8601::DateTime.new('+2014-05-31T16:26:00Z').year).to eq(2014)
+  end
+
+  it "should respond to delegated casting methods" do
+    dt = ISO8601::DateTime.new('2014-12-11T10:09:08Z')
+    expect(dt).to respond_to(:to_s, :to_time, :to_date, :to_datetime)
+  end
+
+  describe '#+' do
+    it "should return the result of the addition of a number" do
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20Z') + 10).to_s).to eq('2012-07-07T20:20:30+00:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20.5Z') + 10).to_s).to eq('2012-07-07T20:20:30.5+00:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10.09).to_s).to eq('2012-07-07T20:20:30.1+02:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10.1).to_s).to eq('2012-07-07T20:20:30.1+02:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10).second).to eq(30)
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20.5Z') + 10).second).to eq(30.5)
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10.09).second).to eq(30.1)
+    end
+  end
+
+  describe '#-' do
+    it "should return the result of the subtraction of a number" do
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20Z') - 10).to_s).to eq('2012-07-07T20:20:10+00:00')
+    end
+  end
+
+  describe '#to_a' do
+    it "should return an array of atoms" do
+      dt = ISO8601::DateTime.new('2014-05-31T19:29:39Z').to_a
+      expect(dt).to be_kind_of(Array)
+      expect(dt).to eq([2014, 5, 31, 19, 29, 39, '+00:00'])
+    end
+  end
+
+  describe '#hash' do
+    it "should return the datetime hash" do
+      subject = ISO8601::DateTime.new('2014-08-16T20:11:10Z')
+      contrast = ISO8601::DateTime.new('2014-08-16T20:11:10Z')
+
+      expect(subject.hash == contrast.hash).to be_truthy
+      expect(subject.hash).to eq(contrast.hash)
+    end
+  end
+
+  describe '#==' do
+    it "should identify loose precision datetimes" do
+      expect(ISO8601::DateTime.new('2014') == ISO8601::DateTime.new('2014')).to be_truthy
+      expect(ISO8601::DateTime.new('2014') == ISO8601::DateTime.new('2015')).to be_falsy
+      expect(ISO8601::DateTime.new('2014-10') == ISO8601::DateTime.new('2014-11')).to be_falsy
+      expect(ISO8601::DateTime.new('2014-10') == ISO8601::DateTime.new('2014-11')).to be_falsy
+      expect(ISO8601::DateTime.new('2014-10-11T12') == ISO8601::DateTime.new('2014-10-11T13')).to be_falsy
+      expect(ISO8601::DateTime.new('2014-10-11T12:13') == ISO8601::DateTime.new('2014-10-11T12:14')).to be_falsy
+      expect(ISO8601::DateTime.new('2014-10-11T12:13:10') == ISO8601::DateTime.new('2014-10-11T12:13:10.0')).to be_truthy
+      expect(ISO8601::DateTime.new('2014-10-11T12:13:10.1') == ISO8601::DateTime.new('2014-10-11T12:13:10.2')).to be_falsy
+    end
+
+    it "should identify as the same when two dates with different timezones are the same timestamp" do
+      expect(ISO8601::DateTime.new('2014-10-11T12:13:14Z') == ISO8601::DateTime.new('2014-10-11T13:13:14+01:00')).to be_truthy
+    end
+  end
+end