ruby-units 1.4.5 → 2.0.0

data/Rakefile.rb

@@ -6,86 +6,22 @@ require './lib/ruby-units'
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
-    gem.name = "ruby-units"
-    gem.summary = %Q{A class that performs unit conversions and unit math}
-    gem.description = %Q{Provides classes and methods to perform unit math and conversions}
-    gem.authors = ["Kevin Olbrich, Ph.D."]
-    gem.email = ["kevin.olbrich+ruby_units@gmail.com"]
-    gem.homepage = "https://github.com/olbrich/ruby-units"
-    gem.files.exclude(".*","test/**/*","spec/**/*","autotest/**/*", "Gemfile")
-    gem.license = "MIT"
-	gem.post_install_message = <<-EOS
-====================
-Deprecation Warning
-====================
-
-Several convenience methods that ruby-units added to the string class have
-been deprecated in this release.  These methods include String#to, String#from, String#ago, String#before and others.
-If your code relies on these functions, they can be added back by adding this line to your code.
-
-require 'ruby-units/string/extras'
-# note that these methods do not play well with Rails, which is one of the reasons they are being removed.
-
-The extra functions mostly work the same, but will no longer properly handle cases when they are called with strings..
-
-'min'.from("4-1-2011") # => Exception
-
-Pass in a Date, Time, or DateTime object to get the expected result.
-
-They will go away completely in the next release, so it would be a good idea to refactor your code
-to avoid using them.  They will also throw deprecation warnings when they are used.
-EOS
+    gem.name = 'ruby-units'
+    gem.summary = 'A class that performs unit conversions and unit math'
+    gem.description = 'Provides classes and methods to perform unit math and conversions'
+    gem.authors = ['Kevin Olbrich, Ph.D.']
+    gem.email = ['kevin.olbrich+ruby_units@gmail.com']
+    gem.homepage = 'https://github.com/olbrich/ruby-units'
+    gem.files.exclude('.*', 'test/**/*', 'spec/**/*', 'Gemfile', 'Guardfile')
+    gem.license = 'MIT'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-begin
-  require 'simplecov'
-  desc "code coverage report using simplecov (ruby 1.9+)"
-  task :simplecov do
-    ENV['COVERAGE']='true'
-    Rake::Task['spec'].invoke
-  end
-rescue LoadError
-end
-
-begin
-  require 'rspec/core/rake_task'
-
-  desc "Run specs"
-  RSpec::Core::RakeTask.new do |spec|
-	puts
-	# puts %x{rvm current}
-	puts
-  end
-  
-  desc  "Run all specs with rcov"
-  RSpec::Core::RakeTask.new("spec:rcov") do |t|
-    t.rcov = true
-    t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/,features\/}
-  end
-rescue LoadError
-end
-
-task :specs => :spec
-
-rubies = {
-      "ruby-1.8.7" => %w{ruby-1.8.7-p357@ruby-units ruby-1.8.7-p357@ruby-units-with-chronic},
-      "ruby-1.9.2" => %w{ruby-1.9.2-p290@ruby-units ruby-1.9.2-p290@ruby-units-with-chronic},
-      "rbx"        => %w{rbx-head@ruby-units},
-      "jruby"      => %w{jruby-1.6.7@ruby-units}
-    }
-
-rubies.each do |name, ruby|
-  desc "Run Spec against #{name}"
-  task "spec:#{name}" do
-    sh "rvm #{ruby.join(',')} do rake spec"
-  end
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
 end
 
-desc "Run specs against several ruby versions, requires rvm"
-task "spec:all" => rubies.keys.map {|name| "spec:#{name}"}
+require 'rspec/core/rake_task'
+desc 'Run specs'
+RSpec::Core::RakeTask.new
 
-task :default => :spec
+task default: :spec

data/VERSION

@@ -1 +1 @@
-1.4.5
+2.0.0

data/lib/ruby-units.rb

@@ -1,9 +1,3 @@
 $LOAD_PATH << File.dirname(__FILE__)
-
 require_relative 'ruby_units/namespaced'
-
-# only include the Unit('unit') helper if we aren't fully namespaced
-require_relative 'ruby_units/object'
-
-
 Unit = RubyUnits::Unit

data/lib/ruby_units/array.rb

@@ -1,11 +1,9 @@
 class Array
   # Construct a unit from an array
-  # @example [1, 'mm'].to_unit => RubyUnits::Unit("1 mm")
+  # @example [1, 'mm'].to_unit => RubyUnits::Unit.new("1 mm")
   # @return (see RubyUnits::Unit#initialize)
   # @param [Object] other convert to same units as passed
   def to_unit(other = nil)
     other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
   end
-  alias :unit :to_unit
-  alias :u :to_unit
 end

data/lib/ruby_units/date.rb

@@ -1,66 +1,64 @@
 require 'date'
 
 # Allow date objects to do offsets by a time unit
-# Date.today + U"1 week" => gives today+1 week
+# Date.today + Unit.new("1 week") => gives today+1 week
 class Date
-  alias :unit_date_add :+
-  # @param [Object] unit
+  alias_method :unit_date_add, :+
+  # @param [Object] other
   # @return [Unit]
-  def +(unit)
-    case unit
-    when Unit
-      unit = unit.convert_to('d').round if ['y', 'decade', 'century'].include? unit.units 
-      unit_date_add(unit.convert_to('day').scalar)
+  def +(other)
+    case other
+    when RubyUnits::Unit
+      other = other.convert_to('d').round if %w(y decade century).include? other.units
+      unit_date_add(other.convert_to('day').scalar)
     else
-      unit_date_add(unit)
+      unit_date_add(other)
     end
   end
- 
-  alias :unit_date_sub :-    
-  # @param [Object] unit
+
+  alias_method :unit_date_sub, :-
+  # @param [Object] other
   # @return [Unit]
-  def -(unit)
-    case unit
-    when Unit 
-      unit = unit.convert_to('d').round if ['y', 'decade', 'century'].include? unit.units 
-      unit_date_sub(unit.convert_to('day').scalar)
+  def -(other)
+    case other
+    when RubyUnits::Unit
+      other = other.convert_to('d').round if %w(y decade century).include? other.units
+      unit_date_sub(other.convert_to('day').scalar)
     else
-      unit_date_sub(unit)
+      unit_date_sub(other)
     end
   end
-  
+
   # Construct a unit from a Date
   # @example Date.today.to_unit => Unit
   # @return (see Unit#initialize)
   # @param [Object] other convert to same units as passed
   def to_unit(other = nil)
-    other ? Unit.new(self).convert_to(other) : Unit.new(self)
+    other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
   end
-  alias :unit :to_unit
-  
+
   # :nocov_19:
   unless Date.instance_methods.include?(:to_time)
     # @return [Time]
     def to_time
-      Time.local(*ParseDate.parsedate(self.to_s))
+      Time.local(*ParseDate.parsedate(to_s))
     end
   end
   # :nocov_19:
-  
-  alias :units_datetime_inspect :inspect
+
+  alias_method :units_datetime_inspect, :inspect
   # @deprecated
-  def inspect(raw = false)
-    return self.units_datetime_inspect if raw
-    self.to_s
+  def inspect(dump = false)
+    return units_datetime_inspect if dump
+    to_s
   end
-  
+
   unless Date.instance_methods.include?(:to_date)
     # :nocov_19:
     # @return [Date]
     def to_date
-      Date.civil(self.year, self.month, self.day)
+      Date.civil(year, month, day)
     end
     # :nocov_19:
   end
-  
-end
+end

data/lib/ruby_units/definition.rb

@@ -2,32 +2,32 @@ class RubyUnits::Unit < Numeric
 
   # Handle the definition of units
   class Definition
-    
+
     # @return [Array]
     attr_writer :aliases
-    
+
     # @return [Symbol]
     attr_accessor :kind
-    
+
     # @return [Numeric]
     attr_accessor :scalar
-    
+
     # @return [Array]
     attr_accessor :numerator
 
     # @return [Array]
     attr_accessor :denominator
-    
+
     # @return [String]
     attr_accessor :display_name
-    
+
     # @example Raw definition from a hash
     #   Unit::Definition.new("rack-unit",[%w{U rack-U}, (6405920109971793/144115188075855872), :length, %w{<meter>} ])
-    # 
+    #
     # @example Block form
     #   Unit::Definition.new("rack-unit") do |unit|
     #     unit.aliases = %w{U rack-U}
-    #     unit.definition = Unit("7/4 inches")
+    #     unit.definition = RubyUnits::Unit.new("7/4 inches")
     #   end
     #
     def initialize(_name, _definition = [], &block)
