barometer 0.7.3 → 0.8.0

data/spec/formats/icao_spec.rb

@@ -1,61 +1,55 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Query::Icao" do
-  
+describe Barometer::Query::Format::Icao do
   before(:each) do
     @valid = "KSFO"
     @invalid = "invalid"
   end
-  
+
   describe "and class methods" do
-    
     it "returns a format" do
-      Query::Format::Icao.format.should == :icao
+      Barometer::Query::Format::Icao.format.should == :icao
     end
-    
+
     it "returns a country" do
-      Query::Format::Icao.country_code.should be_nil
-      Query::Format::Icao.country_code("KSFO").should == "US"
-      Query::Format::Icao.country_code("CYYC").should == "CA"
-      Query::Format::Icao.country_code("ETAA").should == "DE"
+      Barometer::Query::Format::Icao.country_code.should be_nil
+      Barometer::Query::Format::Icao.country_code("KSFO").should == "US"
+      Barometer::Query::Format::Icao.country_code("CYYC").should == "CA"
+      Barometer::Query::Format::Icao.country_code("ETAA").should == "DE"
     end
-    
+
     it "returns a regex" do
-      Query::Format::Icao.regex.should_not be_nil
-      Query::Format::Icao.regex.is_a?(Regexp).should be_true
+      Barometer::Query::Format::Icao.regex.should_not be_nil
+      Barometer::Query::Format::Icao.regex.is_a?(Regexp).should be_true
     end
-    
+
     it "returns the convertable_formats" do
-      Query::Format::Icao.convertable_formats.should_not be_nil
-      Query::Format::Icao.convertable_formats.is_a?(Array).should be_true
-      Query::Format::Icao.convertable_formats.should == []
+      Barometer::Query::Format::Icao.convertable_formats.should_not be_nil
+      Barometer::Query::Format::Icao.convertable_formats.is_a?(Array).should be_true
+      Barometer::Query::Format::Icao.convertable_formats.should == []
     end
-    
+
     describe "is?," do
-      
       it "recognizes a valid format" do
-        Query::Format::Icao.is?(@valid).should be_true
+        Barometer::Query::Format::Icao.is?(@valid).should be_true
       end
-      
+
       it "recognizes non-valid format" do
-        Query::Format::Icao.is?(@invalid).should be_false
+        Barometer::Query::Format::Icao.is?(@invalid).should be_false
       end
-      
     end
-  
+
     it "stubs to" do
-      Query::Format::Icao.to.should be_nil
+      Barometer::Query::Format::Icao.to.should be_nil
     end
-    
+
     it "stubs convertable_formats" do
-      Query::Format::Icao.convertable_formats.should == []
+      Barometer::Query::Format::Icao.convertable_formats.should == []
     end
-    
+
     it "doesn't convert" do
       query = Barometer::Query.new(@valid)
-      Query::Format::Icao.converts?(query).should be_false
+      Barometer::Query::Format::Icao.converts?(query).should be_false
     end
-    
   end
-  
-end
+end

data/spec/formats/postalcode_spec.rb

@@ -1,59 +1,53 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Query::Postalcode" do
-  
+describe Barometer::Query::Format::Postalcode do
   before(:each) do
     @valid = "T5B 4M9"
     @invalid = "90210"
   end
-  
+
   describe "and class methods" do
-    
     it "returns a format" do
-      Query::Format::Postalcode.format.should == :postalcode
+      Barometer::Query::Format::Postalcode.format.should == :postalcode
     end
-    
+
     it "returns a country" do
-      Query::Format::Postalcode.country_code.should == "CA"
-      Query::Format::Postalcode.country_code("ignored").should == "CA"
+      Barometer::Query::Format::Postalcode.country_code.should == "CA"
+      Barometer::Query::Format::Postalcode.country_code("ignored").should == "CA"
     end
-    
+
     it "returns a regex" do
-      Query::Format::Postalcode.regex.should_not be_nil
-      Query::Format::Postalcode.regex.is_a?(Regexp).should be_true
+      Barometer::Query::Format::Postalcode.regex.should_not be_nil
+      Barometer::Query::Format::Postalcode.regex.is_a?(Regexp).should be_true
     end
