barometer 0.9.1 → 0.9.2

data/README.md

@@ -212,6 +212,7 @@ Thank you to these developers who have contributed. No contribution is too small
 * plukevdh (https://github.com/plukevdh)
 * gkop (https://github.com/gkop)
 * avit (https://github.com/avit)
+* jimjeffers (https://github.com/jimjeffers)
 
 ## Links
 

data/lib/barometer/query/base.rb

@@ -63,7 +63,7 @@ module Barometer
       def detect_format
         Format.match?(@q) do |key, klass|
           @format = key
-          @geo = Data::Geo.new(country_code: klass.country_code(@q))
+          @geo = Data::Geo.new(klass.geo(@q))
           @format_klass = klass
         end
       end

data/lib/barometer/query/formats/base.rb

@@ -10,7 +10,7 @@ module Barometer
       #
       class Base
         def self.regex; raise NotImplementedError; end
-        def self.country_code(query); nil; end
+        def self.geo(query); nil; end
         def self.convert_query(query); query; end
 
         def self.is?(query)

data/lib/barometer/query/formats/coordinates.rb

@@ -6,6 +6,13 @@ module Barometer
       #
       class Coordinates < Base
         def self.regex; /^[-]?[0-9\.]+[,]{1}\s?[-]?[0-9\.]+$/; end
+
+        def self.geo(query)
+          return unless query
+
+          coordinates = query.split(',')
+          {latitude: coordinates[0].to_f, longitude: coordinates[1].to_f}
+        end
       end
     end
   end

data/lib/barometer/query/formats/icao.rb

@@ -19,13 +19,15 @@ module Barometer
 
         # in some cases the first letter can designate the country
         #
-        def self.country_code(query)
+        def self.geo(query)
           return unless query && query.is_a?(String)
           $:.unshift(File.dirname(__FILE__))
           @@codes ||= YAML.load_file(@@codes_file)
           return unless @@codes && @@codes['one_letter'] && @@codes['two_letter']
-          @@codes['one_letter'][query[0..0].upcase.to_s] ||
+          country_code = @@codes['one_letter'][query[0..0].upcase.to_s] ||
             @@codes['two_letter'][query[0..1].upcase.to_s] || nil
+
+          {country_code: country_code}
         end
       end
     end

data/lib/barometer/query/formats/postalcode.rb

@@ -5,7 +5,7 @@ module Barometer
       # eg. H0H 0H0
       #
       class Postalcode < Base
-        def self.country_code(query); "CA"; end
+        def self.geo(query); {country_code: 'CA'}; end
         def self.regex
           # Rules: no D, F, I, O, Q, or U anywhere
           # Basic validation: ^[ABCEGHJ-NPRSTVXY]{1}[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}

data/lib/barometer/query/formats/short_zipcode.rb

@@ -5,7 +5,7 @@ module Barometer
       # eg. 90210
       #
       class ShortZipcode < Base
-        def self.country_code(query); "US"; end
+        def self.geo(query); {country_code: 'US'}; end
         def self.regex; /(^[0-9]{5}$)/; end
       end
     end

data/lib/barometer/query/formats/weather_id.rb

@@ -11,8 +11,11 @@ module Barometer
         @@fixes = nil
 
         def self.regex; /(^[A-Za-z]{4}[0-9]{4}$)/; end
-        def self.country_code(query)
-          (query && query.size >= 2) ? _fix_country(query[0..1]) : nil
+
+        def self.geo(query)
+          if query && query.size >= 2
+            { country_code: _fix_country(query[0..1]) }
+          end
         end
 
         private

data/lib/barometer/query/formats/zipcode.rb

@@ -5,7 +5,7 @@ module Barometer
       # eg. 90210 or 90210-5555
       #
       class Zipcode < Base
-        def self.country_code(query); "US"; end
+        def self.geo(query); {country_code: 'US'}; end
         def self.regex; /(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)/; end
       end
     end

data/lib/barometer/version.rb

@@ -1,3 +1,3 @@
 module Barometer
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
 end

data/lib/barometer/weather_services/weather_bug/query.rb

@@ -29,7 +29,7 @@ module Barometer
           if converted_query.format == :short_zipcode
             {zipCode: converted_query.q}
           else
-            {lat: converted_query.latitude, long: converted_query.longitude}
+            {lat: converted_query.geo.latitude, long: converted_query.geo.longitude}
           end
         end
 

data/spec/query/base_spec.rb

@@ -38,6 +38,8 @@ module Barometer
           query = Query::Base.new('40.756054,-73.986951')
           expect( query.format ).to eq :coordinates
           expect( query.geo.country_code ).to be_nil
+          expect( query.geo.latitude ).to eq 40.756054
+          expect( query.geo.longitude ).to eq -73.986951
         end
 
         it 'defaults to :unknown' do

data/spec/query/formats/base_spec.rb

@@ -1,15 +1,15 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Base do
-  describe "and class methods" do
-    describe "is?," do
-      it "calls a stubbed undefined method" do
-        expect { Barometer::Query::Format::Base.is?("valid") }.to raise_error(NotImplementedError)
+module Barometer::Query
+  describe Format::Base do
+    describe '.is?' do
+      it 'raises an error by default' do
+        expect { Format::Base.is?('valid') }.to raise_error(NotImplementedError)
       end
     end
 
-    it "stubs country_code" do
-      Barometer::Query::Format::Base.country_code(nil).should be_nil
+    describe '.geo' do
+      specify { expect( Format::Base.geo(nil) ).to be_nil }
     end
   end
 end

data/spec/query/formats/coordinates_spec.rb

@@ -1,13 +1,23 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Coordinates do
-  describe ".is?" do
-    it "returns true when valid" do
-      Barometer::Query::Format::Coordinates.is?("40.756054,-73.986951").should be_true
+module Barometer::Query
+  describe Format::Coordinates do
+    describe '.geo' do
+      specify { expect( Format::Coordinates.geo(nil) ).to be_nil }
+
+      it 'parses out the latitude and longitude' do
+        expect( Format::Coordinates.geo('11.22,33.44') ).to eq({latitude: 11.22, longitude: 33.44})
+      end
     end
 
-    it "returns false when not valid" do
-      Barometer::Query::Format::Coordinates.is?("90210").should be_false
+    describe '.is?' do
+      it 'returns true when valid' do
+        expect( Format::Coordinates.is?('40.756054,-73.986951') ).to be_true
+      end
+
+      it 'returns false when not valid' do
+        expect( Format::Coordinates.is?('90210') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/geocode_spec.rb

@@ -1,9 +1,11 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Geocode do
-  describe ".is?" do
-    it "returns false" do
-      Barometer::Query::Format::Geocode.is?("New York, NY").should be_false
+module Barometer::Query
+  describe Format::Geocode do
+    describe '.is?' do
+      it 'returns false' do
+        expect( Format::Geocode.is?('New York, NY') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/icao_spec.rb

@@ -1,20 +1,22 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Icao do
-  it ".country_code" do
-    Barometer::Query::Format::Icao.country_code(nil).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
-
-  describe ".is?" do
-    it "recognizes a valid format" do
-      Barometer::Query::Format::Icao.is?("KSFO").should be_true
+module Barometer::Query
+  describe Format::Icao do
+    describe '.geo' do
+      specify { expect( Format::Icao.geo(nil) ).to be_nil }
+      specify { expect( Format::Icao.geo('KSFO') ).to eq({country_code: 'US'}) }
+      specify { expect( Format::Icao.geo('CYYC') ).to eq({country_code: 'CA'}) }
+      specify { expect( Format::Icao.geo('ETAA') ).to eq({country_code: 'DE'}) }
     end
 
-    it "recognizes non-valid format" do
-      Barometer::Query::Format::Icao.is?("invalid").should be_false
+    describe '.is?' do
+      it 'recognizes a valid format' do
+        expect( Format::Icao.is?('KSFO') ).to be_true
+      end
+
+      it 'recognizes non-valid format' do
+        expect( Format::Icao.is?('invalid') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/noaa_station_id_spec.rb

@@ -1,9 +1,11 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::NoaaStationId do
-  describe ".is?" do
-    it "returns false" do
-      Barometer::Query::Format::NoaaStationId.is?("").should be_false
+module Barometer::Query
+  describe Format::NoaaStationId do
+    describe '.is?' do
+      it 'returns false' do
+        expect( Format::NoaaStationId.is?('') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/postalcode_spec.rb

@@ -1,18 +1,20 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Postalcode do
-  it ".country_code" do
-    Barometer::Query::Format::Postalcode.country_code(nil).should == "CA"
-    Barometer::Query::Format::Postalcode.country_code("ignored").should == "CA"
-  end
-
-  describe ".is?" do
-    it "recognizes a valid format" do
-      Barometer::Query::Format::Postalcode.is?("T5B 4M9").should be_true
+module Barometer::Query
+  describe Format::Postalcode do
+    describe '.geo' do
+      specify { expect( Format::Postalcode.geo(nil) ).to eq({country_code: 'CA'}) }
+      specify { expect( Format::Postalcode.geo('ignored') ).to eq({country_code: 'CA'}) }
     end
 
-    it "recognizes non-valid format" do
-      Barometer::Query::Format::Postalcode.is?("90210").should be_false
+    describe '.is?' do
+      it 'recognizes a valid format' do
+        expect( Format::Postalcode.is?('T5B 4M9') ).to be_true
+      end
+
+      it 'recognizes non-valid format' do
+        expect( Format::Postalcode.is?('90210') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/short_zipcode_spec.rb

@@ -1,18 +1,20 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::ShortZipcode do
-  it ".country_code" do
-    Barometer::Query::Format::ShortZipcode.country_code(nil).should == "US"
-    Barometer::Query::Format::ShortZipcode.country_code("ignored").should == "US"
-  end
-
-  describe ".is?" do
-    it "recognizes a valid format" do
-      Barometer::Query::Format::ShortZipcode.is?("90210").should be_true
+module Barometer::Query
+  describe Format::ShortZipcode do
+    describe '.geo' do
+      specify { expect( Format::ShortZipcode.geo(nil) ).to eq({country_code: 'US'}) }
+      specify { expect( Format::ShortZipcode.geo('ignored') ).to eq({country_code: 'US'}) }
     end
 
-    it "recognizes non-valid format" do
-      Barometer::Query::Format::ShortZipcode.is?("90210-5555").should be_false
+    describe '.is?' do
+      it 'recognizes a valid format' do
+        expect( Format::ShortZipcode.is?('90210') ).to be_true
+      end
+
+      it 'recognizes non-valid format' do
+        expect( Format::ShortZipcode.is?('90210-5555') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/unknown_spec.rb

@@ -1,9 +1,11 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Unknown do
-  describe ".is?" do
-    it "returns true" do
-      Barometer::Query::Format::Unknown.is?("New York, NY").should be_true
+module Barometer::Query
+  describe Format::Unknown do
+    describe '.is?' do
+      it 'returns true' do
+        expect( Format::Unknown.is?('New York, NY') ).to be_true
+      end
     end
   end
 end

data/spec/query/formats/weather_id_spec.rb

@@ -1,31 +1,29 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::WeatherID do
-  it ".country_code" do
-    Barometer::Query::Format::WeatherID.country_code(nil).should be_nil
-    Barometer::Query::Format::WeatherID.country_code("i").should be_nil
-    Barometer::Query::Format::WeatherID.country_code("USGA0000").should == "US"
-    Barometer::Query::Format::WeatherID.country_code("CAAB0000").should == "CA"
-    Barometer::Query::Format::WeatherID.country_code("SPXX0000").should == "ES"
-  end
+module Barometer::Query
+  describe Format::WeatherID do
+    describe '.geo' do
+      specify { expect( Format::WeatherID.geo(nil) ).to be_nil }
+      specify { expect( Format::WeatherID.geo('i') ).to be_nil }
 
-  describe ".is?" do
-    it "recognizes a valid format" do
-      Barometer::Query::Format::WeatherID.is?("USGA0028").should be_true
-    end
+      context 'when the country code is standard' do
+        specify { expect( Format::WeatherID.geo('USGA0000') ).to eq({country_code: 'US'}) }
+        specify { expect( Format::WeatherID.geo('CAAB0000') ).to eq({country_code: 'CA'}) }
+      end
 
-    it "recognizes non-valid format" do
-      Barometer::Query::Format::WeatherID.is?("invalid").should be_false
+      context 'when the country code is non standard' do
+        specify { expect( Format::WeatherID.geo('SPXX0000') ).to eq({country_code: 'ES'}) }
+      end
     end
-  end
 
-  describe "fixing country codes" do
-    it "doesn't fix a correct code" do
-      Barometer::Query::Format::WeatherID.send("_fix_country", "CA").should == "CA"
-    end
+    describe '.is?' do
+      it 'recognizes a valid format' do
+        expect( Format::WeatherID.is?('USGA0028') ).to be_true
+      end
 
-    it "fixes an incorrect code" do
-      Barometer::Query::Format::WeatherID.send("_fix_country", "SP").should == "ES"
+      it 'recognizes non-valid format' do
+        expect( Format::WeatherID.is?('invalid') ).to be_false
+      end
     end
   end
 end

data/spec/query/formats/zipcode_spec.rb

@@ -1,18 +1,20 @@
 require_relative '../../spec_helper'
 
-describe Barometer::Query::Format::Zipcode do
-  it ".country_code" do
-    Barometer::Query::Format::Zipcode.country_code(nil).should == "US"
-    Barometer::Query::Format::Zipcode.country_code("ignored").should == "US"
-  end
-
-  describe ".is?" do
-    it "recognizes a valid format" do
-      Barometer::Query::Format::Zipcode.is?("90210-5555").should be_true
+module Barometer::Query
+  describe Format::Zipcode do
+    describe '.geo' do
+      specify { expect( Format::Zipcode.geo(nil) ).to eq({country_code: 'US'}) }
+      specify { expect( Format::Zipcode.geo('ignored') ).to eq({country_code: 'US'}) }
     end
 
-    it "recognizes non-valid format" do
-      Barometer::Query::Format::Zipcode.is?("invalid").should be_false
+    describe '.is?' do
+      it 'recognizes a valid format' do
+        expect( Format::Zipcode.is?('90210-5555') ).to be_true
+      end
+
+      it 'recognizes non-valid format' do
+        expect( Format::Zipcode.is?('invalid') ).to be_false
+      end
     end
   end
 end

data/spec/weather_services/weather_bug/query_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../../spec_helper'
+
+module Barometer::WeatherService
+  describe WeatherBug::Query do
+    describe '#to_param' do
+      let(:converted_query) { double(:converted_query).as_null_object }
+      let(:query) { WeatherBug::Query.new(converted_query) }
+
+      context 'when the query is a :short_zipcode' do
+        before { converted_query.stub(format: :short_zipcode, q: '90210') }
+
+        it 'includes the correct parameters' do
+          expect( query.to_param[:zipCode] ).to eq '90210'
+        end
+      end
+
+      context 'and the query is a :coordinates' do
+        let(:geo) { double(:geo, latitude: '11.22', longitude: '33.44') }
+        before { converted_query.stub(format: :coordinates, geo: geo) }
+
+        it 'includes the correct parameters' do
+          expect( query.to_param[:lat] ).to eq '11.22'
+          expect( query.to_param[:long] ).to eq '33.44'
+        end
+      end
+
+      context 'and the query is metric' do
+        before { converted_query.stub(metric?: true) }
+
+        it 'includes the correct parameters' do
+          expect( query.to_param[:UnitType] ).to eq '1'
+        end
+      end
+
+      context 'and the query is imperial' do
+        before { converted_query.stub(metric?: false) }
+
+        it 'includes the correct parameters' do
+          expect( query.to_param[:UnitType] ).to eq '0'
+        end
+      end
+    end
+  end
+end

data/spec/weather_services/weather_bug_spec.rb

@@ -1,77 +1,79 @@
 require_relative '../spec_helper'
 
-describe Barometer::WeatherService::WeatherBug, vcr: {
-  cassette_name: "WeatherService::WeatherBug"
-} do
+module Barometer
+  describe WeatherService::WeatherBug, vcr: {
+    cassette_name: 'WeatherService::WeatherBug'
+  } do
 
-  it "auto-registers this weather service as :weather_bug" do
-    Barometer::WeatherService.source(:weather_bug).should == Barometer::WeatherService::WeatherBug
-  end
+    it 'auto-registers this weather service as :weather_bug' do
+      expect( WeatherService.source(:weather_bug) ).to eq WeatherService::WeatherBug
+    end
 
-  describe ".call" do
-    context "when no keys provided" do
-      let(:query) { build_query }
+    describe '.call' do
+      context 'when no keys are provided' do
+        let(:query) { build_query }
 
-      it "raises error" do
-        expect {
-          Barometer::WeatherService::WeatherBug.call(query)
-        }.to raise_error(Barometer::WeatherService::KeyRequired)
+        it 'raises an error' do
+          expect {
+            WeatherService::WeatherBug.call(query)
+          }.to raise_error(WeatherService::KeyRequired)
+        end
       end
-    end
 
-    context "when keys are provided" do
-      let(:converted_query) { Barometer::ConvertedQuery.new("90210", :short_zipcode, :metric) }
-      let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
-      let(:config) { {keys: {code: WEATHERBUG_CODE}} }
+      context 'when keys are provided' do
+        let(:converted_query) { Barometer::ConvertedQuery.new('90210', :short_zipcode, :metric) }
+        let(:query) { build_query.tap{|q|q.stub(:convert! => converted_query)} }
+        let(:config) { {keys: {code: WEATHERBUG_CODE}} }
 
-      subject { Barometer::WeatherService::WeatherBug.call(query, config) }
+        subject { WeatherService::WeatherBug.call(query, config) }
 
-      it "asks the query to convert to accepted formats" do
-        query.should_receive(:convert!).with(:short_zipcode, :coordinates)
-        subject
-      end
+        it 'converts the query to accepted formats' do
+          subject
+          expect( query ).to have_received(:convert!).with(:short_zipcode, :coordinates).at_least(:once)
+        end
 
-      it "includes the expected data" do
-        subject.query.should == '90210'
-        subject.format.should == :short_zipcode
-        subject.should be_metric
+        it 'includes the expected data' do
+          expect( subject.query ).to eq '90210'
+          expect( subject.format ).to eq :short_zipcode
+          expect( subject ).to be_metric
 
-        should have_data(:current, :observed_at).as_format(:time)
-        should have_data(:current, :stale_at).as_format(:time)
+          should have_data(:current, :observed_at).as_format(:time)
+          should have_data(:current, :stale_at).as_format(:time)
 
-        should have_data(:current, :humidity).as_format(:float)
-        should have_data(:current, :condition).as_format(:string)
-        should have_data(:current, :icon).as_format(:number)
-        should have_data(:current, :temperature).as_format(:temperature)
-        should have_data(:current, :dew_point).as_format(:temperature)
-        should have_data(:current, :wind_chill).as_format(:temperature)
-        should have_data(:current, :wind).as_format(:vector)
-        should have_data(:current, :pressure).as_format(:pressure)
-        should have_data(:current, :sun, :rise).as_format(:time)
-        should have_data(:current, :sun, :set).as_format(:time)
+          should have_data(:current, :humidity).as_format(:float)
+          should have_data(:current, :condition).as_format(:string)
+          should have_data(:current, :icon).as_format(:number)
+          should have_data(:current, :temperature).as_format(:temperature)
+          should have_data(:current, :dew_point).as_format(:temperature)
+          should have_data(:current, :wind_chill).as_format(:temperature)
+          should have_data(:current, :wind).as_format(:vector)
+          should have_data(:current, :pressure).as_format(:pressure)
+          should have_data(:current, :sun, :rise).as_format(:time)
+          should have_data(:current, :sun, :set).as_format(:time)
 
-        should have_data(:station, :id).as_value("NRTSH")
-        should have_data(:station, :name).as_value("Campbell Hall School")
-        should have_data(:station, :city).as_value("Valley Village")
-        should have_data(:station, :state_code).as_value("CA")
-        should have_data(:station, :country).as_value("USA")
-        should have_data(:station, :zip_code).as_value("91617")
-        should have_data(:station, :latitude).as_value(34.1536102294922)
-        should have_data(:station, :longitude).as_value(-118.398056030273)
+          should have_data(:station, :id).as_value('NRTSH')
+          should have_data(:station, :name).as_value('Campbell Hall School')
+          should have_data(:station, :city).as_value('Valley Village')
+          should have_data(:station, :state_code).as_value('CA')
+          should have_data(:station, :country).as_value('USA')
+          should have_data(:station, :zip_code).as_value('91617')
+          should have_data(:station, :latitude).as_value(34.1536102294922)
+          should have_data(:station, :longitude).as_value(-118.398056030273)
 
-        should have_data(:location, :city).as_value("Beverly Hills")
-        should have_data(:location, :state_code).as_value("CA")
-        should have_data(:location, :zip_code).as_value("90210")
+          should have_data(:location, :city).as_value('Beverly Hills')
+          should have_data(:location, :state_code).as_value('CA')
+          should have_data(:location, :zip_code).as_value('90210')
 
-        should have_data(:timezone, :to_s).as_format(/^P[DS]T$/i)
+          should have_data(:timezone, :to_s).as_format(/^P[DS]T$/i)
 
-        subject.forecast.size.should == 7
-        should have_forecast(:starts_at).as_format(:time)
-        should have_forecast(:ends_at).as_format(:time)
-        should have_forecast(:condition).as_format(:string)
-        should have_forecast(:icon).as_format(:number)
-        should have_forecast(:high).as_format(:temperature)
-        should have_forecast(:low).as_format(:temperature)
+          expect( subject.forecast.size ).to eq 7
+          should have_forecast(:starts_at).as_format(:time)
+          should have_forecast(:ends_at).as_format(:time)
+          should have_forecast(:condition).as_format(:string)
+          should have_forecast(:icon).as_format(:number)
+          should have_forecast(:high).as_format(:temperature)
+          should have_forecast(:low).as_format(:temperature)
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: barometer
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-31 00:00:00.000000000 Z
+date: 2013-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -475,6 +475,7 @@ files:
 - spec/weather_services/noaa_spec.rb
 - spec/weather_services/weather_bug/current_response_spec.rb
 - spec/weather_services/weather_bug/forecast_response_spec.rb
+- spec/weather_services/weather_bug/query_spec.rb
 - spec/weather_services/weather_bug_spec.rb
 - spec/weather_services/wunderground_v1/current_response_spec.rb
 - spec/weather_services/wunderground_v1/forecast_response_spec.rb
@@ -603,6 +604,7 @@ test_files:
 - spec/weather_services/noaa_spec.rb
 - spec/weather_services/weather_bug/current_response_spec.rb
 - spec/weather_services/weather_bug/forecast_response_spec.rb
+- spec/weather_services/weather_bug/query_spec.rb
 - spec/weather_services/weather_bug_spec.rb
 - spec/weather_services/wunderground_v1/current_response_spec.rb
 - spec/weather_services/wunderground_v1/forecast_response_spec.rb