barometer 0.1.0

data/lib/barometer/data.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__))
+
+# measurements and units
+require 'data/measurement'
+require 'data/current'
+require 'data/forecast'
+require 'data/zone'
+require 'data/sun'
+require 'data/geo'
+require 'data/location'
+require 'data/units'
+require 'data/temperature'
+require 'data/distance'
+require 'data/speed'
+require 'data/pressure'

data/lib/barometer/data/current.rb

@@ -0,0 +1,93 @@
+module Barometer
+  #
+  # Current Measurement
+  # a data class for current weather conditions
+  #
+  # This is basically a data holding class for the current weather
+  # conditions.
+  #
+  class CurrentMeasurement
+    
+    attr_accessor :time, :local_time
+    attr_reader :humidity, :icon, :condition
+    attr_reader :temperature, :dew_point, :heat_index, :wind_chill
+    attr_reader :wind, :pressure, :visibility, :sun
+    
+    def time=(time)
+      #raise ArgumentError unless time.is_a?(Time)
+      @time = time
+    end
+    
+    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?(Barometer::Temperature)
+      @temperature = temperature
+    end
+    
+    def dew_point=(dew_point)
+      raise ArgumentError unless dew_point.is_a?(Barometer::Temperature)
+      @dew_point = dew_point
+    end
+    
+    def heat_index=(heat_index)
+      raise ArgumentError unless heat_index.is_a?(Barometer::Temperature)
+      @heat_index = heat_index
+    end
+    
+    def wind_chill=(wind_chill)
+      raise ArgumentError unless wind_chill.is_a?(Barometer::Temperature)
+      @wind_chill = wind_chill
+    end
+    
+    def wind=(wind)
+      raise ArgumentError unless wind.is_a?(Barometer::Speed)
+      @wind = wind
+    end
+    
+    def pressure=(pressure)
+      raise ArgumentError unless pressure.is_a?(Barometer::Pressure)
+      @pressure = pressure
+    end
+    
+    def visibility=(visibility)
+      raise ArgumentError unless visibility.is_a?(Barometer::Distance)
+      @visibility = visibility
+    end
+    
+    def sun=(sun)
+      raise ArgumentError unless sun.is_a?(Barometer::Sun)
+      @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
+    
+  end
+end

data/lib/barometer/data/distance.rb

