unitwise 0.1.0

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

data/lib/unitwise/standard/scale.rb

@@ -0,0 +1,25 @@
+module Unitwise::Standard
+  class Scale
+    attr_accessor :nori
+
+    def initialize(nori)
+      @nori = nori
+    end
+
+    def value
+      nori.attributes["value"].to_f
+    end
+
+    def primary_unit_code
+      nori.attributes["Unit"]
+    end
+
+    def secondary_unit_code
+      nori.attributes["UNIT"]
+    end
+
+    def to_hash
+      {value: value, unit_code: primary_unit_code}
+    end
+  end
+end

data/lib/unitwise/term.rb

@@ -0,0 +1,106 @@
+require 'signed_multiset'
+module Unitwise
+  class Term
+    attr_writer :atom_code, :prefix_code, :atom, :prefix
+    attr_writer :factor, :exponent
+    attr_accessor :annotation
+
+    include Unitwise::Composable
+
+    def initialize(attributes)
+      attributes.each do |k,v|
+        public_send :"#{k}=", v
+      end
+    end
+
+    def prefix_code
+      @prefix_code ||= (@prefix.primary_code if @prefix)
+    end
+
+    def prefix
+      @prefix ||= (Prefix.find(@prefix_code) if @prefix_code)
+    end
+
+    def atom_code
+      @atom_code ||= (@atom.primary_code if @atom)
+    end
+
+    def atom
+      @atom ||= (Atom.find(@atom_code) if @atom_code)
+    end
+
+    def special?
+      atom.special rescue false
+    end
+
+    def depth
+      atom ? atom.depth + 1 : 0
+    end
+
+    def terminal?
+      depth <= 3
+    end
+
+    def factor
+      @factor ||= 1
+    end
+
+    def exponent
+      @exponent ||= 1
+    end
+
+    def scalar
+      (factor * (prefix ? prefix.scalar : 1) * (atom ? atom.scalar : 1)) ** exponent
+    end
+
+    def functional(value, direction=1)
+      (factor * (prefix ? prefix.scalar : 1)) * (atom ? atom.functional(value, direction) : 1) ** exponent
+    end
+
+    def root_terms
+      if terminal?
+        [self]
+      else
+        atom.scale.root_terms.map do |t|
+          self.class.new(atom: t.atom, exponent: t.exponent * exponent)
+        end
+      end
+    end
+
+    def to_hash
+      [:prefix, :atom, :exponent, :factor, :annotation].inject({}) do |h, a|
+        h[a] = send a; h
+      end
+    end
+
+    def *(other)
+      if other.respond_to?(:terms)
+        Unit.new(other.terms << self)
+      else
+        Unit.new([self, other])
+      end
+    end
+
+    def /(other)
+      if other.respond_to?(:terms)
+        Unit.new(other.terms.map{|t| t ** -1} << self)
+      else
+        Unit.new([self, other ** -1])
+      end
+    end
+
+    def **(integer)
+      self.class.new(to_hash.merge(exponent: exponent * integer))
+    end
+
+    def to_s
+      [(factor if factor != 1), prefix_code,
+        atom_code, (exponent if exponent != 1)].compact.join('')
+    end
+
+    def inspect
+      "<#{self.class} #{to_s}>"
+    end
+
+  end
+end

data/lib/unitwise/unit.rb

@@ -0,0 +1,89 @@
+module Unitwise
+  class Unit
+    include Unitwise::Composable
+    attr_writer :terms, :expression
+
+    def initialize(input)
+      if input.respond_to?(:expression)
+        @expression = input.expression
+      elsif input.respond_to?(:each)
+        @terms = input
+      else
+        @expression = input.to_s
+      end
+    end
+
+    def expression
+      @expression ||= (Expression.compose(@terms) if @terms)
+    end
+
+    def terms
+      @terms ||= (Expression.decompose(@expression) if @expression)
+    end
+
+    def atoms
+      terms.map(&:atom)
+    end
+
+    def special?
+      terms.count == 1 && terms.all?(&:special?)
+    end
+
+    def functional(value, direction=1)
+      terms.first.functional(value, direction)
+    end
+
+    def dup
+      self.class.new(expression)
+    end
+
+    def depth
+      terms.map(&:depth).max + 1
+    end
+
+    def terminal?
+      depth <= 3
+    end
+
+    def root_terms
+      terms.flat_map(&:root_terms)
+    end
+
+    def scalar
+      if terms.empty?
+        1
+      else
+        terms.map(&:scalar).inject(&:*)
+      end
+    end
+
+    def *(other)
+      if other.respond_to?(:terms)
+        self.class.new(terms + other.terms)
+      else
+        raise TypeError, "Can't multiply #{inspect} by #{other}."
+      end
+    end
+
+    def /(other)
+      if other.respond_to?(:terms)
+        self.class.new(terms + other.terms.map{ |t| t ** -1})
+      else
+        raise TypeError, "Can't divide #{inspect} by #{other}."
+      end
+    end
+
+    def **(number)
+      self.class.new(terms.map{ |t| t ** number })
+    end
+
+    def to_s
+      expression
+    end
+
+    def inspect
+      "<#{self.class} #{to_s}>"
+    end
+
+  end
+end

