barometer 0.5.0 → 0.6.1

data/lib/barometer/weather_services/weather_dot_com.rb

@@ -43,9 +43,6 @@ module Barometer
     @@partner_key = nil
     @@license_key = nil
 
-    def self.source_name; :weather_dot_com; end
-    def self.accepted_formats; [:short_zipcode, :weather_id]; end
-
     def self.keys=(keys)
       raise ArgumentError unless keys.is_a?(Hash)
       keys.each do |key, value|
@@ -54,64 +51,56 @@ module Barometer
       end
     end
 
-    def self.has_keys?; !@@partner_key.nil? && !@@license_key.nil?; end
-    def self.requires_keys?; true; end
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
+
+    def self._source_name; :weather_dot_com; end
+    def self._accepted_formats; [:short_zipcode, :weather_id]; end
 
-    def self.wet_icon_codes
+    def self._has_keys?; !@@partner_key.nil? && !@@license_key.nil?; end
+    def self._requires_keys?; true; end
+
+    def self._wet_icon_codes
       codes = (0..18).to_a + [35] + (37..43).to_a + (45..47).to_a
       codes.collect {|c| c.to_s}
     end
-    def self.sunny_icon_codes
+    def self._sunny_icon_codes
       codes = [19, 22, 28, 30, 32, 34, 36]
       codes.collect {|c| c.to_s}
     end
 
