unitwise 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efe1918460c38d338cba7dda0e8f267d344df801
-  data.tar.gz: 545fe050c3ed7f2f09ed5b58d013d4a2176ce280
+  metadata.gz: a0843dbdae33b496f257324dc0006e71ac292c7a
+  data.tar.gz: 808f425fccb8a1f757194feecd9de18b91eb03a7
 SHA512:
-  metadata.gz: ba9651ddcf3dad823abdfaf1a24e7860a3917b13c026f993523bc939da4abbe76e0da4669be68deb56eccc7743cac44fcbc6db4bc86a413594298cff746c08ed
-  data.tar.gz: 06b6747e60076e5b9629aefe2632cd6095122d14337cd583869171be32ca8157f4d416e56392857e10ebe84bc0a445c02f4efd4bd4cce22ca188ecb1288dcdb1
+  metadata.gz: d60cd4a403b09294175f3e0df799a73c14d0c389ebf3141a04dec4de02e0dd5bcbdea8bb99ebb2740ad4f8c86d27534d65b6462c49651670f23561fa7b8013df
+  data.tar.gz: 1ebdb94e5df860af1807b8158f038351be2bc161c713fa186db914a306b5ccc3d08569b0ee293bfb450d9a2b6e128246b694659fd2f88acd685e8f7ffb9fa8d8

data/README.md

