duration.rb 0.3.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4947aa87a27f048e0c81a3a6b7a9ce86e6d60b82d0f76db4667694865bf1887
-  data.tar.gz: 104cc227d961d1e48925b1e8118588f02ba9b88289fdf9e8e3dd06753ac4ced7
+  metadata.gz: 9f7d0f0552f3ce6cb16fd75947bad208ccf403bd8e572b23ae262d4b6aada58f
+  data.tar.gz: 7423385510fa2bb3769521892430705fb036eb12b1a40c276a9b4b5445b7bc94
 SHA512:
-  metadata.gz: 0feb8f48532ed5bc8484f9ff897b294c34b88cfdd5a9c44f77cf4deefba5d7bc4cab774c693fa63fdabc1f6b89cad4a9500b7858257e53131a774b28905d3706
-  data.tar.gz: 82d00f722d7255f803b4c8632d0cf9a788c1cdf22d38f9755ef274281604a22ec74b052c0d5e9f3ecb165eed4abed4bd8f584f213731649cfba1248c6f891848
+  metadata.gz: be48eabdcaddff69c28452886f068623646af55255ea06f17809e38b2fafd0c343ccc7592478952bb1a7879ef60b10433ad074fbbfa0d47ee0c54405b0066723
+  data.tar.gz: 852569a9d5a66c7e576c9c33310c549e6846e369bf934da1eae13d9c54a343a9c6bc06e0dcdbb5da12768fc24f0feabf9c20a1c1b0d3c405b6a40b7f299d9af3

