attack-barometer 0.5.0 → 0.6.0

data/lib/barometer/weather_services/wunderground.rb

@@ -46,72 +46,63 @@ module Barometer
   #
   class WeatherService::Wunderground < WeatherService
     
-    def self.source_name; :wunderground; end
-    def self.accepted_formats
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
+    
+    def self._source_name; :wunderground; end
+    def self._accepted_formats
       [:zipcode, :postalcode, :icao, :coordinates, :geocode]
     end
     
     # these are the icon codes that indicate "wet", used by wet? function
-    def self.wet_icon_codes
+    def self._wet_icon_codes
       %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
+    def self._sunny_icon_codes
       %w(clear mostlysunny partlysunny sunny partlycloudy)
     end
 
-    def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Data::Measurement)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-      measurement.source = self.source_name
-      
-      begin
-        current_result = self.get_current(query.q)
-        measurement.current = self.build_current(current_result, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-      
-      begin
-        forecast_result = self.get_forecast(query.q)
-        measurement.forecast = self.build_forecast(forecast_result, metric)
-      rescue Timeout::Error => e
-        return measurement
-      end
-      
-      measurement.location = self.build_location(current_result)
-      measurement.station = self.build_station(current_result)
-      measurement.timezone = self.build_timezone(forecast_result)
-      
-      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)
-         measurement.current.sun = sun
-      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 && sun
+      if measurement.forecast && measurement.current.sun
         measurement.forecast.each do |forecast|
-          forecast.sun = sun
+          forecast.sun = measurement.current.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._parse_full_timezone(data)
+      raise ArgumentError unless data.is_a?(Hash)
+      if data && data['simpleforecast'] &&
+         data['simpleforecast']['forecastday'] &&
+         data['simpleforecast']['forecastday'].first &&
+         data['simpleforecast']['forecastday'].first['date']
+        Data::Zone.new(
+          data['simpleforecast']['forecastday'].first['date']['tz_long']
+        )
+      end
+    end
     
-    def self.build_current(data, metric=true)
+    def self._build_links(data)
+      links = {}
+      if data["credit"] && data["credit_URL"]
+        links[data["credit"]] = data["credit_URL"]
+      end
+      links
+    end
+
+    def self._build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
       
-      current = Data::CurrentMeasurement.new
+      current = Measurement::Current.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']
@@ -142,15 +133,15 @@ module Barometer
       current
     end
     
-    def self.build_forecast(data, metric=true)
+    def self._build_forecast(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      forecasts = []
+      forecasts = Measurement::ForecastArray.new
       # go through each forecast and create an instance
       if data && data['simpleforecast'] &&
          data['simpleforecast']['forecastday']
          
         data['simpleforecast']['forecastday'].each do |forecast|
-          forecast_measurement = Data::ForecastMeasurement.new
+          forecast_measurement = Measurement::Forecast.new
           forecast_measurement.icon = forecast['icon']
           forecast_measurement.date = Date.parse(forecast['date']['pretty'])
           forecast_measurement.pop = forecast['pop'].to_i
@@ -166,8 +157,8 @@ module Barometer
       end
       forecasts
     end
-
-    def self.build_location(data)
+    
+    def self._build_location(data, geo=nil)
       raise ArgumentError unless data.is_a?(Hash)
       location = Data::Location.new
       if data['display_location']
@@ -183,7 +174,7 @@ module Barometer
       location
     end
     
-    def self.build_station(data)
+    def self._build_station(data)
       raise ArgumentError unless data.is_a?(Hash)
       station = Data::Location.new
       station.id = data['station_id']
@@ -200,69 +191,72 @@ module Barometer
       station
     end
     
-    def self.build_timezone(data)
-      raise ArgumentError unless data.is_a?(Hash)
-      timezone = nil
-      if data && data['simpleforecast'] &&
-         data['simpleforecast']['forecastday'] &&
-         data['simpleforecast']['forecastday'].first &&
-         data['simpleforecast']['forecastday'].first['date']
-        timezone = Data::Zone.new(
-          data['simpleforecast']['forecastday'].first['date']['tz_long']
-        )
-      end
-      timezone || Data::Zone.new(nil)
-    end
-    
-    def self.build_sun(data, timezone)
+    def self._build_sun(data)
       raise ArgumentError unless data.is_a?(Hash)
-      raise ArgumentError unless timezone.is_a?(Data::Zone)
       sun = nil
       if data
         if data['moon_phase']
-          if data['moon_phase']['sunrise']
-            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 = Data::LocalTime.new(
-              data['moon_phase']['sunset']['hour'].to_i,
-              data['moon_phase']['sunset']['minute'].to_i
-            )
-          end
-        
-          sun = Data::Sun.new(
-            rise,
-            set
-          )
+          rise = Data::LocalTime.new(
+            data['moon_phase']['sunrise']['hour'].to_i,
+            data['moon_phase']['sunrise']['minute'].to_i
+          ) if data['moon_phase']['sunrise']
+          set = Data::LocalTime.new(
+            data['moon_phase']['sunset']['hour'].to_i,
+            data['moon_phase']['sunset']['minute'].to_i
+          ) if data['moon_phase']['sunset']
+          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)
+      result << _fetch_forecast(query)
+      result
+    end
+    
     # use HTTParty to get the current weather
