barometer 0.8.0 → 0.9.0

data/lib/barometer/measurements/result_array.rb

@@ -1,75 +0,0 @@
-require 'date'
-module Barometer
-  #
-  # Result Array
-  #
-  # an array that holds multiple results,
-  # with methods for insertion and searching
-  #
-  class Measurement::ResultArray < Array
-
-    def <<(forecast)
-      raise ArgumentError unless forecast.is_a?(Measurement::Result)
-      super(forecast)
-    end
-
-    def [](index)
-      index.is_a?(Fixnum) ? super(index) : self.for(index)
-    end
-
-    #
-    # Returns a forecast for a day given by a Date, DateTime,
-    # Time, or a string that can be parsed to a Data::LocalDateTime
-    #
-    # credit: http://github.com/jdpace/weatherman/
-    #
-    def for(datetime)
-
-      return nil unless self.size > 0
-
-      # Format date into a Date class
-      datetime = case datetime.class.name
-      when 'Date'
-        # if just given a date, assume a time that will be mid-day
-        Data::LocalDateTime.new(datetime.year,datetime.month,datetime.day,12,0,0)
-      when 'Data::LocalDateTime'
-        datetime
-      when 'String'
-        Data::LocalDateTime.parse(datetime)
-      when 'Time'
-        Data::LocalDateTime.parse(datetime)
-      when 'DateTime'
-        Data::LocalDateTime.parse(datetime)
-      end
-
-      day = nil
-      self.each do |f|
-        day = f if f.for_datetime?(datetime)
-      end
-      return day
-    end
-
-    #
-    # answer simple questions
-    #
-
-    def windy?(datetime, threshold=10)
-      (forecast = self[datetime]) ? forecast.windy?(threshold) : nil
-    end
-
-    def day?(datetime)
-      local_time = Data::LocalTime.parse(datetime)
-      (forecast = self[datetime]) ? forecast.day?(local_time) : nil
-    end
-
-    def sunny?(datetime, sunny_icons=nil)
-      local_time = Data::LocalTime.parse(datetime)
-      (forecast = self[datetime]) ? forecast.sunny?(local_time, sunny_icons) : nil
-    end
-
-    def wet?(datetime, wet_icons=nil, pop_threshold=50, humidity_threshold=99)
-      (forecast = self[datetime]) ? forecast.wet?(wet_icons,pop_threshold,humidity_threshold) : nil
-    end
-
-  end
-end

data/lib/barometer/services.rb

@@ -1,19 +0,0 @@
-$:.unshift(File.dirname(__FILE__))
-
-# weather services
-#
-require 'weather_services/service'
-require 'weather_services/wunderground'
-require 'weather_services/yahoo'
-require 'weather_services/weather_bug'
-require 'weather_services/noaa'
-
-#
-# web services (non weather)
-#
-require 'web_services/web_service'
-require 'web_services/geocode'
-require 'web_services/weather_id'
-require 'web_services/timezone'
-require 'web_services/placemaker'
-require 'web_services/noaa_station_id'

data/lib/barometer/weather_services/service.rb

