barometer 0.5.0 → 0.6.1

data/lib/barometer/weather_services/service.rb

@@ -10,10 +10,11 @@ module Barometer
   # Service Class
   #
   # This is a base class for creating alternate weather api-consuming
-  # drivers.  Each driver inherits from this class.
+  # drivers.  Each driver inherits from this class.  This class creates
+  # some default behaviours, but they can easily be over-ridden.
   # 
   # Basically, all a service is required to do is take a query
-  # (ie "Paris") and return a complete Data::Measurement instance.
+  # (ie "Paris") and return a complete Barometer::Measurement instance.
   #
   class WeatherService
     # all service drivers will use the HTTParty gem
@@ -34,300 +35,157 @@ module Barometer
     def self.measure(query, metric=true)
       raise ArgumentError unless query.is_a?(Barometer::Query)
       
-      measurement = Data::Measurement.new(self.source_name, metric)
-      if self.meets_requirements?(query)
-        converted_query = query.convert!(self.accepted_formats)
+      measurement = Barometer::Measurement.new(self._source_name, metric)
+      measurement.start_at = Time.now.utc
+      if self._meets_requirements?(query)
+        converted_query = query.convert!(self._accepted_formats)
         if converted_query
+          measurement.source = self._source_name
           measurement.query = converted_query.q
           measurement.format = converted_query.format
           measurement = self._measure(measurement, converted_query, metric)
         end
       end
+      measurement.end_at = Time.now.utc
       measurement
     end
     
-    def self.meets_requirements?(query=nil)
-      self.supports_country?(query) && (!self.requires_keys? || self.has_keys?)
-    end
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
     
     #
-    # NOTE: The following methods MUST be re-defined by each driver.
+    # REQUIRED
+    # re-defining these methods will be required
     #
     
-    # STUB: define this method to actually retireve the source_name
-    def self.source_name; raise NotImplementedError; end
-
-    # STUB: define this method to indicate what query formats are accepted
-    def self.accepted_formats; raise NotImplementedError; end
+    def self._source_name; raise NotImplementedError; end
+    def self._accepted_formats; raise NotImplementedError; end
+    def self._fetch(query=nil, metric=true); nil; end
+    def self._build_current(result=nil, metric=true); nil; end
+    def self._build_forecast(result=nil, metric=true); nil; end
     
-    # STUB: define this method to measure the current & future weather
-    def self._measure(measurement=nil, query=nil, metric=true)
-      raise NotImplementedError
+    #
+    # PROBABLE
+    # re-defining these methods is probable though not a must
+    #
+    
+    # data processing stubs
+    #
+    def self._build_location(result=nil, geo=nil); nil; end
+    def self._build_station(result=nil); Data::Location.new; end
+    def self._build_links(result=nil); {}; end
+    def self._build_sun(result=nil); Data::Sun.new; end
+    def self._build_timezone(result=nil); nil; end
+    def self._build_extra(measurement=nil, result=nil, metric=true); measurement; end
+    def self._build_local_time(measurement)
+      (measurement && measurement.timezone) ? Data::LocalTime.parse(measurement.timezone.now) : nil
     end
-
+    
+    # given the result set, return the full_timezone or local time ...
+    # if not available return nil
+    def self._parse_full_timezone(result=nil); nil; end
+    def self._parse_local_time(result=nil); nil; end
+    
+    # this returns an array of codes that indicate "wet"
+    def self._wet_icon_codes; nil; end
+    # this returns an array of codes that indicate "sunny"
+    def self._sunny_icon_codes; nil; end
+    
     #
-    # NOTE: The following methods can be re-defined by each driver. [OPTIONAL]
+    # OPTIONAL
+    # re-defining these methods will be optional
     #
 
     # STUB: define this method to check for the existance of API keys,
     #       this method is NOT needed if requires_keys? returns false
-    def self.has_keys?; raise NotImplementedError; end
+    def self._has_keys?; raise NotImplementedError; end
 
     # STUB: define this method to check for the existance of API keys,
     #       this method is NOT needed if requires_keys? returns false
