barometer 0.8.0 → 0.9.0

data/spec/data/convertable_units_spec.rb

@@ -0,0 +1,299 @@
+require_relative '../spec_helper'
+
+module Barometer::Data
+  class TestData < ConvertableUnits
+    private
+
+    def convert_imperial_to_metric(imperial_value)
+      imperial_value*200
+    end
+
+    def convert_metric_to_imperial(metric_value)
+      metric_value/200
+    end
+  end
+
+  describe ConvertableUnits do
+    describe '.initialize' do
+      it 'sets metric value' do
+        test_data = TestData.new(200.0, nil)
+        expect( test_data.metric ).to eq 200.0
+      end
+
+      it 'sets imperial value' do
+        test_data = TestData.new(nil, 1.0)
+        expect( test_data.imperial ).to eq 1.0
+      end
+
+      it 'defaults to metric' do
+        test_data = TestData.new(200)
+        expect( test_data ).to be_metric
+        expect( test_data.metric ).to eq 200.0
+      end
+
+      context 'when setting the unit type' do
+        it 'sets metric via boolean' do
+          test_data = TestData.new(true, 200, nil)
+          expect( test_data.to_s ).to eq '200 METRIC'
+        end
+
+        it 'sets metric via symbol' do
+          test_data = TestData.new(:metric, 200, nil)
+          expect( test_data.to_s ).to eq '200 METRIC'
+        end
+
+        it 'sets imperial via boolean' do
+          test_data = TestData.new(false, nil, 1.0)
+          expect( test_data.to_s ).to eq '1.0 IMPERIAL'
+        end
+
+        it 'sets imperial via symbol' do
+          test_data = TestData.new(:imperial, nil, 1.0)
+          expect( test_data.to_s ).to eq '1.0 IMPERIAL'
+        end
+
+        context 'and only provided one magnitude' do
+          context 'and metric is set' do
+            it 'interprets magnitude as metric value' do
+              test_data = TestData.new(:metric, 200)
+              expect( test_data.to_s ).to eq '200 METRIC'
+            end
+          end
+
+          context 'and imperial is set' do
+            it 'interprets magnitude as imperial value' do
+              test_data = TestData.new(:imperial, 1)
+              expect( test_data.to_s ).to eq '1 IMPERIAL'
+            end
+          end
+        end
+      end
+    end
+
+    describe '#imperial' do
+      it 'calculates imperial value from metric value' do
+        test_data = TestData.new(:metric, 200.0)
+        expect( test_data.imperial ).to eq 1.0
+      end
+
+      it 'returns nil if imperial value is nil' do
+        test_data = TestData.new(:imperial, nil)
+        expect( test_data.imperial ).to be_nil
+      end
+
+      it 'returns known value as imperial value' do
+        test_data = TestData.new(:imperial, 1)
+        expect( test_data.imperial ).to eq 1
+      end
+
+      # it 'keeps integer resolution' do
+      #   test_data = TestData.new(:imperial, 10)
+      #   expect( test_data.metric ).to eq 16
+      # end
+
+      # it 'keeps float resolution' do
+      #   test_data = TestData.new(:imperial, 10.0)
+      #   expect( test_data.metric ).to eq 16.1
+      # end
+    end
+
+    describe '#metric' do
+      it 'calculates metric value from imperial value' do
+        test_data = TestData.new(:imperial, 1.0)
+        expect( test_data.metric ).to eq 200.0
+      end
+
+      it 'returns nil if metric value is nil' do
+        test_data = TestData.new(:metric, nil)
+        expect( test_data.metric ).to be_nil
+      end
+
+      it 'returns known value as metric value' do
+        test_data = TestData.new(:metric, 200)
+        expect( test_data.metric ).to eq 200
+      end
+
+      # it 'keeps integer resolution' do
+      #   test_data = TestData.new(:imperial, 10)
+      #   expect( test_data.metric ).to eq 16
+      # end
+
+      # it 'keeps float resolution' do
+      #   test_data = TestData.new(:imperial, 10.0)
+      #   expect( test_data.metric ).to eq 16.1
+      # end
+    end
+
+    describe '#<=>' do
+      context 'when comparing two metric test_datas' do
+        it 'returns > correctly' do
+          test_data1 = TestData.new(:metric, 200)
+          test_data2 = TestData.new(:metric, 200.2)
+
+          expect( test_data2 ).to be > test_data1
+        end
+
+        it 'returns == correctly' do
+          test_data1 = TestData.new(:metric, 200)
+          test_data2 = TestData.new(:metric, 200.0)
+
+          expect( test_data2 ).to eq test_data1
+        end
+
+        it 'returns < correctly' do
+          test_data1 = TestData.new(:metric, 200)
+          test_data2 = TestData.new(:metric, 200.2)
+
+          expect( test_data1 ).to be < test_data2
+        end
+      end
+
+      context 'when comparing two imperial test_datas' do
+        it 'returns > correctly' do
+          test_data1 = TestData.new(:imperial, 1)
+          test_data2 = TestData.new(:imperial, 1.2)
+
+          expect( test_data2 ).to be > test_data1
+        end
+
+        it 'returns == correctly' do
+          test_data1 = TestData.new(:imperial, 1)
+          test_data2 = TestData.new(:imperial, 1.0)
+
+          expect( test_data2 ).to eq test_data1
+        end
+
+        it 'returns < correctly' do
+          test_data1 = TestData.new(:imperial, 1)
+          test_data2 = TestData.new(:imperial, 1.2)
+
+          expect( test_data1 ).to be < test_data2
+        end
+      end
+
+      context 'when comparing a mtric and an imperial test_data' do
+        it 'returns > correctly' do
+          test_data1 = TestData.new(:metric, 200.0)
+          test_data2 = TestData.new(:imperial, 1.2)
+
+          expect( test_data2 ).to be > test_data1
+        end
+
+        it 'returns == correctly' do
+          test_data1 = TestData.new(:metric, 200.0)
+          test_data2 = TestData.new(:imperial, 1.0)
+
+          expect( test_data2 ).to eq test_data1
+        end
+
+        it 'returns < correctly' do
+          test_data1 = TestData.new(:metric, 200.3)
+          test_data2 = TestData.new(:imperial, 1.0)
+
+          expect( test_data2 ).to be < test_data1
+        end
+      end
+    end
+
+    describe '#units' do
+      context 'when test_data is metric' do
+        it 'returns metric value' do
+          test_data = TestData.new(:metric, 200.0)
+          expect( test_data.units ).to eq 'METRIC'
+        end
+      end
+
+      context 'when test_data is imperial' do
+        it 'returns imperial value' do
+          test_data = TestData.new(:imperial, 1.0)
+          expect( test_data.units ).to eq 'IMPERIAL'
+        end
+      end
+    end
+
+    describe '#to_i' do
+      context 'when test_data is metric' do
+        it 'returns the value of metric value' do
+          test_data = TestData.new(:metric, 200.0, 1.0)
+          expect( test_data.to_i ).to eq 200
+        end
+
+        it 'returns 0 if nothing is set' do
+          test_data = TestData.new(:metric, nil)
+          expect( test_data.to_i ).to eq 0
+        end
+      end
+
+      context 'when test_data is imperial' do
+        it 'returns the value of imperial value' do
+          test_data = TestData.new(:imperial, 200.0, 1.0)
+          expect( test_data.to_i ).to eq 1
+        end
+
+        it 'returns 0 if nothing is set' do
+          test_data = TestData.new(:imperial, nil)
+          expect( test_data.to_i ).to eq 0
+        end
+      end
+    end
+
+    describe '#to_f' do
+      context 'when test_data is metric' do
+        it 'returns the value of metric value' do
+          test_data = TestData.new(:metric, 200, 1)
+          expect( test_data.to_f ).to eq 200.0
+        end
+
+        it 'returns 0 if nothing is set' do
+          test_data = TestData.new(:metric, nil)
+          expect( test_data.to_f ).to eq 0.0
+        end
+      end
+
+      context 'when test_data is imperial' do
+        it 'returns the value of imperial value' do
+          test_data = TestData.new(:imperial, 200, 1)
+          expect( test_data.to_f ).to eq 1.0
+        end
+
+        it 'returns 0 if nothing is set' do
+          test_data = TestData.new(:imperial, nil)
+          expect( test_data.to_f ).to eq 0.0
+        end
+      end
+    end
+
+    describe '#to_s' do
+      context 'when test_data is metric' do
+        it 'returns metric value' do
+          test_data = TestData.new(:metric, 200)
+          expect( test_data.to_s ).to eq '200 METRIC'
+        end
+      end
+
+      context 'when test_data is imperial' do
+        it 'returns imperial value' do
+          test_data = TestData.new(:imperial, 1)
+          expect( test_data.to_s ).to eq '1 IMPERIAL'
+        end
+      end
+    end
+
+    describe '#nil?' do
+      it 'returns true if nothing is set' do
+        test_data = TestData.new(nil, nil)
+        expect( test_data ).to be_nil
+      end
+
+      it 'returns false if only metric value set' do
+        test_data = TestData.new(200, nil)
+        expect( test_data ).to_not be_nil
+      end
+
+      it 'returns false if only imperial value set' do
+        test_data = TestData.new(nil, 1)
+        expect( test_data ).to_not be_nil
+      end
+    end
+  end
+end

