barometer 0.3.2 → 0.5.0

data/spec/{data_current_spec.rb → data/current_spec.rb}

@@ -5,11 +5,7 @@ describe "Current Measurement" do
   describe "when initialized" do
     
     before(:each) do
-      @current = Barometer::CurrentMeasurement.new
-    end
-    
-    it "responds to time" do
-      @current.time.should be_nil
+      @current = Data::CurrentMeasurement.new
     end
     
     it "responds to humidity" do
@@ -56,24 +52,22 @@ describe "Current Measurement" do
       @current.sun.should be_nil
     end
     
+    it "responds to current_at" do
+      @current.current_at.should be_nil
+    end
+    
+    it "responds to updated_at" do
+      @current.updated_at.should be_nil
+    end
+    
   end
   
   describe "when writing data" do
     
     before(:each) do
-      @current = Barometer::CurrentMeasurement.new
+      @current = Data::CurrentMeasurement.new
     end
     
-    # it "only accepts Time for time" do
-    #   invalid_data = 1
-    #   invalid_data.class.should_not == Time
-    #   lambda { @current.time = invalid_data }.should raise_error(ArgumentError)
-    #   
-    #   valid_data = Time.new
-    #   valid_data.class.should == Time
-    #   lambda { @current.time = valid_data }.should_not raise_error(ArgumentError)
-    # end
-    
     it "only accepts Fixnum or Float for humidity" do
       invalid_data = "invalid"
       invalid_data.class.should_not == Fixnum
