ruby-units 2.4.1 → 4.0.0

data/lib/ruby_units/math.rb

@@ -1,125 +1,148 @@
-# Math will convert unit objects to radians and then attempt to use the value for
-# trigonometric functions.
-module Math
-  alias unit_sqrt sqrt
-  # @return [Numeric]
-  def sqrt(n)
-    if n.is_a?(RubyUnits::Unit)
-      (n**Rational(1, 2)).to_unit
-    else
-      unit_sqrt(n)
+module RubyUnits
+  # Math will convert unit objects to radians and then attempt to use the value for
+  # trigonometric functions.
+  module Math
+    # Take the square root of a unit or number
+    #
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric, RubyUnits::Unit]
+    def sqrt(number)
+      if number.is_a?(RubyUnits::Unit)
+        (number**Rational(1, 2)).to_unit
+      else
+        super
+      end
     end
-  end
-  # @return [Numeric]
-  module_function :unit_sqrt
-  # @return [Numeric]
-  module_function :sqrt
-
-  #:nocov:
-  if respond_to?(:cbrt)
-    alias unit_cbrt cbrt
+
+    # Take the cube root of a unit or number
+    #
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric, RubyUnits::Unit]
+    def cbrt(number)
+      if number.is_a?(RubyUnits::Unit)
+        (number**Rational(1, 3)).to_unit
+      else
+        super
+      end
+    end
+
+    # @param angle [Numeric, RubyUnits::Unit]
     # @return [Numeric]
-    def cbrt(n)
-      if RubyUnits::Unit === n
-        (n**Rational(1, 3)).to_unit
+    def sin(angle)
+      angle.is_a?(RubyUnits::Unit) ? super(angle.convert_to('radian').scalar) : super
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric, RubyUnits::Unit]
+    def asin(number)
+      if number.is_a?(RubyUnits::Unit)
+        [super(number), 'radian'].to_unit
       else
-        unit_cbrt(n)
+        super
       end
     end
+
+    # @param angle [Numeric, RubyUnits::Unit]
     # @return [Numeric]
-    module_function :unit_cbrt
+    def cos(angle)
+      angle.is_a?(RubyUnits::Unit) ? super(angle.convert_to('radian').scalar) : super
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric, RubyUnits::Unit]
+    def acos(number)
+      if number.is_a?(RubyUnits::Unit)
+        [super(number), 'radian'].to_unit
+      else
+        super
+      end
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
     # @return [Numeric]
-    module_function :cbrt
-  end
-  #:nocov:
+    def sinh(number)
+      number.is_a?(RubyUnits::Unit) ? super(number.convert_to('radian').scalar) : super
+    end
 
-  alias unit_sin sin
-  # @return [Numeric]
-  def sin(n)
-    RubyUnits::Unit === n ? unit_sin(n.convert_to('radian').scalar) : unit_sin(n)
-  end
-  # @return [Numeric]
-  module_function :unit_sin
-  # @return [Numeric]
-  module_function :sin
-
-  alias unit_cos cos
-  # @return [Numeric]
-  def cos(n)
-    RubyUnits::Unit === n ? unit_cos(n.convert_to('radian').scalar) : unit_cos(n)
-  end
-  # @return [Numeric]
-  module_function :unit_cos
-  # @return [Numeric]
-  module_function :cos
-
-  alias unit_sinh sinh
-  # @return [Numeric]
-  def sinh(n)
-    RubyUnits::Unit === n ? unit_sinh(n.convert_to('radian').scalar) : unit_sinh(n)
-  end
-  # @return [Numeric]
-  module_function :unit_sinh
-  # @return [Numeric]
-  module_function :sinh
-
-  alias unit_cosh cosh
-  # @return [Numeric]
-  def cosh(n)
-    RubyUnits::Unit === n ? unit_cosh(n.convert_to('radian').scalar) : unit_cosh(n)
-  end
-  # @return [Numeric]
-  module_function :unit_cosh
-  # @return [Numeric]
-  module_function :cosh
-
-  alias unit_tan tan
-  # @return [Numeric]
-  def tan(n)
-    RubyUnits::Unit === n ? unit_tan(n.convert_to('radian').scalar) : unit_tan(n)
-  end
-  # @return [Numeric]
-  module_function :tan
-  # @return [Numeric]
-  module_function :unit_tan
-
-  alias unit_tanh tanh
-  # @return [Numeric]
-  def tanh(n)
-    RubyUnits::Unit === n ? unit_tanh(n.convert_to('radian').scalar) : unit_tanh(n)
-  end
-  # @return [Numeric]
-  module_function :unit_tanh
-  # @return [Numeric]
-  module_function :tanh
-
-  alias unit_hypot hypot
-  # Convert parameters to consistent units and perform the function
-  # @return [Numeric]
-  def hypot(x, y)
-    if RubyUnits::Unit === x && RubyUnits::Unit === y
-      (x**2 + y**2)**Rational(1, 2)
-    else
-      unit_hypot(x, y)
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric]
+    def cosh(number)
+      number.is_a?(RubyUnits::Unit) ? super(number.convert_to('radian').scalar) : super
     end