-    
+
     it "returns the convertable_formats" do
-      Query::Format::Postalcode.convertable_formats.should_not be_nil
-      Query::Format::Postalcode.convertable_formats.is_a?(Array).should be_true
-      Query::Format::Postalcode.convertable_formats.should == []
+      Barometer::Query::Format::Postalcode.convertable_formats.should_not be_nil
+      Barometer::Query::Format::Postalcode.convertable_formats.is_a?(Array).should be_true
+      Barometer::Query::Format::Postalcode.convertable_formats.should == []
     end
-    
+
     describe "is?," do
-      
       it "recognizes a valid format" do
-        Query::Format::Postalcode.is?(@valid).should be_true
+        Barometer::Query::Format::Postalcode.is?(@valid).should be_true
       end
-      
+
       it "recognizes non-valid format" do
-        Query::Format::Postalcode.is?(@invalid).should be_false
+        Barometer::Query::Format::Postalcode.is?(@invalid).should be_false
       end
-      
     end
-  
+
     it "stubs to" do
-      Query::Format::Postalcode.to.should be_nil
+      Barometer::Query::Format::Postalcode.to.should be_nil
     end
 
     it "stubs convertable_formats" do
-      Query::Format::Postalcode.convertable_formats.should == []
+      Barometer::Query::Format::Postalcode.convertable_formats.should == []
     end
 
     it "doesn't convert" do
       query = Barometer::Query.new(@valid)
-      Query::Format::Postalcode.converts?(query).should be_false
+      Barometer::Query::Format::Postalcode.converts?(query).should be_false
     end
-
   end
-  
-end
+end

data/spec/formats/short_zipcode_spec.rb

@@ -1,53 +1,47 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Query::ShortZipcode" do
-  
+describe Barometer::Query::Format::ShortZipcode do
   before(:each) do
     @valid = "90210"
     @invalid = "90210-5555"
   end
-  
+
   describe "and class methods" do
-    
     it "returns a format" do
-      Query::Format::ShortZipcode.format.should == :short_zipcode
+      Barometer::Query::Format::ShortZipcode.format.should == :short_zipcode
     end
-    
+
     it "returns a country" do
-      Query::Format::ShortZipcode.country_code.should == "US"
-      Query::Format::ShortZipcode.country_code("ignored").should == "US"
+      Barometer::Query::Format::ShortZipcode.country_code.should == "US"
+      Barometer::Query::Format::ShortZipcode.country_code("ignored").should == "US"
     end
-    
+
     it "returns a regex" do
-      Query::Format::ShortZipcode.regex.should_not be_nil
-      Query::Format::ShortZipcode.regex.is_a?(Regexp).should be_true
+      Barometer::Query::Format::ShortZipcode.regex.should_not be_nil
+      Barometer::Query::Format::ShortZipcode.regex.is_a?(Regexp).should be_true
     end
-    
+
     describe "is?," do
-      
       it "recognizes a valid format" do
-        Query::Format::ShortZipcode.is?(@valid).should be_true
+        Barometer::Query::Format::ShortZipcode.is?(@valid).should be_true
       end
-      
+
       it "recognizes non-valid format" do
-        Query::Format::ShortZipcode.is?(@invalid).should be_false
+        Barometer::Query::Format::ShortZipcode.is?(@invalid).should be_false
       end
-      
     end
-  
+
     it "stubs to" do
-      Query::Format::ShortZipcode.to.should be_nil
+      Barometer::Query::Format::ShortZipcode.to.should be_nil
     end
-    
+
     it "stubs convertable_formats" do
-      Query::Format::ShortZipcode.convertable_formats.should == []
+      Barometer::Query::Format::ShortZipcode.convertable_formats.should == []
     end
-    
+
     it "doesn't convert" do
       query = Barometer::Query.new(@valid)
-      Query::Format::ShortZipcode.converts?(query).should be_false
+      Barometer::Query::Format::ShortZipcode.converts?(query).should be_false
     end
-    
   end
-  
-end
+end

data/spec/formats/weather_id_spec.rb