@@ -109,92 +103,122 @@ describe "Current Measurement" do
       lambda { @current.condition = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for temperature" do
+    it "only accepts Data::Temperature for temperature" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @current.temperature = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @current.temperature = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for dew_point" do
+    it "only accepts Data::Temperature for dew_point" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @current.dew_point = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @current.dew_point = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for heat_index" do
+    it "only accepts Data::Temperature for heat_index" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @current.heat_index = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @current.heat_index = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for wind_chill" do
+    it "only accepts Data::Temperature for wind_chill" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @current.wind_chill = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @current.wind_chill = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Speed for wind" do
+    it "only accepts Data::Speed for wind" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Speed
+      invalid_data.class.should_not == Data::Speed
       lambda { @current.wind = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Speed.new
-      valid_data.class.should == Barometer::Speed
+      valid_data = Data::Speed.new
+      valid_data.class.should == Data::Speed
       lambda { @current.wind = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Pressure for pressure" do
+    it "only accepts Data::Pressure for pressure" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Pressure
+      invalid_data.class.should_not == Data::Pressure
       lambda { @current.pressure = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Pressure.new
-      valid_data.class.should == Barometer::Pressure
+      valid_data = Data::Pressure.new
+      valid_data.class.should == Data::Pressure
       lambda { @current.pressure = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Distance for visibility" do
+    it "only accepts Data::Distance for visibility" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Distance
+      invalid_data.class.should_not == Data::Distance
       lambda { @current.visibility = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Distance.new
-      valid_data.class.should == Barometer::Distance
+      valid_data = Data::Distance.new
+      valid_data.class.should == Data::Distance
       lambda { @current.visibility = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Sun for sun" do
+    it "only accepts Data::Sun for sun" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Sun
+      invalid_data.class.should_not == Data::Sun
       lambda { @current.sun = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Sun.new
-      valid_data.class.should == Barometer::Sun
+      valid_data = Data::Sun.new
+      valid_data.class.should == Data::Sun
       lambda { @current.sun = valid_data }.should_not raise_error(ArgumentError)
     end
     
+    it "only accepts Data::LocalTime || Data::LocalDateTime current_at" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalTime
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @current.current_at = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::LocalTime.new
+      valid_data.class.should == Data::LocalTime
+      lambda { @current.current_at = valid_data }.should_not raise_error(ArgumentError)
+      
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @current.current_at = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Data::LocalTime || Data::LocalDateTime current_at" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::LocalTime
+      invalid_data.class.should_not == Data::LocalDateTime
+      lambda { @current.updated_at = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::LocalTime.new
+      valid_data.class.should == Data::LocalTime
+      lambda { @current.updated_at = valid_data }.should_not raise_error(ArgumentError)
+      
+      valid_data = Data::LocalDateTime.new(2009,1,1)
+      valid_data.class.should == Data::LocalDateTime
+      lambda { @current.updated_at = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
   end
   
   describe "method missing" do
     
     before(:each) do
-      @current = Barometer::CurrentMeasurement.new
+      @current = Data::CurrentMeasurement.new
     end
     
     it "responds to method + ?" do

data/spec/{data_distance_spec.rb → data/distance_spec.rb}

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe "Distance" do
+describe "Data::Distance" do
   
   describe "when initialized" do
     
     it "defines METRIC_UNITS" do
-      Barometer::Distance.const_defined?("METRIC_UNITS").should be_true
-      Barometer::Distance::METRIC_UNITS.should == "km"
+      Data::Distance.const_defined?("METRIC_UNITS").should be_true
+      Data::Distance::METRIC_UNITS.should == "km"
     end
     
     it "defines IMPERIAL_UNITS" do
-      Barometer::Distance.const_defined?("IMPERIAL_UNITS").should be_true
-      Barometer::Distance::IMPERIAL_UNITS.should == "m"
+      Data::Distance.const_defined?("IMPERIAL_UNITS").should be_true
+      Data::Distance::IMPERIAL_UNITS.should == "m"
     end
     
     before(:each) do
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
     end
     
     it "responds to kilometers" do
@@ -52,20 +52,20 @@ describe "Distance" do
     end
     
     it "requires a value, that is either Integer or Float" do
-      Barometer::Distance.km_to_m(nil).should be_nil
-      Barometer::Distance.m_to_km(nil).should be_nil
+      Data::Distance.km_to_m(nil).should be_nil
+      Data::Distance.m_to_km(nil).should be_nil
       
       not_float_or_integer = "string"
-      Barometer::Distance.km_to_m(not_float_or_integer).should be_nil
-      Barometer::Distance.m_to_km(not_float_or_integer).should be_nil
+      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
-      ((Barometer::Distance.km_to_m(@km)*10).round/10.0).should == @m
+      ((Data::Distance.km_to_m(@km)*10).round/10.0).should == @m
     end
     
     it "converts M to KM" do
-      ((Barometer::Distance.m_to_km(@m)*10).round/10.0).should == @km
+      ((Data::Distance.m_to_km(@m)*10).round/10.0).should == @km
     end
     
   end
@@ -73,7 +73,7 @@ describe "Distance" do
   describe "updating" do
     
     before(:each) do
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
       @m = 26.2
       @km = 42.2
     end
@@ -123,7 +123,7 @@ describe "Distance" do
   describe "storing" do
     
     before(:each) do
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
       @m = 26.2
       @km = 42.2
     end
@@ -165,7 +165,7 @@ describe "Distance" do
   describe "retrieving" do
     
     before(:each) do
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
       @m = 26.2
       @km = 42.16
     end
@@ -233,52 +233,52 @@ describe "Distance" do
     before(:each) do
       @m = 26.2
       @km = 42.16
-      @distance_low = Barometer::Distance.new
+      @distance_low = Data::Distance.new
       @distance_low.km = (@m - 1.0)
-      @distance_high = Barometer::Distance.new
+      @distance_high = Data::Distance.new
       @distance_high.km = (@km + 1.0)
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
       @distance.km = @km
-      @distance_same = Barometer::Distance.new
+      @distance_same = Data::Distance.new
       @distance_same.km = @km
     end
     
     it "defines <=>" do
-      Barometer::Distance.method_defined?("<=>").should be_true
+      Data::Distance.method_defined?("<=>").should be_true
       (@distance_low <=> @distance_high).should == -1
       (@distance_high <=> @distance_low).should == 1
       (@distance <=> @distance_same).should == 0
     end
     
     it "defines <" do
-      Barometer::Distance.method_defined?("<").should be_true
+      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
-      Barometer::Distance.method_defined?(">").should be_true
+      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
-      Barometer::Distance.method_defined?("==").should be_true
+      Data::Distance.method_defined?("==").should be_true
       @distance_low.should_not == @distance_high
       @distance.should == @distance_same
     end
     
     it "defines <=" do
-      Barometer::Distance.method_defined?("<=").should be_true
+      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
-      Barometer::Distance.method_defined?(">=").should be_true
+      Data::Distance.method_defined?(">=").should be_true
       @distance_low.should_not >= @distance_high
       @distance_high.should >= @distance_low
       @distance.should >= @distance_same
@@ -291,7 +291,7 @@ describe "Distance" do
     before(:each) do
       @m = 26.2
       @km = 42.16
-      @distance = Barometer::Distance.new
+      @distance = Data::Distance.new
       @distance.km = @km
     end
     
@@ -315,20 +315,20 @@ describe "Distance" do
     
     it "returns just the integer value with units" do
       @distance.metric?.should be_true
-      @distance.to_s.should == "#{@km.to_i} #{Barometer::Distance::METRIC_UNITS}"
+      @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} #{Barometer::Distance::IMPERIAL_UNITS}"
+      @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 == Barometer::Distance::METRIC_UNITS
+      @distance.units.should == Data::Distance::METRIC_UNITS
 
       @distance.imperial!
       @distance.metric?.should be_false
-      @distance.units.should == Barometer::Distance::IMPERIAL_UNITS
+      @distance.units.should == Data::Distance::IMPERIAL_UNITS
     end
 
   end

data/spec/{data_forecast_spec.rb → data/forecast_spec.rb}

@@ -5,7 +5,7 @@ describe "Forecast Measurement" do
   describe "when initialized" do
     
     before(:each) do
-      @forecast = Barometer::ForecastMeasurement.new
+      @forecast = Data::ForecastMeasurement.new
     end
     
     it "responds to date" do
@@ -32,16 +32,28 @@ describe "Forecast Measurement" do
       @forecast.pop.should be_nil
     end
     
+    it "responds to humidity" do
+      @forecast.humidity.should be_nil
+    end
+    
+    it "responds to wind" do
+      @forecast.wind.should be_nil
+    end
+    
     it "responds to sun" do
       @forecast.sun.should be_nil
     end
     
+    it "responds to night" do
+      @forecast.night.should be_nil
+    end
+    
   end
   
   describe "when writing data" do
     
     before(:each) do
-      @forecast = Barometer::ForecastMeasurement.new
+      @forecast = Data::ForecastMeasurement.new
     end
     
     it "only accepts Date for date" do
@@ -74,23 +86,23 @@ describe "Forecast Measurement" do
       lambda { @forecast.condition = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for high" do
+    it "only accepts Data::Temperature for high" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @forecast.high = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @forecast.high = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Temperature for low" do
+    it "only accepts Data::Temperature for low" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Temperature
+      invalid_data.class.should_not == Data::Temperature
       lambda { @forecast.low = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Temperature.new
-      valid_data.class.should == Barometer::Temperature
+      valid_data = Data::Temperature.new
+      valid_data.class.should == Data::Temperature
       lambda { @forecast.low = valid_data }.should_not raise_error(ArgumentError)
     end
     
@@ -104,22 +116,52 @@ describe "Forecast Measurement" do
       lambda { @forecast.pop = valid_data }.should_not raise_error(ArgumentError)
     end
     
-    it "only accepts Barometer::Sun for sun" do
+    it "only accepts Data::Speed for wind" do
+      invalid_data = "test"
+      invalid_data.class.should_not == Data::Speed
+      lambda { @forecast.wind = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::Speed.new
+      valid_data.class.should == Data::Speed
+      lambda { @forecast.wind = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Fixnum for humidity" do
+      invalid_data = "test"
+      invalid_data.class.should_not == Fixnum
+      lambda { @forecast.humidity = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = 50
+      valid_data.class.should == Fixnum
+      lambda { @forecast.humidity = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Data::Sun for sun" do
       invalid_data = 1
-      invalid_data.class.should_not == Barometer::Sun
+      invalid_data.class.should_not == Data::Sun
       lambda { @forecast.sun = invalid_data }.should raise_error(ArgumentError)
       
-      valid_data = Barometer::Sun.new
-      valid_data.class.should == Barometer::Sun
+      valid_data = Data::Sun.new
+      valid_data.class.should == Data::Sun
       lambda { @forecast.sun = valid_data }.should_not raise_error(ArgumentError)
     end
     
+    it "only accepts Data::NightMeasurement for sun" do
+      invalid_data = 1
+      invalid_data.class.should_not == Data::NightMeasurement
+      lambda { @forecast.night = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Data::NightMeasurement.new
+      valid_data.class.should == Data::NightMeasurement
+      lambda { @forecast.night = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
   end
   
   describe "method missing" do
     
     before(:each) do
-      @forecast = Barometer::ForecastMeasurement.new
+      @forecast = Data::ForecastMeasurement.new
     end
     
     it "responds to method + ?" do