monotime 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a97344679471a970a324027b84b560faf9dfc9597c0937094de1486cc0da602
-  data.tar.gz: 35d55277a3181f0033939263122296b3a5328c5cc1605722644dd21aa9305ac1
+  metadata.gz: d77cca7907b76e8276296abc382f10612e7879605f7472ab46e4b26c9594426d
+  data.tar.gz: d4d1284f11de89438125a3e28e4686bdde6a78cf02a431d3eb57e861e7345613
 SHA512:
-  metadata.gz: 29d7c0fb1aa092127f1a1a3036552466d9f6ea83d337fa3c9ffda0e88d3b5fb4ca996f81c828701a2a1bee4bf44d8c6392395298ac9f257034b3b71b8d0437b3
-  data.tar.gz: bd3bef852b6d5b25810091e0ee7452e60e03a5cd25cc5577e25760452804d3d201cfc05efd2dcf19d91680ff6bdacbd93b9428473def942ac3c024aea4675c9d
+  metadata.gz: 4975756b4d469b02437d7ad45216eef58d5e20b3675f6c725c64d1b8d1da3518c5eec89fc98cbc1d9d0e6238665232e837415783726132b757cf2e19ab2ef4fc
+  data.tar.gz: cfe8ffd03b80d308d512f5df277e5b9d82c6c88f47cb048390245dd8b34f598e03c41ad9286576add9f75dfdd1cbb2230101b60dc6bed844f85de9fab1247a76

data/README.md

@@ -61,7 +61,7 @@ And how to do basic maths on itself:
 
 ```ruby
 (Duration.from_millis(42) + Duration.from_secs(1)).to_s  # => "1.042s"
-(Duration.from_millis(42) - Duration.from_secs(-1)).to_s # => "-958ms"
+(Duration.from_millis(42) - Duration.from_secs(1)).to_s  # => "-958ms"
 ```
 
 `Instant` does some simple maths too:

data/lib/monotime.rb

@@ -2,8 +2,6 @@
 
 require 'monotime/version'
 
-require 'dry-equalizer'
-
 module Monotime
   # A measurement from the operating system's monotonic clock, with up to
   # nanosecond precision.
@@ -12,136 +10,202 @@ module Monotime
     # non-portable outside the process that created it.
     protected def ns() @ns end
 
-    include Dry::Equalizer(:ns)
     include Comparable
 
-    # Create a new +Instant+ from a given nanosecond measurement, defaulting to
-    # that given by +Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond))+.
+    # Create a new +Instant+ from an optional nanosecond measurement.
     #
     # Users should generally *not* pass anything to this function.
+    #
+    # @param nanos [Integer]
     def initialize(nanos = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond))
       @ns = Integer(nanos)
     end
 
     # An alias to +new+, and generally preferred over it.
+    #
+    # @return [Instant]
     def self.now
       new
     end
 
     # Return a +Duration+ between this +Instant+ and another.
+    #
+    # @param earlier [Instant]
+    # @return [Duration]
     def duration_since(earlier)
-      case earlier
-      when Instant then earlier - self
-      else raise TypeError, 'Not an Instant'
-      end
+      raise TypeError, 'Not an Instant' unless earlier.is_a?(Instant)
+
+      earlier - self
     end
 
     # Return a +Duration+ since this +Instant+ and now.
+    #
+    # @return [Duration]
     def elapsed
       duration_since(self.class.now)
     end
 
     # Sugar for +elapsed.to_s+.
+    #
+    # @see Duration#to_s
     def to_s(*args)
       elapsed.to_s(*args)
     end
 
     # Add a +Duration+ to this +Instant+, returning a new +Instant+.
+    #
+    # @param other [Duration, #to_nanos]
+    # @return [Instant]
     def +(other)
-      case other
-      when Duration then Instant.new(@ns + other.to_nanos)
-      else raise TypeError, 'Not a Duration'
-      end
+      return TypeError, 'Not one of: [Duration, #to_nanos]' unless other.respond_to?(:to_nanos)
+
+      Instant.new(@ns + other.to_nanos)
     end
 
     # Subtract another +Instant+ to generate a +Duration+ between the two,
     # or a +Duration+, to generate an +Instant+ offset by it.
+    #
+    # @param other [Instant, Duration, #to_nanos]
+    # @return [Duration, Instant]
     def -(other)
