barometer 0.8.0 → 0.9.0

data/lib/barometer/query/services/geonames_timezone.rb

@@ -0,0 +1,18 @@
+require_relative 'apis/geonames_timezone'
+
+module Barometer
+  module Query
+    module Service
+      class GeonamesTimezone
+        def self.fetch(latitude, longitude)
+          return unless latitude && longitude
+
+          api = GeonamesTimezone::Api.new(latitude, longitude)
+          payload = api.get
+
+          Data::Zone.new( payload.fetch('timezoneId') )
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/google_geocode.rb

@@ -0,0 +1,106 @@
+require_relative 'apis/google_geocode'
+
+module Barometer
+  module Query
+    module Service
+      class GoogleGeocode
+        def initialize(query)
+          @query = query
+        end
+
+        def call
+          converted_query = query.get_conversion(:short_zipcode, :zipcode, :postalcode, :coordinates, :icao, :unknown)
+          return unless converted_query
+
+          @payload = GoogleGeocode::Api.new(converted_query).get
+          parse_payload
+        end
+
+        private
+
+        attr_reader :query, :payload
+
+        def parse_payload
+          Data::Geo.new(
+            latitude: latitude,
+            longitude: longitude,
+            locality: locality,
+            region: region,
+            country: country,
+            country_code: country_code,
+            postal_code: postal_code,
+            query: full_query
+          )
+        end
+
+        def latitude
+          payload.fetch('geometry', 'location', 'lat')
+        end
+
+        def longitude
+          payload.fetch('geometry', 'location', 'lng')
+        end
+
+        def locality
+          find_name('sublocality', 'long_name') || find_name('locality', 'long_name')
+        end
+
+        def region
+          find_name('administrative_area_level_1', 'short_name')
+        end
+
+        def country
+          find_name('country', 'long_name')
+        end
+
+        def country_code
+          find_name('country', 'short_name')
+        end
+
+        def postal_code
+          find_name('postal_code', 'short_name')
+        end
+
+        def full_query
+          return if query_is_street_address? || query_is_route?
+          find_detected_types.map{|address_component| address_component.fetch('short_name')}.join(', ')
+        end
+
+        def address_components
+          @address_components ||= payload.fetch('address_components').
+            select{|address_component| address_component.has_key? 'types'}
+        end
+
+        def find_type(address_component_type)
+          address_components.find do |address_component|
+            address_component.fetch('types').include?(address_component_type)
+          end
+        end
+
+        def find_name(address_component_type, name)
+          if result = find_type(address_component_type)
+            result.fetch(name)
+          end
+        end
+
+        def detected_query_types
+          @detected_query_types ||= payload.fetch('types')
+        end
+
+        def find_detected_types
+          address_components.select do |address_component|
+            (address_component.fetch('types') & detected_query_types).any?
+          end
+        end
+
+        def query_is_street_address?
+          detected_query_types.include? 'street_address'
+        end
+
+        def query_is_route?
+          detected_query_types.include? 'route'
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/noaa_station_id.rb

@@ -0,0 +1,28 @@
+require_relative 'apis/noaa_station'
+require 'nokogiri'
+
+module Barometer
+  module Query
+    module Service
+      class NoaaStation
+        def self.fetch(query)
+          converted_query = query.get_conversion(:coordinates)
+          return unless converted_query
+
+          api = NoaaStation::Api.new(converted_query)
+          _parse_content(api.get)
+        end
+
+        def self._parse_content(content)
+          doc = Nokogiri::HTML.parse(content)
+          if doc && links = doc.search(".current-conditions-extra a")
+            sid_link = links.detect{|link| link.attr("href").match(/sid=(.*)&/)}
+            sid_link.attr("href").match(/sid=(.*?)&/)[1]
+          end
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/to_weather_id.rb

@@ -0,0 +1,25 @@
+require_relative 'apis/weather_id'
+
+module Barometer
+  module Query
+    module Service
+      module ToWeatherId
+        def self.call(query)
+          converted_query = query.get_conversion(:geocode, :unknown)
+          return unless converted_query
+
+          api = WeatherId::Api.new(converted_query)
+          _parse_content(api.get)
+        end
+
+        def self._parse_content(payload)
+          if payload.fetch('loc').is_a? Array
+            payload.fetch('loc', 0, '@id')
+          else
+            payload.fetch('loc', '@id')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/to_woe_id.rb

@@ -0,0 +1,29 @@
+require_relative 'apis/yahoo_placefinder'
+
+module Barometer
+  module Query
+    module Service
+      class ToWoeId
+        def initialize(query)
+          @query = query
+        end
+
+        def call
+          converted_query = query.get_conversion(:short_zipcode, :zipcode, :geocode, :unknown, :coordinates, :postalcode, :ipv4_address)
+          return unless converted_query
+
+          @payload = YahooPlacefinder::Api.new(converted_query).get
+          parse_payload
+        end
+
+        private
+
+        attr_reader :query, :payload
+
+        def parse_payload
+          payload.fetch('woeid')
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/wunderground_timezone.rb

@@ -0,0 +1,18 @@
+require_relative 'apis/wunderground_timezone'
+
+module Barometer
+  module Query
+    module Service
+      class WundergroundTimezone
+        def self.fetch(latitude, longitude)
+          return unless latitude && longitude
+
+          api = WundergroundTimezone::Api.new(latitude, longitude)
+          payload = api.get
+
+          Data::Zone.new( payload.fetch('date', 'tz_long') )
+        end
+      end
+    end
+  end
+end

data/lib/barometer/query/services/yahoo_geocode.rb

@@ -0,0 +1,69 @@
+require_relative 'apis/yahoo_placefinder'
+
+module Barometer
+  module Query
+    module Service
+      class YahooGeocode
+        def initialize(query)
+          @query = query
+        end
+
+        def call
+          converted_query = query.get_conversion(:woe_id, :ipv4_address)
+          return unless converted_query
+
+          @payload = YahooPlacefinder::Api.new(converted_query).get
+          parse_payload
+        end
+
+        private
+
+        attr_reader :query, :payload
+
+        def parse_payload
+          Data::Geo.new(
+            latitude: latitude,
+            longitude: longitude,
+            locality: locality,
+            region: region,
+            country: country,
+            country_code: country_code,
+            postal_code: postal_code,
+            query: full_query
+          )
+        end
+
+        def latitude
+          payload.fetch('latitude')
+        end
+
+        def longitude
+          payload.fetch('longitude')
+        end
+
+        def locality
+          payload.fetch('city')
+        end
+
+        def region
+          payload.fetch('statecode') || payload.fetch('state')
+        end
+
+        def country
+          payload.fetch('country')
+        end
+
+        def country_code
+          payload.fetch('countrycode')
+        end
+
+        def postal_code
+          payload.fetch('uzip')
+        end
+
+        def full_query
+        end
+      end
+    end
+  end
+end

data/lib/barometer/response.rb

@@ -0,0 +1,12 @@
+module Barometer
+  module Response
+    def self.new
+      Barometer::Response::Base.new
+    end
+  end
+end
+
+require_relative 'response/base'
+require_relative 'response/current'
+require_relative 'response/prediction'
+require_relative 'response/prediction_collection'

data/lib/barometer/response/base.rb