@@ -1,7 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Query::WeatherID" do
-  
+describe Barometer::Query::Format::WeatherID, :vcr => {
+  :cassette_name => "Query::Format::WeatherID"
+} do
   before(:each) do
     @short_zipcode = "90210"
     @zipcode = @short_zipcode
@@ -12,120 +13,112 @@ describe "Query::WeatherID" do
     @geocode = "New York, NY"
     @icao = "KSFO"
   end
-  
+
   describe "and class methods" do
-    
     before(:each) do
       @us_query = "USGA0000"
       @ca_query = "CAAB0000"
       @es_query = "SPXX0000"
     end
-    
+
     it "returns a format" do
-      Query::Format::WeatherID.format.should == :weather_id
+      Barometer::Query::Format::WeatherID.format.should == :weather_id
     end
-    
+
     it "returns a country" do
-      Query::Format::WeatherID.country_code.should be_nil
-      Query::Format::WeatherID.country_code("i").should be_nil
-      Query::Format::WeatherID.country_code(@us_query).should == "US"
-      Query::Format::WeatherID.country_code(@ca_query).should == "CA"
-      Query::Format::WeatherID.country_code(@es_query).should == "ES"
+      Barometer::Query::Format::WeatherID.country_code.should be_nil
+      Barometer::Query::Format::WeatherID.country_code("i").should be_nil
+      Barometer::Query::Format::WeatherID.country_code(@us_query).should == "US"
+      Barometer::Query::Format::WeatherID.country_code(@ca_query).should == "CA"
+      Barometer::Query::Format::WeatherID.country_code(@es_query).should == "ES"
     end
-    
+
     it "returns a regex" do
-      Query::Format::WeatherID.regex.should_not be_nil
-      Query::Format::WeatherID.regex.is_a?(Regexp).should be_true
+      Barometer::Query::Format::WeatherID.regex.should_not be_nil
+      Barometer::Query::Format::WeatherID.regex.is_a?(Regexp).should be_true
     end
-    
+
     it "returns the convertable_formats" do
-      Query::Format::WeatherID.convertable_formats.should_not be_nil
-      Query::Format::WeatherID.convertable_formats.is_a?(Array).should be_true
-      Query::Format::WeatherID.convertable_formats.include?(:short_zipcode).should be_true
-      Query::Format::WeatherID.convertable_formats.include?(:zipcode).should be_true
-      Query::Format::WeatherID.convertable_formats.include?(:coordinates).should be_true
-      Query::Format::WeatherID.convertable_formats.include?(:geocode).should be_true
+      Barometer::Query::Format::WeatherID.convertable_formats.should_not be_nil
+      Barometer::Query::Format::WeatherID.convertable_formats.is_a?(Array).should be_true
+      Barometer::Query::Format::WeatherID.convertable_formats.include?(:short_zipcode).should be_true
+      Barometer::Query::Format::WeatherID.convertable_formats.include?(:zipcode).should be_true
+      Barometer::Query::Format::WeatherID.convertable_formats.include?(:coordinates).should be_true
+      Barometer::Query::Format::WeatherID.convertable_formats.include?(:geocode).should be_true
     end
-    
+
     describe "is?," do
-      
       before(:each) do
         @valid = "USGA0028"
         @invalid = "invalid"
       end
-      
+
       it "recognizes a valid format" do
-        Query::Format::WeatherID.is?(@valid).should be_true
+        Barometer::Query::Format::WeatherID.is?(@valid).should be_true
       end
-      
+
       it "recognizes non-valid format" do
-        Query::Format::WeatherID.is?(@invalid).should be_false
+        Barometer::Query::Format::WeatherID.is?(@invalid).should be_false
       end
-      
     end
-    
+
     describe "fixing country codes" do
-      
       it "doesn't fix a correct code" do
-        Query::Format::WeatherID.send("_fix_country", "CA").should == "CA"
+        Barometer::Query::Format::WeatherID.send("_fix_country", "CA").should == "CA"
       end
-      
+
       it "fixes an incorrect code" do
-        Query::Format::WeatherID.send("_fix_country", "SP").should == "ES"
+        Barometer::Query::Format::WeatherID.send("_fix_country", "SP").should == "ES"
       end