-    def self.get_current(query)
+    #
+    def self._fetch_current(query)
       return unless query
+      puts "fetch wunderground current: #{query.q}" if Barometer::debug?
       self.get(
        "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml",
-       :query => {:query => query},
+       :query => {:query => query.q},
        :format => :xml,
        :timeout => Barometer.timeout
        )['current_observation']
     end
     
     # use HTTParty to get the forecasted weather
-    def self.get_forecast(query)
+    #
+    def self._fetch_forecast(query)
       return unless query
+      puts "fetch wunderground forecast: #{query.q}" if Barometer::debug?
       self.get(
         "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml",
-        :query => {:query => query},
+        :query => {:query => query.q},
         :format => :xml,
         :timeout => Barometer.timeout
       )['forecast']
     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[0]; end
+    def self._station_result(data=nil); data[0]; end
+    def self._links_result(data=nil); data[0]; end
+    def self._sun_result(data=nil); data[1]; end
+    def self._timezone_result(data=nil); data[1]; end
+    
   end
 end

data/lib/barometer/weather_services/yahoo.rb

@@ -45,103 +45,54 @@ module Barometer
   #
   class WeatherService::Yahoo < WeatherService
     
-    def self.source_name; :yahoo; end
-    def self.accepted_formats; [:zipcode, :weather_id]; end
+    #########################################################################
+    # PRIVATE
+    # If class methods could be private, the remaining methods would be.
+    #
     
-    # these are the icon codes that indicate "wet", used by wet? function
-    def self.wet_icon_codes
+    def self._source_name; :yahoo; end
+    def self._accepted_formats; [:zipcode, :weather_id]; end
+    
+    def self._wet_icon_codes
       codes = [1] + (3..18).to_a + [35] + (37..43).to_a + (45..47).to_a
       codes.collect {|c| c.to_s}
     end
-    def self.sunny_icon_codes
+    def self._sunny_icon_codes
       codes = (29..34).to_a + [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)
-      
-      if result["title"] && result["link"]
-        measurement.links[result["title"]] = result["link"]
-      end
-      
-      sun = nil
-      if measurement.current
-        sun = self.build_sun(result)
-        measurement.current.sun = sun
-      end
-      # use todays sun data for all future days
-      if measurement.forecast && sun
-        measurement.forecast.each do |forecast|
-          forecast.sun = sun
-        end
-      end
-      
-      local_time = self.build_local_time(result)
-      if local_time
-        measurement.measured_at = local_time
-        measurement.current.current_at = local_time
+  
+   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._build_timezone(data)
+      if data && data['item'] && data['item']['pubDate']
+        zone_match = data['item']['pubDate'].match(/ ([A-Z]*)$/)
+        Data::Zone.new(zone_match[1]) if zone_match
       end
-      
-      measurement
     end
     
-def self.build_local_time(data)
-  if data
-    if data['item']
-      # what time is it now?
-      now_utc = Time.now.utc
-      
-      # get published date
-      pub_date = data['item']['pubDate']
-      
-      # get the TIME ZONE CODE
-      zone_match = pub_date.match(/ ([A-Z]*)$/) if pub_date
-      
-      if zone_match
-        zone = zone_match[1] 
-        
-        # try converting pub_date to utc
-#        pub_date_utc = Data::Zone.code_to_utc(Time.parse(pub_date), zone) if zone
-     
-        # how far back was this?
- #       data_age_in_seconds = now_utc - pub_date_utc
-      
-        # is this older then 2 hours
-#        if (data_age_in_seconds < 0) || (data_age_in_seconds > (60 * 60 * 2))
-          # we may have converted the time wrong.
-          # if pub_date in the future, then?
-          # if pub_date too far back, then?
-        
-          # for now do nothing ... don't set measured_time
-#          return nil
-#        else
-          # everything seems fine
-          # convert now to the local time 
-          offset = Data::Zone.zone_to_offset(zone)
-          return Data::LocalTime.parse(now_utc + offset)
-#        end
+    def self._build_links(data)
+      links = {}
+      if data["title"] && data["link"]
+        links[data["title"]] = data["link"]
       end
-      nil
+      links
     end
-  end
-end
     