@@ -0,0 +1,57 @@
+require 'virtus'
+
+module Barometer
+  module Response
+    class Base
+      include Virtus.model
+
+      attribute :weight, Data::Attribute::Integer, default: 1
+      attribute :status_code, Integer
+      attribute :query, String
+      attribute :location, Data::Attribute::Location
+      attribute :station, Data::Attribute::Location
+      attribute :timezone, Data::Attribute::Zone
+      attribute :response_started_at, Data::Attribute::Time
+      attribute :response_ended_at, Data::Attribute::Time
+      attribute :requested_at, Data::Attribute::Time
+      attribute :source, Symbol
+      attribute :format, Symbol
+
+      attr_accessor :current, :forecast
+
+      def initialize
+        super
+        @requested_at = Time.now.utc
+      end
+
+      def success?
+        status_code == 200
+      end
+
+      def complete?
+        current && current.complete?
+      end
+
+      def for(date=nil)
+        forecast.for(date || today)
+      end
+
+      def add_query(query)
+        return unless query
+        @query = query.to_s
+        @format = query.format
+        @metric = query.metric?
+      end
+
+      def metric?
+        !!@metric
+      end
+
+      private
+
+      def today
+        timezone ? timezone.today : Date.today
+      end
+    end
+  end
+end

data/lib/barometer/response/current.rb

@@ -0,0 +1,27 @@
+require 'virtus'
+
+module Barometer
+  module Response
+    class Current
+      include Virtus.model
+
+      attribute :temperature, Data::Attribute::Temperature
+      attribute :dew_point, Data::Attribute::Temperature
+      attribute :heat_index, Data::Attribute::Temperature
+      attribute :wind_chill, Data::Attribute::Temperature
+      attribute :wind, Data::Attribute::Vector
+      attribute :pressure, Data::Attribute::Pressure
+      attribute :visibility, Data::Attribute::Distance
+      attribute :humidity, Data::Attribute::Float
+      attribute :sun, Data::Attribute::Sun
+      attribute :observed_at, Data::Attribute::Time
+      attribute :stale_at, Data::Attribute::Time
+      attribute :icon, String
+      attribute :condition, String
+
+      def complete?
+        !temperature.nil?
+      end
+    end
+  end
+end

data/lib/barometer/response/prediction.rb

@@ -0,0 +1,41 @@
+require 'virtus'
+
+module Barometer
+  module Response
+    class Prediction
+      include Virtus.model
+
+      attribute :high, Data::Attribute::Temperature
+      attribute :low, Data::Attribute::Temperature
+      attribute :pop, Data::Attribute::Float
+      attribute :sun, Data::Attribute::Sun
+      attribute :starts_at, Data::Attribute::Time
+      attribute :ends_at, Data::Attribute::Time
+      attribute :icon, String
+      attribute :condition, String
+
+      attr_reader :date
+
+      def date=(args)
+        args = Array(args)
+        date = args.shift
+        timezone = args.shift
+
+        date_as_time = Utils::Time.parse(date)
+        @starts_at = Utils::Time.start_of_day(date_as_time)
+        @ends_at = Utils::Time.end_of_day(date_as_time)
+        @date = ::Date.new(@starts_at.year, @starts_at.month, @starts_at.day)
+
+        if timezone
+          @starts_at = timezone.local_to_utc(@starts_at)
+          @ends_at = timezone.local_to_utc(@ends_at)
+        end
+      end
+
+      def covers?(time)
+        raise ArgumentError unless time.is_a?(Time)
+        time >= @starts_at && time <= @ends_at
+      end
+    end
+  end
+end

data/lib/barometer/response/prediction_collection.rb

@@ -0,0 +1,48 @@
+require 'date'
+
+module Barometer
+  module Response
+    class PredictionCollection
+      include Enumerable
+
+      def initialize(*predictions)
+        @predictions = predictions
+      end
+
+      def each(&block)
+        @predictions.each(&block)
+      end
+
+      def <<(prediction)
+        @predictions << prediction
+      end
+
+      def [](index)
+        index.respond_to?(:to_i) ? @predictions[index] : self.for(index)
+      end
+
+      def size
+        @predictions.size
+      end
+
+      def for(time)
+        return nil unless size > 0
+
+        time = case time
+        when Date
+          Time.utc(time.year,time.month,time.day,12,0,0)
+        else
+          Utils::Time.parse(time)
+        end
+
+        detect{ |forecast| forecast.covers?(time) }
+      end
+
+      def build
+        prediction = Prediction.new
+        yield(prediction)
+        @predictions << prediction
+      end
+    end
+  end
+end