-      
     end
-    
+
     describe "when reversing lookup" do
-      
       it "requires a Barometer::Query object" do
-        lambda { Query::Format::WeatherID.reverse }.should raise_error(ArgumentError)
-        lambda { Query::Format::WeatherID.reverse("invalid") }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.reverse }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.reverse("invalid") }.should raise_error(ArgumentError)
         query = Barometer::Query.new(@weather_id)
         query.is_a?(Barometer::Query).should be_true
-        lambda { Query::Format::WeatherID.reverse(original_query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.reverse(original_query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Query" do
         query = Barometer::Query.new(@weather_id)
-        Query::Format::WeatherID.reverse(query).is_a?(Barometer::Query).should be_true
+        Barometer::Query::Format::WeatherID.reverse(query).is_a?(Barometer::Query).should be_true
       end
-      
+
       it "reverses a valid weather_id (US)" do
         query = Barometer::Query.new(@weather_id)
-        new_query = Query::Format::WeatherID.reverse(query)
+        new_query = Barometer::Query::Format::WeatherID.reverse(query)
         new_query.q.should == "Atlanta, GA, US"
         new_query.country_code.should be_nil
         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)
-        Query::Format::WeatherID.reverse(query).should be_nil
+        Barometer::Query::Format::WeatherID.reverse(query).should be_nil
       end
-      
     end
-  
+
     describe "when converting using 'to'," do
-      
       it "requires a Barometer::Query object" do
-        lambda { Query::Format::WeatherID.to }.should raise_error(ArgumentError)
-        lambda { Query::Format::WeatherID.to("invalid") }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.to }.should raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.to("invalid") }.should raise_error(ArgumentError)
         query = Barometer::Query.new(@zipcode)
         query.is_a?(Barometer::Query).should be_true
-        lambda { Query::Format::WeatherID.to(original_query) }.should_not raise_error(ArgumentError)
+        lambda { Barometer::Query::Format::WeatherID.to(original_query) }.should_not raise_error(ArgumentError)
       end
-      
+
       it "returns a Barometer::Query" do
         query = Barometer::Query.new(@short_zipcode)
-        Query::Format::WeatherID.to(query).is_a?(Barometer::Query).should be_true
+        Barometer::Query::Format::WeatherID.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::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.q.should == "USCA0090"
         new_query.country_code.should == "US"
         new_query.format.should == :weather_id
@@ -136,7 +129,7 @@ describe "Query::WeatherID" do
         query = Barometer::Query.new(@zipcode)
         query.format = :zipcode
         query.format.should == :zipcode
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.q.should == "USCA0090"
         new_query.country_code.should == "US"
         new_query.format.should == :weather_id
@@ -146,7 +139,7 @@ describe "Query::WeatherID" do
       it "converts from coordinates" do
         query = Barometer::Query.new(@coordinates)
         query.format.should == :coordinates
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.q.should == "USNY0996"
         new_query.country_code.should == "US"
         new_query.format.should == :weather_id
@@ -156,7 +149,7 @@ describe "Query::WeatherID" do
       it "converts from geocode" do
         query = Barometer::Query.new(@geocode)
         query.format.should == :geocode
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.q.should == "USNY0996"
         new_query.country_code.should == "US"
         new_query.format.should == :weather_id
@@ -166,7 +159,7 @@ describe "Query::WeatherID" do
       it "converts from icao" do
         query = Barometer::Query.new(@icao)
         query.format.should == :icao
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.q.should == "USCA0987"
         new_query.country_code.should == "US"
         new_query.format.should == :weather_id
@@ -176,17 +169,14 @@ describe "Query::WeatherID" do
       it "returns nil for other formats" do
         query = Barometer::Query.new(@weather_id)
         query.format.should == :weather_id
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.should be_nil
-        
+
         query = Barometer::Query.new(@postal_code)
         query.format.should == :postalcode
-        new_query = Query::Format::WeatherID.to(query)
+        new_query = Barometer::Query::Format::WeatherID.to(query)
         new_query.should be_nil
       end
-
     end
-
   end
-  
-end
+end