barometer 0.5.0 → 0.6.1

data/lib/barometer/formats/coordinates.rb

@@ -26,7 +26,10 @@ module Barometer
       #
       pre_query = nil
       if original_query.format == :weather_id
-        pre_query = Query::Format::WeatherID.reverse(original_query)
+        unless pre_query = original_query.get_conversion(Query::Format::Geocode.format)
+          pre_query = Query::Format::WeatherID.reverse(original_query)
+          original_query.post_conversion(pre_query)
+        end
       end
       
       # convert & adjust

data/lib/barometer/formats/geocode.rb

@@ -23,11 +23,14 @@ module Barometer
       unless converts?(original_query)
         return (original_query.format == format ? original_query.dup : nil)
       end
-      converted_query = Barometer::Query.new
-    
-      converted_query = (original_query.format == :weather_id ?
-       Query::Format::WeatherID.reverse(original_query) :
-       geocode(original_query))
+      
+      unless converted_query = original_query.get_conversion(format)
+        converted_query = Barometer::Query.new
+        converted_query = (original_query.format == :weather_id ?
+         Query::Format::WeatherID.reverse(original_query) :
+         geocode(original_query))
+        original_query.post_conversion(converted_query) if converted_query
+      end
       converted_query
     end
 
@@ -35,9 +38,8 @@ module Barometer
     #
     def self.geocode(original_query)
       raise ArgumentError unless is_a_query?(original_query)
+      
       converted_query = Barometer::Query.new
-
-      #converted_query.geo = _geocode(original_query)
       converted_query.geo = WebService::Geocode.fetch(original_query)
       if converted_query.geo
         converted_query.country_code = converted_query.geo.country_code

data/lib/barometer/formats/icao.rb

@@ -22,8 +22,8 @@ module Barometer
     #
     def self.regex; /^[A-Za-z]{3,4}$/; end
     
-    # # in some cases the first letter can designate the country
-    # #
+    # in some cases the first letter can designate the country
+    #
     def self.country_code(query=nil)
       return unless query && query.is_a?(String)
       $:.unshift(File.dirname(__FILE__))

data/lib/barometer/formats/weather_id.rb

@@ -17,7 +17,7 @@ module Barometer
     def self.format; :weather_id; end
     def self.regex; /(^[A-Za-z]{4}[0-9]{4}$)/; end
     def self.convertable_formats
-      [:short_zipcode, :zipcode, :coordinates, :geocode]
+      [:short_zipcode, :zipcode, :coordinates, :icao, :geocode]
     end
       
     # the first two letters of the :weather_id is the country_code
@@ -31,10 +31,10 @@ module Barometer
     def self.to(original_query)
       raise ArgumentError unless is_a_query?(original_query)
       return nil unless converts?(original_query)
-      converted_query = Barometer::Query.new
 
       # convert original query to :geocode, as that is the only
       # format we can convert directly from to weather_id
+      converted_query = Barometer::Query.new
       converted_query = Query::Format::Geocode.to(original_query)
       converted_query.q = _search(converted_query)
       converted_query.format = format

data/lib/barometer/measurements/common.rb

