attack-barometer 0.1.0

data/lib/barometer/services/wunderground.rb

@@ -0,0 +1,285 @@
+module Barometer
+  #
+  # = Weather Underground
+  # www.wunderground.com
+  #
+  # - key required: NO
+  # - registration required: NO
+  # - supported countries: ALL
+  #
+  # === performs geo coding
+  # - city: YES
+  # - coordinates: YES
+  # NOTE: provides geo data for location and weather station
+  #
+  # === time info
+  # - sun rise/set: YES (today only)
+  # - provides timezone: YES
+  # - requires TZInfo: YES
+  #
+  # == resources
+  # - API: http://wiki.wunderground.com/index.php/API_-_XML
+  #
+  # === Possible queries:
+  # - http://api.wunderground.com/auto/wui/geo/GeoLookupXML/index.xml?query=94107
+  # - http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=KSFO
+  # - http://api.wunderground.com/weatherstation/WXCurrentObXML.asp?ID=KCASANFR70
+  # - http://api.wunderground.com/auto/wui/geo/AlertsXML/index.xml?query=86445
+  # - http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml?query=Chicago,IL
+  #
+  # where query can be:
+  # - zipcode (US or Canadian)
+  # - city state; city, state
+  # - city
+  # - state
+  # - country
+  # - airport code (3-letter or 4-letter)
+  # - lat,lon
+  #
+  class Wunderground < Service
+    
+    def self.accepted_formats
+      [:zipcode, :postalcode, :coordinates, :geocode]
+    end
+    
+    def self.source_name
+      :wunderground
+    end
+    
+    # these are the icon codes that indicate "wet", used by wet? function
+    def self.wet_icon_codes
+      %w(flurries rain sleet snow tstorms nt_flurries nt_rain nt_sleet nt_snow nt_tstorms)
+    end
+    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?(Barometer::Measurement)
+      raise ArgumentError unless query.is_a?(Barometer::Query)
+      measurement.source = self.source_name
+      
+      # get current measurement
+      begin
+        current_result = self.get_current(query.preferred)
+        measurement.current = self.build_current(current_result, metric)
+      rescue Timeout::Error => e
+        return measurement
+      end
+      
+      # get forecast measurement
+      begin
+        forecast_result = self.get_forecast(query.preferred)
+        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)
+      
+      # add sun data to current
+      sun = nil
+      if measurement.current
+         sun = self.build_sun(forecast_result, measurement.timezone)
+         measurement.current.sun = sun
+      end
+      # use todays sun data for all future days
+      if measurement.forecast && sun
+        start_date = Date.parse(measurement.current.time)
+        measurement.forecast.each do |forecast|
+          days_in_future = forecast.date - start_date
+          forecast.sun = Barometer::Sun.add_days!(sun,days_in_future.to_i)
+        end
+      end
+      
+      measurement
+    end
+
+    def self.build_current(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      
+      current = CurrentMeasurement.new
+      #current.time = Time.parse(current_result['observation_time_rfc822']) unless
+      #  current_result['observation_time_rfc822'].blank?
+      current.time = data['observation_time_rfc822']
+      current.local_time = data['observation_time']
+      current.humidity = data['relative_humidity'].to_i
+      current.icon = data['icon'] if data['icon']
+      
+      current.temperature = Temperature.new(metric)
+      current.temperature << [data['temp_c'], data['temp_f']]
+      
+      current.wind = Speed.new(metric)
+      current.wind.mph = data['wind_mph'].to_f
+      current.wind.degrees = data['wind_degrees'].to_i
+      current.wind.direction = data['wind_dir']
+      
+      current.pressure = Pressure.new(metric)
+      current.pressure << [data['pressure_mb'], data['pressure_in']]
+      
+      current.dew_point = Temperature.new(metric)
+      current.dew_point << [data['dewpoint_c'], data['dewpoint_f']]
+      
+      current.heat_index = Temperature.new(metric)
+      current.heat_index << [data['heat_index_c'], data['heat_index_f']]
+      
+      current.wind_chill = Temperature.new(metric)
+      current.wind_chill << [data['windchill_c'], data['windchill_f']]
+      
+      current.visibility = Distance.new(metric)
+      current.visibility << [data['visibility_km'], data['visibility_mi']]
+      
+      current
+    end
+    
+    def self.build_forecast(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      forecasts = []
+      # go through each forecast and create an instance
+      if data && data['simpleforecast'] &&
+         data['simpleforecast']['forecastday']
+         
+        data['simpleforecast']['forecastday'].each do |forecast|
+          forecast_measurement = ForecastMeasurement.new
+          forecast_measurement.icon = forecast['icon']
+          forecast_measurement.date = Date.parse(forecast['date']['pretty'])
+          forecast_measurement.pop = forecast['pop'].to_i
+          
+          forecast_measurement.high = Temperature.new(metric)
+          forecast_measurement.high << [forecast['high']['celsius'],forecast['high']['fahrenheit']]
+          
+          forecast_measurement.low = Temperature.new(metric)
+          forecast_measurement.low << [forecast['low']['celsius'],forecast['low']['fahrenheit']]
+          
+          forecasts << forecast_measurement
+        end
+      end
+      forecasts
+    end
+
+    def self.build_location(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      location = Location.new
+      if data['display_location']
+        location.name = data['display_location']['full']
+        location.city = data['display_location']['city']
+        location.state_name = data['display_location']['state_name']
+        location.state_code = data['display_location']['state']
+        location.country_code = data['display_location']['country']
+        location.zip_code = data['display_location']['zip']
+        location.latitude = data['display_location']['latitude']
+        location.longitude = data['display_location']['longitude']
+      end
+      location
+    end
+    
+    def self.build_station(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      station = Location.new
+      station.id = data['station_id']
+      if data['observation_location']
+        station.name = data['observation_location']['full']
+        station.city = data['observation_location']['city']
+        station.state_name = data['observation_location']['state_name']
+        station.state_code = data['observation_location']['state']
+        station.country_code = data['observation_location']['country']
+        station.zip_code = data['observation_location']['zip']
+        station.latitude = data['observation_location']['latitude']
+        station.longitude = data['observation_location']['longitude']
+      end
+      station
+    end
+    
+    # <forecastday>
+    #       <date>
+    #         <pretty_short>9:00 PM CST</pretty_short>
+    #         <pretty>9:00 PM CST on January 15, 2008</pretty>
+    #         <isdst>0</isdst>
+    #         <tz_short>CST</tz_short>
+    #         <tz_long>America/Chicago</tz_long>
+    #       </date>
+    #     </forecastday>
+    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 = Barometer::Zone.new(
+          data['simpleforecast']['forecastday'].first['date']['tz_long']
+        )
+      end
+      timezone
+    end
+    
+    def self.build_sun(data, timezone)
+      raise ArgumentError unless data.is_a?(Hash)
+      raise ArgumentError unless timezone.is_a?(Barometer::Zone)
+      
+      sun = nil
+      if data
+        time = nil
+        if data['simpleforecast'] &&
+           data['simpleforecast']['forecastday'] &&
+           data['simpleforecast']['forecastday'].first &&
+           data['simpleforecast']['forecastday'].first['date']
+          
+          # construct current date
+          date_data = data['simpleforecast']['forecastday'].first['date']
+          time = Time.local(
+            date_data['year'], date_data['month'], date_data['day'],
+            date_data['hour'], date_data['min'], date_data['sec']
+          )
+        end
+        if time && data['moon_phase']
+          # get the sun rise and set times (ie "6:32 am")
+          if data['moon_phase']['sunrise']
+            rise = Time.local(
+              time.year, time.month, time.day,
+              data['moon_phase']['sunrise']['hour'],
+              data['moon_phase']['sunrise']['minute']
+            )
+          end
+          if data['moon_phase']['sunset']
+            set = Time.local(
+              time.year, time.month, time.day,
+              data['moon_phase']['sunset']['hour'],
+              data['moon_phase']['sunset']['minute']
+            )
+          end
+        
+          sun = Sun.new(
+            timezone.tz.local_to_utc(rise),
+            timezone.tz.local_to_utc(set)
+          )
+        end
+      end
+      
+      sun || Sun.new
+    end
+    
+    # use HTTParty to get the current weather
+    def self.get_current(query)
+      Barometer::Wunderground.get(
+       "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml",
+       :query => {:query => query},
+       :format => :xml,
+       :timeout => Barometer.timeout
+       )['current_observation']
+    end
+    
+    # use HTTParty to get the forecasted weather
+    def self.get_forecast(query)
+      Barometer::Wunderground.get(
+        "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml",
+        :query => {:query => query},
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )['forecast']
+    end
+    
+  end
+end

data/lib/barometer/services/yahoo.rb

@@ -0,0 +1,274 @@
+module Barometer
+  #
+  # = Yahoo Weather
+  # www.yahoo.com
+  #
+  # - key required: NO
+  # - registration required: NO
+  # - supported countries: US (by zipcode), International (by Yahoo Location ID)
+  #
+  # === performs geo coding
+  # - city: YES
+  # - coordinates: YES
+  #
+  # === time info
+  # - sun rise/set: YES (today only)
+  # - provides timezone: PARTIAL (just short code)
+  # - requires TZInfo: NO
+  # NOTE: since this only supports US, the short code can be used
+  #       to convert times (until yahoo location id support is added)
+  #
+  # == resources
+  # - API: http://developer.yahoo.com/weather/
+  #
+  # === Possible queries:
+  # - http://weather.yahooapis.com/forecastrss?p=94089
+  # - http://weather.yahooapis.com/forecastrss?p=USCA1116
+  # - http://weather.yahooapis.com/forecastrss?p=FRXX0076&u=c
+  #
+  # where query can be:
+  # - zipcode (US)
+  # - Yahoo Location ID (International) - not currently supported
+  #
+  # == notes
+  # - the Yahoo Location ID is a propreitary number (possibly shared with weather.com)
+  #   so this driver currently does not provide a way to get/use this number,
+  #   therefore International support is currently missing
+  #
+  class Yahoo < Service
+    
+    def self.accepted_formats
+      [:zipcode]
+    end
+    
+    def self.source_name
+      :yahoo
+    end
+    
+    # these are the icon codes that indicate "wet", used by wet? function
+    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
+      codes = (29..34).to_a + [36]
+      codes.collect {|c| c.to_s}
+    end
+    
+    # override, only currently supports US
+    def self.supports_country?(query=nil)
+      query && query.country_code && query.country_code.downcase == "us"
+    end
+
+    def self._measure(measurement, query, metric=true)
+      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+      raise ArgumentError unless query.is_a?(Barometer::Query)
+      measurement.source = self.source_name
+      
+      begin
+        result = self.get_all(query.preferred, 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)
+      
+      # add to current
+      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
+        start_date = Date.parse(measurement.current.local_time)
+        measurement.forecast.each do |forecast|
+          days_in_future = forecast.date - start_date
+          forecast.sun = Barometer::Sun.add_days!(sun,days_in_future.to_i)
+        end
+      end
+      
+      measurement
+    end
+    
+    def self.build_current(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      current = CurrentMeasurement.new
+      if data
+        if data['item'] && data['item']['yweather:condition']
+          condition_result = data['item']['yweather:condition']
+          current.local_time = condition_result['date']
+          current.icon = condition_result['code']
+          current.condition = condition_result['text']
+          current.temperature = Temperature.new(metric)
+          current.temperature << condition_result['temp']
+        end
+        if data['yweather:atmosphere']
+          atmosphere_result = data['yweather:atmosphere']
+          current.humidity = atmosphere_result['humidity'].to_i
+          current.pressure = Pressure.new(metric)
+          current.pressure << atmosphere_result['pressure']
+          current.visibility = Distance.new(metric)
+          current.visibility << atmosphere_result['visibility']
+        end
+        if data['yweather:wind']
+          wind_result = data['yweather:wind']
+          current.wind = Speed.new(metric)
+          current.wind << wind_result['speed']
+          current.wind.degrees = wind_result['degrees'].to_f
+          current.wind_chill = Temperature.new(metric)
+          current.wind_chill << wind_result['chill']
+        end
+      end
+      current
+    end
+    
+    def self.build_forecast(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      forecasts = []
+      
+      if data && data['item'] && data['item']['yweather:forecast']
+         forecast_result = data['item']['yweather:forecast']
+         
+        forecast_result.each do |forecast|
+          forecast_measurement = ForecastMeasurement.new
+          forecast_measurement.icon = forecast['code']
+          forecast_measurement.date = Date.parse(forecast['date'])
+          forecast_measurement.condition = forecast['text']
+          forecast_measurement.high = Temperature.new(metric)
+          forecast_measurement.high << forecast['high'].to_f
+          forecast_measurement.low = Temperature.new(metric)
+          forecast_measurement.low << forecast['low'].to_f
+          forecasts << forecast_measurement
+        end
+      end
+      forecasts
+    end
+    
+    def self.build_location(data, geo=nil)
+      raise ArgumentError unless data.is_a?(Hash)
+      raise ArgumentError unless (geo.nil? || geo.is_a?(Barometer::Geo))
+      location = Location.new
+      # use the geocoded data if available, otherwise get data from result
+      if geo
+        location.city = geo.locality
+        location.state_code = geo.region
+        location.country = geo.country
+        location.country_code = geo.country_code
+        location.latitude = geo.latitude
+        location.longitude = geo.longitude
+      else
+        if data && data['yweather:location']
+          location.city = data['yweather:location']['city']
+          location.state_code = data['yweather:location']['region']
+          location.country_code = data['yweather:location']['country']
+          if data['item']
+            location.latitude = data['item']['geo:lat']
+            location.longitude = data['item']['geo:long']
+          end
+        end
+      end
+      location
+    end
+    
+    def self.build_sun(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      sun = nil
+      if data && data['yweather:astronomy'] && data['item']
+        # get the TIME ZONE CODE
+        zone_match = data['item']['pubDate'].match(/ ([A-Z]*)$/)
+        zone = zone_match[1] if zone_match
+        # get the sun rise and set
+        rise = Barometer::Zone.merge(
+          data['yweather:astronomy']['sunrise'],
+          data['item']['pubDate'],
+          zone
+        )
+        set = Barometer::Zone.merge(
+          data['yweather:astronomy']['sunset'],
+          data['item']['pubDate'],
+          zone
+        )
+        sun = Sun.new(rise, set)
+      end
+      sun || Sun.new
+    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 = Barometer::Zone.new(Time.now.utc,data['simpleforecast']['forecastday'].first['date']['tz_long'])
+    #   end
+    #   timezone
+    # end
+    
+    # use HTTParty to get the current weather
+    def self.get_all(query, metric=true)
+      Barometer::Yahoo.get(
+        "http://weather.yahooapis.com/forecastrss",
+        :query => {:p => query, :u => (metric ? 'c' : 'f')},
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )['rss']['channel']
+    end
+    
+  end
+end
+
+# Condition Codes
+# 0   tornado
+# 1   tropical storm
+# 2   hurricane
+# 3   severe thunderstorms
+# 4   thunderstorms
+# 5   mixed rain and snow
+# 6   mixed rain and sleet
+# 7   mixed snow and sleet
+# 8   freezing drizzle
+# 9   drizzle
+# 10  freezing rain
+# 11  showers
+# 12  showers
+# 13  snow flurries
+# 14  light snow showers
+# 15  blowing snow
+# 16  snow
+# 17  hail
+# 18  sleet
+# 19  dust
+# 20  foggy
+# 21  haze
+# 22  smoky
+# 23  blustery
+# 24  windy
+# 25  cold
+# 26  cloudy
+# 27  mostly cloudy (night)
+# 28  mostly cloudy (day)
+# 29  partly cloudy (night)
+# 30  partly cloudy (day)
+# 31  clear (night)
+# 32  sunny
+# 33  fair (night)
+# 34  fair (day)
+# 35  mixed rain and hail
+# 36  hot
+# 37  isolated thunderstorms
+# 38  scattered thunderstorms
+# 39  scattered thunderstorms
+# 40  scattered showers
+# 41  heavy snow
+# 42  scattered snow showers
+# 43  heavy snow
+# 44  partly cloudy
+# 45  thundershowers
+# 46  snow showers
+# 47  isolated thundershowers
+# 3200  not available

data/lib/barometer/services.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'services/service'
+require 'services/wunderground'
+require 'services/google'
+require 'services/yahoo'