-      case other
-      when Instant then Duration.new(@ns - other.ns)
-      when Duration then Instant.new(@ns - other.to_nanos)
-      else raise TypeError, 'Not an Instant or Duration'
+      if other.is_a?(Instant)
+        Duration.new(@ns - other.ns)
+      elsif other.respond_to?(:to_nanos)
+        Instant.new(@ns - other.to_nanos)
+      else
+        raise TypeError, 'Not one of: [Instant, Duration, #to_nanos]'
       end
     end
 
     # Compare this +Instant+ with another.
     def <=>(other)
-      case other
-      when Instant then @ns <=> other.ns
-      else raise TypeError, 'Not an Instant'
-      end
+      @ns <=> other.ns if other.is_a?(Instant)
+    end
+
+    def ==(other)
+      other.is_a?(Instant) && @ns == other.ns
+    end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ @ns.hash
     end
   end
 
   # A type representing a span of time in nanoseconds.
   class Duration
-    include Dry::Equalizer(:to_nanos)
     include Comparable
 
     # Create a new +Duration+ of a specified number of nanoseconds, zero by
     # default.
+    #
+    # @param nanos [Integer]
     def initialize(nanos = 0)
       @ns = Integer(nanos)
     end
 
     class << self
       # Generate a new +Duration+ measuring the given number of seconds.
+      #
+      # @param secs [Numeric]
+      # @return [Duration]
       def from_secs(secs)
         new(Integer(Float(secs) * 1_000_000_000))
       end
 
       # Generate a new +Duration+ measuring the given number of milliseconds.
+      #
+      # @param millis [Numeric]
+      # @return [Duration]
       def from_millis(millis)
         new(Integer(Float(millis) * 1_000_000))
       end
 
       # Generate a new +Duration+ measuring the given number of microseconds.
+      #
+      # @param micros [Numeric]
+      # @return [Duration]
       def from_micros(micros)
         new(Integer(Float(micros) * 1_000))
       end
 
       # Generate a new +Duration+ measuring the given number of nanoseconds.
+      #
+      # @param nanos [Numeric]
+      # @return [Duration]
       def from_nanos(nanos)
         new(Integer(nanos))
       end
 
       # Return a +Duration+ measuring the elapsed time of the yielded block.
+      #
+      # @return [Duration]
       def measure
         Instant.now.tap { yield }.elapsed
       end
     end
 
     # Add another +Duration+ to this one, returning a new +Duration+.
+    #
+    # @param [Duration, #to_nanos]
+    #
+    # @return [Duration]
     def +(other)
+      raise TypeError, 'Not one of: [Duration, #to_nanos]' unless other.respond_to?(:to_nanos)
+
       Duration.new(to_nanos + other.to_nanos)
     end
 
     # Subtract another +Duration+ from this one, returning a new +Duration+.
+    #
+    # @param [Duration, #to_nanos]
+    # @return [Duration]
     def -(other)
+      raise TypeError, 'Not one of: [Duration, #to_nanos]' unless other.respond_to?(:to_nanos)
+
       Duration.new(to_nanos - other.to_nanos)
     end
 
     # Compare this +Duration+ with another.
     def <=>(other)
-      to_nanos <=> other.to_nanos
+      to_nanos <=> other.to_nanos if other.is_a? Duration
+    end
+
+    def ==(other)
+      other.is_a?(Duration) && to_nanos == other.to_nanos
+    end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ to_nanos.hash
     end
 
     # Return this +Duration+ in seconds.
+    #
+    # @return [Float]
     def to_secs
       to_nanos / 1_000_000_000.0
     end
 
     # Return this +Duration+ in milliseconds.
+    #
+    # @return [Float]
     def to_millis
       to_nanos / 1_000_000.0
     end
 
     # Return this +Duration+ in microseconds.
+    #
+    # @return [Float]
     def to_micros
       to_nanos / 1_000.0
     end
 
     # Return this +Duration+ in nanoseconds.
+    #
+    # @return [Integer]
     def to_nanos
       @ns
     end
@@ -153,11 +217,16 @@ module Monotime
       [0, 'ns']
     ].map(&:freeze).freeze
 
+    private_constant :DIVISORS
+
     # Format this +Duration+ into a human-readable string, with a given number
     # of decimal places.
     #
     # The exact format is subject to change, users with specific requirements
     # are encouraged to use their own formatting methods.
+    #
+    # @param precision [Integer] the maximum number of decimal places
+    # @return [String]
     def to_s(precision = 9)
       precision = Integer(precision).abs
       ns = to_nanos.abs

data/lib/monotime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Monotime
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/monotime.gemspec

@@ -31,8 +31,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "dry-equalizer", '~> 0'
-
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: monotime
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Thomas Hurst
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-02 00:00:00.000000000 Z
+date: 2018-10-04 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: dry-equalizer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement