unitwise-193 1.0.4

data/lib/unitwise/prefix.rb

@@ -0,0 +1,24 @@
+module Unitwise
+  # A prefix can be used with metric atoms to modify their scale.
+  class Prefix < Base
+    liner :scalar
+
+    # The data loaded from the UCUM spec files
+    # @api semipublic
+    def self.data
+      @data ||= YAML.load File.open(data_file)
+    end
+
+    # The location of the UCUM spec prefix data file
+    # @api semipublic
+    def self.data_file
+      Unitwise.data_file 'prefix'
+    end
+
+    # Set the scalar value for the prefix, always as a BigDecimal
+    # @api semipublic
+    def scalar=(value)
+      @scalar = BigDecimal(value.to_s)
+    end
+  end
+end

data/lib/unitwise/scale.rb

@@ -0,0 +1,139 @@
+module Unitwise
+  # A Unitwise::Scale represents a value and a unit, sort of like a vector, it
+  # has two components. In this case, it's a value and unit rather than a
+  # magnitude and direction. This class should be considered mostly privateish.
+  class Scale
+    liner :value, :unit
+    include Unitwise::Compatible
+
+    def initialize(value, unit)
+      self.value = if value.is_a? self.class
+        value.convert_to(unit).value
+      else
+        value
+      end
+      self.unit = unit
+      freeze
+    end
+
+    # Set the unit vector.
+    # @param value [String, Unitwise::Unit]
+    # @api public
+    def unit=(value)
+      @unit = value.is_a?(Unit) ? value : Unit.new(value)
+    end
+
+    # List the atoms associated with this scale's unit.
+    # @return [Array]
+    # @api public
+    def atoms
+      unit.atoms
+    end
+
+    def value=(value)
+      @value = BigDecimal(value.to_s)
+    end
+
+    # List the terms associated with this scale's unit.
+    # @return [Array]
+    # @api public
+    def terms
+      unit.terms
+    end
+
+    # Is this scale's unit special?
+    # @return [true, false]
+    # @api public
+    def special?
+      unit.special?
+    end
+
+    # Get a scalar value for this scale.
+    # @param magnitude [Numeric] An optional magnitude on this scale.
+    # @return [Numeric] A scalar value on a linear scale
+    # @api public
+    def scalar(magnitude = value)
+      if special?
+        unit.scalar(magnitude)
+      else
+        value * unit.scalar
+      end
+    end
+
+    # Get a magnitude based on a linear scale value. Only used by scales with
+    # special atoms in it's hierarchy.
+    # @param scalar [Numeric] A linear scalar value
+    # @return [Numeric] The equivalent magnitude on this scale
+    # @api public
+    def magnitude(scalar = scalar())
+      if special?
+        unit.magnitude(scalar)
+      else
+        value * unit.magnitude
+      end
+    end
+
+    # The base terms this scale's unit is derived from
+    # @return [Array] An array of Unitwise::Term
+    # @api public
+    def root_terms
+      unit.root_terms
+    end
+    memoize :root_terms
+
+    # How far away is this instances unit from the deepest level atom.
+    # @return [Integer]
+    # @api public
+    def depth
+      unit.depth + 1
+    end
+    memoize :depth
+
+    # Attempts to coerce the value to the simplest Numeric that fully expresses
+    # it's value. For instance a value of 1.0 would return 1, a value of
+    # #<BigDecimal:7f9558d559b8,'0.45E1',18(18)> would return 4.5.
+    # @return [Numeric]
+    # @api public
+    def simplified_value
+      if value.is_a?(Integer)
+        value
+      elsif (i = Integer(value)) == value
+        i
+      elsif value.is_a?(Float) || value.is_a?(Rational)
+        value
+      elsif (f = Float(value)) == value
+        f
+      else
+        value
+      end
+    end
+    memoize :simplified_value
+
+    def expression
+      unit.expression
+    end
+
+    # Convert to a simple string representing the scale.
+    # @api public
+    def to_s(mode = nil)
+      "#{simplified_value} #{unit.to_s(mode)}"
+    end
+
+    def inspect
+      "#<#{self.class} value=#{simplified_value} unit=#{unit}>"
+    end
+
+    # Redefine hash for apropriate hash/key lookup
+    # @api semipublic
+    def hash
+      [value, unit.to_s, self.class].hash
+    end
+    memoize :hash
+
+    # Redefine hash equality to match the hashes
+    # @api semipublic
+    def eql?(other)
+      hash == other.hash
+    end
+  end
+end

data/lib/unitwise/search.rb

@@ -0,0 +1,46 @@
+module Unitwise
+  # The search module provides a simple search mechanism around known basic
+  # units. The full list of avaliable units infinite, so this search creates
+  # a small subset of atoms and prefixes to help users find what they are
+  # looking for. Thus, there is a multitude of valid units that may be
+  # constructed that this module will not be aware of.
+  module Search
+    class << self
+      # An abbreviated list of possible units. These are known combinations
+      # of atoms and prefixes.
+      # @return [Array] A list of known units
+      # @api public
+      def all
+        @all ||= begin
+          units = []
+          Atom.all.each do |a|
+            units << build(a)
+            Unitwise::Prefix.all.each { |p| units << build(a, p) } if a.metric?
+          end
+          units
+        end
+      end
+
+      # Search the list of known units for a match.
+      # @param term [String, Regexp] The term to search for
+      # @return [Array] A list of matching units.
+      # @api public
+      def search(term)
+        all.select do |unit|
+          unit.aliases.any? { |str| Regexp.new(term).match(str) }
+        end
+      end
+
+      private
+
+      # Helper method for building a new unit by a known atom and prefix.
+      # @param atom [Unitwise::Atom]
+      # @param prefix [Unitwise::Prefix, nil]
+      # @return [Unitwise::Unit]
+      # @api private
+      def build(atom, prefix = nil)
+        Unit.new([Term.new(:atom => atom, :prefix => prefix)])
+      end
+    end
+  end
+end