-    def self.keys=(keys=nil); nil; end
+    def self._keys=(keys=nil); nil; end
 
     # DEFAULT: override this if you need to determine if the country is specified
-    def self.supports_country?(query=nil); true; end
+    def self._supports_country?(query=nil); true; end
  
     # DEFAULT: override this if you need to determine if API keys are required
-    def self.requires_keys?; false; end
+    def self._requires_keys?; false; end
     
+    # data accessors
+    # (see the wunderground driver for an example of overriding these)
     #
-    # answer simple questions
-    #
-    
-    #
-    # WINDY?
-    #
-    def self.windy?(measurement, threshold=10, time_string=nil)
-      local_time = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
-
-      measurement.current?(local_time) ?
-        self.currently_windy?(measurement, threshold) :
-        self.forecasted_windy?(measurement, threshold, local_time)
-    end
-    
-    # cookie cutter answer, a driver can override this if they answer it differently
-    # if a service doesn't support obtaining the wind value, it will be ignored
-    def self.currently_windy?(measurement, threshold=10)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      return nil if (!measurement.current || !measurement.current.wind?)
-      measurement.metric? ?
-        measurement.current.wind.kph.to_f >= threshold.to_f :
-        measurement.current.wind.mph.to_f >= threshold.to_f
-    end
+    def self._current_result(data=nil); data; end
+    def self._forecast_result(data=nil); data; end
+    def self._location_result(data=nil); data; end
+    def self._station_result(data=nil); data; end
+    def self._links_result(data=nil); data; end
+    def self._sun_result(data=nil); data; end
+    def self._timezone_result(data=nil); data; end
+    def self._time_result(data=nil); data; end
 
-    # no driver can currently answer this question, so it doesn't have any code
-    def self.forecasted_windy?(measurement, threshold, time_string); nil; end
-    
     #
-    # WET?
+    # COMPLETE
+    # re-defining these methods should not be needed, as the behavior
+    # can be adjusted using methods above
     #
-    def self.wet?(measurement, threshold=50, time_string=nil)
-      local_time = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
-      measurement.current?(local_time) ?
-        self.currently_wet?(measurement, threshold) :
-        self.forecasted_wet?(measurement, threshold, local_time)
-    end
-    
-    # cookie cutter answer
-    def self.currently_wet?(measurement, threshold=50)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      return nil unless measurement.current
-      self.currently_wet_by_icon?(measurement.current) ||
-        self.currently_wet_by_dewpoint?(measurement) ||
-        self.currently_wet_by_humidity?(measurement.current) ||
-        self.currently_wet_by_pop?(measurement, threshold)
-    end
-    
-    # cookie cutter answer
-    def self.currently_wet_by_dewpoint?(measurement)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      return nil if (!measurement.current || !measurement.current.temperature? ||
-                     !measurement.current.dew_point?)
-      measurement.metric? ?
-        measurement.current.temperature.c.to_f <= measurement.current.dew_point.c.to_f :
-        measurement.current.temperature.f.to_f <= measurement.current.dew_point.f.to_f
-    end
-    
-    # cookie cutter answer
-    def self.currently_wet_by_humidity?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Data::CurrentMeasurement)
-      return nil unless current_measurement.humidity?
-      current_measurement.humidity.to_i >= 99
-    end
-    
-    # cookie cutter answer
-    def self.currently_wet_by_pop?(measurement, threshold=50)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      return nil unless measurement.forecast
-      # get todays forecast
-      forecast_measurement = measurement.for
-      return nil unless forecast_measurement
-      forecast_measurement.pop.to_f >= threshold.to_f
-    end
-    
-    # cookie cutter answer
-    def self.forecasted_wet?(measurement, threshold=50, time_string=nil)
-      local_time = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
-      return nil unless measurement.forecast
-      forecast_measurement = measurement.for(local_time)
-      return nil unless forecast_measurement
-      self.forecasted_wet_by_icon?(forecast_measurement) ||
-        self.forecasted_wet_by_pop?(forecast_measurement, threshold)
-    end
-
-    # cookie cutter answer
-    def self.forecasted_wet_by_pop?(forecast_measurement, threshold=50)
-      raise ArgumentError unless forecast_measurement.is_a?(Data::ForecastMeasurement)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      return nil unless forecast_measurement.pop?
-      forecast_measurement.pop.to_f >= threshold.to_f
-    end
-
-    def self.currently_wet_by_icon?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Data::CurrentMeasurement)
-      return nil unless self.wet_icon_codes
-      return nil unless current_measurement.icon?
-      current_measurement.icon.is_a?(String) ?
-        self.wet_icon_codes.include?(current_measurement.icon.to_s.downcase) :
-        self.wet_icon_codes.include?(current_measurement.icon)
-    end
-    
-    def self.forecasted_wet_by_icon?(forecast_measurement)
-      raise ArgumentError unless forecast_measurement.is_a?(Data::ForecastMeasurement)
-      return nil unless self.wet_icon_codes
-      return nil unless forecast_measurement.icon?
-      forecast_measurement.icon.is_a?(String) ?
-        self.wet_icon_codes.include?(forecast_measurement.icon.to_s.downcase) :
-        self.wet_icon_codes.include?(forecast_measurement.icon)
-    end
-
-    # this returns an array of codes that indicate "wet"
-    def self.wet_icon_codes; nil; end
     
+    # this is the generic measuring and data processing for each weather service
+    # driver.  this method should be re-defined if the driver in question
+    # doesn't fit into "generic" (ie wunderground)
     #
-    # DAY?
-    #
-    def self.day?(measurement, time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-
-      measurement.current?(local_datetime) ?
-        self.currently_day?(measurement) :
-        self.forecasted_day?(measurement, local_datetime)
-    end
-    
-    def self.currently_day?(measurement)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      return nil unless measurement.current && measurement.current.sun
-      self.currently_after_sunrise?(measurement.current) &&
-        self.currently_before_sunset?(measurement.current)
-    end
-    
-    def self.currently_after_sunrise?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Data::CurrentMeasurement)
-      return nil unless current_measurement.current_at && 
-        current_measurement.sun && current_measurement.sun.rise
-      #Time.now.utc >= current_measurement.sun.rise
-      current_measurement.current_at >= current_measurement.sun.rise
-    end    
-
-    def self.currently_before_sunset?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Data::CurrentMeasurement)
-      return nil unless current_measurement.current_at &&
-        current_measurement.sun && current_measurement.sun.set
-      #Time.now.utc <= current_measurement.sun.set
-      current_measurement.current_at <= current_measurement.sun.set
-    end
-
-    def self.forecasted_day?(measurement, time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      return nil unless measurement.forecast
-      forecast_measurement = measurement.for(local_datetime)
-      return nil unless forecast_measurement
-      self.forecasted_after_sunrise?(forecast_measurement, local_datetime) &&
-        self.forecasted_before_sunset?(forecast_measurement, local_datetime)
-    end
-    
-    def self.forecasted_after_sunrise?(forecast_measurement, time_string)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless forecast_measurement.is_a?(Data::ForecastMeasurement)
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      return nil unless forecast_measurement.sun && forecast_measurement.sun.rise
-      local_datetime >= forecast_measurement.sun.rise
-    end 
-    
-    def self.forecasted_before_sunset?(forecast_measurement, time_string)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless forecast_measurement.is_a?(Data::ForecastMeasurement)
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      return nil unless forecast_measurement.sun && forecast_measurement.sun.set
-      local_datetime <= forecast_measurement.sun.set
+    def self._measure(measurement, query, metric=true)
+      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+      raise ArgumentError unless query.is_a?(Barometer::Query)
+  
+      begin
+        result = _fetch(query, metric)
+      rescue Timeout::Error => e
+        return measurement
+      end
+  
+      if result
+        measurement.current = _build_current(_current_result(result), metric)
+        measurement.forecast = _build_forecast(_forecast_result(result), metric)
+        measurement.location = _build_location(_location_result(result), query.geo)
+        measurement.station = _build_station(_station_result(result))
+        measurement.links = _build_links(_links_result(result))
+        measurement.current.sun = _build_sun(_sun_result(result)) if measurement.current
+        measurement.timezone = _timezone(_timezone_result(result), query, measurement.location)
+        if local_time = _local_time(_time_result(result), measurement)
+           measurement.measured_at = local_time
+           measurement.current.current_at = local_time
+        end
+        measurement = _build_extra(measurement, result, metric)
+      end
+  
+      measurement
     end
     
+    # either get the timezone based on coords, or build it from the data
     #
-    # SUNNY?
-    #
-    def self.sunny?(measurement, time_string=nil)
-      local_time = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
-      measurement.current?(local_time) ?
-        self.currently_sunny?(measurement) :
-        self.forecasted_sunny?(measurement, local_time)
-    end
-    
-    # cookie cutter answer
-    def self.currently_sunny?(measurement)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      return nil unless measurement.current
-      return false if self.currently_day?(measurement) == false
-      self.currently_sunny_by_icon?(measurement.current)
+    def self._timezone(result=nil, query=nil, location=nil)
+      if full_timezone = _parse_full_timezone(result)
+        full_timezone
+      elsif query && query.timezone
+        query.timezone
+      elsif Barometer.enhance_timezone && location &&
+            location.latitude && location.longitude
+        WebService::Timezone.fetch(location.latitude, location.longitude)
+      else
+        _build_timezone(result)
+      end
     end
     
-    # cookie cutter answer
-    def self.forecasted_sunny?(measurement, time_string=nil)
-      local_time = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
-      return nil unless measurement.forecast
-      return false if self.forecasted_day?(measurement, local_time) == false
-      forecast_measurement = measurement.for(local_time)
-      return nil unless forecast_measurement
-      self.forecasted_sunny_by_icon?(forecast_measurement)
-    end
-
-    def self.currently_sunny_by_icon?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Data::CurrentMeasurement)
-      return nil unless self.sunny_icon_codes
-      return nil unless current_measurement.icon?
-      current_measurement.icon.is_a?(String) ?
-        self.sunny_icon_codes.include?(current_measurement.icon.to_s.downcase) :
-        self.sunny_icon_codes.include?(current_measurement.icon)
+    # return the current local time (as Data::LocalTime)
+    #
+    def self._local_time(result, measurement=nil)
+      _parse_local_time(result) || _build_local_time(measurement)
     end
     