@@ -0,0 +1,113 @@
+module Barometer
+  #
+  # Common Measurement
+  #
+  # Code common to both Current and Forecast Measurements
+  #
+  class Measurement::Common
+    
+    attr_reader :humidity, :icon, :condition
+    attr_reader :wind, :sun
+    attr_accessor :metric
+    
+    def initialize(metric=true)
+      @metric = metric
+    end
+    
+    def metric?; metric; end
+    
+    # accessors (with input checking)
+    #
+    def humidity=(humidity)
+      raise ArgumentError unless
+        (humidity.is_a?(Fixnum) || humidity.is_a?(Float))
+      @humidity = humidity
+    end
+    
+    def icon=(icon)
+      raise ArgumentError unless icon.is_a?(String)
+      @icon = icon
+    end
+    
+    def condition=(condition)
+      raise ArgumentError unless condition.is_a?(String)
+      @condition = condition
+    end
+    
+    def wind=(wind)
+      raise ArgumentError unless wind.is_a?(Data::Speed)
+      @wind = wind
+    end
+    
+    def sun=(sun)
+      raise ArgumentError unless (sun.is_a?(Data::Sun) || sun.nil?)
+      @sun = sun
+    end
+    
+    #
+    # helpers
+    #
+    
+    # creates "?" helpers for all attributes (which maps to nil?)
+    #
+    def method_missing(method,*args)
+      # if the method ends in ?, then strip it off and see if we
+      # respond to the method without the ?
+      if (call_method = method.to_s.chomp!("?")) && respond_to?(call_method)
+        return send(call_method).nil? ? false : true
+      else
+        super(method,*args)
+      end
+    end
+    
+    #
+    # answer simple questions
+    #
+    
+    def windy?(threshold=10)
+      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
+      return nil unless wind?
+      wind.to_f(metric?) >= threshold.to_f
+    end
+    
+    def day?(time)
+      return nil unless time && sun?
+      sun.after_rise?(time) && sun.before_set?(time)
+    end
+    
+    def wet?(wet_icons=nil, humidity_threshold=99)
+      result = nil
+      result ||= _wet_by_icon?(wet_icons) if icon?
+      result ||= _wet_by_humidity?(humidity_threshold) if humidity?
+      result
+    end
+    
+    def sunny?(time, sunny_icons=nil)
+      return nil unless time
+      is_day = day?(time)
+      return nil if is_day.nil?
+      is_day && _sunny_by_icon?(sunny_icons)
+    end
+    
+    private
+    
+    def _wet_by_humidity?(threshold=99)
+      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
+      return nil unless humidity?
+      humidity.to_f >= threshold.to_f
+    end
+    
+    def _wet_by_icon?(wet_icons=nil)
+      raise ArgumentError unless (wet_icons.nil? || wet_icons.is_a?(Array))
+      return nil unless (icon? && wet_icons)
+      wet_icons.include?(icon.to_s.downcase)
+    end
+    
+    def _sunny_by_icon?(sunny_icons=nil)
+      raise ArgumentError unless (sunny_icons.nil? || sunny_icons.is_a?(Array))
+      return nil unless (icon? && sunny_icons)
+      sunny_icons.include?(icon.to_s.downcase)
+    end
+    
+  end
+end

data/lib/barometer/{data → measurements}/current.rb

@@ -6,31 +6,14 @@ module Barometer
   # This is basically a data holding class for the current weather
   # conditions.
   #
-  class Data::CurrentMeasurement
+  class Measurement::Current < Measurement::Common
     
     attr_reader :current_at, :updated_at
-    attr_reader :humidity, :icon, :condition
     attr_reader :temperature, :dew_point, :heat_index, :wind_chill
-    attr_reader :wind, :pressure, :visibility, :sun
+    attr_reader :pressure, :visibility
     
     # accessors (with input checking)
     #
-    def humidity=(humidity)
-      raise ArgumentError unless
-        (humidity.is_a?(Fixnum) || humidity.is_a?(Float))
-      @humidity = humidity
-    end
-    
-    def icon=(icon)
-      raise ArgumentError unless icon.is_a?(String)
-      @icon = icon
-    end
-    
-    def condition=(condition)
-      raise ArgumentError unless condition.is_a?(String)
-      @condition = condition
-    end
-    
     def temperature=(temperature)
       raise ArgumentError unless temperature.is_a?(Data::Temperature)
       @temperature = temperature
@@ -51,11 +34,6 @@ module Barometer
       @wind_chill = wind_chill
     end
     
-    def wind=(wind)
-      raise ArgumentError unless wind.is_a?(Data::Speed)
-      @wind = wind
-    end
-    
     def pressure=(pressure)
       raise ArgumentError unless pressure.is_a?(Data::Pressure)
       @pressure = pressure
@@ -66,35 +44,32 @@ module Barometer
       @visibility = visibility
     end
     
-    def sun=(sun)
-      raise ArgumentError unless sun.is_a?(Data::Sun)
-      @sun = sun
-    end
-    
     def current_at=(current_at)
       raise ArgumentError unless (current_at.is_a?(Data::LocalTime) || current_at.is_a?(Data::LocalDateTime))
       @current_at = current_at
     end 
      
     def updated_at=(updated_at)
-    raise ArgumentError unless (updated_at.is_a?(Data::LocalTime) || updated_at.is_a?(Data::LocalDateTime))
-    @updated_at = updated_at
+      raise ArgumentError unless (updated_at.is_a?(Data::LocalTime) || updated_at.is_a?(Data::LocalDateTime))
+      @updated_at = updated_at
     end
     
     #
-    # helpers
+    # answer simple questions
     #
     
-    # creates "?" helpers for all attributes (which maps to nil?)
-    #
-    def method_missing(method,*args)
-      # if the method ends in ?, then strip it off and see if we
-      # respond to the method without the ?
-      if (call_method = method.to_s.chomp!("?")) && respond_to?(call_method)
-        return send(call_method).nil? ? false : true
-      else
-        super(method,*args)
-      end
+    def wet?(wet_icons=nil, humidity_threshold=99)
+      result = nil
+      result ||= super(wet_icons, humidity_threshold) if (icon? || humidity?)
+      result ||= _wet_by_dewpoint? if (dew_point? && temperature?)
+      result
+    end
+    
+    private
+    
+    def _wet_by_dewpoint?
+      return nil unless dew_point? && temperature?
+      temperature.to_f(metric?) <=  dew_point.to_f(metric?)
     end
     
   end

data/lib/barometer/measurements/forecast.rb

@@ -0,0 +1,62 @@
+require 'date'
+module Barometer
+  #
+  # Forecast Measurement
+  # a data class for forecasted weather conditions
+  #
+  # This is basically a data holding class for the forecasted weather
+  # conditions.
+  #
+  class Measurement::Forecast < Measurement::Common
+    
+    attr_reader :date
+    attr_reader :low, :high, :pop, :night
+    
+    # accessors (with input checking)
+    #
+    def date=(date)
+      raise ArgumentError unless date.is_a?(Date)
+      @date = date
+    end
+    
+    def high=(high)
+      raise ArgumentError unless high.is_a?(Data::Temperature)
+      @high = high
+    end
+    
+    def low=(low)
+      raise ArgumentError unless low.is_a?(Data::Temperature)
+      @low = low
+    end
+    
+    def pop=(pop)
+      raise ArgumentError unless pop.is_a?(Fixnum)
+      @pop = pop
+    end
+    
+    def night=(night)
+      raise ArgumentError unless night.is_a?(Measurement::ForecastNight)
+      @night = night
+    end
+    
+    #
+    # answer simple questions
+    #
+    
+    def wet?(wet_icons=nil, pop_threshold=50, humidity_threshold=99)
+      result = nil
+      result ||= _wet_by_pop?(pop_threshold) if pop?
+      result ||= super(wet_icons, humidity_threshold) if (icon? || humidity?)
+      result
+    end
+    
+    private
+    
+    def _wet_by_pop?(threshold=50)
+      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
+      return nil unless pop?
+      pop.to_f >= threshold.to_f
+    end
+    
+  end
+end

data/lib/barometer/measurements/forecast_array.rb

@@ -0,0 +1,72 @@
+require 'date'
+module Barometer
+  #
+  # Forecast Array
+  # an array that holds multiple forecasts
+  #
+  class Measurement::ForecastArray < Array
+    
+    def <<(forecast)
+      raise ArgumentError unless forecast.is_a?(Measurement::Forecast)
+      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 date
+    #
+    # credit: http://github.com/jdpace/weatherman/
+    #
+    def for(date)
+    
+      return nil unless self.size > 0
+      
+      # Format date into a Date class
+      date = case date.class.name
+      when 'Date'
+        date
+      when 'Data::LocalDateTime'
+        date.to_d
+      when 'String'
+        Date.parse(date)
+      when 'Time'
+        Date.new(date.year, date.month, date.day)
+      when 'DateTime'
+        Date.new(date.year, date.month, date.day)
+      end
+      
+      day = nil
+      self.each do |f|
+        day = f if date == f.date
+      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/{data → measurements}/measurement.rb

@@ -12,7 +12,7 @@ module Barometer
   # - time_zone information (for the location in question)
   # - weather station information (for the station that gave collected the data)
   #
-  class Data::Measurement
+  class Measurement
     
     attr_reader :source, :weight
     attr_reader :measured_at, :utc_time_stamp
@@ -20,6 +20,7 @@ module Barometer
     attr_reader :timezone, :station, :location, :links
     attr_reader :success
     attr_accessor :metric, :query, :format
+    attr_accessor :start_at, :end_at
     
     def initialize(source=nil, metric=true)
       @source = source
@@ -39,6 +40,7 @@ module Barometer
     def metric?; @metric; end
     def metric!; @metric=true; end
     def imperial!; @metric=false; end
+    def now; timezone ? timezone.now : nil; end
     
     #
     # this will tell us if the measurement is still current ... if it is still