data/lib/unitwise/standard.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+require 'nori'
+require 'unitwise/standard/base'
+require 'unitwise/standard/prefix'
+require 'unitwise/standard/base_unit'
+require 'unitwise/standard/derived_unit'
+require 'unitwise/standard/scale'
+require 'unitwise/standard/function'
+
+module Unitwise
+  # The Standard module is responsible for fetching the UCUM specification unit
+  # standards and translating them into yaml files. This code is only used for
+  # by the rake task `rake unitwise:update_standard` and as such is not
+  # normally loaded.
+  module Standard
+    HOST = "unitsofmeasure.org"
+    PATH = "/ucum-essence.xml"
+
+    class << self
+      def body
+        @body ||= Net::HTTP.get HOST, PATH
+      end
+
+      def hash
+        Nori.new.parse(body)["root"]
+      end
+    end
+  end
+end

data/lib/unitwise/standard/base.rb

@@ -0,0 +1,73 @@
+require 'unitwise/standard/extras'
+module Unitwise::Standard
+  class Base
+    include Unitwise::Standard::Extras
+
+    attr_accessor :attributes
+
+    def self.local_key
+      remote_key
+    end
+
+    def self.all
+      @all ||= read
+    end
+
+    def self.read
+      Unitwise::Standard.hash[remote_key].inject([]){|a,h| a << self.new(h)}
+    end
+
+    def self.hash
+      self.all.map(&:to_hash)
+    end
+
+    def self.path
+      Unitwise.data_file(local_key)
+    end
+
+    def self.write
+      File.open(path, 'w') do |f|
+        f.write hash.to_yaml
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def names
+      if attributes["name"].respond_to?(:map)
+        attributes["name"].map(&:to_s)
+      else
+        attributes["name"].to_s
+      end
+    end
+
+    def symbol
+      sym = attributes["printSymbol"]
+      if sym.is_a?(Hash)
+        hash_to_markup(sym)
+      elsif sym
+        sym.to_s
+      end
+    end
+
+    def primary_code
+      attributes["@Code"]
+    end
+
+    def secondary_code
+      attributes["@CODE"]
+    end
+
+    def to_hash
+      [:names, :symbol, :primary_code, :secondary_code].inject({}) do |h,a|
+        if v = self.send(a)
+          h[a] = v
+        end
+        h
+      end
+    end
+
+  end
+end

data/lib/unitwise/standard/base_unit.rb

@@ -0,0 +1,21 @@
+module Unitwise::Standard
+  class BaseUnit < Base
+
+    def self.remote_key
+      "base_unit"
+    end
+
+    def property
+      attributes["property"].to_s
+    end
+
+    def dim
+      attributes["@dim"]
+    end
+
+    def to_hash
+      super.merge :property => property, :dim => dim
+    end
+
+  end
+end

data/lib/unitwise/standard/derived_unit.rb

@@ -0,0 +1,49 @@
+module Unitwise::Standard
+  class DerivedUnit < Base
+
+    def self.remote_key
+      "unit"
+    end
+
+    def self.local_key
+      "derived_unit"
+    end
+
+    def property
+      attributes["property"].to_s
+    end
+
+    def scale
+      Scale.new(attributes["value"]) unless special?
+    end
+
+    def function
+      Function.new(attributes["value"]) if special?
+    end
+
+    def classification
+      attributes["@class"]
+    end
+
+    def metric?
+      attributes["@isMetric"] == 'yes'
+    end
+
+    def special?
+      attributes["@isSpecial"] == 'yes'
+    end
+
+    def arbitrary?
+      attributes["@isArbitrary"] == 'yes'
+    end
+
+    def to_hash
+      hash = super()
+      hash[:scale] = (special? ? function.to_hash : scale.to_hash)
+      hash.merge({:classification => classification,
+                  :property => property, :metric => metric?,
+                  :special => special?, :arbitrary => arbitrary?})
+    end
+
+  end
+end

data/lib/unitwise/standard/extras.rb

@@ -0,0 +1,17 @@
+module Unitwise::Standard
+  module Extras
+    def hash_to_markup(hash)
+      hash.map do |k,v|
+        if v.respond_to?(:to_xml)
+          "<#{k}>#{v.to_xml}</#{k}>"
+        elsif v.respond_to?(:map)
+          v.map do |i|
+            "<#{k}>#{i}</#{k}>"
+          end.join('')
+        else
+          "<#{k}>#{v}</#{k}>"
+        end
+      end.join('')
+    end
+  end
+end

data/lib/unitwise/standard/function.rb

@@ -0,0 +1,35 @@
+module Unitwise::Standard
+  class Function
+
+    attr_accessor :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def name
+      attributes["function"]["@name"]
+    end
+
+    def value
+      attributes["function"]["@value"].to_f
+    end
+
+    def unit
+      attributes["function"]["@Unit"]
+    end
+
+    def primary
+      attributes["@Unit"].gsub(/\(.*\)/, '')
+    end
+
+    def secondary
+      attributes["@UNIT"]
+    end
+
+    def to_hash
+      {:function_code => primary, :value => value, :unit_code => unit}
+    end
+
+  end
+end

data/lib/unitwise/standard/prefix.rb

@@ -0,0 +1,17 @@
+module Unitwise::Standard
+  class Prefix < Base
+
+    def self.remote_key
+      "prefix"
+    end
+
+    def scale
+      attributes["value"].attributes["value"]
+    end
+
+    def to_hash
+      super().merge(:scalar => scale)
+    end
+
+  end
+end