attack-barometer 0.1.0

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

data/lib/barometer/data/pressure.rb

@@ -0,0 +1,133 @@
+module Barometer
+  #
+  # A simple Pressure 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: the metric units for pressure aren't commonly used, except
+  #       that this class was designed for storing weather data,
+  #       and it seems that it is more common in this case
+  #
+  class Pressure < Barometer::Units
+    
+    METRIC_UNITS = "mb"
+    IMPERIAL_UNITS = "in"
+    
+    attr_accessor :millibars, :inches
+    
+    def initialize(metric=true)
+      @millibars = nil
+      @inches = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.mb = value; end
+    def imperial_default=(value); self.in = value; end
+
+    #
+    # CONVERTERS
+    #
+    
+    def self.mb_to_in(mb)
+      return nil unless mb && (mb.is_a?(Integer) || mb.is_a?(Float))
+      mb.to_f * 0.02953
+    end
+    
+    def self.in_to_mb(inches)
+      return nil unless inches &&
+        (inches.is_a?(Integer) || inches.is_a?(Float))
+      inches.to_f * 33.8639
+    end
+    
+    #
+    # ACCESSORS
+    #
+    
+    # store millibars
+    def mb=(mb)
+      return if !mb || !(mb.is_a?(Integer) || mb.is_a?(Float))
+      @millibars = mb.to_f
+      self.update_inches(mb.to_f)
+    end
+    
+    # store inches
+    def in=(inches)
+      return if !inches || !(inches.is_a?(Integer) || inches.is_a?(Float))
+      @inches = inches.to_f
+      self.update_millibars(inches.to_f)
+    end
+    
+    # return the stored millibars or convert from inches
+    def mb(as_integer=true)
+      mb = (@millibars || Pressure.in_to_mb(@inches))
+      mb ? (as_integer ? mb.to_i : (100*mb).round/100.0) : nil
+    end
+    
+    # return the stored inches or convert from millibars
+    def in(as_integer=true)
+      inches = (@inches || Pressure.mb_to_in(@millibars))
+      inches ? (as_integer ? inches.to_i : (100*inches).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      self.mb <=> other.mb
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.mb : self.in
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.mb(false) : self.in(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.mb} #{METRIC_UNITS}" : "#{self.in} #{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 inches, it is possible the a non-equivalent value of
+    # millibars remains.  if so, clear it.
+    def update_millibars(inches)
+      return unless @millibars
+      difference = Pressure.in_to_mb(inches.to_f) - @millibars
+      # only clear millibars if the stored millibars is off be more then 1 unit
+      # then the conversion of inches
+      @millibars = nil unless difference.abs <= 1.0
+    end
+    
+    # when we set millibars, it is possible the a non-equivalent value of
+    # inches remains.  if so, clear it.
+    def update_inches(mb)
+      return unless @inches
+      difference = Pressure.mb_to_in(mb.to_f) - @inches
+      # only clear inches if the stored inches is off be more then 1 unit
+      # then the conversion of millibars
+      @inches = nil unless difference.abs <= 1.0
+    end
+    
+    def nil?
+      (@millibars || @inches) ? false : true
+    end
+    
+  end
+end

data/lib/barometer/data/speed.rb

@@ -0,0 +1,147 @@
+module Barometer
+  #
+  # A simple Speed 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.
+  #
+  # Speed is a vector, thus it has a perticular direction, although
+  # the direction is independent of the units
+  #
+  # All comparison operations will be done in metric
+  # 
+  # NOTE: this currently only supports the scale of
+  #       kilometers (km) and miles (m) per hour.  There is currently
+  #       no way to scale to smaller units (eg km -> m -> mm)
+  class Speed < Barometer::Units
+    
+    METRIC_UNITS = "kph"
+    IMPERIAL_UNITS = "mph"
+    
+    attr_accessor :kilometers, :miles
+    attr_accessor :degrees, :direction
+    
+    def initialize(metric=true)
+      @kilometers = nil
+      @miles = nil
+      @degrees = nil
+      @direction = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.kph = value; end
+    def imperial_default=(value); self.mph = 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 per hour
+    def kph=(kph)
+      return if !kph || !(kph.is_a?(Integer) || kph.is_a?(Float))
+      @kilometers = kph.to_f
+      self.update_miles(kph.to_f)
+    end
+    
+    # store miles per hour
+    def mph=(mph)
+      return if !mph || !(mph.is_a?(Integer) || mph.is_a?(Float))
+      @miles = mph.to_f
+      self.update_kilometers(mph.to_f)
+    end
+    
+    def direction=(direction)
+      return if !direction || !direction.is_a?(String)
+      @direction = direction
+    end
+    
+    def degrees=(degrees)
+      return if !degrees || !(degrees.is_a?(Integer) || degrees.is_a?(Float))
+      @degrees = degrees
+    end
+    
+    # return the stored kilometers or convert from miles
+    def kph(as_integer=true)
+      km = (@kilometers || Speed.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 mph(as_integer=true)
+      m = (@miles || Speed.km_to_m(@kilometers))
+      m ? (as_integer ? m.to_i : (100*m).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      self.kph <=> other.kph
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.kph : self.mph
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.kph(false) : self.mph(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.kph} #{METRIC_UNITS}" : "#{self.mph} #{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 = Speed.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 = Speed.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/sun.rb

@@ -0,0 +1,35 @@
+module Barometer
+  #
+  # A simple Sun class
+  # 
+  # Used to store sunrise and sunset information
+  #
+  class Sun
+    
+    def initialize(rise=nil, set=nil)
+      raise ArgumentError unless (rise.is_a?(Time) || rise.nil?)
+      raise ArgumentError unless (set.is_a?(Time) || set.nil?)
+      @rise_utc = rise
+      @set_utc = set
+    end
+
+    def rise; @rise_utc; end
+    def set; @set_utc; end
+    
+    # useful for incrementing the sunrise and sunset times by exactly
+    # N days ... used when using the same sun data for other days
+    def self.add_days!(sun, n=1)
+      raise ArgumentError unless sun.is_a?(Barometer::Sun)
+      raise ArgumentError unless n.is_a?(Fixnum)
+      seconds_to_add = 60*60*24*n
+      rise_utc = sun.rise + seconds_to_add
+      set_utc = sun.set + seconds_to_add
+      self.new(rise_utc, set_utc)
+    end
+    
+    def nil?
+      (@rise_utc || @set_utc) ? false : true
+    end
+    
+  end
+end