@@ -204,6 +204,46 @@ You can also get the official list from the UCUM website in XML format at
 or a YAML version within this repo
 [github.com/joshwlewis/unitwise/tree/master/data](//github.com/joshwlewis/unitwise/tree/master/data).
 
+### UCUM designations
+UCUM defines several designations for it's units: `names`,
+`primary_code`, `secondary_code`, and `symbol`. You can see them all when
+inspecting an atom:
+
+```ruby
+Unitwise::Atom.all.sample
+# => #<Unitwise::Atom names=["British thermal unit"], primary_code="[Btu]", secondary_code="[BTU]", symbol="btu", scale=#<Unitwise::Scale value=1 unit=[Btu_th]>, classification="heat", property="energy", metric=false, special=false, arbitrary=false, dim="L2.M.T-2">
+```
+
+When initializing a measurement, you can use any of the designations:
+
+```ruby
+Unitwise(1, '[Btu]') == Unitwise(1, 'British thermal unit')
+# => true
+Unitwise(1, 'btu') == Unitwise(1, "[BTU]")
+# => true
+```
+
+When inspecting or printing (`to_s`) that measurement, it will remember the
+desigation you used. However, if you want to print it with another designation,
+that's also possible:
+
+```ruby
+temperature_change = Unitwise(10, "Cel/h")
+temperature_change.to_s # => "10 Cel/h"
+temperature_change.to_s(:names) # => "10 degree Celsius/hour"
+temperature_change.to_s(:symbol) # => "10 °C/h"
+```
+
+There is on caveat here. You must use the same designation for each atom in a
+complex unit. Meaning you can't mix designations within a unit.
+
+```ruby
+Unitwise(1, "m/s")          # Works, both atoms use their primary_code
+Unitwise(1, "meter/second") # Works, both atoms use a name
+Unitwise(1, "meter/s")      # Does not work, mixed designations (name and primary_code)
+Unitwise(1, "meter") / Unitwise(1, "s") # Also works
+```
+
 ## Supported Ruby Versions
 
 This library aims to support and is tested against the following Ruby

data/lib/unitwise/base.rb

@@ -47,10 +47,12 @@ module Unitwise
     memoize :slugs
 
     # String representation for the instance.
+    # @param mode [symbol] The attribute to for stringification
     # @return [String]
     # @api public
-    def to_s
-      primary_code
+    def to_s(mode = :primary_code)
+      res = self.send(mode)
+      res.respond_to?(:each) ? res.first.to_s : res.to_s
     end
   end
 end

data/lib/unitwise/expression.rb

@@ -15,8 +15,8 @@ module Unitwise
       # @example
       #   Unitwise::Expression.compose(terms) # => "m2/s2"
       # @api public
-      def compose(terms)
-        Composer.new(terms).expression
+      def compose(terms, method=:primary_code)
+        Composer.new(terms, method).expression
       end
 
       # Convert a string representation of a unit, and turn it into a

data/lib/unitwise/expression/composer.rb

@@ -1,14 +1,18 @@
 module Unitwise
   module Expression
     class Composer
-      attr_reader :terms
-      def initialize(terms)
-        @terms = terms
+      attr_reader :terms, :mode
+      def initialize(terms, mode)
+        @terms  = terms
+        @mode = mode || :primary_code
       end
 
       def set
         @set ||= terms.reduce(SignedMultiset.new) do |s, t|
-          s.increment({:f => t.factor, :p => t.prefix, :a => t.atom}, t.exponent); s
+          identifier = { :f => t.factor,
+                         :p => (t.prefix.to_s(mode) if t.prefix),
+                         :a => (t.atom.to_s(mode) if t.atom) }
+          s.increment(identifier, t.exponent); s
         end
       end
 

data/lib/unitwise/expression/decomposer.rb

@@ -2,39 +2,40 @@ module Unitwise
   module Expression
     class Decomposer
 
-      METHODS = [:primary_code, :secondary_code, :names, :slugs, :symbol]
+      MODES = [:primary_code, :secondary_code, :names, :slugs, :symbol]
 
-      PARSERS = METHODS.reduce({}) do |hash, method|
-        hash[method] = Parser.new(method); hash
+      PARSERS = MODES.reduce({}) do |hash, mode|
+        hash[mode] = Parser.new(mode); hash
       end
 
       TRANSFORMER = Transformer.new
 
-      attr_reader :expression
+      attr_reader :expression, :mode
 
       def initialize(expression)
         @expression = expression.to_s
         if terms.nil? || terms.empty?
-          raise ExpressionError, "Could not evaluate '#{@expression}'."
+          fail ExpressionError, "Could not evaluate '#{@expression}'."
         end
       end
 
-      def transform
-        PARSERS.reduce(nil) do |foo, (method, parser)|
-          if parsed = parser.parse(expression) rescue next
-            return TRANSFORMER.apply(parsed, :key => method)
-          end
+      def parse
+        @parse ||= PARSERS.reduce(nil) do |null,(mode, parser)|
+          parsed = parser.parse(expression) rescue next
+          @mode = mode
+          break parsed
         end
       end
 
+      def transform
+        @transform ||= TRANSFORMER.apply(parse, :mode => mode)
+      end
+
       def terms
-        @terms ||= begin
-          transformation = transform
-          if transformation.respond_to?(:terms)
-            transformation.terms
-          else
-            Array(transformation)
-          end
+        @terms ||= if transform.respond_to?(:terms)
+          transform.terms
+        else
+          Array(transform)
         end
       end
 

data/lib/unitwise/expression/matcher.rb

@@ -2,28 +2,28 @@ module Unitwise
   module Expression
     class Matcher
       class << self
-        def atom(method)
-          new(Atom.all, method).alternative
+        def atom(mode)
+          new(Atom.all, mode).alternative
         end
 
-        def metric_atom(method)
-          new(Atom.all.select(&:metric?), method).alternative
+        def metric_atom(mode)
+          new(Atom.all.select(&:metric?), mode).alternative
         end
 
-        def prefix(method)
-          new(Prefix.all, method).alternative
+        def prefix(mode)
+          new(Prefix.all, mode).alternative
         end
       end
 
-      attr_reader :collection, :method
+      attr_reader :collection, :mode
 
-      def initialize(collection, method=:primary_code)
+      def initialize(collection, mode=:primary_code)
         @collection = collection
-        @method = method
+        @mode = mode
       end
 
       def strings
-        @stings ||= collection.map(&method).flatten.compact.sort do |x,y|
+        @stings ||= collection.map(&mode).flatten.compact.sort do |x,y|
           y.length <=> x.length
         end
       end

data/lib/unitwise/expression/transformer.rb

@@ -5,8 +5,8 @@ module Unitwise
       rule(:integer => simple(:i)) { i.to_i }
       rule(:fixnum => simple(:f)) { f.to_f }
 
-      rule(:prefix_code => simple(:c)) { |ctx| Prefix.find(ctx[:c], ctx[:key]) }
-      rule(:atom_code => simple(:c))   { |ctx| Atom.find(ctx[:c], ctx[:key]) }
+      rule(:prefix_code => simple(:c)) { |ctx| Prefix.find(ctx[:c], ctx[:mode]) }
+      rule(:atom_code => simple(:c))   { |ctx| Atom.find(ctx[:c], ctx[:mode]) }
       rule(:term => subtree(:h))       { Term.new(h) }
 
       rule(:operator => simple(:o), :right => simple(:r)) do

data/lib/unitwise/measurement.rb

@@ -1,7 +1,7 @@
 module Unitwise
   # A Measurement is a combination of a numeric value and a unit. You can think
   # of this as a type of vector where the direction is the unit designation and
-  # the value is the magnitued. This is the primary class that outside code
+  # the value is the magnitude. This is the primary class that outside code
   # will interact with. Comes with conversion, comparison, and math methods.
   class Measurement < Scale
     # Create a new Measurement
@@ -13,7 +13,7 @@ module Unitwise
     # @api public
     def initialize(*args)
       super(*args)
-      fail ExpressionError, "Could not evaluate `#{unit}`." if terms.nil?
+      terms
     end
 
     # Convert this measurement to a compatible unit.

data/lib/unitwise/scale.rb

@@ -100,8 +100,8 @@ module Unitwise
 
     # Convert to a simple string representing the scale.
     # @api public
-    def to_s
-      "#{simplified_value} #{unit}"
+    def to_s(mode = nil)
+      "#{simplified_value} #{unit.to_s(mode)}"
     end
 
     def inspect

data/lib/unitwise/term.rb

@@ -122,13 +122,10 @@ module Unitwise
       end
     end
 
-    # String representation for this term.
-    # @return [String]
-    def to_s
-      [(factor if factor != 1), prefix.to_s,
-        atom.to_s, (exponent if exponent != 1)].compact.join('')
+    def to_s(mode = :primary_code)
+      [(factor if factor != 1), (prefix.send(mode) if prefix),
+        (atom.send(mode) if atom), (exponent if exponent != 1)].compact.join('')
     end
-    memoize :to_s
 
     private
 

data/lib/unitwise/unit.rb

@@ -17,13 +17,23 @@ module Unitwise
         @expression = input.to_s
       else
         @terms = input
-        @expression = Expression.compose(input)
       end
-      freeze
     end
 
     def terms
-      @terms || Expression.decompose(expression)
+      unless frozen?
+        unless @terms
+          decomposer = Expression::Decomposer.new(@expression)
+          @mode  = decomposer.mode
+          @terms = decomposer.terms
+        end
+        freeze
+      end
+      @terms
+    end
+
+    def expression(mode = mode)
+      Expression.compose(terms, mode)
     end
 
     def atoms
@@ -88,8 +98,14 @@ module Unitwise
       end
     end
 
-    def to_s
-      expression
+    def to_s(mode = mode)
+      expression(mode || self.mode)
     end
+
+    def mode
+      terms
+      @mode || :primary_code
+    end
+
   end
 end

data/lib/unitwise/version.rb

@@ -1,3 +1,3 @@
 module Unitwise
-  VERSION = '0.8.1'
+  VERSION = '0.9.0'
 end

data/test/support/scale_tests.rb

@@ -106,6 +106,7 @@ module ScaleTests
           end
         end
       end
+
     end
   end
 end

data/test/unitwise/measurement_test.rb

@@ -201,4 +201,18 @@ describe Unitwise::Measurement do
     end
   end
 
+  describe "#to_s" do
+    it "should include the simplified value and use the mode it was created with" do
+      foot = described_class.new(7.00, "foot")
+      foot.to_s.must_equal "7 foot"
+      meter = described_class.new(Rational(22,7), "m")
+      meter.to_s.must_equal "3.142857142857143 m"
+    end
+    it "should accept a mode and print that mode string" do
+      temp = described_class.new(25, "degree Celsius")
+      temp.to_s(:primary_code).must_equal("25 Cel")
+      temp.to_s(:symbol).must_equal("25 °C")
+    end
+  end
+
 end

data/test/unitwise/unit_test.rb

@@ -65,8 +65,22 @@ describe Unitwise::Unit do
 
   describe "#frozen?" do
     it "should be frozen" do
+      kg.to_s
       kg.frozen?.must_equal true
     end
   end
 
+  describe "#to_s" do
+    it "should return an expression in the same mode it was initialized with" do
+      ['meter','m', 'mm', '%'].each do |name|
+        Unitwise::Unit.new(name).to_s.must_equal(name)
+      end
+    end
+    it "should accept an optional mode to build the expression with" do
+      temp_change = Unitwise::Unit.new("degree Celsius/hour")
+      temp_change.to_s(:primary_code).must_equal("Cel/h")
+      temp_change.to_s(:symbol).must_equal("°C/h")
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unitwise
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Josh Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liner