barometer 0.8.0 → 0.9.0

data/lib/barometer/utils/xml_reader.rb

@@ -0,0 +1,27 @@
+require 'nokogiri'
+require 'nori'
+require 'rexml/document'
+
+module Barometer
+  module Utils
+    module XmlReader
+      def self.parse(xml, *nodes_to_remove)
+        xml_reader = Nori.new(
+          parser: :nokogiri,
+          strip_namespaces: true
+        )
+        output = xml_reader.parse(xml)
+
+        nodes_to_remove.each do |node|
+          output = output.fetch(node, output)
+        end
+
+        if block_given? && output
+          output = yield(output)
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/barometer/utils/zone_code_lookup.rb

@@ -0,0 +1,30 @@
+module Barometer
+  module Utils
+    class ZoneCodeLookup
+      @@zone_codes_file = File.expand_path(
+        File.join(File.dirname(__FILE__), 'translations', 'zone_codes.yml'))
+      @@zone_codes = nil
+
+      def self._load_zone_codes
+        $:.unshift(File.dirname(__FILE__))
+        @@zone_codes ||= YAML.load_file(@@zone_codes_file)
+      end
+
+      def self.exists?(code)
+        _load_zone_codes unless @@zone_codes
+        (::Time.zone_offset(code.to_s) || @@zone_codes && @@zone_codes.has_key?(code))
+      end
+
+      # Known conflicts:
+      # IRT (ireland and india)
+      # CST (central standard time, china standard time)
+      #
+      def self.offset(code)
+        # http://www.timeanddate.com/library/abbreviations/timezones/
+        # http://www.worldtimezone.com/wtz-names/timezonenames.html
+        _load_zone_codes unless @@zone_codes
+        ::Time.zone_offset(code) || ((@@zone_codes[code.to_s.upcase] || 0) * 60 * 60)
+      end
+    end
+  end
+end

data/lib/barometer/version.rb

@@ -1,3 +1,3 @@
 module Barometer
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/lib/barometer/weather.rb

@@ -1,211 +1,82 @@
 module Barometer
-  #
-  # Weather
-  #
-  # holds all the measurements taken and provdes
-  # methods to interact with the data
-  #
   class Weather
-
-    attr_accessor :measurements
+    attr_accessor :responses
     attr_accessor :start_at, :end_at
 
-    def initialize; @measurements = []; end
-
-    # the default measurement is the first successful measurement
-    #
-    def default
-      return nil unless self.sources
-      self.source(self.sources.first)
+    def initialize(units=:metric)
+      @units = units
+      @responses = []
     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
+      responses.detect{|response| response.source == source}
     end
 
-    # list successful sources
-    #
-    def sources
-      @measurements.collect {|m| m.source.to_sym if m.success?}.compact
+    def success?
+      responses.any?(&:success?)
     end
 
-    #
-    # Quick access methods
-    #
+    def current
+      successful_responses.first.current if successful_responses.any?
+    end
 
-    def metric?; self.default ? self.default.metric? : true; end
-    def current; (default = self.default) ? default.current : nil; end
-    def forecast; (default = self.default) ? default.forecast : nil; end
-    def now; self.current; end
+    def forecast
+      successful_responses.first.forecast if successful_responses.any?
+    end
 
     def today
-      default = self.default
-      default && default.forecast ? default.forecast[0] : nil
+      successful_responses.first.forecast[0] if successful_responses.any?
     end
 
     def tomorrow
-      default = self.default
-      default && default.forecast ? default.forecast[1] : nil
+      successful_responses.first.forecast[1] if successful_responses.any?
     end
 
-    # measurement search
-    # this will search the default measurements forecasts looking for
-    # the matching date
-    #
     def for(query)
-      default = self.default
-      default && default.forecast ? default.for(query) : nil
+      successful_responses.first.for(query) if successful_responses.any?
     end
 
+    def temperature; average(:temperature, Data::Temperature); end
+    def dew_point; average(:dew_point, Data::Temperature); end
+    def heat_index; average(:heat_index, Data::Temperature); end
+    def wind_chill; average(:wind_chill, Data::Temperature); end
+    def pressure; average(:pressure, Data::Pressure); end
+    def visibility; average(:visibility, Data::Distance); end
+    def wind; average(:wind, Data::Vector); end
+    def humidity; average(:humidity); end
 
-    #
-    # helper methods
-    #
-    # these are handy methods that can average values for successful weather
-    # sources, or answer a simple question (ie: weather.windy?)
-    #
-
-    #
-    # averages
-    #
-
-    # this assumes calculating for current, and that "to_f" for a value
-    # will return the value needed
-    # value_name = the name of the value we are averaging
-    # if a measurement has weighting, it will respect that
-    #
-    def current_average(value_name)
-      values = []
-      @measurements.each do |measurement|
-        if measurement.weight && measurement.weight > 1
-          measurement.weight.times do
-            values << measurement.current.send(value_name).to_f if measurement.success? &&
-              measurement.current.send(value_name)
-          end
-        else
-          values << measurement.current.send(value_name).to_f if measurement.success? &&
-            measurement.current.send(value_name)
-        end
-      end
-      values.compact!
-      return nil unless values && values.size > 0
-      values.inject(0.0) { |sum,v| sum += v if v } / values.size
-    end
+    private
 
-    def average(value_name, do_average=true, class_name=nil)
-      if class_name
-        if do_average
-          avg = Data.const_get(class_name).new(self.metric?)
-          avg << self.current_average(value_name)
-        else
-          avg = self.now.send(value_name)
-        end
-      else
-        avg = (do_average ? self.current_average(value_name) : self.now.send(value_name))
-      end
-      avg
+    def successful_responses
+      @successful_responses ||= responses.select(&:success?)
     end
 
-    # average of all values
-    #
-    def humidity(do_average=true); average("humidity",do_average); end
-    def temperature(do_average=true); average("temperature",do_average,"Temperature"); end
-    def wind(do_average=true); average("wind",do_average,"Speed"); end
-    def pressure(do_average=true); average("pressure",do_average,"Pressure"); end
-    def dew_point(do_average=true); average("dew_point",do_average,"Temperature"); end
-    def heat_index(do_average=true); average("heat_index",do_average,"Temperature"); end
-    def wind_chill(do_average=true); average("wind_chill",do_average,"Temperature"); end
-    def visibility(do_average=true); average("visibility",do_average,"Distance"); 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?(time_string=nil, threshold=10)
-      local_datetime = Data::LocalDateTime.parse(time_string)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
-
-      is_windy = nil
-      @measurements.each do |measurement|
-        if measurement.success?
-          is_windy = measurement.windy?(local_datetime, threshold)
-          return is_windy if !is_windy.nil?
-        end
-      end
-      is_windy
+    def average(field, data_class=nil)
+      return if successful_responses.empty?
+      value = raw_average(field)
+      data_class ? data_class.new(@units, value) : value
     end
 
-    def wet?(time_string=nil, threshold=50)
-      local_datetime = Data::LocalDateTime.parse(time_string)
-      raise ArgumentError unless (threshold.is_a?(Fixnum) || threshold.is_a?(Float))
-      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
-
-      is_wet = nil
-      @measurements.each do |measurement|
-        if measurement.success?
-          is_wet = measurement.wet?(local_datetime, threshold)
-          return is_wet if !is_wet.nil?
-        end
-      end
-      is_wet
+    def raw_average(field)
+      weighted_value(field) / total_weight(field)
     end
 
-    def day?(time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string)
-      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
-
-      is_day = nil
-      @measurements.each do |measurement|
-        if measurement.success?
-          is_day = measurement.day?(local_datetime)
-          return is_day if !is_day.nil?
-        end
+    def total_weight(field)
+      successful_responses.inject(0) do |sum, response|
+        sum + (response.current.send(field) ? response.weight : 0)
       end
-      is_day
     end
 