-    def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-      measurement.source = self.source_name
-      
-      begin
-        result = self.fetch(query.q, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-    
-      measurement.current = self.build_current(result, metric)
-      measurement.forecast = self.build_forecast(result, metric)
-      measurement.location = self.build_location(result, query.geo)
-      measurement.current.sun = self.build_sun(result)
-      
-      # add links
-      if result && result['lnks'] && result['lnks']['link']
-        result['lnks']['link'].each do |link_hash|
-          measurement.links[link_hash['t']] = link_hash['l']
+    # first try to match the zone code, otherwise use the zone offset
+    #
+    def self._build_timezone(data)
+      if data
+        if data['cc'] && data['cc']['lsup'] &&
+           (zone_match = data['cc']['lsup'].match(/ ([A-Z]{1,4})$/))
+          Data::Zone.new(zone_match[1])
+        elsif data['loc'] && data['loc']['zone']
+          Data::Zone.new(data['loc']['zone'].to_f)
         end
       end
-      
-      # set local time of measurement
-      local_time = self.build_local_time(result)
-      measurement.measured_at = local_time
-      measurement.current.current_at = local_time
-
-      measurement
     end
     
-    # WARNING
-    # this is a best guess method.  the data provided for time conversions
-    # leaves a lot to be desired.  some time zones, offsets, local times are
-    # out to lunch.  eg. Tahiti (all times seem to be 30 min off), but there
-    # is no way to determine this
-    #
-    # regardless of the above, this method will trust the data given to it
-    #
-    def self.build_local_time(data)
+    def self._parse_local_time(data)
       (data && data['loc']) ? Data::LocalTime.parse(data['loc']['tm']) : nil
     end
-    
-    def self.build_current(data, metric=true)
+
+    def self._build_links(data)
+      links = {}
+      if data && data['lnks'] && data['lnks']['link']
+        data['lnks']['link'].each do |link_hash|
+          links[link_hash['t']] = link_hash['l']
+        end
+      end
+      links
+    end
+
+    def self._build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      current = Data::CurrentMeasurement.new
+      current = Measurement::Current.new
       if data
         if data['cc']
           current.updated_at = Data::LocalDateTime.parse(data['cc']['lsup'])
@@ -141,14 +130,14 @@ module Barometer
       current
     end
     
-    def self.build_forecast(data, metric=true)
+    def self._build_forecast(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      forecasts = []
+      forecasts = Measurement::ForecastArray.new
     
       if data && data['dayf'] && data['dayf']['day']
         local_date = data['dayf']['lsup']
         data['dayf']['day'].each do |forecast|
-          forecast_measurement = Data::ForecastMeasurement.new
+          forecast_measurement = Measurement::Forecast.new
           forecast_measurement.date = Date.parse(forecast['dt'])
           
           forecast_measurement.high = Data::Temperature.new(metric)
@@ -180,7 +169,7 @@ module Barometer
                 
               elsif part['p'] == 'n'  
                 # add this to the NightMeasurement
-                forecast_measurement.night = Data::NightMeasurement.new
+                forecast_measurement.night = Measurement::ForecastNight.new
                 forecast_measurement.night.condition = part['t']
                 forecast_measurement.night.icon = part['icon']
                 forecast_measurement.night.pop = part['ppcp'].to_i
@@ -202,7 +191,7 @@ module Barometer
       forecasts
     end
 
-    def self.build_location(data, geo=nil)
+    def self._build_location(data, geo=nil)
       raise ArgumentError unless data.is_a?(Hash)
       raise ArgumentError unless (geo.nil? || geo.is_a?(Data::Geo))
       location = Data::Location.new
@@ -224,7 +213,7 @@ module Barometer
       location
     end
     
-    def self.build_sun(data)
+    def self._build_sun(data)
       raise ArgumentError unless data.is_a?(Hash)
       sun = nil
       if data
@@ -239,9 +228,11 @@ module Barometer
 
     # use HTTParty to get the current weather
     #
-    def self.fetch(query, metric=true)
+    def self._fetch(query, metric=true)
+      return unless query
+      puts "fetch weather.com: #{query.q}" if Barometer::debug?
       self.get(
-        "http://xoap.weather.com/weather/local/#{query}",
+        "http://xoap.weather.com/weather/local/#{query.q}",
         :query => { :par => @@partner_key, :key => @@license_key,
           :prod => "xoap", :link => "xoap", :cc => "*",
           :dayf => "5", :unit => (metric ? 'm' : 's')

data/lib/barometer/weather_services/wunderground.rb

@@ -46,72 +46,63 @@ module Barometer
   #
   class WeatherService::Wunderground < WeatherService
     
-    def self.source_name; :wunderground; end
-    def self.accepted_formats
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
+    
+    def self._source_name; :wunderground; end
+    def self._accepted_formats
       [:zipcode, :postalcode, :icao, :coordinates, :geocode]
     end
     
     # these are the icon codes that indicate "wet", used by wet? function
-    def self.wet_icon_codes
+    def self._wet_icon_codes
       %w(flurries rain sleet snow tstorms nt_flurries nt_rain nt_sleet nt_snow nt_tstorms chancerain chancetstorms)
     end
     # these are the icon codes that indicate "sun", used by sunny? function
-    def self.sunny_icon_codes
+    def self._sunny_icon_codes
       %w(clear mostlysunny partlysunny sunny partlycloudy)
     end
 
-    def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-      measurement.source = self.source_name
-      
-      begin
-        current_result = self.get_current(query.q)
-        measurement.current = self.build_current(current_result, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-      
-      begin
-        forecast_result = self.get_forecast(query.q)
-        measurement.forecast = self.build_forecast(forecast_result, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-      
-      measurement.location = self.build_location(current_result)
-      measurement.station = self.build_station(current_result)
-      measurement.timezone = self.build_timezone(forecast_result)
-      
-      if current_result["credit"] && current_result["credit_URL"]
-        measurement.links[current_result["credit"]] = current_result["credit_URL"]
-      end
-      
-      sun = nil
-      if measurement.current
-         sun = self.build_sun(forecast_result, measurement.timezone)
-         measurement.current.sun = sun
-      end
+    def self._build_extra(measurement, result, metric=true)
+      #raise ArgumentError unless measurement.is_a?(Data::Measurement)
+      #raise ArgumentError unless query.is_a?(Barometer::Query)
+
       # use todays sun data for all future days
-      if measurement.forecast && sun
+      if measurement.forecast && measurement.current.sun
         measurement.forecast.each do |forecast|
-          forecast.sun = sun
+          forecast.sun = measurement.current.sun
         end
       end
       
-      local_time = measurement.timezone ? Data::LocalTime.parse(
-        measurement.timezone.utc_to_local(Time.now.utc)
-      ) : nil
-      measurement.measured_at = local_time
-      measurement.current.current_at = local_time
-      
       measurement
     end
+
+    def self._parse_full_timezone(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      if data && data['simpleforecast'] &&
+         data['simpleforecast']['forecastday'] &&
+         data['simpleforecast']['forecastday'].first &&
+         data['simpleforecast']['forecastday'].first['date']
+        Data::Zone.new(
+          data['simpleforecast']['forecastday'].first['date']['tz_long']
+        )
+      end
+    end
     
-    def self.build_current(data, metric=true)
+    def self._build_links(data)
+      links = {}
+      if data["credit"] && data["credit_URL"]
+        links[data["credit"]] = data["credit_URL"]
+      end
+      links
+    end
+
+    def self._build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
       
-      current = Data::CurrentMeasurement.new
+      current = Measurement::Current.new
       current.updated_at = Data::LocalDateTime.parse(data['observation_time']) if data['observation_time']
       current.humidity = data['relative_humidity'].to_i
       current.icon = data['icon'] if data['icon']
@@ -142,15 +133,15 @@ module Barometer
       current
     end
     
-    def self.build_forecast(data, metric=true)
+    def self._build_forecast(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      forecasts = []
+      forecasts = Measurement::ForecastArray.new
       # go through each forecast and create an instance
       if data && data['simpleforecast'] &&
          data['simpleforecast']['forecastday']
          
         data['simpleforecast']['forecastday'].each do |forecast|
-          forecast_measurement = Data::ForecastMeasurement.new
+          forecast_measurement = Measurement::Forecast.new
           forecast_measurement.icon = forecast['icon']
           forecast_measurement.date = Date.parse(forecast['date']['pretty'])
           forecast_measurement.pop = forecast['pop'].to_i
@@ -166,8 +157,8 @@ module Barometer
       end
       forecasts
     end
-
-    def self.build_location(data)
+    
+    def self._build_location(data, geo=nil)
       raise ArgumentError unless data.is_a?(Hash)
       location = Data::Location.new
       if data['display_location']
@@ -183,7 +174,7 @@ module Barometer
       location
     end
     
-    def self.build_station(data)
+    def self._build_station(data)
       raise ArgumentError unless data.is_a?(Hash)
       station = Data::Location.new
       station.id = data['station_id']
@@ -200,69 +191,72 @@ module Barometer
       station
     end
     
-    def self.build_timezone(data)
-      raise ArgumentError unless data.is_a?(Hash)
-      timezone = nil
-      if data && data['simpleforecast'] &&
-         data['simpleforecast']['forecastday'] &&
-         data['simpleforecast']['forecastday'].first &&
-         data['simpleforecast']['forecastday'].first['date']
-        timezone = Data::Zone.new(
-          data['simpleforecast']['forecastday'].first['date']['tz_long']
-        )
-      end
-      timezone || Data::Zone.new(nil)
-    end
-    
-    def self.build_sun(data, timezone)
+    def self._build_sun(data)
       raise ArgumentError unless data.is_a?(Hash)
-      raise ArgumentError unless timezone.is_a?(Data::Zone)
       sun = nil
       if data
         if data['moon_phase']
-          if data['moon_phase']['sunrise']
-            rise = Data::LocalTime.new(
-              data['moon_phase']['sunrise']['hour'].to_i,
-              data['moon_phase']['sunrise']['minute'].to_i
-            )
-          end
-          if data['moon_phase']['sunset']
-            set = Data::LocalTime.new(
-              data['moon_phase']['sunset']['hour'].to_i,
-              data['moon_phase']['sunset']['minute'].to_i
-            )
-          end
-        
-          sun = Data::Sun.new(
-            rise,
-            set
-          )
+          rise = Data::LocalTime.new(
+            data['moon_phase']['sunrise']['hour'].to_i,
+            data['moon_phase']['sunrise']['minute'].to_i
+          ) if data['moon_phase']['sunrise']
+          set = Data::LocalTime.new(
+            data['moon_phase']['sunset']['hour'].to_i,
+            data['moon_phase']['sunset']['minute'].to_i
+          ) if data['moon_phase']['sunset']
+          sun = Data::Sun.new(rise,set)
         end
       end
       sun || Data::Sun.new
     end
     
+    # override default _fetch behavior
+    # this service requires TWO seperate http requests (one for current
+    # and one for forecasted weather) ... combine the results
+    #
+    def self._fetch(query, metric=true)
+      result = []
+      result << _fetch_current(query)
+      result << _fetch_forecast(query)
+      result
+    end
+    
     # use HTTParty to get the current weather
-    def self.get_current(query)
+    #
+    def self._fetch_current(query)
       return unless query
+      puts "fetch wunderground current: #{query.q}" if Barometer::debug?
       self.get(
        "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml",
-       :query => {:query => query},
+       :query => {:query => query.q},
        :format => :xml,
        :timeout => Barometer.timeout
        )['current_observation']
     end
     
     # use HTTParty to get the forecasted weather
-    def self.get_forecast(query)
+    #
+    def self._fetch_forecast(query)
       return unless query
+      puts "fetch wunderground forecast: #{query.q}" if Barometer::debug?
       self.get(
         "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml",
-        :query => {:query => query},
+        :query => {:query => query.q},
         :format => :xml,
         :timeout => Barometer.timeout
       )['forecast']
     end
     
+    # since we have two sets of data, override these calls to choose the
+    # right set of data
+    #
+    def self._current_result(data); data[0]; end
+    def self._forecast_result(data=nil); data[1]; end
+    def self._location_result(data=nil); data[0]; end
+    def self._station_result(data=nil); data[0]; end
+    def self._links_result(data=nil); data[0]; end
+    def self._sun_result(data=nil); data[1]; end
+    def self._timezone_result(data=nil); data[1]; end
+    
   end
 end

data/lib/barometer/weather_services/yahoo.rb

@@ -45,103 +45,54 @@ module Barometer
   #
   class WeatherService::Yahoo < WeatherService
     
-    def self.source_name; :yahoo; end
-    def self.accepted_formats; [:zipcode, :weather_id]; end
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
     
-    # these are the icon codes that indicate "wet", used by wet? function
-    def self.wet_icon_codes
+    def self._source_name; :yahoo; end
+    def self._accepted_formats; [:zipcode, :weather_id]; end
+    
+    def self._wet_icon_codes
       codes = [1] + (3..18).to_a + [35] + (37..43).to_a + (45..47).to_a
       codes.collect {|c| c.to_s}
     end
-    def self.sunny_icon_codes
+    def self._sunny_icon_codes
       codes = (29..34).to_a + [36]
       codes.collect {|c| c.to_s}
     end
-
-    def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-      measurement.source = self.source_name
-      
-      begin
-        result = self.fetch(query.q, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-      
-      measurement.current = self.build_current(result, metric)
-      measurement.forecast = self.build_forecast(result, metric)
-      measurement.location = self.build_location(result, query.geo)
-      
-      if result["title"] && result["link"]
-        measurement.links[result["title"]] = result["link"]
-      end
-      
-      sun = nil
-      if measurement.current
-        sun = self.build_sun(result)
-        measurement.current.sun = sun
-      end
-      # use todays sun data for all future days
-      if measurement.forecast && sun
-        measurement.forecast.each do |forecast|
-          forecast.sun = sun
-        end
-      end
-      
-      local_time = self.build_local_time(result)
-      if local_time
-        measurement.measured_at = local_time
-        measurement.current.current_at = local_time
+  
+   def self._build_extra(measurement, result, metric=true)
+     #raise ArgumentError unless measurement.is_a?(Data::Measurement)
+     #raise ArgumentError unless query.is_a?(Barometer::Query)
+     
+     # use todays sun data for all future days
+     if measurement.forecast && measurement.current.sun
+       measurement.forecast.each do |forecast|
+         forecast.sun = measurement.current.sun
+       end
+     end
+     measurement
+   end
+   
+    def self._build_timezone(data)
+      if data && data['item'] && data['item']['pubDate']
+        zone_match = data['item']['pubDate'].match(/ ([A-Z]*)$/)
+        Data::Zone.new(zone_match[1]) if zone_match
       end
-      
-      measurement
     end
     
-def self.build_local_time(data)
-  if data
-    if data['item']
-      # what time is it now?
-      now_utc = Time.now.utc
-      
-      # get published date
-      pub_date = data['item']['pubDate']
-      
-      # get the TIME ZONE CODE
-      zone_match = pub_date.match(/ ([A-Z]*)$/) if pub_date
-      
-      if zone_match
-        zone = zone_match[1] 
-        
-        # try converting pub_date to utc
-#        pub_date_utc = Data::Zone.code_to_utc(Time.parse(pub_date), zone) if zone
-     
-        # how far back was this?
- #       data_age_in_seconds = now_utc - pub_date_utc
-      
-        # is this older then 2 hours
-#        if (data_age_in_seconds < 0) || (data_age_in_seconds > (60 * 60 * 2))
-          # we may have converted the time wrong.
-          # if pub_date in the future, then?
-          # if pub_date too far back, then?
-        
-          # for now do nothing ... don't set measured_time
-#          return nil
-#        else
-          # everything seems fine
-          # convert now to the local time 
-          offset = Data::Zone.zone_to_offset(zone)
-          return Data::LocalTime.parse(now_utc + offset)
-#        end
+    def self._build_links(data)
+      links = {}
+      if data["title"] && data["link"]
+        links[data["title"]] = data["link"]
       end
-      nil
+      links
     end
-  end
-end
     
-    def self.build_current(data, metric=true)
+    def self._build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      current = Data::CurrentMeasurement.new
+      current = Measurement::Current.new(metric)
       if data
         if data['item'] && data['item']['yweather:condition']
           condition_result = data['item']['yweather:condition']
@@ -171,15 +122,15 @@ end
       current
     end
     
-    def self.build_forecast(data, metric=true)
+    def self._build_forecast(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      forecasts = []
+      forecasts = Measurement::ForecastArray.new
       
       if data && data['item'] && data['item']['yweather:forecast']
          forecast_result = data['item']['yweather:forecast']
          
         forecast_result.each do |forecast|
-          forecast_measurement = Data::ForecastMeasurement.new
+          forecast_measurement = Measurement::Forecast.new
           forecast_measurement.icon = forecast['code']
           forecast_measurement.date = Date.parse(forecast['date'])
           forecast_measurement.condition = forecast['text']
@@ -193,7 +144,7 @@ end
       forecasts
     end
     
-    def self.build_location(data, geo=nil)
+    def self._build_location(data, geo=nil)
       raise ArgumentError unless data.is_a?(Hash)
       raise ArgumentError unless (geo.nil? || geo.is_a?(Data::Geo))
       location = Data::Location.new
@@ -219,7 +170,7 @@ end
       location
     end
     
-    def self.build_sun(data)
+    def self._build_sun(data)
       raise ArgumentError unless data.is_a?(Hash)
       sun = nil
       if data && data['yweather:astronomy'] && data['item']
@@ -229,12 +180,14 @@ end
       end
       sun || Data::Sun.new
     end
-
+    
     # use HTTParty to get the current weather
-    def self.fetch(query, metric=true)
+    def self._fetch(query, metric=true)
+      return unless query
+      puts "fetch yahoo: #{query.q}" if Barometer::debug?
       self.get(
         "http://weather.yahooapis.com/forecastrss",
-        :query => {:p => query, :u => (metric ? 'c' : 'f')},
+        :query => {:p => query.q, :u => (metric ? 'c' : 'f')},
         :format => :xml,
         :timeout => Barometer.timeout
       )['rss']['channel']