@@ -40,7 +40,7 @@ class RubyUnits::Unit < Numeric
       @denominator  ||= _definition[4] || RubyUnits::Unit::UNITY_ARRAY
       @display_name ||= @aliases.first
     end
-    
+
     # name of the unit
     # nil if name is not set, adds '<' and '>' around the name
     # @return [String, nil]
@@ -48,14 +48,14 @@ class RubyUnits::Unit < Numeric
     def name
       "<#{@name}>" if (defined?(@name) && @name)
     end
-    
+
     # set the name, strip off '<' and '>'
     # @param [String]
     # @return [String]
     def name=(_name)
       @name = _name.gsub(/[<>]/,'')
     end
-    
+
     # alias array must contain the name of the unit and entries must be unique
     # @return [Array]
     def aliases
@@ -79,13 +79,13 @@ class RubyUnits::Unit < Numeric
     def prefix?
       self.kind == :prefix
     end
-    
+
     # Is this definition the unity definition?
     # @return [Boolean]
     def unity?
       self.prefix? && self.scalar == 1
     end
-    
+
     # is this a base unit?
     # units are base units if the scalar is one, and the unit is defined in terms of itself.
     # @return [Boolean]

data/lib/ruby_units/namespaced.rb

@@ -12,5 +12,4 @@ require_relative 'math'
 require_relative 'numeric'
 require_relative 'string'
 require_relative 'unit'
-require_relative 'fixnum'
 require_relative 'unit_definitions'

data/lib/ruby_units/numeric.rb

@@ -4,6 +4,4 @@ class Numeric
   def to_unit(other = nil)
     other ? RubyUnits::Unit.new(self, other) : RubyUnits::Unit.new(self)
   end
-  alias :unit :to_unit
-  alias :u :to_unit
 end

data/lib/ruby_units/string.rb

@@ -5,31 +5,24 @@ class String
   def to_unit(other = nil)
     other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
   end
-  alias :unit :to_unit
-  alias :u :to_unit
 
-
-  alias :unit_format :%  
-  # format unit output using formating codes 
-  # @example '%0.2f' % '1 mm'.unit => '1.00 mm'
+  alias_method :original_format, :%
+  # format unit output using formating codes
+  # @example '%0.2f' % '1 mm'.to_unit => '1.00 mm'
   # @return [String]
-  def %(*args)
-		return "" if self.empty?
-    case 
-    when args.first.is_a?(RubyUnits::Unit)
-      args.first.to_s(self)
-    when (!defined?(Uncertain).nil? && args.first.is_a?(Uncertain))
-      args.first.to_s(self)
-    when args.first.is_a?(Complex)
-      args.first.to_s
+  def format_with_unit(*other)
+    case
+    when other.first.is_a?(RubyUnits::Unit)
+      other.first.to_s(self)
     else
-      unit_format(*args)
+      original_format(*other)
     end
   end
-  
+  alias_method :%, :format_with_unit
+
   # @param (see RubyUnits::Unit#convert_to)
   # @return (see RubyUnits::Unit#convert_to)
   def convert_to(other)
-    self.unit.convert_to(other)
+    to_unit.convert_to(other)
   end
 end

data/lib/ruby_units/time.rb

@@ -2,15 +2,15 @@ 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 
+# 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 
+
+  # 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
@@ -34,21 +34,19 @@ class Time
   def to_unit(other = nil)
     other ? RubyUnits::Unit.new(self).convert_to(other) : RubyUnits::Unit.new(self)
   end
-  alias :unit :to_unit
-  alias :u :to_unit
 
   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 ['y', 'decade', 'century'].include? other.units  
+      other = other.convert_to('d').round.convert_to('s') if ['y', 'decade', 'century'].include? other.units
       begin
         unit_add(other.convert_to('s').scalar)
       rescue RangeError
@@ -58,21 +56,21 @@ class Time
       unit_add(other)
     end
   end
-  
+
   # @example
   #  Time.in '5 min'
   # @return (see Time#+)
   def self.in(duration)
     Time.now + duration.to_unit
   end
-  
+
   alias :unit_sub :-
-  
+
   # @return [RubyUnits::Unit, Time]
   def -(other)
     case other
     when RubyUnits::Unit