data/CHANGELOG

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## 20260718
+
+0.4.0: + Nanoseconds and Microseconds, arithmetic and comparison, exact conversions without a base, and the Numeric monkeypatch made opt-in.
+
+1. + Duration::Nanoseconds
+2. + Duration::Microseconds: This and Nanoseconds are the two units the clock actually speaks, Process.clock_gettime taking :nanosecond and :microsecond directly. Milliseconds was the floor, which left nothing beneath it.
+3. ~ Duration::Common: + #+, #-, and Comparable via #<=>. Arithmetic and comparison happen in the receiver's own unit, so 5.minutes + 30.seconds is 5.5 minutes rather than any number of seconds, and no unit is privileged. Combining with a non-duration raises TypeError, since a bare number has no unit. Comparing with a non-duration returns nil rather than raising, so that == is false.
+4. ~ lib/Duration/*.rb: - the coercion to Float in initialize. The value is held as given, so an Integer stays an Integer and a Rational stays a Rational. A Float stays a Float: the library neither manufactures precision nor discards it.
+5. ~ lib/Duration/*.rb: Conversions divide by a Rational literal (60r, 1000r) rather than an Integer, so a conversion is exact for an exact input. 5.minutes.to_hours holds 1/12, not 0.0833..., and (1.hour - 50.minutes).to_minutes.to_f is 10.0 rather than 9.999999999999998. There is no base and no Float floor in the interior; to_f is the edge where a Float is asked for.
+6. + Duration::Relative#ago, #hence, moved here from Common. Every unit includes it, Months among them, so 1.month.ago remains: it displaces by the mean month, approximate rather than calendar-correct (see 0.3.5's note), as 1.month.to_days is a mean.
+7. + lib/Duration/*.rb: A private #unit per class, naming the unit as a symbol, which Common uses to reach the quantity and to convert the other operand. Explicit rather than reflected from the class name.
+8. ~ lib/Duration.rb: + require the two new classes
+9. ~ lib/Duration.rb: - require Duration/Numeric. BREAKING: require 'Duration' no longer monkeypatches Numeric, so 30.minutes is not available until Duration/Numeric is required. A duration library used directly may want the sugar, but a gem depending on this one should not have Numeric extended from under it.
+10. ~ lib/Duration/Numeric.rb: + require the classes, so require 'Duration/Numeric' stands alone, + nanoseconds and microseconds with their singular aliases.
+11. + test/Duration/Nanoseconds_test.rb, test/Duration/Microseconds_test.rb, test/Duration/Common_test.rb: The new units, and the arithmetic, comparison and exactness.
+12. ~ test/Duration/Numeric_test.rb: + require Duration/Numeric, since it is no longer loaded by default, + the nanosecond and microsecond extensions.
+13. ~ test/Duration/Seconds_test.rb: + that an Integer and a Rational are held without coercion.
+14. ~ lib/Duration.rb --> lib/duration.rb: The one file required from outside the gem, lowercased to match the gem name so require 'duration' resolves on a case-sensitive filesystem and not only on a case-insensitive one. The Duration/ subtree stays PascalCase, reached by exact-case require_relative.
+15. ~ lib/Duration/Numeric.rb: /require_relative '../Duration'/require_relative '../duration'/. The one interior reference reaching back up to the load file, which would otherwise have failed on a case-sensitive filesystem after the rename.
+16. + lib/duration-numeric.rb: A lowercase top-level shim that require_relatives Duration/Numeric, so the sugar opts in via require 'duration-numeric' rather than reaching into the PascalCase namespace with require 'Duration/Numeric'. A file rather than a duration/ directory, so it does not collide with Duration/ where the filesystem is case-insensitive.
+17. ~ test/test_helper.rb: /require_relative '../lib/Duration'/require_relative '../lib/duration'/, following the rename.
+18. ~ README.md: + Philosophy and Loading sections, + the new units, arithmetic and comparison, and the exactness through Rational.
+19. ~ README.md: /require 'Duration'/require 'duration'/, and /require 'Duration/Numeric'/require 'duration-numeric'/ in the Loading section.
+20. ~ Duration::VERSION: /0.3.6/0.4.0/
 
 ## 20260717
 
@@ -11,7 +35,8 @@
 4. ~ duration.rb.gemspec: + Gem::Specification#development_dependencies=
 5. ~ duration.rb.gemspec: + development_dependencies
 6. - test/test_all.rb
-9. ~ Duration::VERSION: /0.3.5/0.3.6/
+7. ~ Duration::VERSION: /0.3.5/0.3.6/
+
 
 ## 20260717
 

data/README.md

@@ -21,90 +21,111 @@ Or install directly:
 $ gem install duration.rb
 ```
 
+## Philosophy
+
+This is the anti-`ActiveSupport::Duration`. There, every duration is really a
+number of seconds and the unit is decoration: `1.hour == 3600`. Here the unit
+*is* the class. A `Minutes` holds minutes — not seconds it renders as minutes —
+so `30.minutes.to_i` is `30`, not `1800`. No unit is privileged; there is no
+base. Conversion is a behaviour (`to_hours`), not a representation.
+
+Because nothing is normalised at construction, exactness is yours to keep: hand
+a constructor an `Integer` or a `Rational` and it stays exact all the way
+through, since conversions divide by exact ratios rather than through a float.
+Hand it a `Float` and it stays a `Float` — the library never manufactures
+precision and never silently discards it.
+
+```ruby
+Duration::Minutes.new(5).to_hours.to_f   # => 0.08333333333333333
+Duration::Minutes.new(5).to_hours        # holds exactly 1/12, not 0.0833...
+(Duration::Hours.new(1) - Duration::Minutes.new(50)).to_minutes.to_f
+                                         # => 10.0 exactly (no float drift)
+```
+
+## Loading
+
+```ruby
+require 'duration'          # the duration classes only
+
+require 'duration-numeric'  # opt in to the Numeric sugar (5.minutes, etc.),
+                            # which monkeypatches Numeric
+```
+
+The examples below use the `Numeric` sugar, so they assume
+`require 'duration-numeric'`. Without it, construct durations directly with
+`Duration::Minutes.new(5)` and friends.
+
 ## Usage
 
 ### Basic Duration Creation
 ```ruby
 # Create durations using convenience methods
-200.milliseconds        # => #<Milliseconds: @milliseconds=200>
-1.second                # => #<Seconds: @seconds=1>
-30.minutes              # => #<Minutes: @minutes=30>
-2.hours                 # => #<Hours: @hours=2>
-7.days                  # => #<Days: @days=7>
-4.weeks                 # => #<Weeks: @weeks=4>
-6.months                # => #<Months: @months=6>
+500.nanoseconds         # => #<Nanoseconds @nanoseconds=500>
+500.microseconds        # => #<Microseconds @microseconds=500>
+200.milliseconds        # => #<Milliseconds @milliseconds=200>
+1.second                # => #<Seconds @seconds=1>
+30.minutes              # => #<Minutes @minutes=30>
+2.hours                 # => #<Hours @hours=2>
+7.days                  # => #<Days @days=7>
+4.weeks                 # => #<Weeks @weeks=4>
+6.months                # => #<Months @months=6>
 ```
 
 ### Conversions
 ```ruby
-# Convert to integers
-200.milliseconds.to_i   # => 200
-1.second.to_i           # => 1
-30.minutes.to_i         # => 30
-2.hours.to_i            # => 2
-7.days.to_i             # => 7
-4.weeks.to_i            # => 4
-6.months.to_i           # => 6
-
-# Convert to floats
-200.milliseconds.to_f   # => 200.0
-1.second.to_f           # => 1.0
+# The number is in the unit's own terms, not a base:
+30.minutes.to_i         # => 30 (not 1800)
 30.minutes.to_f         # => 30.0
-2.hours.to_f            # => 2.0
-7.days.to_f             # => 7.0
-4.weeks.to_f            # => 4.0
-6.months.to_f           # => 6.0
-
-# Convert between units
-90.minutes.to_hours             # => #<Hours: @hours=1.5>
-1.5.hours.to_minutes            # => #<Minutes: @minutes=90>
-1.day.to_seconds                # => #<Seconds: @seconds=86400>
 
-# Chain conversions
+# Convert between units. The result is exact (a Rational internally) when the
+# input is exact; call to_f at the edge for a float.
+90.minutes.to_hours             # => #<Hours @hours=(3/2)>
 90.minutes.to_hours.to_f        # => 1.5
 1.5.hours.to_minutes.to_i       # => 90
 1.day.to_seconds.to_i           # => 86400
+5.minutes.to_hours.to_f         # => 0.08333333333333333
+```
+
+### Arithmetic and Comparison
+```ruby
+# Durations add and subtract, with the left operand's unit deciding the result:
+5.minutes + 30.seconds          # => #<Minutes @minutes=(11/2)>  (5.5 minutes)
+5.minutes - 30.seconds          # => #<Minutes @minutes=(9/2)>   (4.5 minutes)
+5.minutes + 30                  # => TypeError (a bare number has no unit)
+
+# Durations are Comparable, across units and exactly:
+5.minutes == 300.seconds        # => true
+90.seconds > 1.minute           # => true
+[1.hour, 30.seconds, 5.minutes].sort
+                                # => [30.seconds, 5.minutes, 1.hour]
 ```
 
 ### Time Calculations
 ```ruby
 # The past
-1.millisecond.ago               # => #<Time:> (now - 1.millisecond.to_seconds.to_f)
 2.seconds.ago                   # => #<Time:> (now - 2.seconds.to_seconds.to_f)
 3.minutes.ago                   # => #<Time:> (now - 3.minutes.to_seconds.to_f)
 4.hours.ago                     # => #<Time:> (now - 4.hours.to_seconds.to_f)
 5.days.ago                      # => #<Time:> (now - 5.days.to_seconds.to_f)
 6.weeks.ago                     # => #<Time:> (now - 6.weeks.to_seconds.to_f)
-7.months.ago                    # => #<Time:> (now - 7.months.to_seconds.to_f)
 
 # The future
-1.millisecond.hence             # => #<Time:> (now + 1.millisecond.to_seconds.to_f)
 2.seconds.hence                 # => #<Time:> (now + 2.seconds.to_seconds.to_f)
 3.minutes.hence                 # => #<Time:> (now + 3.minutes.to_seconds.to_f)
 4.hours.hence                   # => #<Time:> (now + 4.hours.to_seconds.to_f)
 5.days.hence                    # => #<Time:> (now + 5.days.to_seconds.to_f)
 6.weeks.hence                   # => #<Time:> (now + 6.weeks.to_seconds.to_f)
-7.months.hence                  # => #<Time:> (now + 7.months.to_seconds.to_f)
 ```
 
 ### A Note on Months
-
 `Months` is the odd one out. Every other unit is a fixed quantity with an exact
-ratio to every other, but a month is a calendar operation whose length depends
-on which month. The conversions use the Gregorian mean month (2629746 seconds),
-so they are honest only as a statistical average:
-
-```ruby
-12.months.to_days               # => 365.2425, the Gregorian mean year
-```
-
-Two actual calendar months are anywhere from 59 to 62 days, while the mean gives
-about 60.87 — no particular pair of months. No single constant can be right.
-
-For the same reason `ago` and `hence` are not calendar-correct on `Months`: one
-month before the 15th of March is the 15th of February to a calendar, but the
-mean lands on the 12th. Where the calendar matters, reach for a date-anchored
-type such as month.rb.
+ratio to every other; a month is a calendar operation whose length depends on
+the calendar. Its conversions use the Gregorian mean month (2629746 seconds),
+so they are honest only as a statistical average, never as calendar-correct
+arithmetic. Its `ago`/`hence` inherit this — they displace by the mean month,
+so they are approximate rather than calendar-correct; reach for a
+calendar-anchored type such as `month.rb` when that matters. `Months` is slated
+for removal in 0.5.0.
 
 ## Contributing
 

data/lib/Duration/Common.rb

@@ -3,12 +3,34 @@
 
 module Duration
   module Common
-    def ago
-      Time.now - self.to_seconds.to_f
+    include Comparable
+
+    def +(other)
+      combine(:+, other)
+    end
+
+    def -(other)
+      combine(:-, other)
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Duration::Common)
+      quantity <=> other.send(:"to_#{unit}").quantity
     end
 
-    def hence
-      Time.now + self.to_seconds.to_f
+    protected
+
+    def quantity
+      instance_variable_get(:"@#{unit}")
+    end
+
+    private
+
+    def combine(operator, other)
+      unless other.is_a?(Duration::Common)
+        raise TypeError, "can't combine #{self.class} with #{other.class}"
+      end
+      self.class.new(quantity.send(operator, other.send(:"to_#{unit}").quantity))
     end
   end
 end

data/lib/Duration/Days.rb

@@ -2,12 +2,22 @@
 # Duration::Days
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Hours'
 require_relative './Weeks'
 
 module Duration
   class Days
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_hours.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_hours.to_microseconds
+    end
 
     def to_milliseconds
       to_hours.to_milliseconds
@@ -30,7 +40,7 @@ module Duration
     end
 
     def to_weeks
-      Duration::Weeks.new(@days/7)
+      Duration::Weeks.new(@days / 7r)
     end
 
     def to_months
@@ -42,13 +52,17 @@ module Duration
     end
 
     def to_f
-      @days
+      @days.to_f
     end
 
     private
 
     def initialize(days = nil)
-      @days = days.to_f
+      @days = days
+    end
+
+    def unit
+      :days
     end
   end
 end

data/lib/Duration/Hours.rb

@@ -2,12 +2,22 @@
 # Duration::Hours
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Minutes'
 require_relative './Days'
 
 module Duration
   class Hours
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_minutes.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_minutes.to_microseconds
+    end
 
     def to_milliseconds
       to_minutes.to_milliseconds
@@ -26,7 +36,7 @@ module Duration
     end
 
     def to_days
-      Duration::Days.new(@hours/24)
+      Duration::Days.new(@hours / 24r)
     end
 
     def to_weeks
@@ -42,13 +52,17 @@ module Duration
     end
 
     def to_f
-      @hours
+      @hours.to_f
     end
 
     private
 
     def initialize(hours = nil)
-      @hours = hours.to_f
+      @hours = hours
+    end
+
+    def unit
+      :hours
     end
   end
 end

data/lib/Duration/Microseconds.rb

@@ -0,0 +1,68 @@
+# Duration/Microseconds.rb
+# Duration::Microseconds
+
+require_relative './Common'
+require_relative './Relative'
+require_relative './Nanoseconds'
+require_relative './Milliseconds'
+
+module Duration
+  class Microseconds
+    include Common
+    include Relative
+
+    def to_nanoseconds
+      Duration::Nanoseconds.new(@microseconds * 1000)
+    end
+
+    def to_microseconds
+      self
+    end
+
+    def to_milliseconds
+      Duration::Milliseconds.new(@microseconds / 1000r)
+    end
+
+    def to_seconds
+      to_milliseconds.to_seconds
+    end
+
+    def to_minutes
+      to_milliseconds.to_minutes
+    end
+
+    def to_hours
+      to_milliseconds.to_hours
+    end
+
+    def to_days
+      to_milliseconds.to_days
+    end
+
+    def to_weeks
+      to_milliseconds.to_weeks
+    end
+
+    def to_months
+      to_milliseconds.to_months
+    end
+
+    def to_i
+      @microseconds.to_i
+    end
+
+    def to_f
+      @microseconds.to_f
+    end
+
+    private
+
+    def initialize(microseconds = nil)
+      @microseconds = microseconds
+    end
+
+    def unit
+      :microseconds
+    end
+  end
+end

data/lib/Duration/Milliseconds.rb

@@ -2,18 +2,29 @@
 # Duration::Milliseconds
 
 require_relative './Common'
+require_relative './Relative'
+require_relative './Microseconds'
 require_relative './Seconds'
 
 module Duration
   class Milliseconds
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_microseconds.to_nanoseconds
+    end
+
+    def to_microseconds
+      Duration::Microseconds.new(@milliseconds * 1000)
+    end
 
     def to_milliseconds
       self
     end
 
     def to_seconds
-      Duration::Seconds.new(@milliseconds/1000)
+      Duration::Seconds.new(@milliseconds / 1000r)
     end
 
     def to_minutes
@@ -41,13 +52,17 @@ module Duration
     end
 
     def to_f
-      @milliseconds
+      @milliseconds.to_f
     end
 
     private
 
     def initialize(milliseconds = nil)
-      @milliseconds = milliseconds.to_f
+      @milliseconds = milliseconds
+    end
+
+    def unit
+      :milliseconds
     end
   end
 end

data/lib/Duration/Minutes.rb

@@ -2,12 +2,22 @@
 # Duration::Minutes
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Seconds'
 require_relative './Hours'
 
 module Duration
   class Minutes
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_seconds.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_seconds.to_microseconds
+    end
 
     def to_milliseconds
       to_seconds.to_milliseconds
@@ -22,7 +32,7 @@ module Duration
     end
 
     def to_hours
-      Duration::Hours.new(@minutes/60)
+      Duration::Hours.new(@minutes / 60r)
     end
 
     def to_days
@@ -42,13 +52,17 @@ module Duration
     end
 
     def to_f
-      @minutes
+      @minutes.to_f
     end
 
     private
 
     def initialize(minutes = nil)
-      @minutes = minutes.to_f
+      @minutes = minutes
+    end
+
+    def unit
+      :minutes
     end
   end
 end

data/lib/Duration/Months.rb

@@ -2,11 +2,29 @@
 # Duration::Months
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Weeks'
 
 module Duration
+  # A month is not a fixed quantity: its length depends on the calendar. The
+  # conversions below use the Gregorian mean month (2629746 seconds), so they
+  # are honest only as a statistical average, never as calendar-correct
+  # arithmetic. For that, reach for a calendar-anchored type such as month.rb.
+  #
+  # ago and hence (via Relative) inherit the same caveat: they displace by the
+  # mean month rather than an actual calendar month, so they are approximate,
+  # not calendar-correct. Months is slated for removal in 0.5.0.
   class Months
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_weeks.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_weeks.to_microseconds
+    end
 
     def to_milliseconds
       to_weeks.to_milliseconds
@@ -30,7 +48,7 @@ module Duration
 
     def to_weeks
       # A month is the Gregorian mean: 2629746 seconds against 604800 per week.
-      Duration::Weeks.new(@months * 2629746 / 604800.0)
+      Duration::Weeks.new(@months * 2629746 / 604800r)
     end
 
     def to_months
@@ -42,13 +60,17 @@ module Duration
     end
 
     def to_f
-      @months
+      @months.to_f
     end
 
     private
 
     def initialize(months = nil)
-      @months = months.to_f
+      @months = months
+    end
+
+    def unit
+      :months
     end
   end
 end

data/lib/Duration/Nanoseconds.rb

@@ -0,0 +1,67 @@
+# Duration/Nanoseconds.rb
+# Duration::Nanoseconds
+
+require_relative './Common'
+require_relative './Relative'
+require_relative './Microseconds'
+
+module Duration
+  class Nanoseconds
+    include Common
+    include Relative
+
+    def to_nanoseconds
+      self
+    end
+
+    def to_microseconds
+      Duration::Microseconds.new(@nanoseconds / 1000r)
+    end
+
+    def to_milliseconds
+      to_microseconds.to_milliseconds
+    end
+
+    def to_seconds
+      to_microseconds.to_seconds
+    end
+
+    def to_minutes
+      to_microseconds.to_minutes
+    end
+
+    def to_hours
+      to_microseconds.to_hours
+    end
+
+    def to_days
+      to_microseconds.to_days
+    end
+
+    def to_weeks
+      to_microseconds.to_weeks
+    end
+
+    def to_months
+      to_microseconds.to_months
+    end
+
+    def to_i
+      @nanoseconds.to_i
+    end
+
+    def to_f
+      @nanoseconds.to_f
+    end
+
+    private
+
+    def initialize(nanoseconds = nil)
+      @nanoseconds = nanoseconds
+    end
+
+    def unit
+      :nanoseconds
+    end
+  end
+end

data/lib/Duration/Numeric.rb

@@ -1,8 +1,20 @@
 # Duration/Numeric.rb
 # Duration::Numeric
 
+require_relative '../duration'
+
 module Duration
   module Numeric
+    def nanoseconds
+      Duration::Nanoseconds.new(self)
+    end
+    alias_method :nanosecond, :nanoseconds
+
+    def microseconds
+      Duration::Microseconds.new(self)
+    end
+    alias_method :microsecond, :microseconds
+
     def milliseconds
       Duration::Milliseconds.new(self)
     end

data/lib/Duration/Relative.rb

@@ -0,0 +1,14 @@
+# Duration/Relative.rb
+# Duration::Relative
+
+module Duration
+  module Relative
+    def ago
+      Time.now - self.to_seconds.to_f
+    end
+
+    def hence
+      Time.now + self.to_seconds.to_f
+    end
+  end
+end

data/lib/Duration/Seconds.rb

@@ -2,12 +2,22 @@
 # Duration::Seconds
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Milliseconds'
 require_relative './Minutes'
 
 module Duration
   class Seconds
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_milliseconds.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_milliseconds.to_microseconds
+    end
 
     def to_milliseconds
       Duration::Milliseconds.new(@seconds * 1000)
@@ -18,7 +28,7 @@ module Duration
     end
 
     def to_minutes
-      Duration::Minutes.new(@seconds/60)
+      Duration::Minutes.new(@seconds / 60r)
     end
 
     def to_hours
@@ -42,13 +52,17 @@ module Duration
     end
 
     def to_f
-      @seconds
+      @seconds.to_f
     end
 
     private
 
     def initialize(seconds = nil)
-      @seconds = seconds.to_f
+      @seconds = seconds
+    end
+
+    def unit
+      :seconds
     end
   end
 end

data/lib/Duration/VERSION.rb

@@ -1,3 +1,3 @@
 module Duration
-  VERSION = '0.3.6'
+  VERSION = '0.4.0'
 end

data/lib/Duration/Weeks.rb

@@ -2,12 +2,22 @@
 # Duration::Weeks
 
 require_relative './Common'
+require_relative './Relative'
 require_relative './Days'
 require_relative './Months'
 
 module Duration
   class Weeks
     include Common
+    include Relative
+
+    def to_nanoseconds
+      to_days.to_nanoseconds
+    end
+
+    def to_microseconds
+      to_days.to_microseconds
+    end
 
     def to_milliseconds
       to_days.to_milliseconds
@@ -35,7 +45,7 @@ module Duration
 
     def to_months
       # A month is the Gregorian mean: 2629746 seconds against 604800 per week.
-      Duration::Months.new(@weeks * 604800 / 2629746.0)
+      Duration::Months.new(@weeks * 604800 / 2629746r)
     end
 
     def to_i
@@ -43,13 +53,17 @@ module Duration
     end
 
     def to_f
-      @weeks
+      @weeks.to_f
     end
 
     private
 
     def initialize(weeks = nil)
-      @weeks = weeks.to_f
+      @weeks = weeks
+    end
+
+    def unit
+      :weeks
     end
   end
 end

data/lib/duration-numeric.rb

@@ -0,0 +1,4 @@
+# duration-numeric.rb
+# Duration::Numeric
+
+require_relative 'Duration/Numeric'

data/lib/{Duration.rb → duration.rb}

@@ -3,6 +3,8 @@
 
 module Duration; end
 
+require_relative 'Duration/Nanoseconds'
+require_relative 'Duration/Microseconds'
 require_relative 'Duration/Milliseconds'
 require_relative 'Duration/Seconds'
 require_relative 'Duration/Minutes'
@@ -10,5 +12,4 @@ require_relative 'Duration/Hours'
 require_relative 'Duration/Days'
 require_relative 'Duration/Weeks'
 require_relative 'Duration/Months'
-require_relative 'Duration/Numeric'
 require_relative 'Duration/VERSION'

data/test/Duration/Common_test.rb

@@ -0,0 +1,61 @@
+# test/duration/common_test.rb
+
+require_relative '../test_helper'
+require_relative '../../lib/Duration/Numeric'
+
+describe Duration::Common do
+  describe "addition" do
+    it "adds two durations of the same unit" do
+      result = 5.minutes + 3.minutes
+      _(result).must_be_instance_of Duration::Minutes
+      _(result.to_i).must_equal 8
+    end
+
+    it "adds across units in the left operand's unit" do
+      result = 5.minutes + 30.seconds
+      _(result).must_be_instance_of Duration::Minutes
+      _(result.to_f).must_equal 5.5
+    end
+
+    it "raises when combined with a non-duration" do
+      _{5.minutes + 30}.must_raise TypeError
+    end
+  end
+
+  describe "subtraction" do
+    it "subtracts across units in the left operand's unit" do
+      result = 5.minutes - 30.seconds
+      _(result).must_be_instance_of Duration::Minutes
+      _(result.to_f).must_equal 4.5
+    end
+  end
+
+  describe "comparison" do
+    it "compares durations of different units exactly" do
+      _(5.minutes).must_equal 300.seconds
+      _(90.seconds).must_be :>, 1.minute
+      _(1.hour).must_be :<, 2.hours
+    end
+
+    it "sorts a mixed collection" do
+      sorted = [1.hour, 30.seconds, 5.minutes].sort
+      _(sorted).must_equal [30.seconds, 5.minutes, 1.hour]
+    end
+
+    it "returns nil against a non-duration rather than raising" do
+      _(5.minutes <=> 30).must_be_nil
+    end
+
+    it "is not equal to a non-duration" do
+      _(5.minutes == 300).must_equal false
+    end
+  end
+
+  describe "exactness" do
+    it "converts without float drift" do
+      # 1/6 of an hour is exactly 10 minutes; a float round-trip would not
+      # land on 10.0.
+      _((1.hour - 50.minutes).to_minutes.to_f).must_equal 10.0
+    end
+  end
+end

data/test/Duration/Microseconds_test.rb

@@ -0,0 +1,68 @@
+# test/duration/microseconds_test.rb
+
+require_relative '../test_helper'
+
+describe Duration::Microseconds do
+  describe "initialization" do
+    it "holds an integer without coercing to a float" do
+      us = Duration::Microseconds.new(1500)
+      _(us.instance_variable_get(:@microseconds)).must_equal 1500
+      _(us.instance_variable_get(:@microseconds)).must_be_kind_of Integer
+    end
+  end
+
+  describe "conversions" do
+    subject do
+      Duration::Microseconds.new(2_000_000)
+    end
+
+    it "converts to nanoseconds" do
+      ns = subject.to_nanoseconds
+      _(ns).must_be_instance_of Duration::Nanoseconds
+      _(ns.to_i).must_equal 2_000_000_000
+    end
+
+    it "converts to milliseconds" do
+      ms = subject.to_milliseconds
+      _(ms).must_be_instance_of Duration::Milliseconds
+      _(ms.to_f).must_equal 2000.0
+    end
+
+    it "converts to seconds" do
+      secs = subject.to_seconds
+      _(secs).must_be_instance_of Duration::Seconds
+      _(secs.to_f).must_equal 2.0
+    end
+
+    it "converts to minutes" do
+      mins = subject.to_minutes
+      _(mins).must_be_instance_of Duration::Minutes
+      _(mins.to_f).must_be_close_to 0.0333, 0.0001
+    end
+
+    it "converts to milliseconds without truncating sub-millisecond precision" do
+      ms = Duration::Microseconds.new(1500).to_milliseconds
+      _(ms.to_f).must_equal 1.5
+    end
+
+    it "returns itself for to_microseconds" do
+      _((subject.to_microseconds).object_id).must_equal subject.object_id
+    end
+  end
+
+  describe "time calculations" do
+    it "calculates ago from current time" do
+      us = Duration::Microseconds.new(1_000_000)
+      time_ago = us.ago
+      _(time_ago).must_be_instance_of Time
+      _(Time.now - time_ago).must_be_close_to 1.0, 1.0
+    end
+
+    it "calculates hence from current time" do
+      us = Duration::Microseconds.new(1_000_000)
+      time_hence = us.hence
+      _(time_hence).must_be_instance_of Time
+      _(time_hence - Time.now).must_be_close_to 1.0, 1.0
+    end
+  end
+end

data/test/Duration/Months_test.rb

@@ -19,13 +19,13 @@ describe Duration::Months do
     it "converts to milliseconds" do
       ms = subject.to_milliseconds
       _(ms).must_be_instance_of Duration::Milliseconds
-      _(ms.to_f).must_be_close_to 5259492000.0, 0.001
+      _(ms.to_f).must_equal 5259492000.0
     end
 
     it "converts to seconds" do
       secs = subject.to_seconds
       _(secs).must_be_instance_of Duration::Seconds
-      _(secs.to_f).must_be_close_to 5259492.0, 0.001
+      _(secs.to_f).must_equal 5259492.0
     end
 
     it "converts to minutes" do
@@ -58,20 +58,20 @@ describe Duration::Months do
   end
 
   describe "time calculations" do
+    # ago and hence displace by the mean month, so they are approximate rather
+    # than calendar-correct. See month.rb for calendar-anchored work.
     it "calculates ago from current time" do
       months = Duration::Months.new(1)
       time_ago = months.ago
       _(time_ago).must_be_instance_of Time
-      # Approximately 30 days worth of seconds
-      _(Time.now - time_ago).must_be :>, 2500000.0
+      _(Time.now - time_ago).must_be_close_to 2629746.0, 1.0
     end
 
     it "calculates hence from current time" do
       months = Duration::Months.new(1)
       time_hence = months.hence
       _(time_hence).must_be_instance_of Time
-      # Approximately 30 days worth of seconds
-      _(time_hence - Time.now).must_be :>, 2500000.0
+      _(time_hence - Time.now).must_be_close_to 2629746.0, 1.0
     end
   end
 end

data/test/Duration/Nanoseconds_test.rb

@@ -0,0 +1,68 @@
+# test/duration/nanoseconds_test.rb
+
+require_relative '../test_helper'
+
+describe Duration::Nanoseconds do
+  describe "initialization" do
+    it "holds an integer without coercing to a float" do
+      ns = Duration::Nanoseconds.new(1500)
+      _(ns.instance_variable_get(:@nanoseconds)).must_equal 1500
+      _(ns.instance_variable_get(:@nanoseconds)).must_be_kind_of Integer
+    end
+  end
+
+  describe "conversions" do
+    subject do
+      Duration::Nanoseconds.new(2_000_000_000)
+    end
+
+    it "converts to microseconds" do
+      us = subject.to_microseconds
+      _(us).must_be_instance_of Duration::Microseconds
+      _(us.to_f).must_equal 2_000_000.0
+    end
+
+    it "converts to milliseconds" do
+      ms = subject.to_milliseconds
+      _(ms).must_be_instance_of Duration::Milliseconds
+      _(ms.to_f).must_equal 2000.0
+    end
+
+    it "converts to seconds" do
+      secs = subject.to_seconds
+      _(secs).must_be_instance_of Duration::Seconds
+      _(secs.to_f).must_equal 2.0
+    end
+
+    it "converts to minutes" do
+      mins = subject.to_minutes
+      _(mins).must_be_instance_of Duration::Minutes
+      _(mins.to_f).must_be_close_to 0.0333, 0.0001
+    end
+
+    it "converts to microseconds without truncating sub-microsecond precision" do
+      us = Duration::Nanoseconds.new(1_500_500).to_microseconds
+      _(us.to_f).must_equal 1500.5
+    end
+
+    it "returns itself for to_nanoseconds" do
+      _((subject.to_nanoseconds).object_id).must_equal subject.object_id
+    end
+  end
+
+  describe "time calculations" do
+    it "calculates ago from current time" do
+      ns = Duration::Nanoseconds.new(1_000_000_000)
+      time_ago = ns.ago
+      _(time_ago).must_be_instance_of Time
+      _(Time.now - time_ago).must_be_close_to 1.0, 1.0
+    end
+
+    it "calculates hence from current time" do
+      ns = Duration::Nanoseconds.new(1_000_000_000)
+      time_hence = ns.hence
+      _(time_hence).must_be_instance_of Time
+      _(time_hence - Time.now).must_be_close_to 1.0, 1.0
+    end
+  end
+end

data/test/Duration/Numeric_test.rb

@@ -1,8 +1,37 @@
 # test/duration/numeric_test.rb
 
 require_relative '../test_helper'
+require_relative '../../lib/Duration/Numeric'
 
 describe Duration::Numeric do
+  describe "nanosecond extensions" do
+    it "creates Nanoseconds from integer" do
+      ns = 1000.nanoseconds
+      _(ns).must_be_instance_of Duration::Nanoseconds
+      _(ns.to_i).must_equal 1000
+    end
+
+    it "supports singular alias" do
+      ns = 1.nanosecond
+      _(ns).must_be_instance_of Duration::Nanoseconds
+      _(ns.to_i).must_equal 1
+    end
+  end
+
+  describe "microsecond extensions" do
+    it "creates Microseconds from integer" do
+      us = 1000.microseconds
+      _(us).must_be_instance_of Duration::Microseconds
+      _(us.to_i).must_equal 1000
+    end
+
+    it "supports singular alias" do
+      us = 1.microsecond
+      _(us).must_be_instance_of Duration::Microseconds
+      _(us.to_i).must_equal 1
+    end
+  end
+
   describe "millisecond extensions" do
     it "creates Milliseconds from integer" do
       ms = 1000.milliseconds

data/test/Duration/Seconds_test.rb

@@ -9,6 +9,18 @@ describe Duration::Seconds do
       _(secs.instance_variable_get(:@seconds)).must_equal 60.5
       _(secs.instance_variable_get(:@seconds)).must_be_kind_of Float
     end
+
+    it "holds an integer without coercing to a float" do
+      secs = Duration::Seconds.new(90)
+      _(secs.instance_variable_get(:@seconds)).must_equal 90
+      _(secs.instance_variable_get(:@seconds)).must_be_kind_of Integer
+    end
+
+    it "holds a rational without coercing" do
+      secs = Duration::Seconds.new(Rational(3, 2))
+      _(secs.instance_variable_get(:@seconds)).must_equal Rational(3, 2)
+      _(secs.instance_variable_get(:@seconds)).must_be_kind_of Rational
+    end
   end
 
   describe "conversions" do

data/test/test_helper.rb

@@ -3,4 +3,4 @@
 require 'minitest/autorun'
 require 'minitest/spec'
 
-require_relative '../lib/Duration'
+require_relative '../lib/duration'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duration.rb
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
 platform: ruby
 authors:
 - thoran
@@ -62,22 +62,29 @@ files:
 - README.md
 - Rakefile
 - duration.rb.gemspec
-- lib/Duration.rb
 - lib/Duration/Common.rb
 - lib/Duration/Days.rb
 - lib/Duration/Hours.rb
+- lib/Duration/Microseconds.rb
 - lib/Duration/Milliseconds.rb
 - lib/Duration/Minutes.rb
 - lib/Duration/Months.rb
+- lib/Duration/Nanoseconds.rb
 - lib/Duration/Numeric.rb
+- lib/Duration/Relative.rb
 - lib/Duration/Seconds.rb
 - lib/Duration/VERSION.rb
 - lib/Duration/Weeks.rb
+- lib/duration-numeric.rb
+- lib/duration.rb
+- test/Duration/Common_test.rb
 - test/Duration/Days_test.rb
 - test/Duration/Hours_test.rb
+- test/Duration/Microseconds_test.rb
 - test/Duration/Milliseconds_test.rb
 - test/Duration/Minutes_test.rb
 - test/Duration/Months_test.rb
+- test/Duration/Nanoseconds_test.rb
 - test/Duration/Numeric_test.rb
 - test/Duration/Seconds_test.rb
 - test/Duration/Weeks_test.rb