barometer 0.7.3 → 0.8.0

data/spec/measurements/result_array_spec.rb

@@ -1,33 +1,28 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Result Array" do
-  
+describe Barometer::Measurement::ResultArray do
   describe "instance methods" do
-    
     before(:each) do
-      @array = Measurement::ResultArray.new
+      @array = Barometer::Measurement::ResultArray.new
     end
-    
+
     describe "'<<'" do
-    
-      it "requires Measurement::Result" do
+      it "requires Barometer::Measurement::Result" do
         lambda { @array << "invalid" }.should raise_error(ArgumentError)
       end
-      
+
       it "adds ForecastMeasurement" do
         @array.size.should == 0
-        forecast = Measurement::Result.new
+        forecast = Barometer::Measurement::Result.new
         @array << forecast
         @array.size.should == 1
       end
-      
     end
-    
-    describe "when searching forecasts using 'for'" do
 
+    describe "when searching forecasts using 'for'" do
       before(:each) do
         1.upto(4) do |i|
-          forecast_measurement = Measurement::Result.new
+          forecast_measurement = Barometer::Measurement::Result.new
           forecast_measurement.date = Date.parse((Time.now + (i * 60 * 60 * 24)).to_s)
           @array << forecast_measurement
         end
@@ -37,7 +32,7 @@ describe "Result Array" do
       end
 
       it "returns nil when there are no forecasts" do
-        @array = Measurement::ResultArray.new
+        @array = Barometer::Measurement::ResultArray.new
         @array.size.should == 0
         @array.for(@tommorrow).should be_nil
       end
@@ -76,38 +71,32 @@ describe "Result Array" do
         yesterday.class.should == Time
         @array.for(yesterday).should be_nil
       end
-      
+
       it "finds using '[]'" do
         tommorrow = @tommorrow.to_s
         tommorrow.class.should == String
         @array[tommorrow].should == @array.first
       end
-
     end
-
   end
-  
+
   describe "simple questions" do
-    
     before(:each) do
-      @array = Measurement::ResultArray.new
-      #@early = Data::LocalTime("6:00 am")
-      #@noon = Data::LocalTime("12:00 pm")
-      #@late = Data::LocalTime("8:00 pm")
+      @array = Barometer::Measurement::ResultArray.new
       @now = Time.utc(2009,5,5,10,30,25)
-      
+
       @sun_icons = %w(sunny)
-      
+
       0.upto(1) do |i|
-        forecast_measurement = Measurement::Result.new
+        forecast_measurement = Barometer::Measurement::Result.new
         forecast_measurement.date = Date.parse((@now + (i * 60 * 60 * 24)).to_s)
         wind = Data::Speed.new
         wind << (i * 5)
         forecast_measurement.wind = wind
         forecast_measurement.sun = Data::Sun.new(
           Data::LocalTime.parse("9:00 am"), Data::LocalTime.parse("3:00 pm"))
-        forecast_measurement.icon = "sunny"  
-        forecast_measurement.pop = 40 
+        forecast_measurement.icon = "sunny"
+        forecast_measurement.pop = 40
         forecast_measurement.humidity = 95
         @array << forecast_measurement
       end
@@ -117,13 +106,13 @@ describe "Result Array" do
       @earlier = (@now - (60 * 60 * 3))
       @later = (@now + (60 * 60 * 6))
     end
-    
+
     it "answers windy?" do
       @array.windy?(@tommorrow).should be_false
       @array.windy?(@tommorrow,1).should be_true
       @array.windy?(@yesterday).should be_nil
     end
-    
+
     it "answers day?" do
       @array.day?(@yesterday).should be_nil
       @array.day?(@earlier).should be_false
@@ -131,35 +120,31 @@ describe "Result Array" do
       @array.day?(@tommorrow).should be_true
       @array.day?(@now).should be_true
     end
-    
+
     it "answers sunny?" do
       @array.sunny?(@tommorrow,%w(rain)).should be_false
       @array.sunny?(@tommorrow,@sun_icons).should be_true
       @array.sunny?(@yesterday).should be_nil
     end
-    
+
     describe "wet?" do
-      
       it "answers via pop" do
         @array.wet?(@tommorrow).should be_false
         @array.wet?(@tommorrow,nil,50).should be_false
         @array.wet?(@tommorrow,nil,30).should be_true
       end
-      
+
       it "answers via humidity" do
         @array.wet?(@tommorrow).should be_false
         @array.wet?(@tommorrow,nil,50,99).should be_false
         @array.wet?(@tommorrow,nil,50,90).should be_true
       end
-      
+
       it "answers via icon" do
         @array.wet?(@tommorrow,%w(rain)).should be_false
         # pretend that "sun" means wet
         @array.wet?(@tommorrow,@sun_icons).should be_true
       end
