alchemist 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09cdd7bc72d33ef49f70bfa21e7a6b98bc56ca35
-  data.tar.gz: 5930f598e0adec3f2a8b3e3e2030fd61b9c48234
+  metadata.gz: f47215664aef5b08025bbf14fcb971c7b3d8d726
+  data.tar.gz: 92dcc4243340af6f1e4cacfb9593f292a8fdf16c
 SHA512:
-  metadata.gz: 72133a2fa6b707b2e52e6cb5354506d364b176aaab25383b9db8f341be847fa2622a89e888fc3adeb8021f2e347b210961a2fca687d4278a5807da5d41827bc0
-  data.tar.gz: b6ded515a9ebd212ace47ba64a91a9f44619f757457f27a8ae384edf380b327312e5223c444122ae5e3a2552c9d1330964c99e115f88c2e66ac6315f31fc8b3d
+  metadata.gz: 6f38ec388bac7cea190f0ace7bca99c2d5da955f4fa6ce4719cbca2cd4df603ccdfb53bc33e8125ff87169d77bb63873fe927c5e42be43b02549802cf163cd39
+  data.tar.gz: 085ddcae66c574428f71b8c9c2a2b149144ba80debc5585c88d82723e2bd0c0b96bd2fc71166d1920e2815adc242c989d4e49f59c852093d1bed281153ffb5e2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    alchemist (0.1.5)
+    alchemist (0.1.6)
 
 GEM
   remote: https://rubygems.org/

data/lib/alchemist.rb

@@ -2,132 +2,21 @@ require "alchemist/conversion_table"
 require "alchemist/measurement"
 require "alchemist/compound_measurement"
 require "alchemist/module_builder"
+require "alchemist/configuration"
+require "alchemist/library"
 
 module Alchemist
   autoload :Earth, "alchemist/objects/planets/earth"
 
-  DATA_DIR = File.join(File.dirname(__FILE__), "alchemist", "data")
-
-  DEFAULT_UNITS_FILE = File.join(DATA_DIR, "units.yml")
-  DEFAULT_BINARY_PREFIXES_FILE = File.join(DATA_DIR, "binary_prefixes.yml")
-  DEFAULT_SI_UNITS_FILE = File.join(DATA_DIR, "si_units.yml")
-  DEFAULT_UNIT_PREFIXES_FILE = File.join(DATA_DIR, "unit_prefixes.yml")
-
   def self.setup category = nil
     if category
       Numeric.send(:include, ModuleBuilder.new(category).build)
     else
-      conversion_table.keys.each { |category| Numeric.send(:include, ModuleBuilder.new(category).build) }
+      library.categories.each { |category| Numeric.send(:include, ModuleBuilder.new(category).build) }
     end
   end
 
   def self.measure value, unit, exponent = 1.0
     Measurement.new value, unit, exponent
   end
