barometer 0.3.2 → 0.5.0

data/lib/barometer/weather_services/weather_bug.rb

@@ -0,0 +1,6 @@
+module Barometer
+  
+  class WeatherService::WeatherBug < WeatherService
+  end
+  
+end

data/lib/barometer/weather_services/weather_dot_com.rb

@@ -0,0 +1,261 @@
+module Barometer
+  #
+  # = Weather.com
+  # www.weather.com
+  #
+  # - key required: YES (partnerid & licensekey)
+  # - registration required: YES
+  # - supported countries: US (by zipcode), International (by Weather Location ID)
+  #
+  # === performs geo coding
+  # - city: PARTIAL (just a name)
+  # - coordinates: YES
+  #
+  # === time info
+  # - sun rise/set: YES
+  # - provides timezone: NO, but provides a utc offset
+  # - requires TZInfo: NO
+  #
+  # == resources
+  # - API: ?
+  #
+  # === Possible queries:
+  # - http://xoap.weather.com/weather/local/30339?cc=*&dayf=5&link=xoap&prod=xoap&par=[PartnerID]&key=[LicenseKey]
+  #
+  # where query can be:
+  # - zipcode (US) [5 digits only]
+  # - Weather Location ID (International)
+  #
+  # = Weather.com terms of use
+  # ???
+  #
+  # == notes
+  # - the Weather Location ID is a propreitary number (possibly shared with yahoo.com)
+  #
+  # == TODO
+  # - improve "forecasted_wet_by_icon?" to determine if day or night and use right code
+  # - improve "forecasted_sunny_by_icon?" to determine if day or night and use right code
+  # - improve "forcasted_wet_by_humidity?" to use forecasted values
+  # - improve "forcasted_windy?" to use forecasted values
+  #
+  class WeatherService::WeatherDotCom < WeatherService
+    
+    @@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|
+        @@partner_key = value.to_s if key.to_s.downcase == "partner"
+        @@license_key = value.to_s if key.to_s.downcase == "license"
+      end
+    end
+
+    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
+      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']
+        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)
+      (data && data['loc']) ? Data::LocalTime.parse(data['loc']['tm']) : nil
+    end
+    
+    def self.build_current(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      current = Data::CurrentMeasurement.new
+      if data
+        if data['cc']
+          current.updated_at = Data::LocalDateTime.parse(data['cc']['lsup'])
+          current.icon = data['cc']['icon']
+          current.condition = data['cc']['t']
+          current.humidity = data['cc']['hmid'].to_i
+          current.temperature = Data::Temperature.new(metric)
+          current.temperature << data['cc']['tmp']
+          current.dew_point = Data::Temperature.new(metric)
+          current.dew_point << data['cc']['dewp']
+          current.wind_chill = Data::Temperature.new(metric)
+          current.wind_chill << data['cc']['flik']
+          current.visibility = Data::Distance.new(metric)
+          current.visibility << data['cc']['vis']
+          if data['cc']['wind']
+            current.wind = Data::Speed.new(metric)
+            current.wind << data['cc']['wind']['s']
+            current.wind.degrees = data['cc']['wind']['d'].to_f
+            current.wind.direction = data['cc']['wind']['t']
+          end
+          if data['cc']['bar']
+            current.pressure = Data::Pressure.new(metric)
+            current.pressure << data['cc']['bar']['r']
+          end
+        end
+      end
+      current
+    end
+    
+    def self.build_forecast(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      forecasts = []
+    
+      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.date = Date.parse(forecast['dt'])
+          
+          forecast_measurement.high = Data::Temperature.new(metric)
+          forecast_measurement.high << forecast['hi']
+          forecast_measurement.low = Data::Temperature.new(metric)
+          forecast_measurement.low << forecast['low']
+          
+          # build sun
+          rise_local_time = Data::LocalTime.parse(forecast['sunr'])
+          set_local_time = Data::LocalTime.parse(forecast['suns'])
+          sun = Data::Sun.new(rise_local_time, set_local_time)
+          forecast_measurement.sun = sun
+          
+          if forecast['part']
+            forecast['part'].each do |part|
+              if part['p'] == 'd'
+                # add this to the ForecastMeasurement
+                forecast_measurement.condition = part['t']
+                forecast_measurement.icon = part['icon']
+                forecast_measurement.pop = part['ppcp'].to_i
+                forecast_measurement.humidity = part['hmid'].to_i
+                
+                if part['wind']
+                  forecast_measurement.wind = Data::Speed.new(metric)
+                  forecast_measurement.wind << part['wind']['s']
+                  forecast_measurement.wind.degrees = part['wind']['d'].to_i
+                  forecast_measurement.wind.direction = part['wind']['t']
+                end
+                
+              elsif part['p'] == 'n'  
+                # add this to the NightMeasurement
+                forecast_measurement.night = Data::NightMeasurement.new
+                forecast_measurement.night.condition = part['t']
+                forecast_measurement.night.icon = part['icon']
+                forecast_measurement.night.pop = part['ppcp'].to_i
+                forecast_measurement.night.humidity = part['hmid'].to_i
+                
+                if part['wind']
+                  forecast_measurement.night.wind = Data::Speed.new(metric)
+                  forecast_measurement.night.wind << part['wind']['s']
+                  forecast_measurement.night.wind.degrees = part['wind']['d'].to_i
+                  forecast_measurement.night.wind.direction = part['wind']['t']
+                end
+                
+              end
+            end
+          end
+          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?(Data::Geo))
+      location = Data::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['loc']
+          location.name = data['loc']['dnam']
+          location.latitude = data['loc']['lat']
+          location.longitude = data['loc']['lon']
+        end
+      end
+      location
+    end
+    
+    def self.build_sun(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      sun = nil
+      if data
+        if data['loc']
+          rise_local_time = Data::LocalTime.parse(data['loc']['sunr'])
+          set_local_time = Data::LocalTime.parse(data['loc']['suns'])
+        end  
+        sun = Data::Sun.new(rise_local_time, set_local_time)
+      end
+      sun || Data::Sun.new
+    end
+
+    # use HTTParty to get the current weather
+    #
+    def self.fetch(query, metric=true)
+      self.get(
+        "http://xoap.weather.com/weather/local/#{query}",
+        :query => { :par => @@partner_key, :key => @@license_key,
+          :prod => "xoap", :link => "xoap", :cc => "*",
+          :dayf => "5", :unit => (metric ? 'm' : 's')
+        },
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )['weather']
+    end
+    
+  end
+end
+
+# FUTURE DATA TO SUPPORT?
+#    "cc"=>
+#     {"obst"=>"Santa Monica, CA",
+#      "uv"=>{"i"=>"0", "t"=>"Low"},
+#      "moon"=>{"icon"=>"9", "t"=>"Waxing Gibbous"}

data/lib/barometer/{services → weather_services}/wunderground.rb

@@ -1,4 +1,6 @@
 module Barometer
+  #
+  #   [DEFAULT PROVIDER]
   #
   # = Weather Underground
   # www.wunderground.com
@@ -16,6 +18,9 @@ module Barometer
   # - sun rise/set: YES (today only)
   # - provides timezone: YES
   # - requires TZInfo: YES
+  # *NOTE: If accuarcy of times and converting, this service is the top choice.
+  #        They provide the full timezone name that is needed for the most
+  #        accurate time conversions.
   #
   # == resources
   # - API: http://wiki.wunderground.com/index.php/API_-_XML
@@ -36,19 +41,19 @@ module Barometer
   # - airport code (3-letter or 4-letter)
   # - lat,lon
   #
-  class Wunderground < Service
+  # = Wunderground terms of use
+  # Unable to locate.
+  #
+  class WeatherService::Wunderground < WeatherService
     
+    def self.source_name; :wunderground; end
     def self.accepted_formats
       [:zipcode, :postalcode, :icao, :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 chancerain)
+      %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
@@ -56,21 +61,19 @@ module Barometer
     end
 
     def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+      raise ArgumentError unless measurement.is_a?(Data::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)
+        current_result = self.get_current(query.q)
         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)
+        forecast_result = self.get_forecast(query.q)
         measurement.forecast = self.build_forecast(forecast_result, metric)
       rescue Timeout::Error => e
         return measurement
@@ -80,7 +83,10 @@ module Barometer
       measurement.station = self.build_station(current_result)
       measurement.timezone = self.build_timezone(forecast_result)
       
-      # add sun data to current
+      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)
@@ -88,48 +94,49 @@ module Barometer
       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)