data/spec/data/coordinates_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../spec_helper'
+
+module Barometer::Data
+  describe Coordinates do
+    describe '#coordinates' do
+      it 'joins latitude and longitude' do
+        coordinates = Coordinates.new(
+          longitude: '99.99',
+          latitude: '88.88'
+        )
+        expect( coordinates.coordinates ).to eq '88.88,99.99'
+      end
+    end
+  end
+end

data/spec/data/distance_spec.rb

@@ -1,336 +1,52 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Data::Distance" do
-
-  describe "when initialized" do
-
-    it "defines METRIC_UNITS" do
-      Data::Distance.const_defined?("METRIC_UNITS").should be_true
-      Data::Distance::METRIC_UNITS.should == "km"
-    end
-
-    it "defines IMPERIAL_UNITS" do
-      Data::Distance.const_defined?("IMPERIAL_UNITS").should be_true
-      Data::Distance::IMPERIAL_UNITS.should == "m"
-    end
-
-    before(:each) do
-      @distance = Data::Distance.new
-    end
-
-    it "responds to kilometers" do
-      @distance.kilometers.should be_nil
-    end
-
-    it "responds to miles" do
-      @distance.miles.should be_nil
-    end
-
-    it "responds to metric_default" do
-      lambda { @distance.metric_default = 5 }.should_not raise_error(NotImplementedError)
-    end
-
-    it "responds to imperial_default" do
-      lambda { @distance.imperial_default = 5 }.should_not raise_error(NotImplementedError)
-    end
-
-    it "responds to nil?" do
-      @distance.nil?.should be_true
-      @distance.km = 5
-      @distance.nil?.should be_false
-    end
-
-  end
-
-  describe "conversion" do
-
-    # For all conversions
-    # 26.2 M = 42.2 KM
-    before(:each) do
-      @m = 26.2
-      @km = 42.2
-    end
-
-    it "requires a value, that is either Integer or Float" do
-      Data::Distance.km_to_m(nil).should be_nil
-      Data::Distance.m_to_km(nil).should be_nil
-
-      not_float_or_integer = "string"
-      Data::Distance.km_to_m(not_float_or_integer).should be_nil
-      Data::Distance.m_to_km(not_float_or_integer).should be_nil
-    end
-
-    it "converts KM to M" do
-      ((Data::Distance.km_to_m(@km)*10).round/10.0).should == @m
-    end
-
-    it "converts M to KM" do
-      ((Data::Distance.m_to_km(@m)*10).round/10.0).should == @km
-    end
-
-  end
-
-  describe "updating" do
-
-    before(:each) do
-      @distance = Data::Distance.new
-      @m = 26.2
-      @km = 42.2
-    end
-
-    it "nils M if new KM converts to a M that changes more then 1 unit" do
-      @distance.miles = (@m + 1.1)
-      @distance.update_miles(@km)
-      @distance.miles.should be_nil
-    end
-
-    it "doesn't update M if new KM converts to a M that does not change more then 1 unit" do
-      @distance.miles = (@m + 0.9)
-      @distance.update_miles(@km)
-      @distance.miles.should == (@m + 0.9)
-    end
-
-    it "doesn't set M if not already set" do
-      @distance.miles.should be_nil
-      @distance.kilometers.should be_nil
-      @distance.update_miles(@km)
-      @distance.miles.should be_nil
-      @distance.kilometers.should be_nil
-    end
-
-    it "nils KM if new M converts to a KM that changes more then 1 unit" do
-      @distance.kilometers = (@km + 1.1)
-      @distance.update_kilometers(@m)
-      @distance.kilometers.should be_nil
-    end
-
-    it "doesn't update KM if new M converts to a KM that does not change more then 1 unit" do
-      @distance.kilometers = (@km + 0.9)
-      @distance.update_kilometers(@m)
-      @distance.kilometers.should == (@km + 0.9)
-    end
-
-    it "doesn't set KM if not already set" do
-      @distance.miles.should be_nil
-      @distance.kilometers.should be_nil
-      @distance.update_kilometers(@m)
-      @distance.miles.should be_nil
-      @distance.kilometers.should be_nil
-    end
-
-  end
-
-  describe "storing" do
-
-    before(:each) do
-      @distance = Data::Distance.new
-      @m = 26.2
-      @km = 42.2
-    end
-
-    it "doesn't update KM if nil value (or equivalent)" do
-      @distance.kilometers.should be_nil
-      @distance.km = nil
-      @distance.kilometers.should be_nil
-      @distance.km = "na"
-      @distance.kilometers.should be_nil
-    end
-
-    it "stores KM and resets M" do
-      @distance.kilometers.should be_nil
-      @distance.miles = (@m + 1.1)
-      @distance.km = @km
-      @distance.kilometers.should == @km
-      @distance.miles.should be_nil
-    end
-
-    it "doesn't update M if nil value (or equivalent)" do
-      @distance.miles.should be_nil
-      @distance.m = nil
-      @distance.miles.should be_nil
-      @distance.m = "na"
-      @distance.miles.should be_nil
-    end
-
-    it "stores M and resets KM" do
-      @distance.miles.should be_nil
-      @distance.kilometers = (@km + 1.1)
-      @distance.m = @m
-      @distance.miles.should == @m
-      @distance.kilometers.should be_nil
-    end
-
-  end
-
-  describe "retrieving" do
-
-    before(:each) do
-      @distance = Data::Distance.new
-      @m = 26.2
-      @km = 42.16
-    end
-
-    it "returns KM if it exists" do
-      @distance.km = @km
-      @distance.kilometers.should == @km
-      @distance.km(false).should == @km
-    end
-
-    it "auto converts from M if KM is nil and M exists" do
-      @distance.m = @m
-      @distance.miles.should == @m
-      @distance.kilometers.should be_nil
-      @distance.km(false).should == @km
-    end
-
-    it "allows a float to be returned for KM" do
-      km = 42.12
-      @distance.km = km
-      @distance.kilometers.should == km
-      @distance.km(true).should == km.to_i
-      @distance.km(false).should == km.to_f
-    end
-
-    it "allows only 2 decimal precision for KM" do
-      km = 42.1234
-      @distance.km = km
-      @distance.kilometers.should == km
-      @distance.km(false).should == 42.12
-    end
-
-    it "returns M if it exists" do
-      @distance.m = @m
-      @distance.miles.should == @m
-      @distance.m(false).should == @m
-    end
-
-    it "auto converts from KM if M is nil and KM exists" do
-      @distance.km = @km
-      @distance.kilometers.should == @km
-      @distance.miles.should be_nil
-      ((@distance.m(false)*10).round/10.0).should == @m
-    end
-
-    it "allows a float to be returned for M" do
-      m = 26.12
-      @distance.m = m
-      @distance.miles.should == m
-      @distance.m(true).should == m.to_i
-      @distance.m(false).should == m.to_f
-    end
-
-    it "allows only 2 decimal precision for M" do
-      m = 26.1234
-      @distance.m = m
-      @distance.miles.should == m
-      @distance.m(false).should == 26.12
-    end
-
-  end
-
-  describe "operators" do
-
-    before(:each) do
-      @m = 26.2
-      @km = 42.16
-      @distance_low = Data::Distance.new
-      @distance_low.km = (@m - 1.0)
-      @distance_high = Data::Distance.new
-      @distance_high.km = (@km + 1.0)
-      @distance = Data::Distance.new
-      @distance.km = @km
-      @distance_same = Data::Distance.new
-      @distance_same.km = @km
-    end
-
-    it "defines <=>" do
-      Data::Distance.method_defined?("<=>").should be_true
-      (@distance_low <=> @distance_high).should == -1
-      (@distance_high <=> @distance_low).should == 1
-      (@distance <=> @distance_same).should == 0
+require_relative '../spec_helper'
+
+module Barometer::Data
+  describe Distance do
+    describe '.initialize' do
+      it 'sets km' do
+        distance = Distance.new(42.2, nil)
+        expect( distance.km ).to eq 42.2
+      end
+
+      it 'sets m' do
+        distance = Distance.new(nil, 26.2)
+        expect( distance.m ).to eq 26.2
+      end
+
+      it 'defaults to metric' do
+        distance = Distance.new(42)
+        expect( distance ).to be_metric
+      end
+    end
+
+    describe '#m' do
+      it 'returns known value as m' do
+        distance = Distance.new(:imperial, 26)
+        expect( distance.m ).to eq 26
+      end
+    end
+
+    describe '#km' do
+      it 'returns known value as km' do
+        distance = Distance.new(:metric, 42)
+        expect( distance.km ).to eq 42
+      end
+    end
+
+    describe '#units' do
+      context 'when distance is metric' do
+        it 'returns km' do
+          distance = Distance.new(:metric, 42.0)
+          expect( distance.units ).to eq 'km'
+        end
+      end
+
+      context 'when distance is imperial' do
+        it 'returns m' do
+          distance = Distance.new(:imperial, 26.0)
+          expect( distance.units ).to eq 'm'
+        end
+      end
     end
