barometer 0.7.3 → 0.8.0

data/spec/formats/woe_id_spec.rb

@@ -1,7 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "addressable/uri"
 
-describe "Query::WoeID" do
-  
+params_in_body = lambda do |request_1, request_2|
+  a1 = Addressable::URI.parse("?#{request_1.body}")
+  a2 = Addressable::URI.parse("?#{request_2.body}")
+  a1.query_values == a2.query_values
+end
+
+describe Barometer::Query::Format::WoeID, :vcr => {
+  :match_requests_on => [:method, :uri, params_in_body],
+  :cassette_name => "Query::Format::WoeID"
+} do
   before(:each) do
     @short_zipcode = "90210"
     @zipcode = @short_zipcode
@@ -13,81 +22,77 @@ describe "Query::WoeID" do
     @icao = "KSFO"
     @woe_id = "615702"
   end
-  
+
   describe "and class methods" do
-    
     it "returns a format" do
       Barometer::Query::Format::WoeID.format.should == :woe_id
     end
-    
+
     it "returns a country" do
       Barometer::Query::Format::WoeID.country_code.should be_nil
     end
-    
+
     it "returns a regex" do
       Barometer::Query::Format::WoeID.regex.should_not be_nil
       Barometer::Query::Format::WoeID.regex.is_a?(Regexp).should be_true
     end
-    
+
     it "returns the convertable_formats" do
-      Query::Format::WoeID.convertable_formats.should_not be_nil
-      Query::Format::WoeID.convertable_formats.is_a?(Array).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:short_zipcode).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:zipcode).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:postalcode).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:weather_id).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:coordinates).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:icao).should be_true
-      Query::Format::WoeID.convertable_formats.include?(:geocode).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.should_not be_nil
+      Barometer::Query::Format::WoeID.convertable_formats.is_a?(Array).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:short_zipcode).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:zipcode).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:postalcode).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:weather_id).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:coordinates).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:icao).should be_true
+      Barometer::Query::Format::WoeID.convertable_formats.include?(:geocode).should be_true
     end
-    
+
     describe "is?," do
-      
       it "recognizes a valid 4 digit code format" do
         @query = "8775"
         Barometer::Query::Format::WoeID.is?(@query).should be_true
       end
-      
+
       it "recognizes a valid 6 digit code format" do
         @query = "615702"
         Barometer::Query::Format::WoeID.is?(@query).should be_true
       end
-      
+
       it "recognizes a valid 7 digit code format" do
         @query = "2459115"
         Barometer::Query::Format::WoeID.is?(@query).should be_true
       end
-      
+
       it "recognizes a valid 5 digit code with a prepended 'w'" do
         @query = "w90210"
         Barometer::Query::Format::WoeID.is?(@query).should be_true
       end
-      
+
       it "does not recognize a zip code" do
         @query = "90210"
         Barometer::Query::Format::WoeID.is?(@query).should be_false
       end
-      
+
       it "recognizes non-valid format" do
         @query = "USGA0028"
         Barometer::Query::Format::WoeID.is?(@query).should be_false
       end
-      
     end
-    
+
     it "converts the query" do
       query_no_conversion = "2459115"
       query = Barometer::Query.new(query_no_conversion)
       query.q.should == query_no_conversion
-      
+
       query_with_conversion = "w90210"
       query = Barometer::Query.new(query_with_conversion)
       query.q.should_not == query_with_conversion
       query.q.should == "90210"
     end
-    
+
     describe "when reversing lookup" do
-      
       it "requires a Barometer::Query object" do
         lambda { Barometer::Query::Format::WoeID.reverse }.should raise_error(ArgumentError)
         lambda { Barometer::Query::Format::WoeID.reverse("invalid") }.should raise_error(ArgumentError)
@@ -95,12 +100,12 @@ describe "Query::WoeID" do
         query.is_a?(Barometer::Query).should be_true
         lambda { Barometer::Query::Format::WoeID.reverse(original_query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Query" do
         query = Barometer::Query.new(@woe_id)
         Barometer::Query::Format::WoeID.reverse(query).is_a?(Barometer::Query).should be_true
       end
-      
+
       it "reverses a valid woe_id (US)" do
         query = Barometer::Query.new(@woe_id)
         new_query = Barometer::Query::Format::WoeID.reverse(query)
@@ -109,103 +114,98 @@ describe "Query::WoeID" do
         new_query.format.should == :geocode
         new_query.geo.should be_nil
       end
-      
+
       it "doesn't reverse an invalid weather_id" do
         query = Barometer::Query.new(@zipcode)
         Barometer::Query::Format::WoeID.reverse(query).should be_nil
       end
-      
     end
-  
+
     describe "when converting using 'to'," do
-      
       it "requires a Barometer::Query object" do
-        lambda { Query::Format::WoeID.to }.should raise_error(ArgumentError)
-        lambda { Query::Format::WoeID.to("invalid") }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WoeID.to }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WoeID.to("invalid") }.should raise_error(ArgumentError)
         query = Barometer::Query.new(@woe_id)
         query.is_a?(Barometer::Query).should be_true
