unitwise 0.1.0

data/lib/unitwise/expression/parser.rb

@@ -0,0 +1,53 @@
+module Unitwise
+  module Expression
+    class Parser < Parslet::Parser
+      attr_reader :key
+      def initialize(key=:primary_code)
+        @key = key
+      end
+
+      root :expression
+
+      rule (:atom) { Matcher.atom(key).as(:atom_code) }
+      rule (:metric_atom) { Matcher.metric_atom(key).as(:atom_code) }
+      rule (:prefix) { Matcher.prefix(key).as(:prefix_code) }
+
+      rule (:simpleton) do
+        (prefix.as(:prefix) >> metric_atom.as(:atom) | atom.as(:atom))
+      end
+
+      rule (:annotation) do
+        str('{') >> match['^}'].repeat.as(:annotation) >> str('}')
+      end
+
+      rule (:digits) { match['0-9'].repeat(1) }
+
+      rule (:integer) { (str('-').maybe >> digits).as(:integer) }
+
+      rule (:fixnum) do
+        (str('-').maybe >> digits >> str('.') >> digits).as(:fixnum)
+      end
+
+      rule (:number) { fixnum | integer }
+
+      rule (:exponent) { number.as(:exponent) }
+
+      rule (:factor) { number.as(:factor) }
+
+      rule (:operator) { (str('.') | str('/')).as(:operator) }
+
+      rule (:term) do
+        ((simpleton | factor) >> exponent.maybe >> annotation.maybe).as(:term)
+      end
+
+      rule (:group) do
+        (str('(') >> expression.as(:nested) >> str(')') >> exponent.maybe).as(:group)
+      end
+
+      rule (:expression) do
+        (group | term).as(:left) >> (operator >> expression.as(:right)).maybe
+      end
+
+    end
+  end
+end

data/lib/unitwise/expression/transformer.rb

@@ -0,0 +1,22 @@
+module Unitwise
+  module Expression
+    class Transformer < Parslet::Transform
+      rule(integer: simple(:i)) { i.to_i }
+      rule(fixnum: simple(:f)) { f.to_f }
+
+      rule(prefix_code: simple(:c)) { Prefix.find(c) }
+      rule(atom_code: simple(:c)) { Atom.find(c) }
+      rule(term: subtree(:h)) { Term.new(h) }
+
+      rule(left: simple(:l), operator: simple(:o), right: simple(:r)) do
+        o == '/' ? l / r : l * r
+      end
+
+      rule(left: simple(:l)) { l }
+
+      rule(group: { nested: simple(:n) , exponent: simple(:e)}) { n ** e }
+
+      rule(group: { nested: simple(:n) }) { n }
+    end
+  end
+end

data/lib/unitwise/ext.rb

@@ -0,0 +1,2 @@
+require 'unitwise/ext/numeric'
+require 'unitwise/ext/string'

data/lib/unitwise/ext/numeric.rb

@@ -0,0 +1,13 @@
+class Numeric
+  def convert(unit)
+    Unitwise::Measurement.new(self, unit)
+  end
+
+  def method_missing(meth, *args, &block)
+    if Unitwise::Expression.decompose(meth)
+      self.convert(meth)
+    else
+      super(meth, *args, &block)
+    end
+  end
+end

data/lib/unitwise/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_slug
+    self.downcase.strip.gsub(/\s/, '_').gsub(/\W/, '')
+  end
+end

data/lib/unitwise/function.rb

@@ -0,0 +1,51 @@
+module Unitwise
+  class Function
+    include Math
+    class << self
+      def all
+        @all ||= defaults
+      end
+
+      def defaults
+        [ ["cel",   ->(x){ x - 273.15},           ->(x){ x + 273.15}          ],
+          ["degf",  ->(x){9.0 * x / 5.0 - 459.67},->(x){ 5.0/9 * (x + 459.67)}],
+          ["hpX",   ->(x){ -log10(x) },           ->(x){ 10 ** -x }           ],
+          ["hpC",   ->(x){ -log(x) / log(100) },  ->(x){ 100 ** -x }          ],
+          ["tan100",->(x){ 100 * tan(x) },        ->(x){ atan(x / 100) }      ],
+          ["ph",    ->(x){ -log10(x) },           ->(x){ 10 ** -x }           ],
+          ["ld",    ->(x){ log2(x) },             ->(x){ 2 ** -x }            ],
+          ["ln",    ->(x){ log(x) },              ->(x){ Math::E ** x }       ],
+          ["lg",    ->(x){ log10(x) },            ->(x){ 10 ** x }            ],
+          ["2lg",   ->(x){ 2 * log10(x) },         ->(x){ (10 ** x) / 2 }     ]
+        ].map {|args| new(*args) }
+      end
+
+      def add(*args)
+        new_instance = self.new(*args)
+        all << new_instance
+        new_instance
+      end
+
+      def find(name)
+        all.find{|fp| fp.name == name}
+      end
+    end
+
+    attr_reader :name, :direct, :inverse
+
+    def initialize(name, direct, inverse)
+      @name = name
+      @direct = direct
+      @inverse = inverse
+    end
+
+    def functional(x, direction=1)
+      if direction == 1
+        direct.call(x)
+      elsif direction == -1
+        inverse.call(x)
+      end
+    end
+
+  end
+end

