ruby-units 2.4.1 → 3.0.0

data/lib/ruby_units/string.rb

@@ -1,27 +1,40 @@
 require 'time'
-class String
-  # make a string into a unit
-  # @return (see RubyUnits::Unit#initialize)
-  def to_unit(other = nil)
-    other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
-  end
 
-  alias original_format %
-  # format unit output using formating codes
-  # @example '%0.2f' % '1 mm'.to_unit => '1.00 mm'
-  # @return [String]
-  def format_with_unit(*other)
-    if other.first.is_a?(RubyUnits::Unit)
-      other.first.to_s(self)
-    else
-      original_format(*other)
+module RubyUnits
+  # Extra methods for converting [String] objects to [RubyUnits::Unit] objects
+  # and using string formatting with Units.
+  module String
+    # Make a string into a unit
+    #
+    # @param other [RubyUnits::Unit, String] unit to convert to
+    # @return [RubyUnits::Unit]
+    def to_unit(other = nil)
+      other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
+    end
+
+    # Format unit output using formatting codes
+    # @example '%0.2f' % '1 mm'.to_unit => '1.00 mm'
+    #
+    # @param other [RubyUnits::Unit, Object]
+    # @return [String]
+    def %(*other)
+      if other.first.is_a?(RubyUnits::Unit)
+        other.first.to_s(self)
+      else
+        super
+      end
     end
-  end
-  alias % format_with_unit
 
-  # @param (see RubyUnits::Unit#convert_to)
-  # @return (see RubyUnits::Unit#convert_to)
-  def convert_to(other)
-    to_unit.convert_to(other)
+    # @param (see RubyUnits::Unit#convert_to)
+    # @return (see RubyUnits::Unit#convert_to)
+    def convert_to(other)
+      to_unit.convert_to(other)
+    end
   end
 end
+
+# @note Do this instead of String.prepend(RubyUnits::String) to avoid YARD warnings
+# @see https://github.com/lsegal/yard/issues/1353
+class String
+  prepend(RubyUnits::String)
+end

data/lib/ruby_units/time.rb

@@ -1,82 +1,89 @@
 require 'time'
-#
-# Time math is handled slightly differently.  The difference is considered to be an exact duration if
-# the subtracted value is in hours, minutes, or seconds.  It is rounded to the nearest day if the offset
-# is in years, decades, or centuries.  This leads to less precise values, but ones that match the
-# calendar better.
-class Time
-  class << self
-    alias unit_time_at at
-  end
 
-  # Convert a duration to a Time value by considering the duration to be the number of seconds since the
-  # epoch
-  # @param [Time] arg
-  # @param [Integer] ms
-  # @return [RubyUnits::Unit, Time]
-  def self.at(arg, ms = nil)
-    case arg
-    when Time
-      unit_time_at(arg)
-    when RubyUnits::Unit
-      if ms
-        unit_time_at(arg.convert_to('s').scalar, ms)
-      else
-        unit_time_at(arg.convert_to('s').scalar)
+module RubyUnits
+  # Time math is handled slightly differently.  The difference is considered to be an exact duration if
+  # the subtracted value is in hours, minutes, or seconds.  It is rounded to the nearest day if the offset
+  # is in years, decades, or centuries.  This leads to less precise values, but ones that match the
+  # calendar better.
+  module Time
+    # Class methods for [Time] objects
+    module ClassMethods
+      # Convert a duration to a [::Time] object by considering the duration to be
+      # the number of seconds since the epoch
+      #
+      # @param [Array<RubyUnits::Unit, Numeric, Symbol, Hash>] args
+      # @return [::Time]
+      def at(*args, **kwargs)
+        case args.first
+        when RubyUnits::Unit
+          options = args.last.is_a?(Hash) ? args.pop : kwargs
+          secondary_unit = args[2] || 'microsecond'
+          case args[1]
+          when Numeric
+            super((args.first + RubyUnits::Unit.new(args[1], secondary_unit.to_s)).convert_to('second').scalar, **options)
+          else
+            super(args.first.convert_to('second').scalar, **options)
+          end
+        else
+          super(*args, **kwargs)
+        end
       end
-    else
-      ms.nil? ? unit_time_at(arg) : unit_time_at(arg, ms)
-    end
-  end
 
-  # @return (see RubyUnits::Unit#initialize)
-  def to_unit(other = nil)
-    other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
-  end
-
-  unless Time.public_method_defined?(:to_date)
-    # :nocov_19:
-    public :to_date
-    # :nocov_19:
-  end
-
-  alias unit_add +
-  # @return [RubyUnits::Unit, Time]
-  def +(other)
-    case other
-    when RubyUnits::Unit
-      other = other.convert_to('d').round.convert_to('s') if %w[y decade century].include? other.units
-      begin
-        unit_add(other.convert_to('s').scalar)
-      rescue RangeError
-        to_datetime + other
+      # @example
+      #  Time.in '5 min'
+      # @param duration [#to_unit]
+      # @return [::Time]
+      def in(duration)
+        ::Time.now + duration.to_unit
       end
-    else
-      unit_add(other)
     end
-  end
 
-  # @example
-  #  Time.in '5 min'
-  # @return (see Time#+)
-  def self.in(duration)
-    Time.now + duration.to_unit
-  end
+    # Convert a [::Time] object to a [RubyUnits::Unit] object. The time is
+    # considered to be a duration with the number of seconds since the epoch.
+    #
+    # @param other [String, RubyUnits::Unit]
+    # @return [RubyUnits::Unit]
+    def to_unit(other = nil)
+      other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
+    end
 
-  alias unit_sub -
+    # @param other [::Time, RubyUnits::Unit]
+    # @return [RubyUnits::Unit, ::Time]
+    def +(other)
+      case other
+      when RubyUnits::Unit
+        other = other.convert_to('d').round.convert_to('s') if %w[y decade century].include? other.units
+        begin
+          super(other.convert_to('s').scalar)
+        rescue RangeError
+          to_datetime + other
+        end
+      else
+        super
+      end
+    end
 
-  # @return [RubyUnits::Unit, Time]
-  def -(other)
-    case other
-    when RubyUnits::Unit
-      other = other.convert_to('d').round.convert_to('s') if %w[y decade century].include? other.units
-      begin
-        unit_sub(other.convert_to('s').scalar)
-      rescue RangeError
-        send(:to_datetime) - other
+    # @param other [::Time, RubyUnits::Unit]
+    # @return [RubyUnits::Unit, ::Time]
+    def -(other)
+      case other
+      when RubyUnits::Unit
+        other = other.convert_to('d').round.convert_to('s') if %w[y decade century].include? other.units
+        begin
+          super(other.convert_to('s').scalar)
+        rescue RangeError
+          public_send(:to_datetime) - other
+        end
+      else
+        super
       end
-    else
-      unit_sub(other)
     end
   end
 end
+
+# @note Do this instead of Time.prepend(RubyUnits::Time) to avoid YARD warnings
+# @see https://github.com/lsegal/yard/issues/1353
+class Time
+  prepend(RubyUnits::Time)
+  singleton_class.prepend(RubyUnits::Time::ClassMethods)
+end