@@ -58,7 +60,7 @@ module Barometer
         self.current.current_at : self.measured_at)
       
       local_time = (local_time.nil? ? current_at : Data::LocalTime.parse(local_time))
-      return false unless local_time
+      return true unless local_time
       raise ArgumentError unless local_time.is_a?(Data::LocalTime)
       
       hours_still_current = 4
@@ -70,32 +72,12 @@ module Barometer
     # Returns a forecast for a day given by a Date, DateTime,
     # Time, or a string that can be parsed to a date
     #
-    # credit: http://github.com/jdpace/weatherman/
-    #
     def for(date=nil)
       date = @timezone.today unless date || !@timezone
       date ||= Date.today
       return nil unless (@forecast && @forecast.size > 0)
       
-      # Format date into a Date class
-      date = case date.class.name
-      when 'Date'
-        date
-      when 'Data::LocalDateTime'
-        date.to_d
-      when 'String'
-        Date.parse(date)
-      when 'Time'
-        Date.new(date.year, date.month, date.day)
-      when 'DateTime'
-        Date.new(date.year, date.month, date.day)
-      end
-      
-      day = nil
-      @forecast.each do |f|
-        day = f if date == f.date
-      end
-      return day
+      @forecast.for(date)
     end
     
     #
@@ -113,18 +95,19 @@ module Barometer
     end
     
     def current=(current)
-      raise ArgumentError unless current.is_a?(Data::CurrentMeasurement)
+      raise ArgumentError unless current.is_a?(Measurement::Current)
       @current = current
       self.stamp!
       self.success!
     end
     
     def forecast=(forecast)
-      raise ArgumentError unless forecast.is_a?(Array)
+      raise ArgumentError unless forecast.is_a?(Measurement::ForecastArray)
       @forecast = forecast
     end
     
     def timezone=(timezone)
+      return unless timezone
       raise ArgumentError unless timezone.is_a?(Data::Zone)
       @timezone = timezone
     end
@@ -156,34 +139,63 @@ module Barometer
     
     #
     # simple questions
-    # pass questions to the source
     #
     
-    def windy?(threshold=10, time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      Barometer::WeatherService.source(@source).windy?(self, threshold, local_datetime)
-    end
-    
-    def wet?(threshold=50, time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      Barometer::WeatherService.source(@source).wet?(self, threshold, local_datetime)
+    def windy?(time_string=nil, threshold=10)
+      time_string ||= (measured_at || now)
+      local_time = Data::LocalTime.parse(time_string)
+      
+      if current?(local_time)
+        return nil unless current
+        current.windy?(threshold)
+      else
+        return nil unless forecast && (future = forecast[local_time])
+        future.windy?(threshold)
+      end
     end
     
     def day?(time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      Barometer::WeatherService.source(@source).day?(self, local_datetime)
+      time_string ||= (measured_at || now)
+      local_time = Data::LocalTime.parse(time_string)
+      
+      if current?(local_time)
+        return nil unless current
+        current.day?(local_time)
+      else
+        return nil unless forecast && (future = forecast[local_time])
+        future.day?(local_time)
+      end
     end
     
     def sunny?(time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string) if time_string
-      raise ArgumentError unless (local_datetime.is_a?(Data::LocalDateTime) || local_datetime.nil?)
-      return false if self.day?(local_datetime) == false
-      Barometer::WeatherService.source(@source).sunny?(self, local_datetime)
+      time_string ||= (measured_at || now)
+      local_time = Data::LocalTime.parse(time_string)
+      sunny_icons = Barometer::WeatherService.source(@source)._sunny_icon_codes
+      
+      is_day = day?(local_time)
+      return is_day unless is_day
+      
+      if current?(local_time)
+        return nil unless current
+        current.sunny?(local_time, sunny_icons)
+      else
+        return nil unless forecast && (future = forecast[local_time])
+        future.sunny?(local_time, sunny_icons)
+      end
+    end
+    
+    def wet?(time_string=nil, pop_threshold=50, humidity_threshold=99)
+      time_string ||= (measured_at || now)
+      local_time = Data::LocalTime.parse(time_string)
+      wet_icons = Barometer::WeatherService.source(@source)._wet_icon_codes
+      
+      if current?(local_time)
+        return nil unless current
+        current.wet?(wet_icons, humidity_threshold)
+      else
+        return nil unless forecast && (future = forecast[local_time])
+        future.wet?(wet_icons, pop_threshold, humidity_threshold)
+      end
     end
     
   end