-
-    it "defines <" do
-      Data::Distance.method_defined?("<").should be_true
-      @distance_low.should < @distance_high
-      @distance_high.should_not < @distance_low
-      @distance.should_not < @distance_same
-    end
-
-    it "defines >" do
-      Data::Distance.method_defined?(">").should be_true
-      @distance_low.should_not > @distance_high
-      @distance_high.should > @distance_low
-      @distance.should_not > @distance_same
-    end
-
-    it "defines ==" do
-      Data::Distance.method_defined?("==").should be_true
-      @distance_low.should_not == @distance_high
-      @distance.should == @distance_same
-    end
-
-    it "defines <=" do
-      Data::Distance.method_defined?("<=").should be_true
-      @distance_low.should <= @distance_high
-      @distance_high.should_not <= @distance_low
-      @distance.should <= @distance_same
-    end
-
-    it "defines >=" do
-      Data::Distance.method_defined?(">=").should be_true
-      @distance_low.should_not >= @distance_high
-      @distance_high.should >= @distance_low
-      @distance.should >= @distance_same
-    end
-
   end
-
-  describe "changing units" do
-
-    before(:each) do
-      @m = 26.2
-      @km = 42.16
-      @distance = Data::Distance.new
-      @distance.km = @km
-    end
-
-    it "returns just the integer value (no units)" do
-      @distance.metric?.should be_true
-      @distance.to_i.should == @km.to_i
-
-      @distance.imperial!
-      @distance.metric?.should be_false
-      @distance.to_i.should == @m.to_i
-    end
-
-    it "returns just the float value (no units)" do
-      @distance.metric?.should be_true
-      @distance.to_f.should == @km.to_f
-
-      @distance.imperial!
-      @distance.metric?.should be_false
-      ((@distance.to_f*10).round/10.0).should == @m.to_f
-    end
-
-    it "returns just the integer value with units" do
-      @distance.metric?.should be_true
-      @distance.to_s.should == "#{@km.to_i} #{Data::Distance::METRIC_UNITS}"
-
-      @distance.imperial!
-      @distance.metric?.should be_false
-      @distance.to_s.should == "#{@m.to_i} #{Data::Distance::IMPERIAL_UNITS}"
-    end
-
-    it "returns just the units" do
-      @distance.metric?.should be_true
-      @distance.units.should == Data::Distance::METRIC_UNITS
-
-      @distance.imperial!
-      @distance.metric?.should be_false
-      @distance.units.should == Data::Distance::IMPERIAL_UNITS
-    end
-
-  end
-
 end