-  end
-  # @return [Numeric]
-  module_function :unit_hypot
-  # @return [Numeric]
-  module_function :hypot
-
-  alias unit_atan2 atan2
-  # @return [Numeric]
-  def atan2(x, y)
-    raise ArgumentError, 'Incompatible RubyUnits::Units' if (x.is_a?(RubyUnits::Unit) && y.is_a?(RubyUnits::Unit)) && !x.compatible?(y)
-    if (x.is_a?(RubyUnits::Unit) && y.is_a?(RubyUnits::Unit)) && x.compatible?(y)
-      Math.unit_atan2(x.base_scalar, y.base_scalar)
-    else
-      Math.unit_atan2(x, y)
+
+    # @param angle [Numeric, RubyUnits::Unit]
+    # @return [Numeric]
+    def tan(angle)
+      angle.is_a?(RubyUnits::Unit) ? super(angle.convert_to('radian').scalar) : super
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric]
+    def tanh(number)
+      number.is_a?(RubyUnits::Unit) ? super(number.convert_to('radian').scalar) : super
+    end
+
+    # @param x [Numeric, RubyUnits::Unit]
+    # @param y [Numeric, RubyUnits::Unit]
+    # @return [Numeric]
+    def hypot(x, y)
+      if x.is_a?(RubyUnits::Unit) && y.is_a?(RubyUnits::Unit)
+        ((x**2) + (y**2))**Rational(1, 2)
+      else
+        super
+      end
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric] if argument is a number
+    # @return [RubyUnits::Unit] if argument is a unit
+    def atan(number)
+      if number.is_a?(RubyUnits::Unit)
+        [super(number), 'radian'].to_unit
+      else
+        super
+      end
+    end
+
+    # @param x [Numeric, RubyUnits::Unit]
+    # @param y [Numeric, RubyUnits::Unit]
+    # @return [Numeric] if all parameters are numbers
+    # @return [RubyUnits::Unit] if parameters are units
+    # @raise [ArgumentError] if parameters are not numbers or compatible units
+    def atan2(x, y)
+      raise ArgumentError, 'Incompatible RubyUnits::Units' if (x.is_a?(RubyUnits::Unit) && y.is_a?(RubyUnits::Unit)) && !x.compatible?(y)
+
+      if (x.is_a?(RubyUnits::Unit) && y.is_a?(RubyUnits::Unit)) && x.compatible?(y)
+        [super(x.base_scalar, y.base_scalar), 'radian'].to_unit
+      else
+        super
+      end
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @return [Numeric]
+    def log10(number)
+      if number.is_a?(RubyUnits::Unit)
+        super(number.to_f)
+      else
+        super
+      end
+    end
+
+    # @param number [Numeric, RubyUnits::Unit]
+    # @param base [Numeric]
+    # @return [Numeric]
+    def log(number, base = ::Math::E)
+      if number.is_a?(RubyUnits::Unit)
+        super(number.to_f, base)
+      else
+        super
+      end
     end
   end
-  # @return [Numeric]
-  module_function :unit_atan2
-  # @return [Numeric]
-  module_function :atan2
+end
+
+# @see https://github.com/lsegal/yard/issues/1353
+module Math
+  singleton_class.prepend(RubyUnits::Math)
 end

data/lib/ruby_units/numeric.rb

@@ -1,7 +1,23 @@
-class Numeric
-  # make a unitless unit with a given scalar
-  # @return (see RubyUnits::Unit#initialize)
-  def to_unit(other = nil)
-    other ? RubyUnits::Unit.new(self, other) : RubyUnits::Unit.new(self)
+module RubyUnits
+  # Extra methods for [::Numeric] to allow it to be used as a [RubyUnits::Unit]
+  module Numeric
+    # Make a unitless unit with a given scalar.
+    # > In ruby-units <= 2.3.2 this method would create a new [RubyUnits::Unit]
+    # > with the scalar and passed in units. This was changed to be more
+    # > consistent with the behavior of [#to_unit]. Specifically the argument is
+    # > used as a convenience method to convert the unitless scalar unit to a
+    # > compatible unitless unit.
+    #
+    # @param other [RubyUnits::Unit, String] convert to same units as passed
+    # @return [RubyUnits::Unit]
+    def to_unit(other = nil)
+      other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
+    end
   end
 end
+
+# @note Do this instead of Numeric.prepend(RubyUnits::Numeric) to avoid YARD warnings
+# @see https://github.com/lsegal/yard/issues/1353
+class Numeric
+  prepend(RubyUnits::Numeric)
+end

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