barometer 0.8.0 → 0.9.0

data/lib/barometer/formats/zipcode.rb

@@ -1,31 +0,0 @@
-module Barometer
-  #
-  # Format: Zip Code
-  #
-  # eg. 90210 or 90210-5555
-  #
-  # This class is used to determine if a query is a
-  # :zip_code, how to convert to a :zip_code
-  # and what the country_code is.
-  #
-  class Query::Format::Zipcode < Query::Format
-
-    def self.format; :zipcode; end
-    def self.country_code(query=nil); "US"; end
-    def self.regex; /(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)/; end
-    def self.convertable_formats; [:short_zipcode]; end
-
-    # convert to this format, X -> :zipcode
-    #
-    def self.to(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless converts?(original_query)
-      converted_query = Barometer::Query.new
-      converted_query.q = original_query.q
-      converted_query.format = format
-      converted_query.country_code = country_code(converted_query.q)
-      converted_query
-    end
-
-  end
-end

data/lib/barometer/key_file_parser.rb

@@ -1,20 +0,0 @@
-module Barometer
-  KEY_FILE = File.expand_path(File.join('~', '.barometer'))
-
-  class KeyFileParser
-    def self.find(*paths)
-      if File.exists?(KEY_FILE)
-        keys = YAML.load_file(KEY_FILE)
-
-        paths.each do |path|
-          if keys && keys.has_key?(path.to_s)
-            keys = keys.fetch(path.to_s)
-          else
-            keys = nil
-          end
-        end
-        keys
-      end
-    end
-  end
-end

data/lib/barometer/measurements/measurement.rb

@@ -1,202 +0,0 @@
-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 single 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
-
-    attr_reader :source, :weight
-    attr_reader :measured_at, :utc_time_stamp
-    attr_reader :current, :forecast
-    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
-      @metric = metric
-      @success = false
-      @weight = 1
-      @links = {}
-    end
-
-    def success!
-      current && current.temperature &&
-        !current.temperature.c.nil? && @success = true
-    end
-
-    def stamp!; @utc_time_stamp = Time.now.utc; end
-    def success?; @success; end
-    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
-    # 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?(local_time=nil)
-      current_at = ((self.current && self.current.current_at) ?
-        self.current.current_at : self.measured_at)
-
-      local_time = (local_time.nil? ? current_at : Data::LocalTime.parse(local_time))
-      return true unless local_time
-      raise ArgumentError unless local_time.is_a?(Data::LocalTime)
-
-      hours_still_current = 4
-      difference = (local_time.diff(current_at)).to_i.abs
-      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
-    #
-    def for(date=nil)
-      date = @timezone.today unless date || !@timezone
-      date ||= Date.today
-      return nil unless (@forecast && @forecast.size > 0)
-
-      @forecast.for(date)
-    end
-
-    #
-    # accesors (with input checking)
-    #
-
-    def source=(source)
-      raise ArgumentError unless source.is_a?(Symbol)
-      @source = source
-    end
-
-    def utc_time_stamp=(time=Time.now.utc)
-      raise ArgumentError unless time.is_a?(Time)
-      @utc_time_stamp = time
-    end
-
-    def current=(current)
-      raise ArgumentError unless current.is_a?(Measurement::Result)
-      @current = current
-      self.stamp!
-      self.success!
-    end
-
-    def forecast=(forecast)
-      raise ArgumentError unless forecast.is_a?(Measurement::ResultArray)
-      @forecast = forecast
-    end
-
-    def timezone=(timezone)
-      return unless timezone
-      raise ArgumentError unless timezone.is_a?(Data::Zone)
-      @timezone = timezone
-    end
-
-    def station=(station)
-      raise ArgumentError unless station.is_a?(Data::Location)
-      @station = station
-    end
-
-    def location=(location)
-      raise ArgumentError unless location.is_a?(Data::Location)
-      @location = location
-    end
-
-    def weight=(weight)
-      raise ArgumentError unless weight.is_a?(Fixnum)
-      @weight = weight
-    end
-
-    def links=(links)
-      raise ArgumentError unless links.is_a?(Hash)
-      @links = links
-    end
-
-    def measured_at=(measured_at)
-      raise ArgumentError unless measured_at.is_a?(Data::LocalTime)
-      @measured_at = measured_at
-    end
-
-    #
-    # simple questions
-    #
-
-    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)
-      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)
-      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
-end

data/lib/barometer/measurements/result.rb

@@ -1,207 +0,0 @@
-module Barometer
-  #
-  # Result Measurement
-  # a data class for resulting weather conditions
-  #
-  # This is basically a data holding class for the resulting weather
-  # conditions.
-  #
-  class Measurement::Result
-
-    attr_reader :current_at, :updated_at
-    attr_reader :valid_start_date, :valid_end_date, :date
-    attr_reader :humidity, :icon, :condition
-    attr_reader :temperature, :dew_point, :heat_index, :wind_chill
-    attr_reader :low, :high, :pop
-    attr_reader :wind, :sun, :pressure, :visibility
-    attr_accessor :metric, :description
-
-    def initialize(metric=true); @metric = metric; end
-
-    # 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
-
-    def date=(date)
-      raise ArgumentError unless date.is_a?(Date)
-      @date = date
-      @valid_start_date = Data::LocalDateTime.new(date.year,date.month,date.day,0,0,0)
-      @valid_end_date = Data::LocalDateTime.new(date.year,date.month,date.day,23,59,59)
-    end
-
-    def valid_start_date=(date)
-      raise ArgumentError unless date.is_a?(Data::LocalDateTime)
-      @valid_start_date = date
-    end
-
-    def valid_end_date=(date)
-      raise ArgumentError unless date.is_a?(Data::LocalDateTime)
-      @valid_end_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 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
-
-    #
-    # 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 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
-
-    def wet?(wet_icons=nil, pop_threshold=50, humidity_threshold=99)
-      result = nil
-      result ||= _wet_by_pop?(pop_threshold) if pop?
-      result ||= _wet_by_icon?(wet_icons) if icon?
-      result ||= _wet_by_humidity?(humidity_threshold) if humidity?
-      result ||= _wet_by_dewpoint? if (dew_point? && temperature?)
-      result
-    end
-
-    #
-    # helpers
-    #
-
-    def metric?; metric; end
-
-    def for_datetime?(datetime)
-      raise ArgumentError unless datetime.is_a?(Data::LocalDateTime)
-      datetime >= @valid_start_date && datetime <= @valid_end_date
-    end
-
-    # 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
-
-    private
-
-    def _wet_by_dewpoint?
-      return nil unless dew_point? && temperature?
-      temperature.to_f(metric?) <=  dew_point.to_f(metric?)
-    end
-
-    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
-
-    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