@@ -1,189 +0,0 @@
-require 'rubygems'
-require 'httparty'
-
-module Barometer
-  #
-  # Service Class
-  #
-  # This is a base class for creating alternate weather api-consuming
-  # 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 Barometer::Measurement instance.
-  #
-  class WeatherService
-    # all service drivers will use the HTTParty gem
-    include HTTParty
-
-    # 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::WeatherService.const_defined?(source_name)
-      raise ArgumentError unless Barometer::WeatherService.const_get(source_name).superclass == Barometer::WeatherService
-      Barometer::WeatherService.const_get(source_name)
-    end
-
-    #
-    # get current weather and future (forecasted) weather
-    #
-    def self.measure(query, metric=true)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-
-      measurement = Barometer::Measurement.new(self._source_name, metric)
-      measurement.start_at = Time.now.utc
-
-      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
-
-      measurement.end_at = Time.now.utc
-      measurement
-    end
-
-    #########################################################################
-    # PRIVATE
-    # If class methods could be private, the remaining methods would be.
-    #
-
-    #
-    # REQUIRED
-    # re-defining these methods will be required
-    #
-
-    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
-
-    #
-    # 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
-
-    #
-    # 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
-
-    # 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
-
-    # DEFAULT: override this if you need to determine if API keys are required
-    def self._requires_keys?; false; end
-
-    # data accessors
-    # (see the wunderground driver for an example of overriding these)
-    #
-    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
-
-    #
-    # COMPLETE
-    # re-defining these methods should not be needed, as the behavior
-    # can be adjusted using methods above
-    #
-
-    # 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)
-    #
-    def self._measure(measurement, query, metric=true)
-      raise ArgumentError unless measurement.is_a?(Barometer::Measurement)
-      raise ArgumentError unless query.is_a?(Barometer::Query)
-
-      return measurement unless self._meets_requirements?(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
-    #
-    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
-
-    # 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._meets_requirements?(query=nil)
-      self._supports_country?(query) && (!self._requires_keys? || self._has_keys?)
-    end
-
-  end
-end

data/lib/barometer/weather_services/wunderground.rb

@@ -1,264 +0,0 @@
-module Barometer
-  #
-  #   [DEFAULT PROVIDER]
-  #
-  # = Weather Underground
-  # www.wunderground.com
-  #
-  # - key required: NO
-  # - registration required: NO
-  # - supported countries: ALL
-  #
-  # === performs geo coding
-  # - city: YES
-  # - coordinates: YES
-  # NOTE: provides geo data for location and weather station
-  #
-  # === time info
-  # - sun rise/set: YES (today only)
-  # - provides timezone: YES
-  # - requires TZInfo: YES
-  # *NOTE: If accuarcy of times and converting, this service is the top choice.
-  #        They provide the full timezone name that is needed for the most
-  #        accurate time conversions.
-  #
-  # == resources
-  # - API: http://wiki.wunderground.com/index.php/API_-_XML
-  #
-  # === Possible queries:
-  # - http://api.wunderground.com/auto/wui/geo/GeoLookupXML/index.xml?query=94107
-  # - http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=KSFO
-  # - http://api.wunderground.com/weatherstation/WXCurrentObXML.asp?ID=KCASANFR70
-  # - http://api.wunderground.com/auto/wui/geo/AlertsXML/index.xml?query=86445
-  # - http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml?query=Chicago,IL
-  #
-  # where query can be:
-  # - zipcode (US or Canadian)
-  # - city state; city, state
-  # - city
-  # - state
-  # - country
-  # - airport code (3-letter or 4-letter)
-  # - lat,lon
-  #
-  # = Wunderground terms of use
-  # Unable to locate.
-  #
-  class WeatherService::Wunderground < WeatherService
-
-    #########################################################################
-    # 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
-      %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
-      %w(clear mostlysunny partlysunny sunny partlycloudy)
-    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_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_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 = Measurement::Result.new
-      if data['observation_time'] && data['observation_time'].match(/\d/)
-        current.updated_at = Data::LocalDateTime.parse(data['observation_time'])
-      end
-      current.humidity = data['relative_humidity'].to_i
-      current.icon = data['icon'] if data['icon']
-
-      current.temperature = Data::Temperature.new(metric)
-      current.temperature << [data['temp_c'], data['temp_f']]
-
-      current.wind = Data::Speed.new(metric)
-      current.wind.mph = data['wind_mph'].to_f
-      current.wind.degrees = data['wind_degrees'].to_i
-      current.wind.direction = data['wind_dir']
-
-      current.pressure = Data::Pressure.new(metric)
-      current.pressure << [data['pressure_mb'], data['pressure_in']]
-
-      current.dew_point = Data::Temperature.new(metric)
-      current.dew_point << [data['dewpoint_c'], data['dewpoint_f']]
-
-      current.heat_index = Data::Temperature.new(metric)
-      current.heat_index << [data['heat_index_c'], data['heat_index_f']]
-
-      current.wind_chill = Data::Temperature.new(metric)
-      current.wind_chill << [data['windchill_c'], data['windchill_f']]
-
-      current.visibility = Data::Distance.new(metric)
-      current.visibility << [data['visibility_km'], data['visibility_mi']]
-
-      current
-    end
-
-    def self._build_forecast(data, metric=true)
-      raise ArgumentError unless data.is_a?(Hash)
-      forecasts = Measurement::ResultArray.new
-      # go through each forecast and create an instance
-      if data && data['simpleforecast'] &&
-         data['simpleforecast']['forecastday']
-
-        data['simpleforecast']['forecastday'].each do |forecast|
-          forecast_measurement = Measurement::Result.new
-          forecast_measurement.icon = forecast['icon']
-          forecast_measurement.date = Date.parse(forecast['date']['pretty'])
-          forecast_measurement.pop = forecast['pop'].to_i
-
-          forecast_measurement.high = Data::Temperature.new(metric)
-          forecast_measurement.high << [forecast['high']['celsius'],forecast['high']['fahrenheit']]
-
-          forecast_measurement.low = Data::Temperature.new(metric)
-          forecast_measurement.low << [forecast['low']['celsius'],forecast['low']['fahrenheit']]
-
-          forecasts << forecast_measurement
-        end
-      end
-      forecasts
-    end
-
-    def self._build_location(data, geo=nil)
-      raise ArgumentError unless data.is_a?(Hash)
-      location = Data::Location.new
-      if data['display_location']
-        location.name = data['display_location']['full']
-        location.city = data['display_location']['city']
-        location.state_name = data['display_location']['state_name']
-        location.state_code = data['display_location']['state']
-        location.country_code = data['display_location']['country']
-        location.zip_code = data['display_location']['zip']
-        location.latitude = data['display_location']['latitude']
-        location.longitude = data['display_location']['longitude']
-      end
-      location
-    end
-
-    def self._build_station(data)
-      raise ArgumentError unless data.is_a?(Hash)
-      station = Data::Location.new
-      station.id = data['station_id']
-      if data['observation_location']
-        station.name = data['observation_location']['full']
-        station.city = data['observation_location']['city']
-        station.state_name = data['observation_location']['state_name']
-        station.state_code = data['observation_location']['state']
-        station.country_code = data['observation_location']['country']
-        station.zip_code = data['observation_location']['zip']
-        station.latitude = data['observation_location']['latitude']
-        station.longitude = data['observation_location']['longitude']
-      end
-      station
-    end
-
-    def self._build_sun(data)
-      raise ArgumentError unless data.is_a?(Hash)
-      sun = nil
-      if data
-        if data['moon_phase']
-          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._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.q},
-       :format => :xml,
-       :timeout => Barometer.timeout
-       )['current_observation']
-    end
-
-    # use HTTParty to get the forecasted weather
-    #
-    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.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