-    def self.forecasted_sunny_by_icon?(forecast_measurement)
-      raise ArgumentError unless forecast_measurement.is_a?(Data::ForecastMeasurement)
-      return nil unless self.sunny_icon_codes
-      return nil unless forecast_measurement.icon?
-      forecast_measurement.icon.is_a?(String) ?
-        self.sunny_icon_codes.include?(forecast_measurement.icon.to_s.downcase) :
-        self.sunny_icon_codes.include?(forecast_measurement.icon)
+    def self._meets_requirements?(query=nil)
+      self._supports_country?(query) && (!self._requires_keys? || self._has_keys?)
     end
-
-    # this returns an array of codes that indicate "sunny"
-    def self.sunny_icon_codes; nil; end
     
   end
-end  
-  
-  # def key_name
-  #   # what variables holds the api key?
-  # end
+end

data/lib/barometer/weather_services/weather_bug.rb

@@ -1,6 +1,295 @@
 module Barometer
-  
+  #
+  # = WeatherBug
+  # www.weatherbug.com
+  #
+  # - key required: YES (api_code)
+  # - registration required: YES
+  # - supported countries: US (by zipcode), International (by coordinates)
+  #
+  # === performs geo coding
+  # - city: YES
+  # - coordinates: PARTIAL (just for weather station)
+  #
+  # === time info
+  # - sun rise/set: YES
+  # - provides timezone: NO, but provides a timezone short code and utc offset
+  # - requires TZInfo: NO
+  #
+  # == resources
+  # - API: http://weather.weatherbug.com/corporate/products/API/help.aspx
+  #
+  # === Possible queries:
+  # - http://[API_Code].api.wxbug.net:80/getLiveWeatherRSS.aspx?ACode=[API_Code]&OutputType=1&UnitType=1&zipCode=90210
+  #
+  # where query can be:
+  # - zipcode (US) [5 digits only]
+  # - coordinates (International)
+  #
+  # = WeatherBug.com terms of use
+  # ???
+  #
+  # == notes
+  # - WeatherBug also supports queries using "citycode" and "stationID", but these
+  #   are specific to WeatherBug and un-supported by Barometer
+  #
   class WeatherService::WeatherBug < WeatherService
