attack-barometer 0.5.0 → 0.6.0

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