-      other = other.convert_to('d').round.convert_to('s') if ['y', 'decade', 'century'].include? other.units  
+      other = other.convert_to('d').round.convert_to('s') if ['y', 'decade', 'century'].include? other.units
       begin
         unit_sub(other.convert_to('s').scalar)
       rescue RangeError

data/lib/ruby_units/unit.rb

@@ -1,13 +1,6 @@
 # encoding: utf-8
 require 'date'
-if RUBY_VERSION < "1.9"
-  # :nocov_19:
-  require 'parsedate'
-  require 'rational'
-  # :nocov_19:
-end
-# Copyright 2006-2012
-#
+# Copyright 2006-2015
 # @author Kevin C. Olbrich, Ph.D.
 # @see https://github.com/olbrich/ruby-units
 #
@@ -28,10 +21,6 @@ end
 #    unit.definition = RubyUnits::Unit.new("1 baz")
 #  end
 #
-# @todo fix class variables so they conform to standard naming conventions and refactor away as many of them as possible
-# @todo pull caching out into its own class
-# @todo refactor internal representation of units
-# @todo method to determine best natural prefix
 module RubyUnits
   class Unit < Numeric
     VERSION            = Unit::Version::STRING
@@ -44,9 +33,15 @@ module RubyUnits
     @@UNIT_MATCH_REGEX = nil
     UNITY              = '<1>'
     UNITY_ARRAY        = [UNITY]
