alchemist 0.1.5 → 0.1.6

data/lib/alchemist/data/binary_prefixes.yml

@@ -0,0 +1,33 @@
+---
+:yotta: 1.2089258196146292e+24
+:Y: 1.2089258196146292e+24
+:zetta: 1.1805916207174113e+21
+:Z: 1.1805916207174113e+21
+:exa: 1.152921504606847e+18
+:E: 1.152921504606847e+18
+:peta: 1.125899906842624e+15
+:P: 1.125899906842624e+15
+:tera: 1099511627776.0
+:T: 1099511627776.0
+:giga: 1073741824.0
+:G: 1073741824.0
+:mega: 1048576.0
+:M: 1048576.0
+:kilo: 1024.0
+:k: 1024.0
+:kibi: 1024.0
+:Ki: 1024.0
+:mebi: 1048576.0
+:Mi: 1048576.0
+:gibi: 1073741824.0
+:Gi: 1073741824.0
+:tebi: 1099511627776.0
+:Ti: 1099511627776.0
+:pebi: 1.125899906842624e+15
+:Pi: 1.125899906842624e+15
+:exbi: 1.152921504606847e+18
+:Ei: 1.152921504606847e+18
+:zebi: 1.1805916207174113e+21
+:Zi: 1.1805916207174113e+21
+:yobi: 1.2089258196146292e+24
+:Yi: 1.2089258196146292e+24

data/lib/alchemist/data/si_units.yml

@@ -0,0 +1,76 @@
+---
+- m
+- meter
+- metre
+- meters
+- metres
+- liter
+- litre
+- litres
+- liters
+- l
+- L
+- farad
+- farads
+- F
+- coulombs
+- C
+- gray
+- grays
+- Gy
+- siemen
+- siemens
+- S
+- mhos
+- mho
+- ohm
+- ohms
+- volt
+- volts
+- V
+- joule
+- joules
+- J
+- newton
+- newtons
+- N
+- lux
+- lx
+- henry
+- henrys
+- H
+- b
+- B
+- bits
+- bytes
+- bit
+- byte
+- lumen
+- lumens
+- lm
+- candela
+- candelas
+- cd
+- tesla
+- teslas
+- T
+- gauss
+- Gs
+- G
+- gram
+- gramme
+- grams
+- grammes
+- g
+- watt
+- watts
+- W
+- pascal
+- pascals
+- Pa
+- becquerel
+- becquerels
+- Bq
+- curie
+- curies
+- Ci

data/lib/alchemist/data/unit_prefixes.yml

@@ -0,0 +1,58 @@
+---
+:googol: 1.0e+100
+:yotta: 1.0e+24
+:Y: 1.0e+24
+:zetta: 1.0e+21
+:Z: 1.0e+21
+:exa: 1.0e+18
+:E: 1.0e+18
+:peta: 1.0e+15
+:P: 1.0e+15
+:tera: 1000000000000.0
+:T: 1000000000000.0
+:giga: 1000000000.0
+:G: 1000000000.0
+:mega: 1000000.0
+:M: 1000000.0
+:kilo: 1000.0
+:k: 1000.0
+:hecto: 100.0
+:h: 100.0
+:deca: 10
+:da: 10
+:deci: 0.1
+:d: 0.1
+:centi: 0.01
+:c: 0.01
+:milli: 0.001
+:m: 0.001
+:micro: 1.0e-06
+:u: 1.0e-06
+:nano: 1.0e-09
+:n: 1.0e-09
+:pico: 1.0e-12
+:p: 1.0e-12
+:femto: 1.0e-15
+:f: 1.0e-15
+:atto: 1.0e-18
+:a: 1.0e-18
+:zepto: 1.0e-21
+:z: 1.0e-21
+:yocto: 1.0e-24
+:y: 1.0e-24
+:kibi: 1024.0
+:Ki: 1024.0
+:mebi: 1048576.0
+:Mi: 1048576.0
+:gibi: 1073741824.0
+:Gi: 1073741824.0
+:tebi: 1099511627776.0
+:Ti: 1099511627776.0
+:pebi: 1.125899906842624e+15
+:Pi: 1.125899906842624e+15
+:exbi: 1.152921504606847e+18
+:Ei: 1.152921504606847e+18
+:zebi: 1.1805916207174113e+21
+:Zi: 1.1805916207174113e+21
+:yobi: 1.2089258196146292e+24
+:Yi: 1.2089258196146292e+24