-      
     end
-    
   end
-  
 end

data/spec/measurements/result_spec.rb

@@ -1,45 +1,43 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Result Measurement" do
-  
+describe Barometer::Measurement::Result do
   describe "when initialized" do
-    
     before(:each) do
-      @result = Measurement::Result.new
+      @result = Barometer::Measurement::Result.new
     end
-    
+
     it "responds to temperature" do
       @result.temperature.should be_nil
     end
-    
+
     it "responds to dew_point" do
       @result.dew_point.should be_nil
     end
-    
+
     it "responds to heat_index" do
       @result.heat_index.should be_nil
     end
-    
+
     it "responds to wind_chill" do
       @result.wind_chill.should be_nil
     end
-    
+
     it "responds to pressure" do
       @result.pressure.should be_nil
     end
-    
+
     it "responds to visibility" do
       @result.pressure.should be_nil
     end
-    
+
     it "responds to current_at" do
       @result.current_at.should be_nil
     end
-    
+
     it "responds to updated_at" do
       @result.updated_at.should be_nil
     end
-    
+
     it "responds to date" do
       @result.date.should be_nil
     end
@@ -47,217 +45,215 @@ describe "Result Measurement" do
     it "responds to low" do
       @result.low.should be_nil
     end
-    
+
     it "responds to high" do
       @result.high.should be_nil
     end
-    
+
     it "responds to pop" do
       @result.pop.should be_nil
     end
-    
+
     it "responds to valid_start_date" do
       @result.valid_start_date.should be_nil
     end
-    
+
     it "responds to valid_end_date" do
       @result.valid_end_date.should be_nil
     end
-    
+
     it "responds to description" do
       @result.description.should be_nil
     end
-    
+
     it "responds to humidity" do
       @result.humidity.should be_nil
     end
-    
+
     it "responds to icon" do
       @result.icon.should be_nil
     end
-    
+
     it "responds to condition" do
       @result.condition.should be_nil
     end
-    
+
     it "responds to wind" do
       @result.wind.should be_nil
     end
-    
+
     it "responds to sun" do
       @result.sun.should be_nil
     end
-    
+
     it "responds to metric" do
       @result.metric.should be_true
     end
-    
+
     it "responds to metric?" do
       @result.metric?.should be_true
       @result.metric = false
       @result.metric?.should be_false
     end
-    
   end
-  
+
   describe "when writing data" do
-    
     before(:each) do
-      @result = Measurement::Result.new
+      @result = Barometer::Measurement::Result.new
     end