-        lambda { Query::Format::WoeID.to(original_query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WoeID.to(original_query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Query" do
         query = Barometer::Query.new(@geocode)
-        Query::Format::WoeID.to(query).is_a?(Barometer::Query).should be_true
+        Barometer::Query::Format::WoeID.to(query).is_a?(Barometer::Query).should be_true
       end
-      
+
       it "converts from short_zipcode" do
         query = Barometer::Query.new(@short_zipcode)
         query.format.should == :short_zipcode
-        new_query = Query::Format::WoeID.to(query)
+        new_query = Barometer::Query::Format::WoeID.to(query)
         new_query.q.should == "2363796"
         new_query.country_code.should == "US"
         new_query.format.should == :woe_id
         new_query.geo.should_not be_nil
       end
-          
+
       it "converts from zipcode" do
         query = Barometer::Query.new(@zipcode)
         query.format = :zipcode
         query.format.should == :zipcode
-        new_query = Query::Format::WoeID.to(query)
+        new_query = Barometer::Query::Format::WoeID.to(query)
         new_query.q.should == "2363796"
         new_query.country_code.should == "US"
         new_query.format.should == :woe_id
         new_query.geo.should_not be_nil
       end
-          
+
       it "converts from postal code" do
         query = Barometer::Query.new(@postal_code)
         query.format = :postalcode
         query.format.should == :postalcode
-        new_query = Query::Format::WoeID.to(query)
+        new_query = Barometer::Query::Format::WoeID.to(query)
         new_query.q.should == "8676"
         new_query.country_code.should == "CA"
         new_query.format.should == :woe_id
         new_query.geo.should be_nil
       end
-          
+
       it "converts from coordinates" do
         query = Barometer::Query.new(@coordinates)
         query.format.should == :coordinates
-        new_query = Query::Format::WoeID.to(query)
-        new_query.q.should == "2459115"
+        new_query = Barometer::Query::Format::WoeID.to(query)
+        new_query.q.should == "12589342"
         new_query.country_code.should be_nil
         new_query.format.should == :woe_id
         new_query.geo.should be_nil
       end
-          
+
       it "converts from geocode" do
         query = Barometer::Query.new(@geocode)
         query.format.should == :geocode
-        new_query = Query::Format::WoeID.to(query)
+        new_query = Barometer::Query::Format::WoeID.to(query)
         new_query.q.should == "2459115"
         new_query.country_code.should be_nil
         new_query.format.should == :woe_id
         new_query.geo.should be_nil
       end
-          
+
       it "converts from weather_id" do
         query = Barometer::Query.new(@weather_id)
         query.format.should == :weather_id
-        new_query = Query::Format::WoeID.to(query)
+        new_query = Barometer::Query::Format::WoeID.to(query)
         new_query.q.should == "2357024"
         new_query.country_code.should be_nil
         new_query.format.should == :woe_id
         new_query.geo.should be_nil
       end
-          
+
       it "converts from icao" do
         query = Barometer::Query.new(@icao)
         query.format.should == :icao
-        new_query = Query::Format::WoeID.to(query)
-        new_query.q.should == "2451206"
+        new_query = Barometer::Query::Format::WoeID.to(query)
+        new_query.q.should == "2487956"
         new_query.country_code.should == "US"
         new_query.format.should == :woe_id
         new_query.geo.should_not be_nil
       end
-    
     end
-
   end
-  
-end
+end

data/spec/formats/zipcode_spec.rb

@@ -1,7 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Query::Zipcode" do
-  
+describe Barometer::Query::Format::Zipcode do
   before(:each) do
     @short_zipcode = "90210"
     @zipcode = @short_zipcode
@@ -12,100 +11,93 @@ describe "Query::Zipcode" do
     @geocode = "New York, NY"
     @icao = "KSFO"
   end
-  
+
   describe "and class methods" do
-    
     it "returns a format" do
-      Query::Format::Zipcode.format.should == :zipcode
+      Barometer::Query::Format::Zipcode.format.should == :zipcode
     end
-    
+
     it "returns a country" do
-      Query::Format::Zipcode.country_code.should == "US"
-      Query::Format::Zipcode.country_code("ignored").should == "US"
+      Barometer::Query::Format::Zipcode.country_code.should == "US"
+      Barometer::Query::Format::Zipcode.country_code("ignored").should == "US"
     end
-    
+
     it "returns a regex" do
-      Query::Format::Zipcode.regex.should_not be_nil
-      Query::Format::Zipcode.regex.is_a?(Regexp).should be_true
+      Barometer::Query::Format::Zipcode.regex.should_not be_nil
+      Barometer::Query::Format::Zipcode.regex.is_a?(Regexp).should be_true
     end
-    
+
     it "returns the convertable_formats" do
-      Query::Format::Zipcode.convertable_formats.should_not be_nil
-      Query::Format::Zipcode.convertable_formats.is_a?(Array).should be_true
-      Query::Format::Zipcode.convertable_formats.include?(:short_zipcode).should be_true
+      Barometer::Query::Format::Zipcode.convertable_formats.should_not be_nil
+      Barometer::Query::Format::Zipcode.convertable_formats.is_a?(Array).should be_true
+      Barometer::Query::Format::Zipcode.convertable_formats.include?(:short_zipcode).should be_true
     end
-    
+
     describe "is?," do
-      
       before(:each) do
         @valid = "90210-5555"
         @invalid = "invalid"
       end
-      
+
       it "recognizes a valid format" do
-        Query::Format::Zipcode.is?(@valid).should be_true
+        Barometer::Query::Format::Zipcode.is?(@valid).should be_true
       end
-      
+
       it "recognizes non-valid format" do
-        Query::Format::Zipcode.is?(@invalid).should be_false
+        Barometer::Query::Format::Zipcode.is?(@invalid).should be_false
       end
-      
     end
-  
+
     describe "when converting using 'to'," do
-      
       it "requires a Barometer::Query object" do
-        lambda { Query::Format::Zipcode.to }.should raise_error(ArgumentError)
-        lambda { Query::Format::Zipcode.to("invalid") }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::Zipcode.to }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::Zipcode.to("invalid") }.should raise_error(ArgumentError)
         query = Barometer::Query.new(@zipcode)
         query.is_a?(Barometer::Query).should be_true
-        lambda { Query::Format::Zipcode.to(original_query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::Zipcode.to(original_query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Query" do
         query = Barometer::Query.new(@short_zipcode)
-        Query::Format::Zipcode.to(query).is_a?(Barometer::Query).should be_true
+        Barometer::Query::Format::Zipcode.to(query).is_a?(Barometer::Query).should be_true
       end
-      
+
       it "converts from short_zipcode" do
         query = Barometer::Query.new(@short_zipcode)
         query.format.should == :short_zipcode
-        new_query = Query::Format::Zipcode.to(query)
+        new_query = Barometer::Query::Format::Zipcode.to(query)
         new_query.q.should == @short_zipcode
         new_query.format.should == :zipcode
         new_query.country_code.should == "US"
         new_query.geo.should be_nil
       end
-      
+
       it "returns nil for other formats" do
         query = Barometer::Query.new(@zipcode)
         query.format = :zipcode
         query.format.should == :zipcode
-        Query::Format::Zipcode.to(query).should be_nil
-        
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
+
         query = Barometer::Query.new(@weather_id)
         query.format.should == :weather_id
-        Query::Format::Zipcode.to(query).should be_nil
-        
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
+
         query = Barometer::Query.new(@postal_code)
         query.format.should == :postalcode
-        Query::Format::Zipcode.to(query).should be_nil
-        
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
+
         query = Barometer::Query.new(@coordinates)
         query.format.should == :coordinates
-        Query::Format::Zipcode.to(query).should be_nil
-        
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
+
         query = Barometer::Query.new(@geocode)
         query.format.should == :geocode
-        Query::Format::Zipcode.to(query).should be_nil
-        
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
+
         query = Barometer::Query.new(@icao)
         query.format.should == :icao
-        Query::Format::Zipcode.to(query).should be_nil
+        Barometer::Query::Format::Zipcode.to(query).should be_nil
       end
-      
     end
-    
   end
-  
-end
+end

data/spec/key_file_parser_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Barometer::KeyFileParser do
+  include FakeFS::SpecHelpers
+
+  it "returns the the KEY for the given path" do
+    FakeFS do
+      FileUtils.mkdir("~")
+      File.open(Barometer::KEY_FILE, 'w') {|f| f << "\weather_bug:\n  code: ABC123" }
+      Barometer::KeyFileParser.find(:weather_bug, :code).should == "ABC123"
+    end
+  end
+
+  it "returns nil when the key does not exist" do
+    FakeFS do
+      FileUtils.mkdir("~")
+      File.open(Barometer::KEY_FILE, 'w') {|f| f << "\weather_bug:\n" }
+      Barometer::KeyFileParser.find(:weather_bug, :code).should be_nil
+    end
+  end
+
+  it "returns nil when the file does not exist" do
+    FakeFS do
+      FileUtils.mkdir("~")
+      Barometer::KeyFileParser.find(:weather_bug, :code).should be_nil
+    end
+  end
+end

data/spec/measurements/measurement_spec.rb

@@ -1,199 +1,189 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Measurement" do
-  
+describe Barometer::Measurement do
   describe "when initialized" do
-    
     before(:each) do
       @measurement = Barometer::Measurement.new
     end
-    
+
     it "responds to source" do
       @measurement.source.should be_nil
     end
-    
+
     it "stores the source" do
       source = :wunderground
       measurement = Barometer::Measurement.new(source)
       measurement.source.should_not be_nil
       measurement.source.should == source
     end
-    
+
     it "responds to utc_time_stamp" do
       @measurement.utc_time_stamp.should be_nil
     end
-    
+
     it "responds to current" do
       @measurement.current.should be_nil
     end
-    
+
     it "responds to forecast (and defaults to an empty Array)" do
       @measurement.forecast.should be_nil
     end
-    
+
     it "responds to timezone" do
       @measurement.timezone.should be_nil
     end
-    
+
     it "responds to station" do
       @measurement.station.should be_nil
     end
-    
+
     it "responds to location" do
       @measurement.location.should be_nil
     end
-    
+
     it "responds to success" do
       @measurement.success.should be_false
     end
-    
+
     it "responds to current?" do
       @measurement.current?.should be_true
     end
-    
+
     it "responds to metric" do
       @measurement.metric.should be_true
     end
-    
+
     it "responds to weight" do
       @measurement.weight.should == 1
     end
-    
+
     it "responds to links" do
       @measurement.links.should == {}
     end
-    
+
     it "responds to measured_at" do
       @measurement.measured_at.should be_nil
     end
-    
-    # it "responds to measured_for" do
-    #   @measurement.links.should == {}
-    # end
-    
   end
-  
+
   describe "when writing data" do
-    
     before(:each) do
       @measurement = Barometer::Measurement.new
     end
-    
+
     it "only accepts Symbol for source" do
       invalid_data = 1
       invalid_data.class.should_not == Symbol
       lambda { @measurement.source = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = :valid
       valid_data.class.should == Symbol
       lambda { @measurement.source = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Time for utc_time_stamp" do
       invalid_data = 1
       invalid_data.class.should_not == Time
       lambda { @measurement.utc_time_stamp = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Time.now.utc
       valid_data.class.should == Time
       lambda { @measurement.utc_time_stamp = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Measurement::Result for current" do
       invalid_data = "invalid"
       invalid_data.class.should_not == Barometer::Measurement::Result
       lambda { @measurement.current = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Barometer::Measurement::Result.new
       valid_data.class.should == Barometer::Measurement::Result
       lambda { @measurement.current = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::ResultArray for forecast" do
       invalid_data = 1
       invalid_data.class.should_not == Barometer::Measurement::ResultArray
       lambda { @measurement.forecast = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Barometer::Measurement::ResultArray.new
       valid_data.class.should == Barometer::Measurement::ResultArray
       lambda { @measurement.forecast = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Zone for timezone" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Zone
       lambda { @measurement.timezone = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Zone.new("Europe/Paris")
       valid_data.class.should == Data::Zone
       lambda { @measurement.timezone = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Location for station" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Location
       lambda { @measurement.station = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Location.new
       valid_data.class.should == Data::Location
       lambda { @measurement.station = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::Location for location" do
       invalid_data = 1
       invalid_data.class.should_not == Data::Location
       lambda { @measurement.location = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::Location.new
       valid_data.class.should == Data::Location
       lambda { @measurement.location = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Fixnum for weight" do
       invalid_data = "test"
       invalid_data.class.should_not == Fixnum
       lambda { @measurement.weight = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = 1
       valid_data.class.should == Fixnum
       lambda { @measurement.weight = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Array for links" do
       invalid_data = 1
       invalid_data.class.should_not == Hash
       lambda { @measurement.links = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = {1 => nil}
       valid_data.class.should == Hash
       lambda { @measurement.links = valid_data }.should_not raise_error(ArgumentError)
     end
-    
+
     it "only accepts Data::LocalTime for measured_at" do
       invalid_data = 1
       invalid_data.class.should_not == Data::LocalTime
       lambda { @measurement.measured_at = invalid_data }.should raise_error(ArgumentError)
-      
+
       valid_data = Data::LocalTime.new
       valid_data.class.should == Data::LocalTime
       lambda { @measurement.measured_at = valid_data }.should_not raise_error(ArgumentError)
     end
-    
   end
-  
+
   describe "and the helpers" do
-    
     before(:each) do
       @measurement = Barometer::Measurement.new
     end
-    
+
     it "changes state to successful (if successful)" do
       @measurement.success.should be_false
       @measurement.success!
       @measurement.utc_time_stamp.should be_nil
       @measurement.current.should be_nil
       @measurement.success.should be_false
-      
+
       @measurement.current = Barometer::Measurement::Result.new
       @measurement.current.temperature = Data::Temperature.new
       @measurement.current.temperature.c = 10
@@ -201,7 +191,7 @@ describe "Measurement" do
       @measurement.success!
       @measurement.success.should be_true
     end
-    
+
     it "returns successful state" do
       @measurement.current = Barometer::Measurement::Result.new
       @measurement.current.temperature = Data::Temperature.new
@@ -210,50 +200,32 @@ describe "Measurement" do
       @measurement.success.should be_true
       @measurement.success?.should be_true
     end
-    
+
     it "returns non-successful state" do
       @measurement.success.should be_false
       @measurement.success?.should be_false
     end
-    
+
     it "stamps the utc_time_stamp" do
       @measurement.utc_time_stamp.should be_nil
       @measurement.stamp!
       @measurement.utc_time_stamp.should_not be_nil
     end
-    
+
     it "indicates if current" do
       @measurement.current.should be_nil
       @measurement.current?.should be_true
-      
+
       @measurement.current = Barometer::Measurement::Result.new
       @measurement.current.current_at.should be_nil
       @measurement.current?.should be_true
-        
+
       @measurement.current.current_at = Data::LocalTime.new(9,0,0)
       @measurement.current?.should be_true
       @measurement.current?("9:00 am").should be_true
-      
-      
-    end
-      
-    
-    # it "indicates if current" do
-    #   #@measurement.time.should be_nil
-    #   @measurement.current?.should be_false
-    #   @measurement.stamp!
-    #   @measurement.time.should_not be_nil
-    #   @measurement.current?.should be_true
-    #   
-    #   @measurement.time -= (60*60*3)
-    #   @measurement.current?.should be_true
-    #   
-    #   @measurement.time -= (60*60*5)
-    #   @measurement.current?.should be_false
-    # end
-    
-    describe "changing units" do
+    end
 
+    describe "changing units" do
       before(:each) do
         @measurement = Barometer::Measurement.new
       end
@@ -278,16 +250,13 @@ describe "Measurement" do
         @measurement.metric!
         @measurement.metric?.should be_true
       end
-
     end
-
   end
-  
+
   describe "when searching forecasts using 'for'" do
-    
     before(:each) do
       @measurement = Barometer::Measurement.new
-      
+
       # create a measurement object with a result array that includes
       # dates for 4 consecutive days starting with tommorrow
       @measurement.forecast = Barometer::Measurement::ResultArray.new
@@ -297,139 +266,116 @@ describe "Measurement" do
         @measurement.forecast << forecast_measurement
       end
       @measurement.forecast.size.should == 4
-      
+
       @tommorrow = (Time.now + (60 * 60 * 24))
     end
-    
+
     it "returns nil when there are no forecasts" do
       @measurement.forecast = Barometer::Measurement::ResultArray.new
       @measurement.forecast.size.should == 0
       @measurement.for.should be_nil
     end
-    
+
     it "finds the date using a String" do
       tommorrow = @tommorrow.to_s
       tommorrow.class.should == String
       @measurement.for(tommorrow).should == @measurement.forecast.first
     end
-    
+
     it "finds the date using a Date" do
       tommorrow = Date.parse(@tommorrow.to_s)
       tommorrow.class.should == Date
       @measurement.for(tommorrow).should == @measurement.forecast.first
     end
-    
+
     it "finds the date using a DateTime" do
       tommorrow = DateTime.parse(@tommorrow.to_s)
       tommorrow.class.should == DateTime
       @measurement.for(tommorrow).should == @measurement.forecast.first
     end
-    
+
     it "finds the date using a Time" do
       @tommorrow.class.should == Time
       @measurement.for(@tommorrow).should == @measurement.forecast.first
     end
-    
+
     it "fidns the date using Data::LocalDateTime" do
       tommorrow = Data::LocalDateTime.parse(@tommorrow.to_s)
       tommorrow.class.should == Data::LocalDateTime
       @measurement.for(tommorrow).should == @measurement.forecast.first
     end
-    
+
     it "finds nothing when there is not a match" do
       yesterday = (Time.now - (60 * 60 * 24))
       yesterday.class.should == Time
       @measurement.for(yesterday).should be_nil
     end
-    
   end
-  
+
   describe "when answering the simple questions," do
-    
     before(:each) do
       @measurement = Barometer::Measurement.new(:wunderground)
       @measurement.current = Barometer::Measurement::Result.new
       @now = Data::LocalDateTime.parse("2009-05-01 2:05 pm")
     end
-    
-    # def windy?(time_string=nil, threshold=10)
-    #   local_time = Data::LocalTime.parse(time_string)
-    #   if current?(local_time)
-    #     return nil unless current
-    #     current.windy?(threshold)
-    #   else
-    #     return nil unless forecast && (future = forecast[local_time])
-    #     future.windy?(threshold)
-    #   end
-    # end
-    
+
     describe "windy?" do
-      
       it "returns true if a current_measurement returns true" do
-        @measurement.current.stubs(:windy?).returns(true)
+        @measurement.current.stub(:windy? => true)
         @measurement.windy?.should be_true
       end
-      
+
       it "returns false if a current_measurement returns false" do
-        @measurement.current.stubs(:windy?).returns(false)
+        @measurement.current.stub(:windy? => false)
         @measurement.windy?.should be_false
       end
-      
     end
-    
+
      describe "wet?" do
-       
        it "returns true if the current_measurement returns true" do
-         @measurement.current.stubs(:wet?).returns(true)
+         @measurement.current.stub(:wet? => true)
          @measurement.wet?.should be_true
        end
-     
+
        it "returns false if the current_measurement returns false" do
-         @measurement.current.stubs(:wet?).returns(false)
+         @measurement.current.stub(:wet? => false)
          @measurement.wet?.should be_false
        end
-       
      end
-     
+
     describe "day?" do
-    
       it "returns true if the current_measurement returns true" do
-        @measurement.current.stubs(:day?).returns(true)
+        @measurement.current.stub(:day? => true)
         @measurement.day?.should be_true
       end
-    
+
       it "returns false if the current_measurement returns false" do
-        @measurement.current.stubs(:day?).returns(false)
+        @measurement.current.stub(:day? => false)
         @measurement.day?.should be_false
       end
-      
     end
-    
+
     describe "sunny?" do
-      
       it "returns true if the current_measurement returns true and day" do
-        @measurement.current.stubs(:day?).returns(true)
-        @measurement.current.stubs(:sunny?).returns(true)
+        @measurement.current.stub(:day? => true)
+        @measurement.current.stub(:sunny? => true)
         @measurement.day?.should be_true
         @measurement.sunny?.should be_true
       end
-    
+
       it "returns false if the current_measurement returns false and day" do
-        @measurement.current.stubs(:day?).returns(true)
-        @measurement.current.stubs(:sunny?).returns(false)
+        @measurement.current.stub(:day? => true)
+        @measurement.current.stub(:sunny? => false)
         @measurement.day?.should be_true
         @measurement.sunny?.should be_false
       end
-      
+
       it "returns false if night time" do
-        @measurement.current.stubs(:day?).returns(false)
-        @measurement.current.stubs(:sunny?).returns(true)
+        @measurement.current.stub(:day? => false)
+        @measurement.current.stub(:sunny? => true)
         @measurement.day?.should be_false
         @measurement.sunny?.should be_false
       end
-    
     end
-    
   end
-  
 end