attack-barometer 0.1.0

data/lib/barometer/weather.rb

@@ -0,0 +1,187 @@
+module Barometer
+  
+  class Weather
+    
+    # hash of measurements indexed by :source
+    attr_accessor :measurements
+    
+    def initialize
+      @measurements = []
+    end
+    
+    # the default source is the first source/measurement that we
+    # have successful results for
+    def default
+      return nil unless self.sources
+      self.source(self.sources.first)
+    end
+    
+    # find the measurement for the given source, if it exists
+    def source(source)
+      raise ArgumentError unless (source.is_a?(String) || source.is_a?(Symbol))
+      @measurements.each do |measurement|
+        return measurement if measurement.source == source.to_sym
+      end
+      nil
+    end
+    
+    # list successful sources
+    def sources
+      @measurements.collect {|m| m.source.to_sym if m.success?}.compact
+    end
+    
+    #
+    # Quick access methods
+    #
+    
+    def current
+      (default = self.default) ? default.current : nil
+    end
+    
+    def forecast
+      (default = self.default) ? default.forecast : nil
+    end
+
+    def now
+      self.current
+    end
+    
+    def today
+      default = self.default
+      default && default.forecast ? default.forecast[0] : nil
+    end
+    
+    def tomorrow
+      default = self.default
+      default && default.forecast ? default.forecast[1] : nil
+    end
+    
+    def for(query)
+      default = self.default
+      default && default.forecast ? default.for(query) : nil
+    end
+    
+    #
+    # helper methods
+    #
+    # these are handy methods that can average values for successful weather
+    # sources, or answer a simple question (ie: weather.windy?)
+    #
+    
+    #
+    # averages
+    #
+    
+    # average of all humidity values
+    # def humidity
+    # end
+    # 
+    # # average of all temperature values
+    # def temperature
+    # end
+    # 
+    # # average of all wind speed values
+    # def wind
+    # end
+    # 
+    # # average of all pressure values
+    # def pressure
+    # end
+    # 
+    # # average of all dew_point values
+    # def dew_point
+    # end
+    # 
+    # # average of all heat_index values
+    # def heat_index
+    # end
+    # 
+    # # average of all wind_chill values
+    # def wind_chill
+    # end
+    # 
+    # # average of all visibility values
+    # def visibility
+    # end
+    
+    #
+    # quick access methods
+    #
+    
+    # what is the current local time and date?
+    # def time
+    # end
+    
+    # def icon
+    #   self.current.icon
+    # end
+    
+    #
+    # simple questions
+    # pass the question on to each successful measurement until we get an answer
+    #
+    
+    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)
+      
+      is_windy = nil
+      @measurements.each do |measurement|
+        if measurement.success?
+          is_windy = measurement.windy?(threshold, utc_time)
+          return is_windy if !is_windy.nil?
+        end
+      end
+      is_windy
+    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)
+      
+      is_wet = nil
+      @measurements.each do |measurement|
+        if measurement.success?
+          is_wet = measurement.wet?(threshold, utc_time)
+          return is_wet if !is_wet.nil?
+        end
+      end
+      is_wet
+    end
+
+    def day?(utc_time=Time.now.utc)
+      raise ArgumentError unless utc_time.is_a?(Time)
+      
+      is_day = nil
+      @measurements.each do |measurement|
+        if measurement.success?
+          is_day = measurement.day?(utc_time)
+          return is_day if !is_day.nil?
+        end
+      end
+      is_day
+    end
+
+    def night?(utc_time=Time.now.utc)
+      raise ArgumentError unless utc_time.is_a?(Time)
+      is_day = self.day?(utc_time)
+      is_day.nil? ? nil : !is_day
+    end
+
+    def sunny?(utc_time=Time.now.utc)
+      raise ArgumentError unless utc_time.is_a?(Time)
+      
+      is_sunny = nil
+      @measurements.each do |measurement|
+        if measurement.success?
+          return false if self.day?(utc_time) == false
+          is_sunny = measurement.sunny?(utc_time)
+          return is_sunny if !is_sunny.nil?
+        end
+      end
+      is_sunny
+    end
+
+  end
+  
+end

data/lib/barometer.rb

@@ -0,0 +1,52 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'barometer/base'
+require 'barometer/query'
+require 'barometer/weather'
+require 'barometer/services'
+require 'barometer/data'
+ 
+module Barometer
+  
+  @@google_geocode_key = nil
+  def self.google_geocode_key; @@google_geocode_key; end;
+  def self.google_geocode_key=(key); @@google_geocode_key = key; end;
+  
+  @@skip_graticule = false
+  def self.skip_graticule; @@skip_graticule; end;
+  def self.skip_graticule=(value); @@skip_graticule = value; end;
+  
+  # sometimes a query is used as is and never gets geocoded (ie zipcode)
+  # often, it is useful have queries geocoded to know where in the
+  # world that query points to.  you can force the geocoding of
+  # queries (even when not required) so that you have the geocoded
+  # data.  the reason this isn't the default is that it will use an
+  # extra web service query when not normally required
+  @@force_geocode = false
+  def self.force_geocode; @@force_geocode; end;
+  def self.force_geocode=(value); @@force_geocode = value; end;
+  def self.force_geocode!; @@force_geocode = true; end;
+  
+  @@timeout = 15
+  def self.timeout; @@timeout; end;
+  def self.timeout=(value); @@timeout = value; end;
+  
+  def self.new(query=nil)
+    Barometer::Base.new(query)
+  end
+  
+  def self.selection=(selection=nil)
+    Barometer::Base.selection = selection
+  end
+  
+  # shortcut to Barometer::Service.source method
+  # allows Barometer.source(:wunderground)
+  def self.source(source)
+    Barometer::Service.source(source)
+  end
+
+  # custom errors
+  class OutOfSources < StandardError; end
+  
+end
+

data/spec/barometer_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe "Barometer" do
+  
+  before(:each) do
+    @preference_hash = { 1 => [:wunderground] }
+    @key = "ABQIAAAAq8TH4offRcGrok8JVY_MyxRi_j0U6kJrkFvY4-OX2XYmEAa76BSFwMlSow1YgX8BOPUeve_shMG7xw"
+  end
+  
+  describe "and class methods" do
+  
+    it "defines selection" do
+      Barometer::Base.respond_to?("selection").should be_true
+      Barometer::Base.selection.should == { 1 => [:wunderground] }
+      Barometer::Base.selection = { 1 => [:yahoo] }
+      Barometer::Base.selection.should == { 1 => [:yahoo] }
+      Barometer.selection = @preference_hash
+    end
+    
+    it "returns a Weather Service driver" do
+      Barometer.source(:wunderground).should == Barometer::Wunderground
+    end
+    
+    it "sets the Graticule Google geocoding API key" do
+      Barometer.respond_to?("google_geocode_key").should be_true
+      Barometer.google_geocode_key.should be_nil
+      Barometer.google_geocode_key = @key
+      Barometer.google_geocode_key.should == @key
+    end
+    
+    it "skips the use of Graticule" do
+      Barometer.respond_to?("skip_graticule").should be_true
+      Barometer.skip_graticule.should be_false
+      Barometer.skip_graticule = true
+      Barometer.skip_graticule.should be_true
+    end
+    
+    it "forces the geocoding of queries" do
+      Barometer.respond_to?("force_geocode").should be_true
+      Barometer.force_geocode.should be_false
+      Barometer.force_geocode = true
+      Barometer.force_geocode.should be_true
+    end
+    
+    it "forces the geocoding of queries" do
+      Barometer.respond_to?("force_geocode!").should be_true
+      Barometer.force_geocode = false
+      Barometer.force_geocode.should be_false
+      Barometer.force_geocode!
+      Barometer.force_geocode.should be_true
+    end
+    
+    it "set the global service timeout" do
+      Barometer.respond_to?("timeout").should be_true
+      Barometer.timeout.should == 15
+      Barometer.timeout = 5
+      Barometer.timeout.should == 5
+    end
+    
+  end
+
+  describe "when initialized" do
+    
+    before(:each) do
+      @barometer_direct = Barometer.new
+      @barometer = Barometer::Base.new
+    end
+    
+    it "responds to query" do
+      @barometer_direct.respond_to?("query").should be_true
+      @barometer.respond_to?("query").should be_true
+    end
+    
+    it "sets the query" do
+      query = "query"
+      barometer = Barometer.new(query)
+      barometer.query.is_a?(Barometer::Query)
+      barometer.query.q.should == query
+      
+      barometer = Barometer::Base.new(query)
+      barometer.query.is_a?(Barometer::Query)
+      barometer.query.q.should == query
+    end
+    
+    it "responds to weather" do
+      @barometer.weather.is_a?(Barometer::Weather).should be_true
+      @barometer_direct.weather.is_a?(Barometer::Weather).should be_true
+    end
+    
+    it "responds to success" do
+      @barometer.success.should be_false
+      @barometer_direct.success.should be_false
+      @barometer_direct.success?.should be_false
+      @barometer_direct.success = true
+      @barometer_direct.success?.should be_true
+    end
+    
+  end
+  
+  describe "when measuring" do
+    
+    before(:each) do
+      Barometer.google_geocode_key = @key
+      query_term = "Calgary,AB"
+      @barometer = Barometer::Base.new(query_term)
+      @time = Time.now
+      FakeWeb.register_uri(:get, 
+        "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=#{CGI.escape(query_term)}",
+        :string => File.read(File.join(File.dirname(__FILE__), 
+          'fixtures', 
+          'current_calgary_ab.xml')
+        )
+      )
+      FakeWeb.register_uri(:get, 
+        "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml?query=#{CGI.escape(query_term)}",
+        :string => File.read(File.join(File.dirname(__FILE__), 
+          'fixtures', 
+          'forecast_calgary_ab.xml')
+        )
+      )
+      FakeWeb.register_uri(:get, 
+        "http://maps.google.com:80/maps/geo?gl=&q=Calgary%2CAB&output=xml&key=#{@key}",
+        :string => File.read(File.join(File.dirname(__FILE__), 
+          'fixtures', 
+          'geocode_calgary_ab.xml')
+        )
+      )
+      
+      
+      FakeWeb.register_uri(:get, 
+        "http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=51.055149%2C-114.062438",
+        :string => File.read(File.join(File.dirname(__FILE__), 
+          'fixtures', 
+          'current_calgary_ab.xml')
+        )
+      )  
+      FakeWeb.register_uri(:get, 
+        "http://api.wunderground.com/auto/wui/geo/ForecastXML/index.xml?query=51.055149%2C-114.062438",
+        :string => File.read(File.join(File.dirname(__FILE__), 
+          'fixtures', 
+          'forecast_calgary_ab.xml')
+        )
+      )
+      
+    end
+    
+    it "responds to measure" do
+      @barometer.respond_to?("measure").should be_true
+    end
+    
+    it "returns a Barometer::Weather object" do
+      @barometer.measure.is_a?(Barometer::Weather).should be_true
+    end
+    
+    it "raises OutOfSources if no services successful" do
+      Barometer::Base.selection = { 1 => [] }
+      lambda { @barometer.measure }.should raise_error(Barometer::OutOfSources)
+    end
+    
+  end
+
+end

data/spec/data_current_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe "Current Measurement" do
+  
+  describe "when initialized" do
+    
+    before(:each) do
+      @current = Barometer::CurrentMeasurement.new
+    end
+    
+    it "responds to time" do
+      @current.time.should be_nil
+    end
+    
+    it "responds to humidity" do
+      @current.humidity.should be_nil
+    end
+    
+    it "responds to icon" do
+      @current.icon.should be_nil
+    end
+    
+    it "responds to condition" do
+      @current.condition.should be_nil
+    end
+    
+    it "responds to temperature" do
+      @current.temperature.should be_nil
+    end
+    
+    it "responds to dew_point" do
+      @current.dew_point.should be_nil
+    end
+    
+    it "responds to heat_index" do
+      @current.heat_index.should be_nil
+    end
+    
+    it "responds to wind_chill" do
+      @current.wind_chill.should be_nil
+    end
+    
+    it "responds to wind" do
+      @current.wind.should be_nil
+    end
+    
+    it "responds to pressure" do
+      @current.pressure.should be_nil
+    end
+    
+    it "responds to visibility" do
+      @current.pressure.should be_nil
+    end
+    
+    it "responds to sun" do
+      @current.sun.should be_nil
+    end
+    
+  end
+  
+  describe "when writing data" do
+    
+    before(:each) do
+      @current = Barometer::CurrentMeasurement.new
+    end
+    
+    # it "only accepts Time for time" do
+    #   invalid_data = 1
+    #   invalid_data.class.should_not == Time
+    #   lambda { @current.time = invalid_data }.should raise_error(ArgumentError)
+    #   
+    #   valid_data = Time.new
+    #   valid_data.class.should == Time
+    #   lambda { @current.time = valid_data }.should_not raise_error(ArgumentError)
+    # end
+    
+    it "only accepts Fixnum or Float for humidity" do
+      invalid_data = "invalid"
+      invalid_data.class.should_not == Fixnum
+      invalid_data.class.should_not == Float
+      lambda { @current.humidity = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = 1.to_i
+      valid_data.class.should == Fixnum
+      lambda { @current.humidity = valid_data }.should_not raise_error(ArgumentError)
+      
+      valid_data = 1.0.to_f
+      valid_data.class.should == Float
+      lambda { @current.humidity = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts String for icon" do
+      invalid_data = 1
+      invalid_data.class.should_not == String
+      lambda { @current.icon = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @current.icon = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts String for condition" do
+      invalid_data = 1
+      invalid_data.class.should_not == String
+      lambda { @current.condition = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = "valid"
+      valid_data.class.should == String
+      lambda { @current.condition = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Temperature for temperature" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Temperature
+      lambda { @current.temperature = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Temperature.new
+      valid_data.class.should == Barometer::Temperature
+      lambda { @current.temperature = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Temperature for dew_point" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Temperature
+      lambda { @current.dew_point = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Temperature.new
+      valid_data.class.should == Barometer::Temperature
+      lambda { @current.dew_point = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Temperature for heat_index" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Temperature
+      lambda { @current.heat_index = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Temperature.new
+      valid_data.class.should == Barometer::Temperature
+      lambda { @current.heat_index = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Temperature for wind_chill" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Temperature
+      lambda { @current.wind_chill = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Temperature.new
+      valid_data.class.should == Barometer::Temperature
+      lambda { @current.wind_chill = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Speed for wind" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Speed
+      lambda { @current.wind = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Speed.new
+      valid_data.class.should == Barometer::Speed
+      lambda { @current.wind = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Pressure for pressure" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Pressure
+      lambda { @current.pressure = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Pressure.new
+      valid_data.class.should == Barometer::Pressure
+      lambda { @current.pressure = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Distance for visibility" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Distance
+      lambda { @current.visibility = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Distance.new
+      valid_data.class.should == Barometer::Distance
+      lambda { @current.visibility = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+    it "only accepts Barometer::Sun for sun" do
+      invalid_data = 1
+      invalid_data.class.should_not == Barometer::Sun
+      lambda { @current.sun = invalid_data }.should raise_error(ArgumentError)
+      
+      valid_data = Barometer::Sun.new
+      valid_data.class.should == Barometer::Sun
+      lambda { @current.sun = valid_data }.should_not raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe "method missing" do
+    
+    before(:each) do
+      @current = Barometer::CurrentMeasurement.new
+    end
+    
+    it "responds to method + ?" do
+      valid_method = "humidity"
+      @current.respond_to?(valid_method).should be_true
+      lambda { @current.send(valid_method + "?") }.should_not raise_error(NoMethodError)
+    end
+    
+    it "ignores non_method + ?" do
+      invalid_method = "humid"
+      @current.respond_to?(invalid_method).should be_false
+      lambda { @current.send(invalid_method + "?") }.should raise_error(NoMethodError)
+    end
+    
+    it "returns true if set" do
+      @current.humidity = 10
+      @current.humidity.should_not be_nil
+      @current.humidity?.should be_true
+    end
+    
+    it "returns false if not set" do
+      @current.humidity.should be_nil
+      @current.humidity?.should be_false
+    end
+    
+  end
+  
+end