+    
+    @@api_code = nil
+
+    def self.keys=(keys)
+      raise ArgumentError unless keys.is_a?(Hash)
+      keys.each do |key, value|
+        @@api_code = value.to_s if key.to_s.downcase == "code"
+      end
+    end
+
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
+
+    def self._source_name; :weather_bug; end
+    def self._accepted_formats; [:short_zipcode, :coordinates]; end
+
+    def self._has_keys?; !@@api_code.nil?; end
+    def self._requires_keys?; true; end
+
+    def self._wet_icon_codes
+      codes = [5,6,8,9,11,12,14,15] + (18..22).to_a + [25] + (27..30).to_a +
+              [32,36] + (38..49).to_a + (52..63).to_a + (80..157).to_a +
+              (161..176).to_a
+      codes.collect {|c| c.to_s}
+    end
+    def self._sunny_icon_codes
+      codes = [0,2,3,4,7,26,31,64,65,75]
+      codes.collect {|c| c.to_s}
+    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 && measurement.current.sun
+        measurement.forecast.each do |forecast|
+          forecast.sun = measurement.current.sun
+        end
+      end
+      
+      measurement
+    end
+
+    def self._parse_local_time(data)
+      Data::LocalTime.new(
+        data["aws:ob_date"]["aws:hour"]["hour_24"].to_i,
+        data["aws:ob_date"]["aws:minute"]["number"].to_i,
+        data["aws:ob_date"]["aws:second"]["number"].to_i
+      ) if data && data["aws:ob_date"]
+    end
+
+    def self._build_timezone(data)
+      if data && data["aws:ob_date"] && data["aws:ob_date"]["aws:time_zone"]
+        Data::Zone.new(data["aws:ob_date"]["aws:time_zone"]["abbrv"])
+      end
+    end
+
+    def self._build_current(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+
+      current = Measurement::Current.new
+      # current.updated_at = Data::LocalDateTime.parse(data['observation_time']) if data['observation_time']
+      current.humidity = data['aws:humidity'].to_i
+      current.condition = data['aws:current_condition'] if data['aws:current_condition']
+      current.icon = data['aws:icon'].to_i.to_s if data['aws:icon']
+
+      current.temperature = Data::Temperature.new(metric)
+      current.temperature << data['aws:temp']
+
+      current.wind = Data::Speed.new(metric)
+      current.wind << data['aws:wind_speed'].to_f
+      current.wind.direction = data['aws:wind_direction']
+
+      current.pressure = Data::Pressure.new(metric)
+      current.pressure << data['aws:pressure']
+
+      current.dew_point = Data::Temperature.new(metric)
+      current.dew_point << data['aws:dew_point']
+
+      current.wind_chill = Data::Temperature.new(metric)
+      current.wind_chill << data['aws:feels_like']
+
+      current
+    end
+    
+    def self._build_forecast(data, metric=true)
+      raise ArgumentError unless data.is_a?(Hash)
+      forecasts = Measurement::ForecastArray.new
+      # go through each forecast and create an instance
+      if data && data["aws:forecast"]
+        start_date = Date.parse(data['date'])
+        i = 0
+        data["aws:forecast"].each do |forecast|
+          forecast_measurement = Measurement::Forecast.new
+          icon_match = forecast['aws:image'].match(/cond(\d*)\.gif$/)
+          forecast_measurement.icon = icon_match[1].to_i.to_s if icon_match
+          forecast_measurement.date = start_date + i
+          forecast_measurement.condition = forecast['aws:short_prediction']
+
+          forecast_measurement.high = Data::Temperature.new(metric)
+          forecast_measurement.high << forecast['aws:high']
+
+          forecast_measurement.low = Data::Temperature.new(metric)
+          forecast_measurement.low << forecast['aws:low']
+
+          forecasts << forecast_measurement
+          i += 1
+        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['aws:location']
+          location.city = data['aws:location']['aws:city']
+          location.state_code = data['aws:location']['aws:state']
+          location.zip_code = data['aws:location']['aws:zip']
+        end
+      end
+      location
+    end
+    
+    def self._build_station(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      station = Data::Location.new
+      station.id = data['aws:station_id']
+      station.name = data['aws:station']
+      station.city = data['aws:city_state'].split(',')[0].strip
+      station.state_code = data['aws:city_state'].split(',')[1].strip
+      station.country = data['aws:country']
+      station.zip_code = data['aws:station_zipcode']
+      station.latitude = data['aws:latitude']
+      station.longitude = data['aws:longitude']
+      station
+    end
+    
+    def self._build_sun(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      sun = nil
+      if data
+        if data['aws:sunrise']
+          rise = Data::LocalTime.new(
+            data['aws:sunrise']['aws:hour']['hour_24'].to_i,
+            data['aws:sunrise']['aws:minute']['number'].to_i,
+            data['aws:sunrise']['aws:second']['number'].to_i
+          )
+        end
+        if data['aws:sunset']
+          set = Data::LocalTime.new(
+            data['aws:sunset']['aws:hour']['hour_24'].to_i,
+            data['aws:sunset']['aws:minute']['number'].to_i,
+            data['aws:sunset']['aws:second']['number'].to_i
+          )
+          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,metric)
+      result << _fetch_forecast(query,metric)
+      result
+    end
+    
+    # use HTTParty to get the current weather
+    #
+    def self._fetch_current(query, metric=true)
+      puts "fetch weatherbug current: #{query.q}" if Barometer::debug?
+      
+      q = ( query.format.to_sym == :short_zipcode ?
+        { :zipCode => query.q } :
+        { :lat => query.q.split(',')[0], :long => query.q.split(',')[1] })
+      
+      # httparty and the xml builder it uses miss some information
+      # 1st - get the raw response
+      # 2nd - manually get the missing information
+      # 3rd - let httparty build xml as normal
+      #
+      response = self.get(
+        "http://#{@@api_code}.api.wxbug.net/getLiveWeatherRSS.aspx",
+        :query => { :ACode => @@api_code,
+          :OutputType => "1", :UnitType => (metric ? '1' : '0')
+        }.merge(q),
+        :format => :plain,
+        :timeout => Barometer.timeout
+      )
+      
+      # get icon
+      icon_match = response.match(/cond(\d*)\.gif/)
+      icon = icon_match[1] if icon_match
+      
+      # get station zipcode
+      zip_match = response.match(/zipcode=\"(\d*)\"/)
+      zipcode = zip_match[1] if zip_match
+      
+      # build xml
+      output = Crack::XML.parse(response)
+      output = output["aws:weather"]["aws:ob"]
+      
+      # add missing data
+      output["aws:icon"] = icon
+      output["aws:station_zipcode"] = zipcode
+      
+      output
+    end
+    
+    # use HTTParty to get the current weather
+    #
+    def self._fetch_forecast(query, metric=true)
+      puts "fetch weatherbug forecast: #{query.q}" if Barometer::debug?
+      
+      q = ( query.format.to_sym == :short_zipcode ?
+        { :zipCode => query.q } :
+        { :lat => query.q.split(',')[0], :long => query.q.split(',')[1] })
+      
+      self.get(
+        "http://#{@@api_code}.api.wxbug.net/getForecastRSS.aspx",
+        :query => { :ACode => @@api_code,
+          :OutputType => "1", :UnitType => (metric ? '1' : '0')
+        }.merge(q),
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )["aws:weather"]["aws:forecasts"]
+    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[1]; end
+    def self._station_result(data=nil); data[0]; end
+    def self._sun_result(data=nil); data[0]; end
+    def self._timezone_result(data=nil); data[0]; end
+    def self._time_result(data=nil); data[0]; end
+
   end
-  
 end