barometer 0.3.2 → 0.5.0

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

@@ -21,7 +21,7 @@ module Barometer
   # - API: http://unknown
   #
   # === Possible queries:
-  # - 
+  # - http://google.com/ig/api?weather=perth
   #
   # where query can be:
   # - zipcode (US or Canadian)
@@ -30,32 +30,28 @@ module Barometer
   # - state
   # - country
   #
-  class Google < Service
+  # = Google terms of use
+  # This is an unoffical API.  There are no terms of use.
+  #
+  class WeatherService::Google < WeatherService
     
-    def self.accepted_formats
-      [:zipcode, :postalcode, :geocode]
-    end
+    def self.source_name; :google; end
+    def self.accepted_formats; [:zipcode, :postalcode, :geocode]; end
     
-    def self.source_name
-      :google
-    end
-    
-    # these are the icon codes that indicate "wet", used by wet? function
     def self.wet_icon_codes
       %w(rain chance_of_rain chance_of_storm thunderstorm mist)
     end
-    # these are the icon codes that indicate "sun", used by sunny? function
     def self.sunny_icon_codes
       %w(sunny mostly_sunny partly_cloudy)
     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
       
       begin
-        result = self.get_all(query.preferred, metric)
+        result = self.get_all(query.q, metric)
       rescue Timeout::Error => e
         return measurement
       end
@@ -68,12 +64,13 @@ module Barometer
 
     def self.build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      current = CurrentMeasurement.new
+      current = Data::CurrentMeasurement.new
 
-      if data && data['forecast_information'] &&
-         data['forecast_information']['current_date_time']
-        current.time = data['forecast_information']['current_date_time']['data']
-      end
+      # google gives utc time, no way to convert to local
+      #if data && data['forecast_information'] &&
+      #   data['forecast_information']['current_date_time']
+      #  current.updated_at = Data::LocalDateTime.parse(data['forecast_information']['current_date_time']['data'])
+      #end
       
       if data['current_conditions']
         data = data['current_conditions']
@@ -86,10 +83,10 @@ module Barometer
         humidity_match = data['humidity']['data'].match(/[\d]+/)
         current.humidity = humidity_match[0].to_i if humidity_match
       
-        current.temperature = Temperature.new(metric)
+        current.temperature = Data::Temperature.new(metric)
         current.temperature << [data['temp_c']['data'], data['temp_f']['data']]
       
-        current.wind = Speed.new(metric)
+        current.wind = Data::Speed.new(metric)
         begin
           current.wind << data['wind_condition']['data'].match(/[\d]+/)[0]
           current.wind.direction = data['wind_condition']['data'].match(/Wind:.*?([\w]+).*?at/)[1]
@@ -111,7 +108,7 @@ module Barometer
       # go through each forecast and create an instance
       d = 0
       data.each do |forecast|
-        forecast_measurement = ForecastMeasurement.new
+        forecast_measurement = Data::ForecastMeasurement.new
         if forecast['icon']
           icon_match = forecast['icon']['data'].match(/.*\/([A-Za-z_]*)\.png/)
           forecast_measurement.icon = icon_match[1] if icon_match
@@ -122,9 +119,9 @@ module Barometer
           forecast_measurement.date = start_date + d
         end
 
-        forecast_measurement.high = Temperature.new(metric)
+        forecast_measurement.high = Data::Temperature.new(metric)
         forecast_measurement.high << forecast['high']['data']
-        forecast_measurement.low = Temperature.new(metric)
+        forecast_measurement.low = Data::Temperature.new(metric)
         forecast_measurement.low << forecast['low']['data']
         
         forecasts << forecast_measurement
@@ -134,8 +131,8 @@ module Barometer
     end
     
     def self.build_location(geo=nil)
-      raise ArgumentError unless (geo.nil? || geo.is_a?(Barometer::Geo))
-      location = Location.new
+      raise ArgumentError unless (geo.nil? || geo.is_a?(Data::Geo))
+      location = Data::Location.new
       if geo
         location.city = geo.locality
         location.state_code = geo.region
@@ -149,7 +146,7 @@ module Barometer
     
     # use HTTParty to get the current weather
     def self.get_all(query, metric=true)
-      Barometer::Google.get(
+      self.get(
         "http://google.com/ig/api",
         :query => {:weather => query, :hl => (metric ? "en-GB" : "en-US")},
         :format => :xml,

data/lib/barometer/weather_services/noaa.rb

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

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

@@ -13,20 +13,19 @@ module Barometer
   # drivers.  Each driver inherits from this class.
   # 
   # Basically, all a service is required to do is take a query
-  # (ie "Paris") and return a complete Barometer::Measurement instance.
+  # (ie "Paris") and return a complete Data::Measurement instance.
   #
-  class Service
-    
+  class WeatherService
     # all service drivers will use the HTTParty gem
     include HTTParty
     
-    # Retrieves the weather source Service object
+    # retrieves the weather source Service object
     def self.source(source_name)
       raise ArgumentError unless (source_name.is_a?(String) || source_name.is_a?(Symbol))
       source_name = source_name.to_s.split("_").collect{ |s| s.capitalize }.join('')
-      raise ArgumentError unless Barometer.const_defined?(source_name)
-      raise ArgumentError unless Barometer.const_get(source_name).superclass == Barometer::Service
-      Barometer.const_get(source_name)
+      raise ArgumentError unless Barometer::WeatherService.const_defined?(source_name)
+      raise ArgumentError unless Barometer::WeatherService.const_get(source_name).superclass == Barometer::WeatherService
+      Barometer::WeatherService.const_get(source_name)
     end
 
     #
@@ -35,10 +34,14 @@ module Barometer
     def self.measure(query, metric=true)
       raise ArgumentError unless query.is_a?(Barometer::Query)
       
-      measurement = Barometer::Measurement.new(self.source_name, metric)
+      measurement = Data::Measurement.new(self.source_name, metric)
       if self.meets_requirements?(query)
-        query.convert!(self.accepted_formats)
-        measurement = self._measure(measurement, query, metric) if query.preferred
+        converted_query = query.convert!(self.accepted_formats)
+        if converted_query
+          measurement.query = converted_query.q
+          measurement.format = converted_query.format
+          measurement = self._measure(measurement, converted_query, metric)
+        end
       end
       measurement
     end
@@ -51,40 +54,34 @@ module Barometer
     # NOTE: The following methods MUST be re-defined by each driver.
     #
     
+    # 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.accepted_formats; raise NotImplementedError; end
     
     # STUB: define this method to measure the current & future weather
     def self._measure(measurement=nil, query=nil, metric=true)
       raise NotImplementedError
     end
 
-    # STUB: define this method to actually retireve the source_name
-    def self.source_name
-      raise NotImplementedError
-    end
+    #
+    # NOTE: The following methods can be re-defined by each driver. [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
 
-    #
-    # NOTE: The following methods can be re-defined by each driver. [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.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
     
     #
     # answer simple questions
@@ -93,20 +90,21 @@ module Barometer
     #
     # WINDY?
     #
-    def self.windy?(measurement, threshold=10, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+    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 (utc_time.is_a?(Time) || utc_time.nil?)
+      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
 
-      measurement.current?(utc_time) ?
+      measurement.current?(local_time) ?
         self.currently_windy?(measurement, threshold) :
-        self.forecasted_windy?(measurement, threshold, utc_time)
+        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?(Barometer::Measurement)
+      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? ?
@@ -115,23 +113,24 @@ module Barometer
     end
 
     # no driver can currently answer this question, so it doesn't have any code
-    def self.forecasted_windy?(measurement, threshold, utc_time); nil; end
+    def self.forecasted_windy?(measurement, threshold, time_string); nil; end
     
     #
     # WET?
     #
-    def self.wet?(measurement, threshold=50, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+    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 (utc_time.is_a?(Time) || utc_time.nil?)
-      measurement.current?(utc_time) ?
+      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, utc_time)
+        self.forecasted_wet?(measurement, threshold, local_time)
     end
     
     # cookie cutter answer
     def self.currently_wet?(measurement, threshold=50)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+      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) ||
@@ -142,7 +141,7 @@ module Barometer
     
     # cookie cutter answer
     def self.currently_wet_by_dewpoint?(measurement)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+      raise ArgumentError unless measurement.is_a?(Data::Measurement)
       return nil if (!measurement.current || !measurement.current.temperature? ||
                      !measurement.current.dew_point?)
       measurement.metric? ?
@@ -152,14 +151,14 @@ module Barometer
     
     # cookie cutter answer
     def self.currently_wet_by_humidity?(current_measurement)
-      raise ArgumentError unless current_measurement.is_a?(Barometer::CurrentMeasurement)
+      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?(Barometer::Measurement)
+      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
@@ -169,12 +168,13 @@ module Barometer
     end
     
     # cookie cutter answer
-    def self.forecasted_wet?(measurement, threshold=50, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
+    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 (utc_time.is_a?(Time) || utc_time.nil?)
+      raise ArgumentError unless (local_time.is_a?(Data::LocalDateTime) || local_time.nil?)
       return nil unless measurement.forecast
-      forecast_measurement = measurement.for(utc_time)
+      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)
@@ -182,14 +182,14 @@ module Barometer
 
     # cookie cutter answer
     def self.forecasted_wet_by_pop?(forecast_measurement, threshold=50)
-      raise ArgumentError unless forecast_measurement.is_a?(Barometer::ForecastMeasurement)
+      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?(Barometer::CurrentMeasurement)
+      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) ?
@@ -198,7 +198,7 @@ module Barometer
     end
     
     def self.forecasted_wet_by_icon?(forecast_measurement)
-      raise ArgumentError unless forecast_measurement.is_a?(Barometer::ForecastMeasurement)
+      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) ?
@@ -212,90 +212,100 @@ module Barometer
     #
     # DAY?
     #
-    def self.day?(measurement, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
-      raise ArgumentError unless (utc_time.is_a?(Time) || utc_time.nil?)
+    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?(utc_time) ?
+      measurement.current?(local_datetime) ?
         self.currently_day?(measurement) :
-        self.forecasted_day?(measurement, utc_time)
+        self.forecasted_day?(measurement, local_datetime)
     end
     
     def self.currently_day?(measurement)
-      raise ArgumentError unless measurement.is_a?(Barometer::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?(Barometer::CurrentMeasurement)
-      return nil unless current_measurement.sun && current_measurement.sun.rise
-      Time.now.utc >= current_measurement.sun.rise
+      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?(Barometer::CurrentMeasurement)
-      return nil unless current_measurement.sun && current_measurement.sun.set
-      Time.now.utc <= current_measurement.sun.set
+      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, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
-      raise ArgumentError unless (utc_time.is_a?(Time) || utc_time.nil?)
+    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(utc_time)
+      forecast_measurement = measurement.for(local_datetime)
       return nil unless forecast_measurement
-      self.forecasted_after_sunrise?(forecast_measurement, utc_time) &&
-        self.forecasted_before_sunset?(forecast_measurement, utc_time)
+      self.forecasted_after_sunrise?(forecast_measurement, local_datetime) &&
+        self.forecasted_before_sunset?(forecast_measurement, local_datetime)
     end
     
-    def self.forecasted_after_sunrise?(forecast_measurement, utc_time)
-      raise ArgumentError unless forecast_measurement.is_a?(Barometer::ForecastMeasurement)
-      raise ArgumentError unless utc_time.is_a?(Time)
+    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
-      utc_time >= forecast_measurement.sun.rise
+      local_datetime >= forecast_measurement.sun.rise
     end 
     
-    def self.forecasted_before_sunset?(forecast_measurement, utc_time)
-      raise ArgumentError unless forecast_measurement.is_a?(Barometer::ForecastMeasurement)
-      raise ArgumentError unless utc_time.is_a?(Time)
+    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
-      utc_time <= forecast_measurement.sun.set
+      local_datetime <= forecast_measurement.sun.set
     end
     
     #
     # SUNNY?
     #
-    def self.sunny?(measurement, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
-      raise ArgumentError unless (utc_time.is_a?(Time) || utc_time.nil?)
-      measurement.current?(utc_time) ?
+    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, utc_time)
+        self.forecasted_sunny?(measurement, local_time)
     end
     
     # cookie cutter answer
     def self.currently_sunny?(measurement)
-      raise ArgumentError unless measurement.is_a?(Barometer::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)
     end
     
     # cookie cutter answer
-    def self.forecasted_sunny?(measurement, utc_time=nil)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
-      raise ArgumentError unless (utc_time.is_a?(Time) || utc_time.nil?)
+    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, utc_time) == false
-      forecast_measurement = measurement.for(utc_time)
+      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?(Barometer::CurrentMeasurement)
+      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) ?
@@ -304,7 +314,7 @@ module Barometer
     end
     
     def self.forecasted_sunny_by_icon?(forecast_measurement)
-      raise ArgumentError unless forecast_measurement.is_a?(Barometer::ForecastMeasurement)
+      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) ?
@@ -316,7 +326,6 @@ module Barometer
     def self.sunny_icon_codes; nil; end
     
   end
-  
 end  
   
   # def key_name