data/lib/unitwise/functional.rb

@@ -0,0 +1,21 @@
+module Unitwise
+  class Functional < Scale
+
+    attr_reader :function
+
+    def initialize(value, unit, function_name)
+      super(value, unit)
+      @function = Function.find(function_name)
+    end
+
+    def scalar
+      puts "Warning: Mathematical operations with special units should be used with caution."
+      super()
+    end
+
+    def functional(x, direction=1)
+      function.functional(x, direction)
+    end
+
+  end
+end

data/lib/unitwise/measurement.rb

@@ -0,0 +1,89 @@
+module Unitwise
+  class Measurement < Scale
+
+    def convert(other_unit)
+      other_unit = Unit.new(other_unit)
+      if similar_to?(other_unit)
+        new(converted_value(other_unit), other_unit)
+      else
+        raise ConversionError, "Can't convert #{inspect} to #{other_unit}."
+      end
+    end
+
+    def *(other)
+      operate(:*, other) || raise(TypeError, "Can't multiply #{inspect} by #{other}.")
+    end
+
+    def /(other)
+      operate(:/, other) || raise(TypeError, "Can't divide #{inspect} by #{other}")
+    end
+
+    def +(other)
+      combine(:+, other) || raise(TypeError, "Can't add #{other} to #{inspect}.")
+    end
+
+    def -(other)
+      combine(:-, other) || raise(TypeError, "Can't subtract #{other} from #{inspect}.")
+    end
+
+    def **(number)
+      if number.is_a?(Numeric)
+        new( value ** number, unit ** number )
+      else
+        raise TypeError, "Can't raise #{inspect} to #{number} power."
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if Unitwise::Expression.decompose(meth)
+        self.convert(meth)
+      else
+        super(meth, *args, &block)
+      end
+    end
+
+    private
+
+    def new(*args)
+      self.class.new(*args)
+    end
+
+    def converted_value(other_unit)
+      if unit.special?
+        if other_unit.special?
+          other_unit.functional functional(value, -1)
+        else
+          functional(value, -1)
+        end
+      else
+        if other_unit.special?
+          other_unit.functional(value)
+        else
+          scalar / other_unit.scalar
+        end
+      end
+    end
+
+    # add or subtract other unit
+    def combine(operator, other)
+      if similar_to?(other)
+        new(value.send(operator, other.convert(unit).value), unit)
+      end
+    end
+
+    # multiply or divide other unit
+    def operate(operator, other)
+      if other.is_a?(Numeric)
+        new(value.send(operator, other), unit)
+      elsif other.respond_to?(:composition)
+        if similar_to?(other)
+          converted = other.convert(unit)
+          new(value.send(operator, converted.value), unit.send(operator, converted.unit))
+        else
+          new(value.send(operator, other.value), unit.send(operator, other.unit))
+        end
+      end
+    end
+
+  end
+end

data/lib/unitwise/prefix.rb

@@ -0,0 +1,17 @@
+module Unitwise
+  class Prefix < Base
+    attr_reader :scalar
+
+    def self.data
+      @data ||= YAML::load File.open(data_file)
+    end
+
+    def self.data_file
+      Unitwise.data_file 'prefix'
+    end
+
+    def scalar=(value)
+      @scalar = value.to_f
+    end
+  end
+end

data/lib/unitwise/scale.rb

@@ -0,0 +1,61 @@
+module Unitwise
+  class Scale
+    attr_reader :value
+
+    include Unitwise::Composable
+
+    def initialize(value, unit)
+      @value = value
+      if unit.is_a?(Unit)
+        @unit = unit.dup
+      else
+        @unit = Unit.new(unit.to_s)
+      end
+    end
+
+    def dup
+      self.class.new(value, unit)
+    end
+
+    def atoms
+      unit.atoms
+    end
+
+    def special?
+      unit.special?
+    end
+
+    def functional(value, direction=1)
+      unit.functional(value, direction)
+    end
+
+    def scalar
+      value * unit.scalar
+    end
+
+    def unit
+      @unit ||= Unit.new(@unit_code)
+    end
+
+    def root_terms
+      unit.root_terms
+    end
+
+    def depth
+      unit.depth + 1
+    end
+
+    def terminal?
+      depth <= 3
+    end
+
+    def to_s
+      "#{value} #{unit}"
+    end
+
+    def inspect
+      "<#{self.class} #{to_s}>"
+    end
+
+  end
+end

data/lib/unitwise/standard.rb

@@ -0,0 +1,26 @@
+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
+  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