+          forecast.sun = 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.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 = Data::CurrentMeasurement.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']
       
-      current.temperature = Temperature.new(metric)
+      current.temperature = Data::Temperature.new(metric)
       current.temperature << [data['temp_c'], data['temp_f']]
       
-      current.wind = Speed.new(metric)
+      current.wind = Data::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.new(metric)
       current.pressure << [data['pressure_mb'], data['pressure_in']]
       
-      current.dew_point = Temperature.new(metric)
+      current.dew_point = Data::Temperature.new(metric)
       current.dew_point << [data['dewpoint_c'], data['dewpoint_f']]
       
-      current.heat_index = Temperature.new(metric)
+      current.heat_index = Data::Temperature.new(metric)
       current.heat_index << [data['heat_index_c'], data['heat_index_f']]
       
-      current.wind_chill = Temperature.new(metric)
+      current.wind_chill = Data::Temperature.new(metric)
       current.wind_chill << [data['windchill_c'], data['windchill_f']]
       
-      current.visibility = Distance.new(metric)
+      current.visibility = Data::Distance.new(metric)
       current.visibility << [data['visibility_km'], data['visibility_mi']]
       
       current
@@ -143,15 +150,15 @@ module Barometer
          data['simpleforecast']['forecastday']
          
         data['simpleforecast']['forecastday'].each do |forecast|