@@ -0,0 +1,131 @@
+module Barometer
+  #
+  # A simple Distance class
+  # 
+  # Think of this like the Integer class. Enhancement
+  # is that you can create a number (in a certain unit), then
+  # get that number back already converted to another unit.
+  #
+  # All comparison operations will be done in metric
+  # 
+  # NOTE: this currently only supports the scale of
+  #       kilometers (km) and miles (m).  There is currently
+  #       no way to scale to smaller units (eg km -> m -> mm)
+  class Distance < Barometer::Units
+    
+    METRIC_UNITS = "km"
+    IMPERIAL_UNITS = "m"
+    
+    attr_accessor :kilometers, :miles
+    
+    def initialize(metric=true)
+      @kilometers = nil
+      @miles = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.km = value; end
+    def imperial_default=(value); self.m = value; end
+
+    #
+    # CONVERTERS
+    #
+    
+    def self.km_to_m(km)
+      return nil unless km && (km.is_a?(Integer) || km.is_a?(Float))
+      km.to_f * 0.622
+    end
+    
+    def self.m_to_km(m)
+      return nil unless m && (m.is_a?(Integer) || m.is_a?(Float))
+      m.to_f * 1.609
+    end
+    
+    #
+    # ACCESSORS
+    #
+    
+    # store kilometers
+    def km=(km)
+      return if !km || !(km.is_a?(Integer) || km.is_a?(Float))
+      @kilometers = km.to_f
+      self.update_miles(km.to_f)
+    end
+    
+    # store miles
+    def m=(m)
+      return if !m || !(m.is_a?(Integer) || m.is_a?(Float))
+      @miles = m.to_f
+      self.update_kilometers(m.to_f)
+    end
+    
+    # return the stored kilometers or convert from miles
+    def km(as_integer=true)
+      km = (@kilometers || Distance.m_to_km(@miles))
+      km ? (as_integer ? km.to_i : (100*km).round/100.0) : nil
+    end
+    
+    # return the stored miles or convert from kilometers
+    def m(as_integer=true)
+      m = (@miles || Distance.km_to_m(@kilometers))
+      m ? (as_integer ? m.to_i : (100*m).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      self.km <=> other.km
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.km : self.m
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.km(false) : self.m(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.km} #{METRIC_UNITS}" : "#{self.m} #{IMPERIAL_UNITS}"
+    end
+    
+    # will just return the units (no value)
+    def units(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? METRIC_UNITS : IMPERIAL_UNITS
+    end
+    
+    # when we set miles, it is possible the a non-equivalent value of
+    # kilometers remains.  if so, clear it.
+    def update_kilometers(m)
+      return unless @kilometers
+      difference = Distance.m_to_km(m.to_f) - @kilometers
+      # only clear kilometers if the stored kilometers is off be more then 1 unit
+      # then the conversion of miles
+      @kilometers = nil unless difference.abs <= 1.0
+    end
+    
+    # when we set kilometers, it is possible the a non-equivalent value of
+    # miles remains.  if so, clear it.
+    def update_miles(km)
+      return unless @miles
+      difference = Distance.km_to_m(km.to_f) - @miles
+      # only clear miles if the stored miles is off be more then 1 unit
+      # then the conversion of kilometers
+      @miles = nil unless difference.abs <= 1.0
+    end
+    
+    def nil?
+      (@kilometers || @miles) ? false : true
+    end
+    
+  end
+end

data/lib/barometer/data/forecast.rb

@@ -0,0 +1,66 @@
+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 ForecastMeasurement
+    
+    attr_reader :date, :icon, :condition
+    attr_reader :low, :high, :pop, :sun
+    
+    def date=(date)
+      raise ArgumentError unless date.is_a?(Date)
+      @date = date
+    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 high=(high)
+      raise ArgumentError unless high.is_a?(Barometer::Temperature)
+      @high = high
+    end
+    
+    def low=(low)
+      raise ArgumentError unless low.is_a?(Barometer::Temperature)
+      @low = low
+    end
+    
+    def pop=(pop)
+      raise ArgumentError unless pop.is_a?(Fixnum)
+      @pop = pop
+    end
+    
+    def sun=(sun)
+      raise ArgumentError unless sun.is_a?(Barometer::Sun)
+      @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
+    
+  end
+end

data/lib/barometer/data/geo.rb

@@ -0,0 +1,98 @@
+module Barometer
+  #
+  # A simple Geo class
+  # 
+  # Used to store location data from Graticule or HTTParty and convert
+  # into just the data needed for geocoding
+  #
+  class Geo
+    
+    attr_accessor :latitude, :longitude
+    attr_accessor :locality, :region, :country, :country_code
+    
+    #
+    # this will take a Location object (either generated by Graticule
+    # or HTTParty), and fill in the applicable data
+    #
+    def initialize(location=nil)
+      return unless location
+      
+      has_graticule = false
+      begin
+        Graticule
+        has_graticule = true
+      rescue
+        # do nothing, Graticule not available
+      end
+      
+      if has_graticule
+        raise ArgumentError unless
+          (location.is_a?(Graticule::Location) || location.is_a?(Hash))
+      else
+        raise ArgumentError unless location.is_a?(Hash)
+      end
+      
+      if has_graticule && location.class == Graticule::Location
+        self.build_from_graticule(location)
+      elsif location.class == Hash
+        self.build_from_httparty(location)
+      end
+      self
+    end
+    
+    def build_from_graticule(location=nil)
+      return nil unless location
+      
+      begin
+        require 'rubygems'
+        require 'graticule'
+        $:.unshift(File.dirname(__FILE__))
+        # load some changes to Graticule
+        # TODO: attempt to get changes into Graticule gem
+        require 'extensions/graticule'
+      end
+
+      raise ArgumentError unless location.is_a?(Graticule::Location)
+      
+      @latitude = location.latitude
+      @longitude = location.longitude
+      @locality = location.locality
+      @region = location.region
+      @country = location.country
+      @country_code = location.country_code
+    end
+    
+    def build_from_httparty(location=nil)
+      return nil unless location
+      raise ArgumentError unless location.is_a?(Hash)
+      
+      placemark = location["Placemark"]
+      placemark = placemark.first if placemark.is_a?(Array)
+      
+      if placemark && placemark["Point"] && placemark["Point"]["coordinates"]
+        @latitude = placemark["Point"]["coordinates"].split(',')[1].to_f
+        @longitude = placemark["Point"]["coordinates"].split(',')[0].to_f
+      end
+      if placemark && placemark["AddressDetails"] && placemark["AddressDetails"]["Country"]
+        if placemark["AddressDetails"]["Country"]["AdministrativeArea"]
+          if placemark["AddressDetails"]["Country"]["AdministrativeArea"]["SubAdministrativeArea"]
+            locality = placemark["AddressDetails"]["Country"]["AdministrativeArea"]["SubAdministrativeArea"]["Locality"]
+          else
+            locality = placemark["AddressDetails"]["Country"]["AdministrativeArea"]["Locality"]
+          end
+          if locality
+            @locality = locality["LocalityName"]
+          end
+          @region = placemark["AddressDetails"]["Country"]["AdministrativeArea"]["AdministrativeAreaName"]
+        end
+        @country = placemark["AddressDetails"]["Country"]["CountryName"]
+        @country_code = placemark["AddressDetails"]["Country"]["CountryNameCode"]
+      end
+    end
+    
+    def coordinates
+      [@latitude, @longitude].join(',')
+    end
+    
+  end
+end

data/lib/barometer/data/location.rb

@@ -0,0 +1,20 @@
+module Barometer
+  #
+  # A simple Location class
+  # 
+  # Used to store location information about the station that
+  # gave the measurement data for a weather query, or the location
+  # that was queried
+  #
+  class Location
+    
+    attr_accessor :id, :name, :city
+    attr_accessor :state_name, :state_code, :country, :country_code, :zip_code
+    attr_accessor :latitude, :longitude
+    
+    def coordinates
+      [@latitude, @longitude].join(',')
+    end
+    
+  end
+end

data/lib/barometer/data/measurement.rb

@@ -0,0 +1,161 @@
+module Barometer
+  #
+  # Measurement
+  # a class that holds the response from a weather service
+  #
+  # its main purpose is to hold all the data collected from a weather service
+  # as it is passed to the weather object
+  #
+  # this response includes
+  # - current weather data (using the CurrentMeasurement class)
+  # - forecasted weather data (an Array of instances of the ForecastMeasurement class)
+  # - time_zone information (for the location in question)
+  # - weather station information (for the station that gave collected the data)
+  #
+  class Measurement
+    
+    # the weather service source
+    attr_reader :source
+    # current and forecasted data
+    attr_reader :current, :forecast
+    attr_reader :timezone, :station, :location
+    attr_reader :success, :time
+    attr_accessor :metric
+    
+    def initialize(source=nil, metric=true)
+      @source = source
+      @metric = metric
+      @success = false
+    end
+    
+    def success!
+      if current && current.temperature && !current.temperature.c.nil?
+        @success = true
+      end
+    end
+    
+    def stamp!; @time = Time.now.utc; end
+    def success?; @success; end
+    def metric?; @metric; end
+    def metric!; @metric=true; end
+    def imperial!; @metric=false; end
+    
+    # this will tell us if the measurement is still current ... if it is still
+    # current this means that the CurrentMeasurement can still used as now
+    #
+    # what it also means is that if you took a measurement right now (time = now)
+    # and then asked if current?(time_in_future) that current? would be true for
+    # any time_in_future within 4 hours of now
+    #
+    # where is this useful?  lets say you take the measurement now (time = now),
+    # and then you want to know if self.windy?(5_hours_in_future) ... we could
+    # not use the current data for this answser as the time 5_hours_in_future
+    # is not current
+    def current?(utc_time=Time.now.utc)
+      return false unless @time
+      raise ArgumentError unless utc_time.is_a?(Time)
+      hours_still_current = 4
+      difference = (@time - utc_time).to_i
+      difference = (difference*(-1)).to_i if difference < 0
+      difference <= (60*60*hours_still_current).to_i
+    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=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 'String'
+        Date.parse(date)
+      when 'Date'
+        date
+      when 'DateTime'
+        Date.new(date.year, date.month, date.day)
+      when 'Time'
+        Date.new(date.year, date.month, date.day)
+      end
+
+      day = nil
+      @forecast.each do |f|
+        day = f if date == f.date
+      end
+      return day
+    end
+    
+    def source=(source)
+      raise ArgumentError unless source.is_a?(Symbol)
+      @source = source
+    end
+    
+    def time=(time=Time.now.utc)
+      raise ArgumentError unless time.is_a?(Time)
+      @time = time
+    end
+    
+    def current=(current)
+      raise ArgumentError unless current.is_a?(Barometer::CurrentMeasurement)
+      @current = current
+      self.stamp!
+      # self-determine success
+      self.success!
+    end
+    
+    def forecast=(forecast)
+      raise ArgumentError unless forecast.is_a?(Array)
+      @forecast = forecast
+    end
+    
+    def timezone=(timezone)
+      #raise ArgumentError unless timezone.is_a?(String)
+      raise ArgumentError unless timezone.is_a?(Barometer::Zone)
+      @timezone = timezone
+    end
+    
+    def station=(station)
+      raise ArgumentError unless station.is_a?(Barometer::Location)
+      @station = station
+    end
+    
+    def location=(location)
+      raise ArgumentError unless location.is_a?(Barometer::Location)
+      @location = location
+    end
+    
+    #
+    # simple questions
+    # pass questions to the source
+    #
+    
+    def windy?(threshold=10, utc_time=Time.now.utc)
+      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
+      raise ArgumentError unless utc_time.is_a?(Time)
+      Barometer::Service.source(@source).windy?(self, threshold, utc_time)
+    end
+    
+    def wet?(threshold=50, utc_time=Time.now.utc)
+      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
+      raise ArgumentError unless utc_time.is_a?(Time)
+      Barometer::Service.source(@source).wet?(self, threshold, utc_time)
+    end
+    
+    def day?(utc_time=Time.now.utc)
+      raise ArgumentError unless utc_time.is_a?(Time)
+      Barometer::Service.source(@source).day?(self, utc_time)
+    end
+    
+    def sunny?(utc_time=Time.now.utc)
+      raise ArgumentError unless utc_time.is_a?(Time)
+      return false if self.day?(utc_time) == false
+      Barometer::Service.source(@source).sunny?(self, utc_time)
+    end
+    
+  end
+end