-    def self.build_current(data, metric=true)
+    def self._build_current(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      current = Data::CurrentMeasurement.new
+      current = Measurement::Current.new(metric)
       if data
         if data['item'] && data['item']['yweather:condition']
           condition_result = data['item']['yweather:condition']
@@ -171,15 +122,15 @@ end
       current
     end
     
-    def self.build_forecast(data, metric=true)
+    def self._build_forecast(data, metric=true)
       raise ArgumentError unless data.is_a?(Hash)
-      forecasts = []
+      forecasts = Measurement::ForecastArray.new
       
       if data && data['item'] && data['item']['yweather:forecast']
          forecast_result = data['item']['yweather:forecast']
          
         forecast_result.each do |forecast|
-          forecast_measurement = Data::ForecastMeasurement.new
+          forecast_measurement = Measurement::Forecast.new
           forecast_measurement.icon = forecast['code']
           forecast_measurement.date = Date.parse(forecast['date'])
           forecast_measurement.condition = forecast['text']
@@ -193,7 +144,7 @@ end
       forecasts
     end
     
-    def self.build_location(data, geo=nil)
+    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
@@ -219,7 +170,7 @@ end
       location
     end
     
-    def self.build_sun(data)
+    def self._build_sun(data)
       raise ArgumentError unless data.is_a?(Hash)
       sun = nil
       if data && data['yweather:astronomy'] && data['item']
@@ -229,12 +180,14 @@ end
       end
       sun || Data::Sun.new
     end
-
+    
     # use HTTParty to get the current weather
-    def self.fetch(query, metric=true)
+    def self._fetch(query, metric=true)
+      return unless query
+      puts "fetch yahoo: #{query.q}" if Barometer::debug?
       self.get(
         "http://weather.yahooapis.com/forecastrss",
-        :query => {:p => query, :u => (metric ? 'c' : 'f')},
+        :query => {:p => query.q, :u => (metric ? 'c' : 'f')},
         :format => :xml,
         :timeout => Barometer.timeout
       )['rss']['channel']

data/lib/barometer/web_services/geocode.rb

@@ -8,6 +8,7 @@ module Barometer
     
     def self.fetch(query)
       raise ArgumentError unless _is_a_query?(query)
+      puts "geocoding: #{query.q}" if Barometer::debug?
       return nil unless _has_geocode_key?
       location = self.get(
         "http://maps.google.com/maps/geo",

data/lib/barometer/web_services/timezone.rb

@@ -0,0 +1,40 @@
+module Barometer
+  #
+  # Web Service: Timezone
+  #
+  # uses geonames.org to obtain the full timezone for given coordinates
+  #
+  class WebService::Timezone < WebService
+    
+    # get the full timezone for given coordinates
+    #
+    def self.fetch(latitude, longitude)
+      puts "timezone: #{latitude}, #{longitude}"
+      return nil unless latitude && longitude
+      _fetch_via_wunderground(latitude, longitude)
+    end
+    
+    def self._fetch_via_geonames(latitude, longitude)
+      response = self.get(
+        "http://ws.geonames.org/timezone",
+        :query => { :lat => latitude, :lng => longitude },
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )['geonames']['timezone']  
+      response ? Data::Zone.new(response['timezoneId']) : nil
+    end
+    
+    def self._fetch_via_wunderground(latitude, longitude)
+      response = self.get(
+        "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml",
+        :query => {:query => "#{latitude},#{longitude}"},
+        :format => :xml,
+        :timeout => Barometer.timeout
+      )['forecast']['simpleforecast']['forecastday'].first
+      response ? Data::Zone.new(response['date']['tz_long']) : nil
+    end
+    
+  end
+end
+
+

data/lib/barometer/web_services/weather_id.rb

@@ -9,11 +9,13 @@ module Barometer
     # get the weather_id for a given query
     #
     def self.fetch(query)
+      puts "fetch weather_id: #{query.q}" if Barometer::debug?
       return nil unless query
       raise ArgumentError unless _is_a_query?(query)
-      response = self.get(
+      
+      self.get(
         "http://xoap.weather.com/search/search",
-        :query => { :where => query.q }, :format => :plain,
+        :query => { :where => _adjust_query(query.q) }, :format => :plain,
         :timeout => Barometer.timeout
       )
     end
@@ -21,6 +23,7 @@ module Barometer
     # get the location_date (geocode) for a given weather_id
     #
     def self.reverse(query)
+      puts "reverse weather_id: #{query.q}" if Barometer::debug?
       return nil unless query
       raise ArgumentError unless _is_a_query?(query)
       self.get(
@@ -30,6 +33,18 @@ module Barometer
         :timeout => Barometer.timeout
       )['rss']['channel']["yweather:location"]
     end
+    
+    # filter out words that weather.com has trouble geo-locating
+    # mostly these are icao related
+    #
+    def self._adjust_query(query)
+      output = query.dup
+      words_to_remove = %w(international airport municipal)
+      words_to_remove.each do |word|
+        output.gsub!(/#{word}/i, "")
+      end
+      output
+    end
 
   end
 end

data/lib/barometer.rb

@@ -9,6 +9,12 @@ require 'barometer/formats'
  
 module Barometer
   
+  @@debug_mode = false
+  def self.debug; @@debug_mode; end;
+  def self.debug=(value); @@debug_mode = value; end;
+  def self.debug!; @@debug_mode = true; end;
+  def self.debug?; @@debug_mode; end;
+  
   @@google_geocode_key = nil
   def self.google_geocode_key; @@google_geocode_key; end;
   def self.google_geocode_key=(key); @@google_geocode_key = key; end;
@@ -25,6 +31,11 @@ module Barometer
   def self.force_geocode=(value); @@force_geocode = value; end;
   def self.force_geocode!; @@force_geocode = true; end;
   
+  @@enhance_timezone = false
+  def self.enhance_timezone; @@enhance_timezone; end;
+  def self.enhance_timezone=(value); @@enhance_timezone = value; end;
+  def self.enhance_timezone!; @@enhance_timezone = true; end;
+  
   # adjust the timeout used when interactind with external web services
   #
   @@timeout = 15

data/lib/demometer/demometer.rb

@@ -32,6 +32,23 @@ class Demometer < Sinatra::Default
     { :weather_dot_com => { :keys => { :partner => partner_key, :license => license_key } } }
   end
 
+  def config_weather_bug
+    if File.exists?(@@config_file)
+    	keys = YAML.load_file(@@config_file)
+    	if keys["weather_bug"] && keys["weather_bug"]["code"]
+    	  code = keys["weather_bug"]["code"].to_s
+      else
+        raise RunTimeError "no weatherbug.com keys"
+        exit
+      end
+    else
+      File.open(@@config_file, 'w') {|f| f << "\weather_bug:\n  code: API_CODE" }
+      raise RunTimeError "no weatherbug.com keys"
+      exit
+    end
+    { :weather_bug => { :keys => { :code => code } } }
+  end
+
   helpers do
     def data(title, value)
       return if value.nil?
@@ -58,6 +75,13 @@ class Demometer < Sinatra::Default
       Barometer::Base.config[1] << config_weather_dot_com
     end
     
+    # setup weatherbug.com
+    if Barometer::Base.config && Barometer::Base.config[1] &&
+      Barometer::Base.config[1].include?(:weather_bug)
+      Barometer::Base.config[1].delete(:weather_bug)
+      Barometer::Base.config[1] << config_weather_bug
+    end
+    
     if params[:query] && !params[:query][:q].empty?
       @barometer = Barometer.new(params[:query][:q])
       @weather = @barometer.measure(metric)
@@ -72,5 +96,9 @@ class Demometer < Sinatra::Default
   get '/readme.html' do
     erb :readme
   end
+  
+  get '/about.html' do
+    erb :about
+  end
 
 end