data/lib/alchemist/geospatial.rb

@@ -0,0 +1,9 @@
+require 'alchemist'
+
+module Alchemist
+  class Measurement
+    def geospatial
+      Alchemist::Earth.new(self).geospatial
+    end
+  end
+end

data/lib/alchemist/measurement.rb

@@ -0,0 +1,128 @@
+require "alchemist/measurement_convertor"
+
+module Alchemist
+  class Measurement
+    include Comparable
+
+    attr_reader :unit_name, :exponent, :value
+
+    def initialize value, unit_name, exponent = 1.0
+      @value = value.to_f
+      @unit_name = unit_name
+      @exponent = exponent
+    end
+
+    def per
+      CompoundMeasurement.new self
+    end
+
+    def to type = nil
+      if type
+        convertor.send(type)
+      else
+        convertor
+      end
+    end
+
+    def + measurement
+      ensure_shared_type!(measurement)
+      converted = measurement.to(unit_name)
+      Measurement.new(value + converted.value, unit_name, exponent)
+    end
+
+    def - measurement
+      ensure_shared_type!(measurement)
+      converted = measurement.to(unit_name)
+      Measurement.new(value - converted.value, unit_name, exponent)
+    end
+
+    def / measurement
+      ensure_shared_type!(measurement)
+      dividend = measurement.is_a?(Measurement) ? measurement.to(unit_name).to_f / exponent : measurement
+      Measurement.new(value / dividend, unit_name, exponent).value
+    end
+
+    def * multiplicand
+      if multiplicand.is_a?(Numeric)
+        Measurement.new(value * multiplicand, unit_name, exponent)
+      else
+        try_raising_dimension(multiplicand)
+      end
+    end
+
+    def base unit_type
+      conversion_base = conversion_base_for(unit_type)
+      convert_to_base conversion_base
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def to_i
+      value.to_i
+    end
+
+    def to_f
+      @value
+    end
+
+    def <=>(other)
+      (self.to_f * exponent).to_f <=> other.to(unit_name).to_f
+    end
+
+    def types
+      Alchemist.measurement_for(unit_name)
+    end
+
+    def shared_types other_unit_name
+      types & Alchemist.measurement_for(other_unit_name)
+    end
+
+    def coerce(number)
+      [self, number]
+    end
+
+    private
+
+    def ensure_shared_type! measurement
+      if !has_shared_types?(measurement.unit_name)
+        incompatible_types
+      end
+    end
+
+    def convert_to_base conversion_base
+      if conversion_base.is_a?(Array)
+        exponent * conversion_base.first.call(value)
+      else
+        exponent * value * conversion_base
+      end
+    end
+
+    def conversion_base_for unit_type
+      Alchemist.conversion_table[unit_type][unit_name]
+    end
+
+    def has_shared_types? other_unit_name
+      shared_types(other_unit_name).length > 0
+    end
+
+    def try_raising_dimension(measurement)
+      valid_types = shared_types(measurement.unit_name)
+      Alchemist.operator_actions[:*].each do |s1, s2, new_type|
+        if (valid_types & [s1, s2]).any?
+          return Alchemist.measure(value * measurement.to_f, new_type)
+        end
+      end
+      incompatible_types
+    end
+
+    def incompatible_types
+      raise Exception, "Incompatible Types"
+    end
+
+    def convertor
+      MeasurementConvertor.new(self)
+    end
+  end
+end

data/lib/alchemist/measurement_convertor.rb

@@ -0,0 +1,35 @@
+require 'bigdecimal'
+
+module Alchemist
+  class MeasurementConvertor
+    def initialize from
+      @from = from
+    end
+
+    def method_missing method, *args, &block
+      exponent, unit_name = Alchemist.parse_prefix(method)
+      convert(from.shared_types(unit_name), unit_name, exponent)
+    end
+
+    private
+    attr_reader :from
+
+    def convert types, unit_name, exponent
+      if type = types[0]
+        conversion_base = BigDecimal.new(from.base(type).to_s)
+        conversion_factor = Alchemist.conversion_table[type][unit_name]
+        if proc_based?(conversion_factor)
+          Measurement.new(conversion_factor[1].call(conversion_base), unit_name, exponent)
+        else
+          Measurement.new(conversion_base / BigDecimal.new(conversion_factor.to_s), unit_name, exponent)
+        end
+      else
+        raise Exception, "Incompatible Types"
+      end
+    end
+
+    def proc_based? conversion_factor
+      conversion_factor.is_a? Array
+    end
+  end
+end

