barometer 0.8.0 → 0.9.0

data/lib/barometer/utils.rb

@@ -0,0 +1,17 @@
+module Barometer
+  module Utils
+  end
+end
+
+require_relative 'utils/api'
+require_relative 'utils/config_reader'
+require_relative 'utils/time'
+require_relative 'utils/payload'
+require_relative 'utils/payload_request'
+require_relative 'utils/versioned_registration'
+require_relative 'utils/xml_reader'
+require_relative 'utils/json_reader'
+require_relative 'utils/address'
+require_relative 'utils/get'
+require_relative 'utils/post'
+require_relative 'utils/zone_code_lookup'

data/lib/barometer/utils/address.rb

@@ -0,0 +1,33 @@
+require 'addressable/uri'
+
+module Barometer
+  module Utils
+    class Address
+      def initialize(url, query={})
+        @address = Addressable::URI.parse(url)
+        add(query) unless query.blank?
+      end
+
+      def query
+        address.query_values
+      end
+
+      def url
+        address.omit(:query).to_s
+      end
+
+      def add(addition)
+        current_values = address.query_values || {}
+        address.query_values = current_values.merge(addition)
+      end
+
+      def to_s
+        address.to_s
+      end
+
+      private
+
+      attr_reader :address
+    end
+  end
+end

data/lib/barometer/utils/api.rb

@@ -0,0 +1,30 @@
+module Barometer
+  module Utils
+    class Api
+      attr_reader :query
+
+      def initialize(query)
+        @query = query
+      end
+
+      def current_query
+        @query.converted_query if @query.respond_to?(:converted_query)
+      end
+
+      def url
+      end
+
+      def params
+        @query.to_param
+      end
+
+      def unwrap_nodes
+        []
+      end
+
+      def get
+        Utils::PayloadRequest.new(self).get
+      end
+    end
+  end
+end

data/lib/barometer/utils/config_reader.rb

@@ -0,0 +1,40 @@
+module Barometer
+  module Utils
+    module ConfigReader
+      def self.take_level_while(&block)
+        Barometer.config.take_while do |level, level_config|
+          yield level
+        end
+      end
+
+      def self.services(level, &block)
+        _dig(Barometer.config[level], {}, &block)
+      end
+
+      # iterate through the setup until we have a source name (and possibly
+      # a config for that source), then yield with that source and config
+      #
+      # this allows for many different config formats, like
+      # { 1 => :wunderground }
+      # { 1 => [:wunderground]}
+      # { 1 => [:wunderground, :yahoo]}
+      # { 1 => [:wunderground, {yahoo: {weight: 2}}]}
+      # { 1 => {wunderground: {weight: 2}}}
+      # { 1 => [{wunderground: {weight: 2}}]}
+      #
+      def self._dig(data, config, &block)
+        if data.respond_to?(:to_sym)
+          yield(data.to_sym, config)
+        elsif data.is_a?(Array)
+          data.each do |datum|
+            _dig(datum, {}, &block)
+          end
+        elsif data.is_a?(Hash)
+          data.each do |datum, config|
+            _dig(datum, config, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/barometer/utils/get.rb

@@ -0,0 +1,17 @@
+require 'httpclient'
+
+module Barometer
+  module Utils
+    module Get
+      def self.call(url, query={})
+        address = Barometer::Utils::Address.new(url, query)
+
+        http = HTTPClient.new
+        http.receive_timeout = Barometer.timeout
+        http.get(address)
+      rescue HTTPClient::TimeoutError
+        raise Barometer::TimeoutError
+      end
+    end
+  end
+end

data/lib/barometer/utils/json_reader.rb

@@ -0,0 +1,22 @@
+require 'yajl'
+
+module Barometer
+  module Utils
+    module JsonReader
+      def self.parse(json, *nodes_to_remove)
+        json_reader = Yajl::Parser.new
+        output = json_reader.parse(json)
+
+        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/payload.rb

@@ -0,0 +1,100 @@
+module Barometer
+  module Utils
+    class Payload
+      attr_reader :hash, :regex, :query
+
+      def initialize(hash, query=nil)
+        @hash = hash
+        @query = query
+      end
+
+      def using(regex)
+        @regex = regex
+        self
+      end
+
+      def fetch(*paths)
+        if hash
+          result = fetch_value_or_attribute(paths)
+        else
+          result = nil
+        end
+
+        result = _apply_regex(result)
+        result = _cleanup(result)
+        result = _convert_alternate_nil_values(result)
+
+        result
+      end
+
+      def each(*paths, &block)
+        path = fetch(*paths)
+        if path
+          path.each do |result|
+            result_payload = Barometer::Utils::Payload.new(result)
+            block.call(result_payload)
+          end
+        end
+      end
+
+      def each_with_index(*paths, &block)
+        fetch(*paths).each_with_index do |result, index|
+          result_payload = Barometer::Utils::Payload.new(result)
+          block.call(result_payload, index)
+        end
+      end
+
+      def fetch_each(*paths, &block)
+        each(*paths, &block)
+      end
+
+      def fetch_each_with_index(*paths, &block)
+        each_with_index(*paths, &block)
+      end
+
+      def units
+        query.units if query
+      end
+
+      private
+
+      def fetch_value_or_attribute(paths)
+        result = paths.inject(hash) do |result, path|
+          fetch_value(result, path) || fetch_attribute(result, path) || break
+        end
+      end
+
+      def fetch_value(result, path)
+        if result.respond_to? :fetch
+          result.fetch(path, nil)
+        end
+      end
+
+      def fetch_attribute(result, path)
+        if path.to_s.start_with?('@') && result.respond_to?(:attributes)
+          result.attributes.fetch(path.slice(1..-1))
+        end
+      end
+
+      def _apply_regex(result)
+        if @regex && @regex.is_a?(Regexp) && matched = result.to_s.match(@regex)
+          result = matched[1] if matched[1]
+        end
+        @regex = nil
+        result
+      end
+
+      def _cleanup(result)
+        result.respond_to?(:strip) ? result.strip : result
+      end
+
+      def _convert_alternate_nil_values(result)
+        if result == "NA"
+          nil
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/barometer/utils/payload_request.rb

@@ -0,0 +1,37 @@
+module Barometer
+  module Utils
+    class PayloadRequest
+      def initialize(api)
+        @api = api
+      end
+
+      def get
+        response = make_request
+        output = parse_response(response)
+        Payload.new(output, api.current_query)
+      end
+
+      private
+
+      def make_request
+        Get.call(api.url, api.params)
+      end
+
+      def parse_response(response)
+        reader(response).parse(response.content, *api.unwrap_nodes)
+      end
+
+      private
+
+      attr_reader :api
+
+      def reader(response)
+        if response.headers.fetch('Content-Type', '').match(/json/)
+          JsonReader
+        else
+          XmlReader
+        end
+      end
+    end
+  end
+end

data/lib/barometer/utils/post.rb

@@ -0,0 +1,24 @@
+require 'httpclient'
+
+module Barometer
+  module Utils
+    module Post
+      def self.call(url, params={})
+        http = HTTPClient.new
+        http.receive_timeout = Barometer.timeout
+        http.post(url, default_params.merge(params)).content
+      rescue HTTPClient::TimeoutError
+        raise Barometer::TimeoutError
+      end
+
+      private
+
+      def self.default_params
+        {
+          documentType: 'text/html',
+          outputType: 'xml'
+        }
+      end
+    end
+  end
+end

data/lib/barometer/utils/time.rb

@@ -0,0 +1,78 @@
+module Barometer
+  module Utils
+    module Time
+      def self.parse(*args)
+        return unless args.compact.size > 0
+        first_arg = args.first
+
+        if first_arg.is_a? ::Time
+          first_arg
+        elsif first_arg.is_a?(::DateTime) || first_arg.is_a?(::Date)
+          ::Time.parse(first_arg.to_s)
+        elsif args.size == 1 || args.size == 2
+          strptime(*args)
+        else
+          ::Time.utc(*args)
+        end
+      end
+
+      def self.strftime(time)
+        time.strftime("%Y-%m-%d %H:%M:%S %z")
+      end
+
+      def self.strptime(str, format=nil)
+        dt = if format
+          ::DateTime.strptime(str, format)
+        else
+          ::DateTime.parse(str)
+        end
+        ::Time.utc(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec) - (dt.zone.to_f * 60 * 60)
+      end
+
+      def self.utc_from_base_plus_local_time(tz, base, hour, min)
+        return unless tz && base
+        local_base = tz.utc_to_local(base.utc)
+
+        local_time = ::Time.utc(local_base.year, local_base.month, local_base.day, hour, min, 0)
+        tz.local_to_utc(local_time)
+      end
+
+      def self.utc_merge_base_plus_time(base_time=nil, time=nil)
+        return unless base_time && time
+        base_time_utc = base_time.utc
+        time_utc = time.utc
+
+        ::Time.utc(
+          base_time_utc.year, base_time_utc.month, base_time_utc.day,
+          time_utc.hour, time_utc.min, 0
+        )
+      end
+
+      def self.add_one_day(time)
+        return unless time
+        one_day_minus_one_second = (60 * 60 * 24 - 1)
+        time + one_day_minus_one_second
+      end
+
+      def self.add_one_hour(time)
+        return unless time
+        one_hour = (60 * 60 * 1)
+        time + one_hour
+      end
+
+      def self.start_of_day(time)
+        ::Time.utc(
+          time.year, time.month, time.day,
+          0, 0, 0
+        )
+      end
+
+      def self.end_of_day(time)
+        ::Time.utc(
+          time.year, time.month, time.day,
+          23, 59, 59
+        )
+      end
+    end
+  end
+end

data/lib/barometer/utils/versioned_registration.rb

@@ -0,0 +1,70 @@
+module Barometer
+  module Utils
+    class VersionedRegistration
+      def initialize
+        @registrations = {}
+      end
+
+      def register(key, *args, &block)
+        if block_given?
+          version = args.shift
+          value = block
+        elsif args.size > 1
+          version = args.shift
+          value = args.shift
+        else
+          version = nil
+          value = args.shift
+        end
+
+        return if has_version?(key, version)
+        add_value(key, version, value)
+      end
+
+      def find(key, version=nil)
+        return unless has_key?(key)
+        registration = find_version(key, version) || find_default(key) || {}
+        registration.fetch(:value, nil)
+      end
+
+      def size
+        @registrations.inject(0){|count,key_value| key_value[1].size + count }
+      end
+
+      private
+
+      def has_key?(key)
+        @registrations.has_key? key
+      end
+
+      def has_version?(key, version)
+        registrations_for_key = @registrations[key] || []
+        registrations_for_key.detect{|r| r[:version] == (version || :default)}
+      end
+
+      def add_value(key, version, value)
+        registration = {
+          version: (version || :default),
+          value: value
+        }
+        add_registration(key, registration)
+      end
+
+      def add_registration(key, registration)
+        registrations_for_key = @registrations[key] || []
+        registrations_for_key << registration
+        @registrations[key] = registrations_for_key
+      end
+
+      def find_version(key, version)
+        registrations = @registrations[key]
+        registrations.detect{|r| r[:version] == version}
+      end
+
+      def find_default(key)
+        registrations = @registrations[key]
+        registrations.detect{|r| r[:version] == :default}
+      end
+    end
+  end
+end