-    FEET_INCH_REGEX    = /(\d+)\s*(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inches)/
+    # ideally we would like to generate this regex from the alias for a 'feet' and 'inches', but they aren't
+    # defined at the point in the code where we need this regex.
+    FEET_INCH_UNITS_REGEX = /(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inch(?:es)?)/
+    FEET_INCH_REGEX    = /(\d+)\s*#{FEET_INCH_UNITS_REGEX}/
+    # ideally we would like to generate this regex from the alias for a 'pound' and 'ounce', but they aren't
+    # defined at the point in the code where we need this regex.
+    LBS_OZ_UNIT_REGEX  = /(?:#|lbs?|pounds?|pound-mass)+[\s,]*(\d+)\s*(?:ozs?|ounces?)/
+    LBS_OZ_REGEX       = /(\d+)\s*#{LBS_OZ_UNIT_REGEX}/
     TIME_REGEX         = /(\d+)*:(\d+)*:*(\d+)*[:,]*(\d+)*/
-    LBS_OZ_REGEX       = /(\d+)\s*(?:#|lbs|pounds|pound-mass)+[\s,]*(\d+)\s*(?:oz|ounces)/
     SCI_NUMBER         = %r{([+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*)}
     RATIONAL_NUMBER    = /\(?([+-])?(\d+[ -])?(\d+)\/(\d+)\)?/
     COMPLEX_NUMBER     = /#{SCI_NUMBER}?#{SCI_NUMBER}i\b/
@@ -54,7 +49,7 @@ module RubyUnits
     UNIT_STRING_REGEX  = /#{SCI_NUMBER}*\s*([^\/]*)\/*(.+)*/
     TOP_REGEX          = /([^ \*]+)(?:\^|\*\*)([\d-]+)/
     BOTTOM_REGEX       = /([^* ]+)(?:\^|\*\*)(\d+)/
-    UNCERTAIN_REGEX    = /#{SCI_NUMBER}\s*\+\/-\s*#{SCI_NUMBER}\s(.+)/
+    NUMBER_UNIT_REGEX  = /#{SCI_NUMBER}?(.*)/
     COMPLEX_REGEX      = /#{COMPLEX_NUMBER}\s?(.+)?/
     RATIONAL_REGEX     = /#{RATIONAL_NUMBER}\s?(.+)?/
     KELVIN             = ['<kelvin>']
@@ -199,11 +194,13 @@ module RubyUnits
     # @yield [RubyUnits::Unit::Definition]
     # @return (see RubyUnits::Unit.define)
     # Get the definition for a unit and allow it to be redefined
-    def self.redefine!(name, &block)
-      raise ArgumentError, "A block is required to redefine a unit" unless block_given?
-      unit_definition = self.definition(name)
+    def self.redefine!(name)
+      fail ArgumentError, 'A block is required to redefine a unit' unless block_given?
+      unit_definition = definition(name)
       yield unit_definition
-      self.define(unit_definition)
+      @@definitions.delete("<#{name}>")
+      define(unit_definition)
+      RubyUnits::Unit.setup
     end
 
     # @param [String] name of unit to undefine
@@ -264,31 +261,6 @@ module RubyUnits
       return self
     end
 
-    if RUBY_VERSION < "1.9"
-      # :nocov_19:
-
-      # a list of properties to emit to yaml
-      # @return [Array]
-      def to_yaml_properties
-        %w{@scalar @numerator @denominator @signature @base_scalar}
-      end
-
-      # basically a copy of the basic to_yaml.  Needed because otherwise it ends up coercing the object to a string
-      # before YAML'izing it.
-      # @param [Hash] opts
-      # @return [String]
-      def to_yaml(opts = {})
-        YAML::quick_emit(object_id, opts) do |out|
-          out.map(taguri, to_yaml_style) do |map|
-            for m in to_yaml_properties do
-              map.add(m[1..-1], instance_variable_get(m))
-            end
-          end
-        end
-      end
-      # :nocov_19:
-    end
-
     # Create a new Unit object.  Can be initialized using a String, a Hash, an Array, Time, DateTime
     #
     # @example Valid options include:
@@ -374,12 +346,14 @@ module RubyUnits
       unary_unit = self.units || ""
       if options.first.instance_of?(String)
         opt_scalar, opt_units = RubyUnits::Unit.parse_into_numbers_and_units(options[0])
-        unless @@cached_units.keys.include?(opt_units) || (opt_units =~ /(#{RubyUnits::Unit.temp_regex})|(pounds|lbs[ ,]\d+ ounces|oz)|('\d+")|(ft|feet[ ,]\d+ in|inch|inches)|%|(#{TIME_REGEX})|i\s?(.+)?|&plusmn;|\+\/-/)
-          @@cached_units[opt_units] = (self.scalar == 1 ? self : opt_units.unit) if opt_units && !opt_units.empty?
+        unless @@cached_units.keys.include?(opt_units) ||
+            (opt_units =~ %r{\D/[\d+\.]+}) ||
+            (opt_units =~ /(#{RubyUnits::Unit.temp_regex})|(#{LBS_OZ_UNIT_REGEX})|(#{FEET_INCH_UNITS_REGEX})|%|(#{TIME_REGEX})|i\s?(.+)?|&plusmn;|\+\/-/)
+          @@cached_units[opt_units] = (self.scalar == 1 ? self : opt_units.to_unit) if opt_units && !opt_units.empty?
         end
       end
       unless @@cached_units.keys.include?(unary_unit) || (unary_unit =~ /#{RubyUnits::Unit.temp_regex}/) then
-        @@cached_units[unary_unit] = (self.scalar == 1 ? self : unary_unit.unit)
+        @@cached_units[unary_unit] = (self.scalar == 1 ? self : unary_unit.to_unit)
       end
       [@scalar, @numerator, @denominator, @base_scalar, @signature, @is_base].each { |x| x.freeze }
       return self
@@ -419,7 +393,7 @@ module RubyUnits
     # @return [Unit]
     def self.parse(input)
       first, second = input.scan(/(.+)\s(?:in|to|as)\s(.+)/i).first
-      return second.nil? ? first.unit : first.unit.convert_to(second)
+      second.nil? ? RubyUnits::Unit.new(first) : RubyUnits::Unit.new(first).convert_to(second)
     end
 
     # @return [Unit]
@@ -448,15 +422,7 @@ module RubyUnits
     def to_base
       return self if self.is_base?
       if @@UNIT_MAP[self.units] =~ /\A<(?:temp|deg)[CRF]>\Z/
-        if RUBY_VERSION < "1.9"
-          # :nocov_19:
-          @signature = @@KINDS.index(:temperature)
-          # :nocov_19:
-        else
-          #:nocov:
-          @signature = @@KINDS.key(:temperature)
-          #:nocov:
-        end
+        @signature = @@KINDS.key(:temperature)
         base = case
                  when self.is_temperature?
                    self.convert_to('tempK')
@@ -494,7 +460,7 @@ module RubyUnits
       num = num.flatten.compact
       den = den.flatten.compact
       num = UNITY_ARRAY if num.empty?
-      base                         = RubyUnits::Unit.new(RubyUnits::Unit.eliminate_terms(q, num, den))
+      base = RubyUnits::Unit.new(RubyUnits::Unit.eliminate_terms(q, num, den))
       @@base_unit_cache[self.units]=base
       return base * @scalar
     end
@@ -522,36 +488,38 @@ module RubyUnits
         return out
       else
         case target_units
-          when :ft
-            inches = self.convert_to("in").scalar.to_int
-            out    = "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
-          when :lbs
-            ounces = self.convert_to("oz").scalar.to_int
-            out    = "#{(ounces / 16).truncate} lbs, #{(ounces % 16).round} oz"
-          when String
-            out = case target_units
-                    when /(%[\-+\.\w#]+)\s*(.+)*/ #format string like '%0.2f in'
-                      begin
-                        if $2 #unit specified, need to convert
-                          self.convert_to($2).to_s($1)
-                        else
-                          "#{$1 % @scalar} #{$2 || self.units}".strip
-                        end
-                      rescue # parse it like a strftime format string
-                        (DateTime.new(0) + self).strftime(target_units)
-                      end
-                    when /(\S+)/ #unit only 'mm' or '1/mm'
-                      self.convert_to($1).to_s
+        when :ft
+          inches = self.convert_to("in").scalar.to_int
+          out    = "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
+        when :lbs
+          ounces = self.convert_to("oz").scalar.to_int
+          out    = "#{(ounces / 16).truncate} lbs, #{(ounces % 16).round} oz"
+        when String
+          out = case target_units.strip
+                when /\A\s*\Z/ # whitespace only
+                  ''
+                when /(%[\-+\.\w#]+)\s*(.+)*/ #format string like '%0.2f in'
+                  begin
+                    if $2 #unit specified, need to convert
+                      self.convert_to($2).to_s($1)
                     else
-                      raise "unhandled case"
+                      "#{$1 % @scalar} #{$2 || self.units}".strip
+                    end
+                  rescue # parse it like a strftime format string
+                    (DateTime.new(0) + self).strftime(target_units)
                   end
-          else
-            out = case @scalar
-                    when Rational
-                      "#{@scalar} #{self.units}"
-                    else
-                      "#{'%g' % @scalar} #{self.units}"
-                  end.strip
+                when /(\S+)/ #unit only 'mm' or '1/mm'
+                  self.convert_to($1).to_s
+                else
+                  raise "unhandled case"
+                end
+        else
+          out = case @scalar
+                when Rational, Complex
+                  "#{@scalar} #{self.units}"
+                else
+                  "#{'%g' % @scalar} #{self.units}"
+                end.strip
         end
         @output[target_units] = out
         return out
@@ -561,9 +529,9 @@ module RubyUnits
     # Normally pretty prints the unit, but if you really want to see the guts of it, pass ':dump'
     # @deprecated
     # @return [String]
-    def inspect(option=nil)
-      return super() if option == :dump
-      return self.to_s
+    def inspect(dump = nil)
+      return super() if dump
+      to_s
     end
 
     # true if unit is a 'temperature', false if a 'degree' or anything else
@@ -584,7 +552,7 @@ module RubyUnits
     alias :degree? :is_degree?
 
     # returns the 'degree' unit associated with a temperature unit
-    # @example '100 tempC'.unit.temperature_scale #=> 'degC'
+    # @example '100 tempC'.to_unit.temperature_scale #=> 'degC'
     # @return [String] possible values: degC, degF, degR, or degK
     def temperature_scale
       return nil unless self.is_temperature?
@@ -718,7 +686,7 @@ module RubyUnits
                   RubyUnits::Unit.new(:scalar => (other.scalar + self.convert_to(other.temperature_scale).scalar), :numerator => other.numerator, :denominator => other.denominator, :signature => other.signature)
                 end
               else
-                @q ||= ((@@cached_units[self.units].scalar / @@cached_units[self.units].base_scalar) rescue (self.units.unit.to_base.scalar))
+                @q ||= ((@@cached_units[self.units].scalar / @@cached_units[self.units].base_scalar) rescue (self.units.to_unit.to_base.scalar))
                 RubyUnits::Unit.new(:scalar => (self.base_scalar + other.base_scalar)*@q, :numerator => @numerator, :denominator => @denominator, :signature => @signature)
               end
             else
@@ -757,7 +725,7 @@ module RubyUnits
                 when other.is_temperature?
                   raise ArgumentError, "Cannot subtract a temperature from a differential degree unit"
                 else
-                  @q ||= ((@@cached_units[self.units].scalar / @@cached_units[self.units].base_scalar) rescue (self.units.unit.scalar/self.units.unit.to_base.scalar))
+                  @q ||= ((@@cached_units[self.units].scalar / @@cached_units[self.units].base_scalar) rescue (self.units.to_unit.scalar/self.units.to_unit.to_base.scalar))
                   RubyUnits::Unit.new(:scalar => (self.base_scalar - other.base_scalar)*@q, :numerator => @numerator, :denominator => @denominator, :signature => @signature)
               end
             else
@@ -1120,18 +1088,10 @@ module RubyUnits
       return RubyUnits::Unit.new(@scalar.floor, @numerator, @denominator)
     end
 
-    if RUBY_VERSION < '1.9'
-      # @return [Numeric,Unit]
-      def round
-        return @scalar.round if self.unitless?
-        return RubyUnits::Unit.new(@scalar.round, @numerator, @denominator)
-      end
-    else
-      # @return [Numeric,Unit]
-      def round(ndigits = 0)
-        return @scalar.round(ndigits) if self.unitless?
-        return RubyUnits::Unit.new(@scalar.round(ndigits), @numerator, @denominator)
-      end
+    # @return [Numeric,Unit]
+    def round(ndigits = 0)
+      return @scalar.round(ndigits) if self.unitless?
+      return RubyUnits::Unit.new(@scalar.round(ndigits), @numerator, @denominator)
     end
 
     # @return [Numeric, Unit]
@@ -1140,7 +1100,7 @@ module RubyUnits
       return RubyUnits::Unit.new(@scalar.truncate, @numerator, @denominator)
     end
 
-    # returns next unit in a range.  '1 mm'.unit.succ #=> '2 mm'.unit
+    # returns next unit in a range.  '1 mm'.to_unit.succ #=> '2 mm'.to_unit
     # only works when the scalar is an integer
     # @return [Unit]
     # @raise [ArgumentError] when scalar is not equal to an integer
@@ -1151,7 +1111,7 @@ module RubyUnits
 
     alias :next :succ
 
-    # returns previous unit in a range.  '2 mm'.unit.pred #=> '1 mm'.unit
+    # returns previous unit in a range.  '2 mm'.to_unit.pred #=> '1 mm'.to_unit
     # only works when the scalar is an integer
     # @return [Unit]
     # @raise [ArgumentError] when scalar is not equal to an integer
@@ -1186,7 +1146,7 @@ module RubyUnits
       return self.base_scalar.zero?
     end
 
-    # @example '5 min'.unit.ago
+    # @example '5 min'.to_unit.ago
     # @return [Unit]
     def ago
       return self.before
@@ -1211,12 +1171,12 @@ module RubyUnits
     # @raise [ArgumentError] when time point is not a Time, Date, or DateTime
     def since(time_point)
       case time_point
-        when Time
-          return (Time.now - time_point).unit('s').convert_to(self)
-        when DateTime, Date
-          return (DateTime.now - time_point).unit('d').convert_to(self)
-        else
-          raise ArgumentError, "Must specify a Time, Date, or DateTime"
+      when Time
+        return (Time.now - time_point).to_unit('s').convert_to(self)
+      when DateTime, Date
+        return (DateTime.now - time_point).to_unit('d').convert_to(self)
+      else
+        fail ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
     end
 
@@ -1225,12 +1185,12 @@ module RubyUnits
     # @return [Unit]
     def until(time_point)
       case time_point
-        when Time
-          return (time_point - Time.now).unit('s').convert_to(self)
-        when DateTime, Date
-          return (time_point - DateTime.now).unit('d').convert_to(self)
-        else
-          raise ArgumentError, "Must specify a Time, Date, or DateTime"
+      when Time
+        return (time_point - Time.now).to_unit('s').convert_to(self)
+      when DateTime, Date
+        return (time_point - DateTime.now).to_unit('d').convert_to(self)
+      else
+        fail ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
     end
 
@@ -1409,24 +1369,13 @@ module RubyUnits
       if unit_string =~ /\$\s*(#{NUMBER_REGEX})/
         unit_string = "#{$1} USD"
       end
-      unit_string.gsub!("\u00b0".force_encoding('utf-8'), 'deg') if RUBY_VERSION >= '1.9' && unit_string.encoding == Encoding::UTF_8
+      unit_string.gsub!("\u00b0".force_encoding('utf-8'), 'deg') if unit_string.encoding == Encoding::UTF_8
 
       unit_string.gsub!(/%/, 'percent')
       unit_string.gsub!(/'/, 'feet')
       unit_string.gsub!(/"/, 'inch')
       unit_string.gsub!(/#/, 'pound')
 
-      #:nocov:
-      #:nocov_19:
-      if defined?(Uncertain) && unit_string =~ /(\+\/-|&plusmn;)/
-        value, uncertainty, unit_s = unit_string.scan(UNCERTAIN_REGEX)[0]
-        result                     = unit_s.unit * Uncertain.new(value.to_f, uncertainty.to_f)
-        copy(result)
-        return
-      end
-      #:nocov:
-      #:nocov_19:
-
       if defined?(Complex) && unit_string =~ COMPLEX_NUMBER
         real, imaginary, unit_s = unit_string.scan(COMPLEX_REGEX)[0]
         result                  = RubyUnits::Unit.new(unit_s || '1') * Complex(real.to_f, imaginary.to_f)
@@ -1463,10 +1412,10 @@ module RubyUnits
       if unit_string =~ /:/
         hours, minutes, seconds, microseconds = unit_string.scan(TIME_REGEX)[0]
         raise ArgumentError, "Invalid Duration" if [hours, minutes, seconds, microseconds].all? { |x| x.nil? }
-        result = "#{hours || 0} h".unit +
-            "#{minutes || 0} minutes".unit +
-            "#{seconds || 0} seconds".unit +
-            "#{microseconds || 0} usec".unit
+        result = RubyUnits::Unit.new("#{hours || 0} h") +
+                 RubyUnits::Unit.new("#{minutes || 0} minutes") +
+                 RubyUnits::Unit.new("#{seconds || 0} seconds") +
+                 RubyUnits::Unit.new("#{microseconds || 0} usec")
         copy(result)
         return
       end
@@ -1502,11 +1451,25 @@ module RubyUnits
             bottom = "#{bottom} #{x * -n}"; top.gsub!(/#{item[0]}(\^|\*\*)#{n}/, "")
         end
       end
-      bottom.gsub!(BOTTOM_REGEX) { |s| "#{$1} " * $2.to_i } if bottom
+      if bottom
+        bottom.gsub!(BOTTOM_REGEX) { |s| "#{$1} " * $2.to_i }
+        # Separate leading decimal from denominator, if any
+        bottom_scalar, bottom = bottom.scan(NUMBER_UNIT_REGEX)[0]
+      end
+
       @scalar = @scalar.to_f unless @scalar.nil? || @scalar.empty?
       @scalar = 1 unless @scalar.kind_of? Numeric
       @scalar = @scalar.to_int if (@scalar.to_int == @scalar)
 
+      case
+      when bottom_scalar.nil? || bottom_scalar.empty?
+      when bottom_scalar.to_i == bottom_scalar
+        @scalar /= bottom_scalar.to_i
+      else
+        @scalar /= bottom_scalar.to_f
+      end
+
+
       @numerator   ||= UNITY_ARRAY
       @denominator ||= UNITY_ARRAY
       @numerator = top.scan(RubyUnits::Unit.unit_match_regex).delete_if { |x| x.empty? }.compact if top
@@ -1537,6 +1500,7 @@ module RubyUnits
     end
 
     # parse a string consisting of a number and a unit string
+    # NOTE: This does not properly handle units formatted like '12mg/6ml'
     # @param [String] string
     # @return [Array] consisting of [Numeric, "unit"]
     # @private
@@ -1547,7 +1511,8 @@ module RubyUnits
       rational  = %r{\(?[+-]?(?:\d+[ -])?\d+\/\d+\)?}
       # complex numbers... -1.2+3i, +1.2-3.3i
       complex   = %r{#{sci}{2,2}i}
-      anynumber = %r{(?:(#{complex}|#{rational}|#{sci})\b)?\s?([^-\d\.].*)?}
+      anynumber = %r{(?:(#{complex}|#{rational}|#{sci}))?\s?([^-\d\.].*)?}
+
       num, unit = string.scan(anynumber).first
 
       return [case num