-          forecast_measurement = ForecastMeasurement.new
+          forecast_measurement = Data::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 = Data::Temperature.new(metric)
           forecast_measurement.high << [forecast['high']['celsius'],forecast['high']['fahrenheit']]
           
-          forecast_measurement.low = Temperature.new(metric)
+          forecast_measurement.low = Data::Temperature.new(metric)
           forecast_measurement.low << [forecast['low']['celsius'],forecast['low']['fahrenheit']]
           
           forecasts << forecast_measurement
@@ -162,7 +169,7 @@ module Barometer
 
     def self.build_location(data)
       raise ArgumentError unless data.is_a?(Hash)
-      location = Location.new
+      location = Data::Location.new
       if data['display_location']
         location.name = data['display_location']['full']
         location.city = data['display_location']['city']
@@ -178,7 +185,7 @@ module Barometer
     
     def self.build_station(data)
       raise ArgumentError unless data.is_a?(Hash)
-      station = Location.new
+      station = Data::Location.new
       station.id = data['station_id']
       if data['observation_location']
         station.name = data['observation_location']['full']
@@ -193,15 +200,6 @@ module Barometer
       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
@@ -209,62 +207,45 @@ module Barometer
          data['simpleforecast']['forecastday'] &&
          data['simpleforecast']['forecastday'].first &&
          data['simpleforecast']['forecastday'].first['date']
-        timezone = Barometer::Zone.new(
+        timezone = Data::Zone.new(
           data['simpleforecast']['forecastday'].first['date']['tz_long']
         )
       end
-      timezone
+      timezone || Data::Zone.new(nil)
     end
     
     def self.build_sun(data, timezone)
       raise ArgumentError unless data.is_a?(Hash)
-      raise ArgumentError unless timezone.is_a?(Barometer::Zone)
-      
+      raise ArgumentError unless timezone.is_a?(Data::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']
           if data['moon_phase']['sunrise']
-            rise = Time.local(
-              time.year, time.month, time.day,
-              data['moon_phase']['sunrise']['hour'],
-              data['moon_phase']['sunrise']['minute']
+            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 = Time.local(
-              time.year, time.month, time.day,
-              data['moon_phase']['sunset']['hour'],
-              data['moon_phase']['sunset']['minute']
+            set = Data::LocalTime.new(
+              data['moon_phase']['sunset']['hour'].to_i,
+              data['moon_phase']['sunset']['minute'].to_i
             )
           end
         
-          sun = Sun.new(
-            timezone.tz.local_to_utc(rise),
-            timezone.tz.local_to_utc(set)
+          sun = Data::Sun.new(
+            rise,
+            set
           )
         end
       end
-      
-      sun || Sun.new
+      sun || Data::Sun.new
     end
     
     # use HTTParty to get the current weather
     def self.get_current(query)
-      Barometer::Wunderground.get(
+      return unless query
+      self.get(
        "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml",
        :query => {:query => query},
        :format => :xml,
@@ -274,7 +255,8 @@ module Barometer
     
     # use HTTParty to get the forecasted weather
     def self.get_forecast(query)
-      Barometer::Wunderground.get(
+      return unless query
+      self.get(
         "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml",
         :query => {:query => query},
         :format => :xml,