-    
+
     it "only accepts Data::Temperature for temperature" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.temperature = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.temperature = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Temperature for dew_point" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.dew_point = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.dew_point = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Temperature for heat_index" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.heat_index = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.heat_index = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Temperature for wind_chill" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.wind_chill = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.wind_chill = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Pressure for pressure" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Pressure
       lambda { @result.pressure = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Pressure.new
       valid_data.class.should == Data::Pressure
       lambda { @result.pressure = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Distance for visibility" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Distance
       lambda { @result.visibility = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Distance.new
       valid_data.class.should == Data::Distance
       lambda { @result.visibility = 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 { @result.current_at = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalTime.new
       valid_data.class.should == Data::LocalTime
       lambda { @result.current_at = valid_data }.should_not raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalDateTime.new(2009,1,1)
       valid_data.class.should == Data::LocalDateTime
       lambda { @result.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 { @result.updated_at = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalTime.new
       valid_data.class.should == Data::LocalTime
       lambda { @result.updated_at = valid_data }.should_not raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalDateTime.new(2009,1,1)
       valid_data.class.should == Data::LocalDateTime
       lambda { @result.updated_at = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Date for date" do
       invalid_data = 1
       invalid_data.class.should_not == Date
       lambda { @result.date = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Date.new
       valid_data.class.should == Date
       lambda { @result.date = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Temperature for high" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.high = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.high = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Temperature for low" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Temperature
       lambda { @result.low = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Temperature.new
       valid_data.class.should == Data::Temperature
       lambda { @result.low = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Fixnum for pop" do
       invalid_data = "test"
       invalid_data.class.should_not == Fixnum
       lambda { @result.pop = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = 50
       valid_data.class.should == Fixnum
       lambda { @result.pop = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::LocalDateTime for valid_start_date" do
       invalid_data = 1
       invalid_data.class.should_not == Data::LocalDateTime
       lambda { @result.valid_start_date = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalDateTime.new(2009,1,1)
       valid_data.class.should == Data::LocalDateTime
       lambda { @result.valid_start_date = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::LocalDateTime for valid_end_date" do
       invalid_data = 1
       invalid_data.class.should_not == Data::LocalDateTime
       lambda { @result.valid_end_date = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalDateTime.new(2009,1,1)
       valid_data.class.should == Data::LocalDateTime
       lambda { @result.valid_end_date = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "sets valid_start_date and valid_end_date if given date" do
-      forecast = Measurement::Result.new
+      forecast = Barometer::Measurement::Result.new
       forecast.valid_start_date.should be_nil
       forecast.valid_end_date.should be_nil
       date = Date.new(2009,05,05)
@@ -269,7 +265,7 @@ describe "Result Measurement" do
       forecast.valid_start_date.hour.should == 0
       forecast.valid_start_date.min.should == 0
       forecast.valid_start_date.sec.should == 0
-      
+
       forecast.valid_end_date.should_not be_nil
       forecast.valid_end_date.year.should == date.year
       forecast.valid_end_date.month.should == date.month
@@ -278,119 +274,114 @@ describe "Result Measurement" do
       forecast.valid_end_date.min.should == 59
       forecast.valid_end_date.sec.should == 59
     end
-    
+
     it "returns true if the valid_date range includes the given date" do
-      forecast = Measurement::Result.new
+      forecast = Barometer::Measurement::Result.new
       forecast.date = Date.new(2009,05,05)
       forecast.for_datetime?(Data::LocalDateTime.new(2009,5,5,12,0,0)).should be_true
     end
-    
+
     it "returns false if the valid_date range excludes the given date" do
-      forecast = Measurement::Result.new
+      forecast = Barometer::Measurement::Result.new
       forecast.date = Date.new(2009,05,05)
       forecast.for_datetime?(Data::LocalDateTime.new(2009,5,4,12,0,0)).should be_false
     end
-    
+
     it "only accepts Fixnum or Float for humidity" do
       invalid_data = "invalid"
       invalid_data.class.should_not == Fixnum
       invalid_data.class.should_not == Float
       lambda { @result.humidity = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = 1.to_i
       valid_data.class.should == Fixnum
       lambda { @result.humidity = valid_data }.should_not raise_error(ArgumentError)
-      
+
       valid_data = 1.0.to_f
       valid_data.class.should == Float
       lambda { @result.humidity = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts String for icon" do
       invalid_data = 1
       invalid_data.class.should_not == String
       lambda { @result.icon = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = "valid"
       valid_data.class.should == String
       lambda { @result.icon = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts String for condition" do
       invalid_data = 1
       invalid_data.class.should_not == String
       lambda { @result.condition = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = "valid"
       valid_data.class.should == String
       lambda { @result.condition = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Speed for wind" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Speed
       lambda { @result.wind = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Speed.new
       valid_data.class.should == Data::Speed
       lambda { @result.wind = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Sun for sun" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Sun
       lambda { @result.sun = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Sun.new
       valid_data.class.should == Data::Sun
       lambda { @result.sun = valid_data }.should_not raise_error(ArgumentError)
     end
-    
   end
-  
+
   describe "method missing" do
-    
     before(:each) do
-      @result = Measurement::Result.new
+      @result = Barometer::Measurement::Result.new
     end
-    
+
     it "responds to method + ?" do
       valid_method = "humidity"
       @result.respond_to?(valid_method).should be_true
       lambda { @result.send(valid_method + "?") }.should_not raise_error(NoMethodError)
     end
-    
+
     it "ignores non_method + ?" do
       invalid_method = "humid"
       @result.respond_to?(invalid_method).should be_false
       lambda { @result.send(invalid_method + "?") }.should raise_error(NoMethodError)
     end
-    
+
     it "returns true if set" do
       @result.humidity = 10
       @result.humidity.should_not be_nil
       @result.humidity?.should be_true
     end
-    
+
     it "returns false if not set" do
       @result.humidity.should be_nil
       @result.humidity?.should be_false
     end
-    
   end
-  
+
   describe "answer simple questions, like" do
-    
     before(:each) do
-      @result = Measurement::Result.new
+      @result = Barometer::Measurement::Result.new
       @result.temperature = Data::Temperature.new
       @result.temperature << 5
       @dew_point = Data::Temperature.new
       @dew_point << 10
     end
-    
+
     describe "windy?" do
-      
       before(:each) do
         @wind = Data::Speed.new
         @wind << 11
@@ -401,7 +392,7 @@ describe "Result Measurement" do
         lambda { @result.windy? }.should_not raise_error(ArgumentError)
         lambda { @result.windy?(10) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns nil when no wind" do
         @result.wind?.should be_false
         @result.windy?.should be_nil
@@ -409,28 +400,26 @@ describe "Result Measurement" do
         @result.wind?.should be_true
         @result.windy?.should_not be_nil
       end
-      
+
       it "return true when current wind over threshold" do
         @result.wind = @wind
         @result.windy?.should be_true
         @result.windy?(10).should be_true
       end
-      
+
       it "return false when current wind under threshold" do
         @result.wind = @wind
         @result.windy?(15).should be_false
       end
-      
     end
-    
+
     describe "day?" do
-      
       before(:each) do
         @early_time = Data::LocalTime.parse("6:00 am")
         @mid_time = Data::LocalTime.parse("11:00 am")
         @late_time = Data::LocalTime.parse("8:00 pm")
         @sun = Data::Sun.new(@early_time, @late_time)
-        
+
       end
 
       it "requires Data::LocalTime object" do
@@ -439,7 +428,7 @@ describe "Result Measurement" do
         lambda { @result.day? }.should raise_error(ArgumentError)
         lambda { @result.day?(@mid_time) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns nil when no sun" do
         @result.sun?.should be_false
         @result.day?(@mid_time).should be_nil
@@ -447,28 +436,25 @@ describe "Result Measurement" do
         @result.sun?.should be_true
         @result.day?(@mid_time).should_not be_nil
       end
-      
+
       it "return true when time between rise and set" do
         @result.sun = @sun
         @result.day?(@mid_time).should be_true
       end
-      
+
       it "return false when time before rise or after set" do
         sun = Data::Sun.new(@mid_time, @late_time)
         @result.sun = sun
         @result.day?(@early_time).should be_false
-        
+
         sun = Data::Sun.new(@early_time, @mid_time)
         @result.sun = sun
         @result.day?(@late_time).should be_false
       end
-      
     end
-    
+
     describe "wet?" do
-      
       describe "wet_by_humidity?" do
-        
         it "requires real threshold number (or nil)" do
           lambda { @result.send("_wet_by_humidity?","invalid") }.should raise_error(ArgumentError)
           lambda { @result.send("_wet_by_humidity?") }.should_not raise_error(ArgumentError)
@@ -497,11 +483,9 @@ describe "Result Measurement" do
           @result.send("_wet_by_humidity?",99).should be_false
           @result.wet?(nil,99).should be_false
         end
-
       end
-      
+
       describe "wet_by_icon?" do
-        
         before(:each) do
           @wet_icons = %w(rain thunderstorm)
         end
@@ -534,11 +518,9 @@ describe "Result Measurement" do
           @result.send("_wet_by_icon?",@wet_icons).should be_false
           @result.wet?(@wet_icons).should be_false
         end
-        
       end
-      
+
       describe "wet_by_dewpoint?" do
-        
         it "returns nil when no dewpoint" do
           @result.dew_point?.should be_false
           @result.send("_wet_by_dewpoint?").should be_nil
@@ -561,11 +543,9 @@ describe "Result Measurement" do
           @result.send("_wet_by_dewpoint?").should be_false
           @result.wet?.should be_false
         end
-
       end
-      
+
       describe "wet_by_pop?" do
-        
         it "requires real threshold number (or nil)" do
           lambda { @result.send("_wet_by_pop?","invalid") }.should raise_error(ArgumentError)
           lambda { @result.send("_wet_by_pop?") }.should_not raise_error(ArgumentError)
@@ -593,22 +573,18 @@ describe "Result Measurement" do
           @result.send("_wet_by_pop?",50).should be_false
           @result.wet?.should be_false
         end
-
       end
-      
     end
-    
+
     describe "sunny?" do
-      
       describe "sunny_by_icon?" do
-        
         before(:each) do
           @sunny_icons = %w(sunny clear)
           @early_time = Data::LocalTime.parse("6:00 am")
           @mid_time = Data::LocalTime.parse("11:00 am")
           @late_time = Data::LocalTime.parse("8:00 pm")
           @sun = Data::Sun.new(@early_time, @late_time)
-          
+
           @result.sun = @sun
         end
 
@@ -640,21 +616,17 @@ describe "Result Measurement" do
           @result.send("_sunny_by_icon?",@sunny_icons).should be_false
           @result.sunny?(@mid_time,@sunny_icons).should be_false
         end
-        
+
         it "returns false when night" do
           @result.icon = "sunny"
           @result.send("_sunny_by_icon?",@sunny_icons).should be_true
           @result.sunny?(@mid_time,@sunny_icons).should be_true
-          
+
           @sun = Data::Sun.new(@mid_time, @late_time)
           @result.sun = @sun
           @result.sunny?(@early_time,@sunny_icons).should be_false
         end
-        
       end
-      
     end
-    
   end
-
-end
+end