-
-  def self.has_measurement? name
-    conversions.keys.include? name.to_sym
-  end
-
-  def self.measurement_for name
-    conversions[ name.to_sym ]
-  end
-
-  def self.register(type, names, value)
-    names = Array(names)
-    value = value.is_a?(Measurement) ? value.base(type) : value
-    Alchemist.conversion_table[type] ||= {}
-
-    names.each do |name|
-      conversions[name] ||= []
-      conversions[name] << type
-      Alchemist.conversion_table[type][name] = value
-    end
-  end
-
-  def self.parse_prefix(unit)
-    matches = unit.to_s.match(prefix_matcher)
-    prefix, parsed_unit = matches.captures
-
-    if prefix && si_units.include?(parsed_unit)
-      value = prefixed_value_for(prefix.to_sym, parsed_unit)
-      [value, parsed_unit.to_sym]
-    else
-      [1, unit]
-    end
-  end
-
-  def self.register_operation_conversions type, other_type, operation, converted_type
-    operator_actions[operation] ||= []
-    operator_actions[operation] << [type, other_type, converted_type]
-  end
-
-  def self.operator_actions
-    @operator_actions ||= {}
-  end
-
-  def self.binary_prefixes
-    @binary_prefixes ||= YAML.load_file(DEFAULT_BINARY_PREFIXES_FILE)
-  end
-
-  def self.si_units
-    @si_units ||= YAML.load_file(DEFAULT_SI_UNITS_FILE)
-  end
-
-  def self.unit_prefixes
-    @unit_prefixes ||= YAML.load_file(DEFAULT_UNIT_PREFIXES_FILE)
-  end
-
-  def self.use_si
-    @use_si ||= false
-  end
-
-  def self.use_si= use_si
-    @use_si = use_si
-  end
-
-  def self.load_conversion_table(filename=DEFAULT_UNITS_FILE)
-    @conversion_table = ConversionTable.new.load_all(filename)
-  end
-
-  def self.conversion_table
-    @conversion_table ||= load_conversion_table
-  end
-
-  def self.conversions
-    @conversions ||= load_conversions
-  end
-
-
-  private
-
-  def self.use_binary_prefix? unit
-    !use_si && measurement_for(unit).include?(:information_storage)
-  end
-
-  def self.prefix_matcher
-    @prefix_matcher ||= begin
-                          prefix_keys = unit_prefixes.keys.map(&:to_s).sort{ |a,b| b.length <=> a.length }
-                          %r{^(#{prefix_keys.join('|')})?(.+)}
-                        end
-  end
-
-  def self.prefixed_value_for prefix, unit
-    if use_binary_prefix? unit
-      binary_prefixes[prefix]
-    else
-      unit_prefixes[prefix]
-    end
-  end
-
-  def self.load_conversions
-    conversions = {}
-    conversion_table.each do |type, table_conversions|
-      table_conversions.each do |name, value|
-        conversions[name] ||= []
-        conversions[name] << type
-      end
-    end
-    conversions
-  end
 end

data/lib/alchemist/compound_measurement.rb

@@ -42,7 +42,7 @@ module Alchemist
 
     def should_remove_units? numerator, denominator
       return false if numerator.is_a?(Numeric) || denominator.is_a?(Numeric)
-      (Alchemist.measurement_for(numerator.unit_name) & Alchemist.measurement_for(denominator.unit_name)).length > 0
+      (Alchemist.library.measurement_for(numerator.unit_name) & Alchemist.library.measurement_for(denominator.unit_name)).length > 0
     end
 
     def set_coefficients
@@ -56,7 +56,7 @@ module Alchemist
     end
 
     def method_missing(method, *attrs, &block)
-      if Alchemist.measurement_for(method)
+      if Alchemist.library.measurement_for(method)
         @denominators << Alchemist.measure(1, method)
         consolidate
       end

data/lib/alchemist/configuration.rb

@@ -0,0 +1,26 @@
+require 'singleton'
+
+module Alchemist
+  def self.config
+    Configuration.instance
+  end
+
+  class Configuration
+    DATA_DIR = File.join(File.dirname(__FILE__), "data")
+    DEFAULT_UNITS_FILE = File.join(DATA_DIR, "units.yml")
+    DEFAULT_SI_UNITS_FILE = File.join(DATA_DIR, "si_units.yml")
+    DEFAULT_BINARY_PREFIXES_FILE = File.join(DATA_DIR, "binary_prefixes.yml")
+    DEFAULT_UNIT_PREFIXES_FILE = File.join(DATA_DIR, "unit_prefixes.yml")
+
+    include Singleton
+
+    attr_accessor :use_si
+    def initialize
+      @use_si = false
+    end
+
+    def use_si?
+      @use_si
+    end
+  end
+end

data/lib/alchemist/library.rb

@@ -0,0 +1,86 @@
+require 'singleton'
+
+module Alchemist
+  def self.library
+    Library.instance
+  end
+
+  class Library
+    include Singleton
+
+    attr_reader :si_units, :unit_prefixes, :conversion_table, :binary_prefixes
+
+    def initialize
+      @conversion_table = load_conversion_table
+      @si_units = YAML.load_file(Configuration::DEFAULT_SI_UNITS_FILE)
+      @unit_prefixes = YAML.load_file(Configuration::DEFAULT_UNIT_PREFIXES_FILE)
+      @binary_prefixes = YAML.load_file(Configuration::DEFAULT_BINARY_PREFIXES_FILE)
+    end
+
+    def categories
+      @conversion_table.keys
+    end
+
+    def unit_names category
+      @conversion_table[category.to_sym].map { |values| values[0] }
+    end
+
+    def measurement_for unit_name
+      conversions[ unit_name.to_sym ]
+    end
+
+    def conversions
+      @conversions ||= load_conversions
+    end
+
+    def conversion_base_for(unit_type, unit_name)
+      @conversion_table[unit_type][unit_name]
+    end
+
+    def has_measurement? name
+      conversions.keys.include? name.to_sym
+    end
+
+    def register_operation_conversions type, other_type, operation, converted_type
+      operator_actions[operation] ||= []
+      operator_actions[operation] << [type, other_type, converted_type]
+    end
+
+    def operator_actions
+      @operator_actions ||= {}
+    end
+
+    def load_conversion_table(filename=Configuration::DEFAULT_UNITS_FILE)
+      if new_table = ConversionTable.new.load_all(filename)
+        @conversion_table = new_table
+      else
+        @conversion_table ||= load_conversion_table
+      end
+    end
+
+    def register(type, names, value)
+      names = Array(names)
+      value = value.is_a?(Measurement) ? value.base(type) : value
+      conversion_table[type] ||= {}
+
+      names.each do |name|
+        conversions[name] ||= []
+        conversions[name] << type
+        conversion_table[type][name] = value
+      end
+    end
+
+    private
+
+    def load_conversions
+      conversions = {}
+      conversion_table.each do |type, table_conversions|
+        table_conversions.each do |name, value|
+          conversions[name] ||= []
+          conversions[name] << type
+        end
+      end
+      conversions
+    end
+  end
+end

data/lib/alchemist/measurement.rb

@@ -18,7 +18,7 @@ module Alchemist
 
     def to type = nil
       if type
-        convertor.send(type)
+        convertor.send(type, exponent)
       else
         convertor
       end
@@ -27,24 +27,28 @@ module Alchemist
     def + measurement
       ensure_shared_type!(measurement)
       converted = measurement.to(unit_name)
-      Measurement.new(value + converted.value, unit_name, exponent)
+      remeasure(value + converted.value)
     end
 
     def - measurement
       ensure_shared_type!(measurement)
       converted = measurement.to(unit_name)
-      Measurement.new(value - converted.value, unit_name, exponent)
+      remeasure(value - converted.value)
     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
+      converted = remeasure(value / dividend(measurement))
+
+      if measurement.is_a?(Measurement)
+        converted.value
+      else
+        converted
+      end
     end
 
     def * multiplicand
       if multiplicand.is_a?(Numeric)
-        Measurement.new(value * multiplicand, unit_name, exponent)
+        remeasure(value * multiplicand)
       else
         try_raising_dimension(multiplicand)
       end
@@ -52,39 +56,68 @@ module Alchemist
 
     def base unit_type
       conversion_base = conversion_base_for(unit_type)
-      convert_to_base conversion_base
+      convert_to_base(conversion_base)
     end
 
     def to_s
-      value.to_s
+      to_f.to_s
     end
 
     def to_i
-      value.to_i
+      to_f.to_i
     end
 
     def to_f
-      @value
+      @value * exponent
     end
 
     def <=>(other)
-      (self.to_f * exponent).to_f <=> other.to(unit_name).to_f
+      self.to_f <=> other.to(unit_name).to_f
     end
 
     def types
-      Alchemist.measurement_for(unit_name)
+      library.measurement_for(unit_name)
     end
 
     def shared_types other_unit_name
-      types & Alchemist.measurement_for(other_unit_name)
+      types & library.measurement_for(other_unit_name)
     end
 
     def coerce(number)
       [self, number]
     end
 
+    def round(*args)
+      remeasure(value.round(*args))
+    end
+
+    def ceil(*args)
+      remeasure(value.ceil(*args))
+    end
+
+    def floor(*args)
+      remeasure(value.floor(*args))
+    end
+
     private
 
+    def dividend measurement
+      if measurement.is_a?(Measurement)
+        ensure_shared_type!(measurement)
+        measurement.to(unit_name).to_f / exponent
+      else
+        measurement
+      end
+    end
+
+    def remeasure value
+      Measurement.new(value, unit_name, exponent)
+    end
+
+    def library
+      Library.instance
+    end
+
     def ensure_shared_type! measurement
       if !has_shared_types?(measurement.unit_name)
         incompatible_types
@@ -100,7 +133,7 @@ module Alchemist
     end
 
     def conversion_base_for unit_type
-      Alchemist.conversion_table[unit_type][unit_name]
+      library.conversion_base_for(unit_type, unit_name)
     end
 
     def has_shared_types? other_unit_name
@@ -109,7 +142,7 @@ module Alchemist
 
     def try_raising_dimension(measurement)
       valid_types = shared_types(measurement.unit_name)
-      Alchemist.operator_actions[:*].each do |s1, s2, new_type|
+      library.operator_actions[:*].each do |s1, s2, new_type|
         if (valid_types & [s1, s2]).any?
           return Alchemist.measure(value * measurement.to_f, new_type)
         end

data/lib/alchemist/measurement_convertor.rb

@@ -1,4 +1,5 @@
 require 'bigdecimal'
+require 'alchemist/prefix_parser'
 
 module Alchemist
   class MeasurementConvertor
@@ -7,27 +8,42 @@ module Alchemist
     end
 
     def method_missing method, *args, &block
-      exponent, unit_name = Alchemist.parse_prefix(method)
-      convert(from.shared_types(unit_name), unit_name, exponent)
+      exponent, unit_name = PrefixParser.new.parse(method)
+      convert(from.shared_types(unit_name), unit_name, args.first || exponent)
     end
 
     private
     attr_reader :from
 
+    def library
+      Library.instance
+    end
+
     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
+        convert_from_type(type, unit_name, exponent)
       else
         raise Exception, "Incompatible Types"
       end
     end
 
+    def convert_from_type(type, unit_name, exponent)
+      conversion_base = BigDecimal.new(from.base(type).to_s)
+      conversion_factor = library.conversion_base_for(type, unit_name)
+
+      value = value_from(conversion_base, conversion_factor)
+      Measurement.new(value / exponent, unit_name, exponent)
+    end
+
+    def value_from(base, factor)
+      if proc_based?(factor)
+        factor[1].call(base)
+      else
+        base / BigDecimal.new(factor.to_s)
+      end
+
+    end
+
     def proc_based? conversion_factor
       conversion_factor.is_a? Array
     end

data/lib/alchemist/module_builder.rb

@@ -21,12 +21,12 @@ module Alchemist
     end
 
     def unit_names
-      Alchemist.conversion_table[category.to_sym].map { |values| values[0] }
+      Library.instance.unit_names(category)
     end
 
     def prefixes_with_value(name)
-      if Alchemist.si_units.include?(name.to_s)
-        Alchemist.unit_prefixes
+      if Library.instance.si_units.include?(name.to_s)
+        Library.instance.unit_prefixes
       else
         []
       end

data/lib/alchemist/prefix_parser.rb

@@ -0,0 +1,42 @@
+module Alchemist
+  class PrefixParser
+    def parse(unit)
+      matches = unit.to_s.match(prefix_matcher)
+      prefix, parsed_unit = matches.captures
+
+      if prefix && library.si_units.include?(parsed_unit)
+        value = prefixed_value_for(prefix.to_sym, parsed_unit)
+        [value, parsed_unit.to_sym]
+      else
+        [1, unit]
+      end
+    end
+
+    def prefix_matcher
+      @prefix_matcher ||= generate_prefix_matcher
+    end
+
+    private
+
+    def library
+      Alchemist.library
+    end
+
+    def generate_prefix_matcher
+      prefix_keys = library.unit_prefixes.keys.map(&:to_s).sort{ |a,b| b.length <=> a.length }
+      %r{^(#{prefix_keys.join('|')})?(.+)}
+    end
+
+    def prefixed_value_for prefix, unit
+      if use_binary_prefix? unit
+        library.binary_prefixes[prefix]
+      else
+        library.unit_prefixes[prefix]
+      end
+    end
+
+    def use_binary_prefix? unit
+      !Alchemist.config.use_si? && library.measurement_for(unit).include?(:information_storage)
+    end
+  end
+end

data/lib/alchemist/setup.rb

@@ -0,0 +1,3 @@
+require 'alchemist'
+
+Alchemist.setup

data/lib/alchemist/version.rb

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

data/spec/alchemist_spec.rb

@@ -3,14 +3,11 @@ 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)
+    category_module = build_category_module
+    fake_numeric = build_fake_numeric
     Alchemist.setup('distance')
+    expect(Alchemist::ModuleBuilder).to have_received(:new).with('distance')
+    expect(fake_numeric).to have_received(:include).with(category_module)
   end
 
   it "creates a measurement" do
@@ -18,34 +15,18 @@ describe Alchemist do
     expect(unit).to eq(1.meter)
   end
 
-  it "knows if it has a measurement" do
-    expect(Alchemist.has_measurement?(:meter)).to be_true
+  def build_category_module
+    double.tap do |category_module|
+      module_builder = double()
+      allow(module_builder).to receive(:build) { category_module }
+      Alchemist::ModuleBuilder.stub(:new).and_return(module_builder)
+    end
   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])
+  def build_fake_numeric
+    double.tap do |fake_module|
+      allow(fake_module).to receive(:include)
+      stub_const("Numeric", fake_module)
+    end
   end
 end

data/spec/conversion_table_spec.rb

@@ -17,11 +17,11 @@ module Alchemist
     end
 
     def conversion_table
-      Alchemist::conversion_table
+      Alchemist.library.conversion_table
     end
 
     def load_file file
-      Alchemist::load_conversion_table file
+      Alchemist.library.load_conversion_table file
     end
 
     def good_file
@@ -33,7 +33,7 @@ module Alchemist
     end
 
     def default_file
-      File.join(File.dirname(__FILE__), "..", "lib", "alchemist", "units.yml")
+      Configuration::DEFAULT_UNITS_FILE
     end
   end
 end

data/spec/library_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Alchemist
+  describe Library do
+    it "returns a list of the binary prefixes" do
+      expect(library.binary_prefixes[:kilo]).to eq(1024.0)
+    end
+
+    it "can register units with formulas" do
+      to = lambda { |t| t + 1 }
+      from = lambda { |t| t - 1 }
+      library.register(:yetis, :yeti, [to, from])
+      expect(library.conversion_table[:yetis]).to eq({:yeti => [to, from]})
+    end
+
+    it "can register units with plural names" do
+      library.register(:beards, [:beard_second, :beard_seconds], 1.0)
+      expect(library.conversion_table[:beards]).to eq({:beard_second=>1.0, :beard_seconds=>1.0})
+    end
+
+    it "can register units" do
+      library.register :quux, :qaat, 1.0
+      library.register :quux, :quut, 3.0
+      expect(library.conversion_table[:quux]).to eq({:qaat=>1.0, :quut=>3.0})
+    end
+
+    it "knows if it has a measurement" do
+      expect(library.has_measurement?(:meter)).to be_true
+    end
+
+    it "knows if it doesn't have a measurement" do
+      expect(library.has_measurement?(:wombat)).to be_false
+    end
+
+    def library
+      Library.instance
+    end
+  end
+end

data/spec/measurement_spec.rb

@@ -15,12 +15,13 @@ module Alchemist
     end
 
     it "can be multiplied" do
-      Alchemist.register_operation_conversions(:distance, :distance, :*, :square_meters)
+      Alchemist.library.register_operation_conversions(:distance, :distance, :*, :square_meters)
       expect(1.meter * 1.meter).to eq(1.square_meter)
     end
 
     it "can be divided" do
       expect(2.meters / 1.meter).to eq(2.0)
+      expect(4.meters / 2).to eq(2.meters)
     end
 
     it "can be added" do
@@ -55,6 +56,25 @@ module Alchemist
       expect(1.meter.coerce(10)).to eq([1.meter, 10])
     end
 
+    it "can round measurements" do
+      expect(1.5.meters.round).to eq(2.meters)
+    end
+
+    it "can ceil measurements" do
+      expect(1.4.meters.ceil).to eq(2.meters)
+    end
+
+    it "can floor measurments" do
+      expect(1.6.meters.floor).to eq(1.meter)
+    end
+
+    it "handles exponents correctly" do
+      expect(1.kg.to.kg).to eq(1.kg)
+      expect(1.kg.to(:kg)).to eq(1.kg)
+      expect(1.kg.to.kg.to.g).to eq(1000.g)
+      expect(1.kg.to.g.to.kg).to eq(1.kg)
+    end
+
     describe '#geospatial' do
 
       it 'should convert angles to meters' do

data/spec/prefix_parser_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Alchemist
+  describe PrefixParser do
+    it "can parse a prefix" do
+      parsed = PrefixParser.new.parse(:kilometer)
+      expect(parsed).to eq([1000.0, :meter])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alchemist
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Matthew Mongeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-02 00:00:00.000000000 Z
+date: 2013-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,23 +53,29 @@ files:
 - alchemist.gemspec
 - lib/alchemist.rb
 - lib/alchemist/compound_measurement.rb
+- lib/alchemist/configuration.rb
 - lib/alchemist/conversion_table.rb
 - lib/alchemist/data/binary_prefixes.yml
 - lib/alchemist/data/si_units.yml
 - lib/alchemist/data/unit_prefixes.yml
 - lib/alchemist/data/units.yml
 - lib/alchemist/geospatial.rb
+- lib/alchemist/library.rb
 - lib/alchemist/measurement.rb
 - lib/alchemist/measurement_convertor.rb
 - lib/alchemist/module_builder.rb
 - lib/alchemist/objects/planets/earth.rb
+- lib/alchemist/prefix_parser.rb
+- lib/alchemist/setup.rb
 - lib/alchemist/version.rb
 - spec/alchemist_spec.rb
 - spec/compound_measurement_spec.rb
 - spec/conversion_table_spec.rb
 - spec/fixtures/bad_test.yml
 - spec/fixtures/good_test.yml
+- spec/library_spec.rb
 - spec/measurement_spec.rb
+- spec/prefix_parser_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/halogenandtoast/alchemist
 licenses:
@@ -101,6 +107,8 @@ test_files:
 - spec/conversion_table_spec.rb
 - spec/fixtures/bad_test.yml
 - spec/fixtures/good_test.yml
+- spec/library_spec.rb
 - spec/measurement_spec.rb
+- spec/prefix_parser_spec.rb
 - spec/spec_helper.rb
 has_rdoc: