barometer 0.6.1 → 0.6.2

data/lib/barometer/measurements/current.rb

@@ -1,76 +0,0 @@
-module Barometer
-  #
-  # Current Measurement
-  # a data class for current weather conditions
-  #
-  # This is basically a data holding class for the current weather
-  # conditions.
-  #
-  class Measurement::Current < Measurement::Common
-    
-    attr_reader :current_at, :updated_at
-    attr_reader :temperature, :dew_point, :heat_index, :wind_chill
-    attr_reader :pressure, :visibility
-    
-    # accessors (with input checking)
-    #
-    def temperature=(temperature)
-      raise ArgumentError unless temperature.is_a?(Data::Temperature)
-      @temperature = temperature
-    end
-    
-    def dew_point=(dew_point)
-      raise ArgumentError unless dew_point.is_a?(Data::Temperature)
-      @dew_point = dew_point
-    end
-    
-    def heat_index=(heat_index)
-      raise ArgumentError unless heat_index.is_a?(Data::Temperature)
-      @heat_index = heat_index
-    end
-    
-    def wind_chill=(wind_chill)
-      raise ArgumentError unless wind_chill.is_a?(Data::Temperature)
-      @wind_chill = wind_chill
-    end
-    
-    def pressure=(pressure)
-      raise ArgumentError unless pressure.is_a?(Data::Pressure)
-      @pressure = pressure
-    end
-    
-    def visibility=(visibility)
-      raise ArgumentError unless visibility.is_a?(Data::Distance)
-      @visibility = visibility
-    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
-    end
-    
-    #
-    # answer simple questions
-    #
-    
-    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
-end

data/lib/barometer/measurements/forecast.rb

@@ -1,62 +0,0 @@
-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/night.rb

@@ -1,27 +0,0 @@
-require 'date'
-module Barometer
-  #
-  # Night Measurement
-  # a data class for forecasted night weather conditions
-  #
-  # This is basically a data holding class for the forecasted night 
-  # weather conditions.
-  #
-  class Measurement::ForecastNight < Measurement::Common
-    
-    attr_reader :date, :pop
-    
-    # accessors (with input checking)
-    #
-    def date=(date)
-      raise ArgumentError unless date.is_a?(Date)
-      @date = date
-    end
-    
-    def pop=(pop)
-      raise ArgumentError unless pop.is_a?(Fixnum)
-      @pop = pop
-    end
-    
-  end
-end

data/spec/measurements/common_spec.rb

@@ -1,352 +0,0 @@
-require 'spec_helper'
-
-describe "Common Measurement" do
-  
-  describe "when initialized" do
-    
-    before(:each) do
-      @common = Measurement::Common.new
-    end
-    
-    it "responds to humidity" do
-      @common.humidity.should be_nil
-    end
-    
-    it "responds to icon" do
-      @common.icon.should be_nil
-    end
-    
-    it "responds to condition" do
-      @common.condition.should be_nil
-    end
-    
-    it "responds to wind" do
-      @common.wind.should be_nil
-    end
-    
-    it "responds to sun" do
-      @common.sun.should be_nil
-    end
-    
-    it "responds to metric" do
-      @common.metric.should be_true
-    end
-    
-    it "responds to metric?" do
-      @common.metric?.should be_true
-      @common.metric = false
-      @common.metric?.should be_false
-    end
-    
-  end
-  
-  describe "when writing data" do
-    
-    before(:each) do
-      @common = Measurement::Common.new
-    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 { @common.humidity = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = 1.to_i
-      valid_data.class.should == Fixnum
-      lambda { @common.humidity = valid_data }.should_not raise_error(ArgumentError)
-      
-      valid_data = 1.0.to_f
-      valid_data.class.should == Float
-      lambda { @common.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 { @common.icon = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = "valid"
-      valid_data.class.should == String
-      lambda { @common.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 { @common.condition = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = "valid"
-      valid_data.class.should == String
-      lambda { @common.condition = valid_data }.should_not raise_error(ArgumentError)
-    end
-    
-    it "only accepts Data::Speed for wind" do
-      invalid_data = 1
-      invalid_data.class.should_not == Data::Speed
-      lambda { @common.wind = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = Data::Speed.new
-      valid_data.class.should == Data::Speed
-      lambda { @common.wind = valid_data }.should_not raise_error(ArgumentError)
-    end
-    
-    it "only accepts Data::Sun for sun" do
-      invalid_data = 1
-      invalid_data.class.should_not == Data::Sun
-      lambda { @common.sun = invalid_data }.should raise_error(ArgumentError)
-      
-      valid_data = Data::Sun.new
-      valid_data.class.should == Data::Sun
-      lambda { @common.sun = valid_data }.should_not raise_error(ArgumentError)
-    end
-    
-  end
-  
-  describe "method missing" do
-    
-    before(:each) do
-      @common = Measurement::Common.new
-    end
-    
-    it "responds to method + ?" do
-      valid_method = "humidity"
-      @common.respond_to?(valid_method).should be_true
-      lambda { @common.send(valid_method + "?") }.should_not raise_error(NoMethodError)
-    end
-    
-    it "ignores non_method + ?" do
-      invalid_method = "humid"
-      @common.respond_to?(invalid_method).should be_false
-      lambda { @common.send(invalid_method + "?") }.should raise_error(NoMethodError)
-    end
-    
-    it "returns true if set" do
-      @common.humidity = 10
-      @common.humidity.should_not be_nil
-      @common.humidity?.should be_true
-    end
-    
-    it "returns false if not set" do
-      @common.humidity.should be_nil
-      @common.humidity?.should be_false
-    end
-    
-  end
-  
-  describe "answer simple questions, like" do
-    
-    before(:each) do
-      @common = Measurement::Common.new
-    end
-    
-    describe "windy?" do
-      
-      before(:each) do
-        @wind = Data::Speed.new
-        @wind << 11
-      end
-
-      it "requires real threshold number (or nil)" do
-        lambda { @common.windy?("invalid") }.should raise_error(ArgumentError)
-        lambda { @common.windy? }.should_not raise_error(ArgumentError)
-        lambda { @common.windy?(10) }.should_not raise_error(ArgumentError)
-      end
-      
-      it "returns nil when no wind" do
-        @common.wind?.should be_false
-        @common.windy?.should be_nil
-        @common.wind = @wind
-        @common.wind?.should be_true
-        @common.windy?.should_not be_nil
-      end
-      
-      it "return true when current wind over threshold" do
-        @common.wind = @wind
-        @common.windy?.should be_true
-        @common.windy?(10).should be_true
-      end
-      
-      it "return false when current wind under threshold" do
-        @common.wind = @wind
-        @common.windy?(15).should be_false
-      end
-      
-    end
-    
-    describe "day?" do
-      
-      before(:each) do
-        @early_time = Data::LocalTime.parse("6:00 am")
-        @mid_time = Data::LocalTime.parse("11:00 am")
-        @late_time = Data::LocalTime.parse("8:00 pm")
-        @sun = Data::Sun.new(@early_time, @late_time)
-        
-      end
-
-      it "requires Data::LocalTime object" do
-        @common.sun = @sun
-        lambda { @common.day?("invalid") }.should raise_error(ArgumentError)
-        lambda { @common.day? }.should raise_error(ArgumentError)
-        lambda { @common.day?(@mid_time) }.should_not raise_error(ArgumentError)
-      end
-      
-      it "returns nil when no sun" do
-        @common.sun?.should be_false
-        @common.day?(@mid_time).should be_nil
-        @common.sun = @sun
-        @common.sun?.should be_true
-        @common.day?(@mid_time).should_not be_nil
-      end
-      
-      it "return true when time between rise and set" do
-        @common.sun = @sun
-        @common.day?(@mid_time).should be_true
-      end
-      
-      it "return false when time before rise or after set" do
-        sun = Data::Sun.new(@mid_time, @late_time)
-        @common.sun = sun
-        @common.day?(@early_time).should be_false
-        
-        sun = Data::Sun.new(@early_time, @mid_time)
-        @common.sun = sun
-        @common.day?(@late_time).should be_false
-      end
-      
-    end
-    
-    describe "wet?" do
-      
-      describe "wet_by_humidity?" do
-        
-        it "requires real threshold number (or nil)" do
-          lambda { @common.send("_wet_by_humidity?","invalid") }.should raise_error(ArgumentError)
-          lambda { @common.send("_wet_by_humidity?") }.should_not raise_error(ArgumentError)
-          lambda { @common.send("_wet_by_humidity?",99) }.should_not raise_error(ArgumentError)
-        end
-
-        it "returns nil when no humidity" do
-          @common.humidity?.should be_false
-          @common.send("_wet_by_humidity?").should be_nil
-          @common.wet?(nil,99).should be_nil
-          @common.humidity = 100
-          @common.humidity?.should be_true
-          @common.send("_wet_by_humidity?").should_not be_nil
-          @common.wet?(nil,99).should_not be_nil
-        end
-
-        it "return true when current humidity over threshold" do
-          @common.humidity = 100
-          @common.send("_wet_by_humidity?").should be_true
-          @common.send("_wet_by_humidity?",99).should be_true
-          @common.wet?(nil,99).should be_true
-        end
-
-        it "return false when current humidity under threshold" do
-          @common.humidity = 98
-          @common.send("_wet_by_humidity?",99).should be_false
-          @common.wet?(nil,99).should be_false
-        end
-
-      end
-      
-      describe "wet_by_icon?" do
-        
-        before(:each) do
-          @wet_icons = %w(rain thunderstorm)
-        end
-
-        it "requires Array (or nil)" do
-          lambda { @common.send("_wet_by_icon?","invalid") }.should raise_error(ArgumentError)
-          lambda { @common.send("_wet_by_icon?") }.should_not raise_error(ArgumentError)
-          lambda { @common.send("_wet_by_icon?",@wet_icons) }.should_not raise_error(ArgumentError)
-        end
-
-        it "returns nil when no icon or Array" do
-          @common.icon?.should be_false
-          @common.send("_wet_by_icon?",@wet_icons).should be_nil
-          @common.wet?(@wet_icons).should be_nil
-          @common.icon = "rain"
-          @common.icon?.should be_true
-          @common.send("_wet_by_icon?").should be_nil
-          @common.send("_wet_by_icon?",@wet_icons).should_not be_nil
-          @common.wet?(@wet_icons).should_not be_nil
-        end
-
-        it "return true when current icon indicates wet" do
-          @common.icon = "rain"
-          @common.send("_wet_by_icon?",@wet_icons).should be_true
-          @common.wet?(@wet_icons).should be_true
-        end
-
-        it "return false when current icon does NOT indicate wet" do
-          @common.icon = "sun"
-          @common.send("_wet_by_icon?",@wet_icons).should be_false
-          @common.wet?(@wet_icons).should be_false
-        end
-        
-      end
-      
-    end
-    
-    describe "sunny?" do
-      
-      describe "sunny_by_icon?" do
-        
-        before(:each) do
-          @sunny_icons = %w(sunny clear)
-          @early_time = Data::LocalTime.parse("6:00 am")
-          @mid_time = Data::LocalTime.parse("11:00 am")
-          @late_time = Data::LocalTime.parse("8:00 pm")
-          @sun = Data::Sun.new(@early_time, @late_time)
-          
-          @common.sun = @sun
-        end
-
-        it "requires Array (or nil)" do
-          lambda { @common.send("_sunny_by_icon?","invalid") }.should raise_error(ArgumentError)
-          lambda { @common.send("_sunny_by_icon?") }.should_not raise_error(ArgumentError)
-          lambda { @common.send("_sunny_by_icon?",@sunny_icons) }.should_not raise_error(ArgumentError)
-        end
-
-        it "returns nil when no icon or Array" do
-          @common.icon?.should be_false
-          @common.send("_sunny_by_icon?",@sunny_icons).should be_nil
-          @common.sunny?(@mid_time,@sunny_icons).should be_nil
-          @common.icon = "sunny"
-          @common.icon?.should be_true
-          @common.send("_sunny_by_icon?").should be_nil
-          @common.send("_sunny_by_icon?",@sunny_icons).should_not be_nil
-          @common.sun?(@mid_time,@sunny_icons).should_not be_nil
-        end
-
-        it "returns true when current icon indicates sunny" do
-          @common.icon = "sunny"
-          @common.send("_sunny_by_icon?",@sunny_icons).should be_true
-          @common.sunny?(@mid_time,@sunny_icons).should be_true
-        end
-
-        it "returns false when current icon does NOT indicate sunny" do
-          @common.icon = "rain"
-          @common.send("_sunny_by_icon?",@sunny_icons).should be_false
-          @common.sunny?(@mid_time,@sunny_icons).should be_false
-        end
-        
-        it "returns false when night" do
-          @common.icon = "sunny"
-          @common.send("_sunny_by_icon?",@sunny_icons).should be_true
-          @common.sunny?(@mid_time,@sunny_icons).should be_true
-          
-          @sun = Data::Sun.new(@mid_time, @late_time)
-          @common.sun = @sun
-          @common.sunny?(@early_time,@sunny_icons).should be_false
-        end
-        
-      end
-      
-    end
-    
-  end
-  
-end