data/lib/unitwise/version.rb

@@ -0,0 +1,3 @@
+module Unitwise
+  VERSION = "0.1.0"
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'unitwise'

data/test/unitwise/atom_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+describe Unitwise::Atom do
+  subject { Unitwise::Atom }
+  describe "::data" do
+    it "must have data" do
+      subject.data.must_be_instance_of Array
+      subject.data.count.must_be :>, 0
+    end
+  end
+
+  describe "::all" do
+    it "must be an Array of instances" do
+      subject.all.must_be_instance_of Array
+      subject.all.first.must_be_instance_of Unitwise::Atom
+    end
+  end
+
+  describe "::find" do
+    it "must find atoms" do
+      subject.find("m").must_be_instance_of Unitwise::Atom
+      subject.find("V").must_be_instance_of Unitwise::Atom
+    end
+  end
+
+  let(:second) { Unitwise::Atom.find("s") }
+  let(:yard) { Unitwise::Atom.find("[yd_i]")}
+  let(:pi) { Unitwise::Atom.find("[pi]")}
+  let(:celsius) { Unitwise::Atom.find("Cel")}
+  let(:pfu) { Unitwise::Atom.find("[PFU]")}
+  describe "#scale" do
+    it "must be nil for base atoms" do
+      second.scale.must_equal nil
+    end
+    it "sould be a Scale object for derived atoms" do
+      yard.scale.must_be_instance_of Unitwise::Scale
+    end
+    it "must be a FunctionalScale object for special atoms" do
+      celsius.scale.must_be_instance_of Unitwise::Functional
+    end
+  end
+
+  describe "#base?" do
+    it "must be true for base atoms" do
+      second.base?.must_equal true
+    end
+    it "must be false for derived atoms" do
+      yard.base?.must_equal false
+      pi.base?.must_equal false
+    end
+  end
+
+  describe "#derived?" do
+    it "must be false for base atoms" do
+      second.derived?.must_equal false
+    end
+    it "must be true for derived atoms" do
+      yard.derived?.must_equal true
+      celsius.derived?.must_equal true
+    end
+  end
+
+  describe "#metric?" do
+    it "must be true for base atoms" do
+      second.metric?.must_equal true
+    end
+    it "must be false for english atoms" do
+      yard.metric?.must_equal false
+    end
+  end
+
+  describe "#special?" do
+    it "must be true for special atoms" do
+      celsius.special?.must_equal true
+    end
+    it "must be false for non-special atoms" do
+      second.special?.must_equal false
+    end
+  end
+
+  describe "#arbitrary?" do
+    it "must be true for arbitrary atoms" do
+      pfu.arbitrary?.must_equal true
+    end
+    it "must be false for non-arbitrary atoms" do
+      yard.arbitrary?.must_equal false
+      celsius.arbitrary?.must_equal false
+    end
+  end
+
+  describe "#terminal?" do
+    it "must be true for atoms without a valid measurement atom" do
+      second.terminal?.must_equal true
+      pi.terminal?.must_equal true
+    end
+    it "must be false for child atoms" do
+      yard.terminal?.must_equal false
+    end
+  end
+
+  describe "#scalar" do
+    it "must return scalar relative to terminal atom" do
+      second.scalar.must_equal 1
+      yard.scalar.must_equal 0.9144000000000001
+      pi.scalar.must_equal 3.141592653589793
+    end
+  end
+
+  describe "#key" do
+    it "must return the dim or the property" do
+      second.key.must_equal "T"
+      pi.key.must_equal "number"
+      celsius.key.must_equal "temperature"
+    end
+  end
+
+  describe "#measurement=" do
+    it "must create a new measurement object and set attributes" do
+      skip("need to figure out mocking and stubbing with minitest")
+    end
+  end
+end