-    def night?(time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string)
-      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
-      is_day = self.day?(local_datetime)
-      is_day.nil? ? nil : !is_day
-    end
-
-    def sunny?(time_string=nil)
-      local_datetime = Data::LocalDateTime.parse(time_string)
-      raise ArgumentError unless (local_datetime.nil? || local_datetime.is_a?(Data::LocalDateTime))
-
-      is_sunny = nil
-      @measurements.each do |measurement|
-        if measurement.success?
-          return false if self.day?(local_datetime) == false
-          is_sunny = measurement.sunny?(local_datetime)
-          return is_sunny if !is_sunny.nil?
-        end
+    def weighted_value(field)
+      successful_responses.inject(0) do |sum, response|
+        sum + (value_in_correct_units(response, field).to_f * response.weight)
       end
-      is_sunny
     end
 
+    def value_in_correct_units(response, field)
+      value = response.current.send(field)
+      value = value.send(@units) if value.respond_to?(@units)
+      value
+    end
   end
-
 end

data/lib/barometer/weather_service.rb

@@ -0,0 +1,41 @@
+require_relative 'weather_services/base'
+require_relative 'weather_services/response'
+
+module Barometer
+  module WeatherService
+    def self.services=(services)
+      @@services = services
+    end
+
+    def self.services
+      @@services ||= Utils::VersionedRegistration.new
+    end
+
+    def self.register(key, *args, &block)
+      if block_given?
+        services.register(key, *args, &block)
+      elsif args.size > 0
+        services.register(key, *args)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def self.source(key, version=nil)
+      services.find(key, version) or raise NotFound
+    end
+
+    def self.new(*args)
+      Base.new(*args)
+    end
+
+    class KeyRequired < StandardError; end
+    class NotFound < StandardError; end
+  end
+end
+
+require_relative 'weather_services/wunderground_v1'
+require_relative 'weather_services/yahoo'
+require_relative 'weather_services/weather_bug'
+require_relative 'weather_services/noaa'
+require_relative 'weather_services/forecast_io'

data/lib/barometer/weather_services/base.rb

@@ -0,0 +1,50 @@
+module Barometer
+  module WeatherService
+    class Base
+      def initialize(source, version=nil)
+        @source = source
+        @service = WeatherService.source(@source, version)
+      end
+
+      def measure(query, options={})
+        @response = Barometer::Response.new
+
+        record_time do
+          measure_and_record_status(query, options)
+        end
+
+        @response.weight = options.fetch(:weight, nil)
+        @response.source = @source
+        @response
+      end
+
+      private
+
+      def measure_and_record_status(query, options)
+        capture_status_code do
+          @response = @service.call(query, options)
+        end
+      end
+
+      def capture_status_code
+        yield
+        @response.status_code = @response.complete? ? 200 : 204
+      rescue KeyRequired
+        @response.status_code = 401
+      rescue Query::ConversionNotPossible
+        @response.status_code = 406
+      rescue Query::UnsupportedRegion
+        @response.status_code = 406
+      rescue Timeout::Error
+        @response.status_code = 408
+      end
+
+      def record_time
+        response_started_at = Time.now.utc
+        yield
+        @response.response_started_at = response_started_at
+        @response.response_ended_at = Time.now.utc
+      end
+    end
+  end
+end

data/lib/barometer/weather_services/forecast_io.rb

@@ -0,0 +1,36 @@
+require_relative 'forecast_io/api'
+require_relative 'forecast_io/response'
+
+module Barometer
+  module WeatherService
+    class ForecastIo
+      def self.call(query, config={})
+        ForecastIo.new(query, config).measure!
+      end
+
+      def initialize(query, config={})
+        @query = query
+        @apikey = config[:keys][:api] if config[:keys]
+      end
+
+      def measure!
+        validate_key!
+
+        api = ForecastIo::Api.new(query, apikey)
+        ForecastIo::Response.new.parse(api.get)
+      end
+
+      private
+
+      attr_reader :query, :apikey
+
+      def validate_key!
+        unless apikey && !apikey.empty?
+          raise KeyRequired
+        end
+      end
+    end
+  end
+end
+
+Barometer::WeatherService.register(:forecast_io, Barometer::WeatherService::ForecastIo)