data/lib/alchemist/module_builder.rb

@@ -0,0 +1,41 @@
+module Alchemist
+  class ModuleBuilder
+    def initialize category
+      @category = category
+    end
+
+    def build
+      Module.new.tap do |category_module|
+        category_module.class_eval %(def self.inspect() "#<Module(#{category})>" end)
+        category_module.class_eval category_methods
+      end
+    end
+
+    private
+    attr_reader :category
+
+    def category_methods
+      unit_names.map do |name|
+        %(define_method("#{name}") { Alchemist.measure self, :#{name} }) + "\n" + prefixed_methods(name)
+      end.join("\n")
+    end
+
+    def unit_names
+      Alchemist.conversion_table[category.to_sym].map { |values| values[0] }
+    end
+
+    def prefixes_with_value(name)
+      if Alchemist.si_units.include?(name.to_s)
+        Alchemist.unit_prefixes
+      else
+        []
+      end
+    end
+
+    def prefixed_methods(name)
+      prefixes_with_value(name).map do |prefix, value|
+        %(define_method("#{prefix}#{name}") { Alchemist.measure self, :#{name}, #{value} })
+      end.join("\n")
+    end
+  end
+end

data/lib/alchemist/objects/planets/earth.rb

@@ -0,0 +1,34 @@
+module Alchemist
+  class Earth
+    RADIUS = Alchemist.measure(6378100, :meters)
+
+    def initialize measurement
+      @measurement = measurement
+    end
+
+    def geospatial
+      if types.include?(:angles)
+        geospatial_angle_to_arc
+      elsif types.include?(:distance)
+        geospatial_arc_to_angle
+      else
+        raise Exception, "geospatial must either be angles or distance"
+      end
+    end
+
+    private
+    attr_reader :measurement, :base
+
+    def types
+      measurement.types
+    end
+
+    def geospatial_angle_to_arc
+      measurement.to(:radians).to_f * RADIUS
+    end
+
+    def geospatial_arc_to_angle
+      Alchemist.measure(measurement.to(:meters) / RADIUS, :radians)
+    end
+  end
+end

data/lib/alchemist/version.rb

@@ -1,3 +1,3 @@
 module Alchemist
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/spec/alchemist_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Alchemist do
+
+  it "sets up Numeric" do
+    category_module = double()
+    module_builder = double()
+    module_builder.should_receive(:build).and_return(category_module)
+    fake_module = double()
+    fake_module.should_receive(:include).with(category_module)
+    Alchemist::ModuleBuilder.should_receive(:new).with('distance').and_return(module_builder)
+    stub_const("Numeric", fake_module)
+    Alchemist.setup('distance')
+  end
+
+  it "creates a measurement" do
+    unit = Alchemist.measure(1, :meter)
+    expect(unit).to eq(1.meter)
+  end
+
+  it "knows if it has a measurement" do
+    expect(Alchemist.has_measurement?(:meter)).to be_true
+  end
+
+  it "knows if it doesn't have a measurement" do
+    expect(Alchemist.has_measurement?(:wombat)).to be_false
+  end
+
+  it "can register units" do
+    Alchemist.register :quux, :qaat, 1.0
+    Alchemist.register :quux, :quut, 3.0
+    expect(Alchemist.conversion_table[:quux]).to eq({:qaat=>1.0, :quut=>3.0})
+  end
+
+  it "can register units with plural names" do
+    Alchemist.register(:beards, [:beard_second, :beard_seconds], 1.0)
+    expect(Alchemist.conversion_table[:beards]).to eq({:beard_second=>1.0, :beard_seconds=>1.0})
+  end
+
+  it "can register units with formulas" do
+    to = lambda { |t| t + 1 }
+    from = lambda { |t| t - 1 }
+    Alchemist.register(:yetis, :yeti, [to, from])
+    expect(Alchemist.conversion_table[:yetis]).to eq({:yeti => [to, from]})
+  end
+
+  it "can parse a prefix" do
+    parsed = Alchemist.parse_prefix(:kilometer)
+    expect(parsed).to eq([1000.0, :meter])
+  end
+end