barometer 0.8.0 → 0.9.0

data/lib/barometer/data/zone.rb

@@ -1,141 +1,138 @@
-require 'rubygems'
 require 'tzinfo'
+require 'delegate'
 
 module Barometer
-  #
-  # A simple Zone class
-  #
-  # Used for building and converting timezone aware date and times
-  # Really, these are just wrappers for TZInfo conversions plus
-  # some extras.
-  #
-  class Data::Zone
-
-    @@zone_codes_file = File.expand_path(
-      File.join(File.dirname(__FILE__), '..', 'translations', 'zone_codes.yml'))
-    @@zone_codes = nil
-
-    attr_accessor :zone_full, :zone_code, :zone_offset, :tz
-
-    def initialize(zone)
-      if Data::Zone.is_zone_full?(zone)
-        @zone_full = zone
-        @tz = TZInfo::Timezone.get(zone)
-      elsif Data::Zone.is_zone_offset?(zone)
-        @zone_offset = zone
-      elsif Data::Zone.is_zone_code?(zone)
-        @zone_code = zone
-      else
-        raise(ArgumentError, "invalid time zone")
+  module Data
+    class Zone < SimpleDelegator
+      def initialize(zone)
+        zone = if ZoneFull.detect?(zone)
+          ZoneFull.new(zone)
+        elsif ZoneOffset.detect?(zone)
+          ZoneOffset.new(zone)
+        elsif ZoneCode.detect?(zone)
+          ZoneCode.new(zone)
+        else
+          raise(ArgumentError, "invalid time zone")
+        end
+        super(zone)
       end
     end
 
-    def current
-      @zone_full || @zone_offset || @zone_code
-    end
+    class ZoneFull
+      def self.detect?(zone)
+        zone.respond_to?(:match) && !!zone.match(/^[A-Za-z]+\/[A-Za-z_]+$/)
+      end
 
-    # what is the Timezone Short Code for the current timezone
-    def code
-      return @zone_code if @zone_code
-      return nil unless @tz
-      @tz.period_for_utc(Time.now.utc).zone_identifier.to_s
-    end
+      def initialize(zone, time_class=::Time)
+        @zone = zone
+        @time_class = time_class
+        @tz = TZInfo::Timezone.get(zone)
+      end
 
-    def full
-      @zone_full || nil
-    end
+      def code
+        tz.period_for_utc(time_class.now.utc).zone_identifier.to_s
+      end
 
-    def offset
-      if @zone_offset
-        @zone_offset.to_f * 60 * 60
-      elsif @zone_code
-        Data::Zone.zone_to_offset(@zone_code)
-      elsif @zone_full
+      def offset
+        tz.period_for_utc(time_class.now.utc).utc_total_offset
       end
-    end
 
-    # is the current timezone in daylights savings mode?
-    def dst?
-      return nil unless @tz
-      @tz.period_for_utc(Time.now.utc).dst?
-    end
+      def now
+        tz.utc_to_local(time_class.now.utc)
+      end
 
-    # return Time.now.utc for the set timezone
-    def now(convert=false)
-      if @zone_full
-        now = @tz.utc_to_local(Time.now.utc)
-      elsif @zone_offset || @zone_code
-        now = Time.now.utc + self.offset
+      def to_s
+        zone
       end
-      convert ? Data::LocalTime.parse(now) : now
-    end
 
-    # return Date.today for the set timezone
-    def today
-      now = self.now
-      Date.new(now.year, now.month, now.day)
-    end
+      def local_to_utc(local_time)
+        tz.local_to_utc(local_time)
+      end
 
-    def local_to_utc(local_time)
-      if @zone_full
-        @tz.local_to_utc(local_time)
-      elsif @zone_offset || @zone_code
-        local_time -= self.offset
-        Time.utc(local_time.year,local_time.month,local_time.day,
-          local_time.hour,local_time.min,local_time.sec)
+      def utc_to_local(utc_time)
+        tz.utc_to_local(utc_time)
       end
+
+      private
+
+      attr_reader :zone, :tz, :time_class
     end
 
-    def utc_to_local(utc_time)
-      if @zone_full
-        @tz.utc_to_local(utc_time)
-      elsif @zone_offset || @zone_code
-        utc_time + self.offset
+    class ZoneOffset
+      def self.detect?(zone)
+        zone.respond_to?(:abs) && zone.abs <= 14
       end
-    end
 
-    #
-    # Class Methods
-    #
+      def initialize(zone, time_class=::Time)
+        @zone = zone
+        @time_class = time_class
+      end
 
-    def self.is_zone_code?(zone)
-      return false unless (zone && zone.is_a?(String))
-      _load_zone_codes unless @@zone_codes
-      Time.zone_offset(zone) || (@@zone_codes && @@zone_codes.has_key?(zone))
-    end
+      def code
+      end
 
-    def self.is_zone_full?(zone)
-      return false unless (zone && zone.is_a?(String))
-      zone.match(/[A-Za-z]+\/[A-Za-z]+/) ? true : false
-    end
+      def offset
+        zone.to_f * 60 * 60
+      end
 
-    def self.is_zone_offset?(zone)
-      return false unless (zone && (zone.is_a?(Fixnum) || zone.is_a?(Float)))
-      zone.to_f.abs <= 14
-    end
+      def now
+        time_class.now.utc + offset
+      end
 
-    #
-    # Known conflicts
-    # IRT (ireland and india)
-    # CST (central standard time, china standard time)
-    #
-    def self.zone_to_offset(timezone)
-      offset = 0
-      seconds_in_hour = 60*60
-      # try to use Time
-      unless offset = Time.zone_offset(timezone)
-        # that would have been too easy, do it manually
-        # http://www.timeanddate.com/library/abbreviations/timezones/
-        # http://www.worldtimezone.com/wtz-names/timezonenames.html
-        offset = (@@zone_codes[timezone.to_s.upcase] || 0) * seconds_in_hour
-      end
-      offset
-    end
+      def to_s
+        zone.to_s
+      end
+
+      def local_to_utc(local_time)
+        local_time - offset
+      end
+
+      def utc_to_local(utc_time)
+        utc_time + offset
+      end
+
+      private
 
-    def self._load_zone_codes
-      $:.unshift(File.dirname(__FILE__))
-      @@zone_codes ||= YAML.load_file(@@zone_codes_file)
+      attr_reader :zone, :time_class
     end
 
+    class ZoneCode
+      def self.detect?(zone)
+        zone.respond_to?(:to_s) && Utils::ZoneCodeLookup.exists?(zone.to_s)
+      end
+
+      def initialize(zone, time_class=::Time)
+        @zone = zone
+        @time_class = time_class
+      end
+
+      def code
+        zone
+      end
+
+      def offset
+        Utils::ZoneCodeLookup.offset(zone)
+      end
+
+      def now
+        time_class.now.utc + offset
+      end
+
+      def to_s
+        zone
+      end
+
+      def local_to_utc(local_time)
+        local_time - offset
+      end
+
+      def utc_to_local(utc_time)
+        utc_time + offset
+      end
+
+      private
+
+      attr_reader :zone, :time_class
+    end
   end
 end

data/lib/barometer/query.rb

@@ -1,172 +1,34 @@
-module Barometer
-  #
-  # This class represents a query and can answer the
-  # questions that a Barometer will need to measure the weather
-  #
-  # Summary:
-  #   When you create a new Query, you set the query string
-  #   ie: "New York, NY" or "90210"
-  #   The class will then determine the query string format
-  #   ie: :zipcode, :postalcode, :geocode, :coordinates
-  #   Now, when a Weather API driver asks for the query, it will prefer
-  #   certain formats, and only permit certain formats.  The Query class
-  #   will attempt to either return the query string as-is if acceptable,
-  #   or it will attempt to convert it to a format that is acceptable
-  #   (most likely this conversion will use Googles geocoding service using
-  #   the Graticule gem).  Worst case scenario is that the Weather API will
-  #   not accept the query string.
-  #
-  class Query
-
-    # This array defines the order to check a query for the format
-    #
-    FORMATS = %w(
-      ShortZipcode Zipcode Postalcode WeatherID Coordinates Icao WoeID Geocode
-    )
-    FORMAT_MAP = {
-      :short_zipcode => "ShortZipcode", :zipcode => "Zipcode",
-      :postalcode => "Postalcode", :weather_id => "WeatherID",
-      :coordinates => "Coordinates", :icao => "Icao",
-      :woe_id => "WoeID", :geocode => "Geocode"
-    }
-
-    attr_writer :q
-    attr_accessor :format, :country_code
-    attr_accessor :geo, :timezone, :conversions
+require_relative 'query/base'
+require_relative 'query/format'
+require_relative 'query/converter'
+require_relative 'query/service'
 
-    def initialize(query=nil)
-      return unless query
-      @q = query
-      self.analyze!
-      @conversions = {}
+module Barometer
+  class ConvertedQuery
+    attr_reader :q, :format, :units, :geo
+
+    def initialize(q, format, units=:metric, geo=nil)
+      @q = q
+      @format = format
+      @units = units
+      @geo = geo
     end
 
-    def q
-      format ? Barometer::Query::Format.const_get(FORMAT_MAP[format.to_sym].to_s).convert_query(@q) : @q
+    def metric?
+      units == :metric
     end
 
-    # analyze the saved query to determine the format.
-    # this delegates the detection to each formats class
-    # until th right one is found
-    #
-    def analyze!
-      return unless @q
-      FORMATS.each do |format|
-        if Query::Format.const_get(format.to_s).is?(@q)
-          @format = Query::Format.const_get(format.to_s).format
-          @country_code = Query::Format.const_get(format.to_s).country_code(@q)
-          break
-        end
-      end
+    def to_s
+      @q
     end
-
-    # take a list of acceptable (and ordered by preference) formats and convert
-    # the current query (q) into the most preferred and acceptable format. a
-    # side effect of the conversions may reveal the country_code, if so save it
-    #
-    def convert!(preferred_formats=nil)
-      raise ArgumentError unless (preferred_formats && preferred_formats.size > 0)
-
-      # why convert if we are already there?
-      # (except in the case that the serivce excepts coordinates and we have a
-      # a geocode ... the google geocode results are superior)
-      #
-      skip_conversion = false
-      unless (@format.to_sym == Query::Format::Geocode.format) &&
-             preferred_formats.include?(Query::Format::Coordinates.format)
-        if preferred_formats.include?(@format.to_sym)
-          skip_conversion = true
-          converted_query = self.dup
-        end
-      end
-
-      unless skip_conversion
-        # go through each acceptable format and try to convert to that
-        converted = false
-        converted_query = Barometer::Query.new
-        preferred_formats.each do |preferred_format|
-          klass = FORMAT_MAP[preferred_format.to_sym]
-          # if we discover that the format we have is the preferred format, return it
-          if preferred_format == @format
-            converted = true
-            converted_query = Barometer::Query.new(@q)
-          end
-          unless converted
-            unless converted_query = get_conversion(preferred_format)
-              converted_query = Query::Format.const_get(klass.to_s).to(self)
-            end
-            converted = true if converted_query
-          end
-          if converted
-            converted_query.country_code ||= Query::Format.const_get(klass.to_s).country_code(converted_query.q)
-            post_conversion(converted_query)
-            break
-          end
-        end
-      end
-
-      # force geocode?, unless we already did
-      #
-      if Barometer.force_geocode && !@geo
-        if converted_query && converted_query.geo
-          @geo = converted_query.geo
-        elsif converted_query
-          puts "enhance geocode: #{converted_query.q}" if Barometer::debug?
-          geo_query = Query::Format::Coordinates.to(converted_query)
-          @geo = geo_query.geo if (geo_query && geo_query.geo)
-          converted_query.geo = @geo.dup
-        end
-      end
-
-      # enhance timezone?, unless we already did
-      #
-      if Barometer.enhance_timezone && !@timezone
-        if converted_query && converted_query.timezone
-          @geo = converted_query.timezone
-        elsif @geo && @geo.latitude && @geo.longitude
-          puts "enhance timezone: #{@geo.latitude}, #{@geo.longitude}" if Barometer::debug?
-          @timezone = WebService::Timezone.fetch(@geo.latitude,@geo.longitude)
-          converted_query.timezone = @timezone.dup
-        end
-      end
-
-      converted_query
-    end
-
-# save the important parts of the conversion ... by saving conversion we
-# can avoid doing the same conversion multiple times
-#
-def post_conversion(converted_query)
-  return unless (converted_query && converted_query.q && converted_query.format)
-  @conversions = {} unless @conversions
-  return if @conversions.has_key?(converted_query.format.to_sym)
-  puts "store: #{self.format} -> #{converted_query.format.to_sym} = #{self.q} -> #{converted_query.q}" if Barometer::debug?
-  @conversions[converted_query.format.to_sym] = converted_query.q
-end
-
-def get_conversion(format)
-  return nil unless format && @conversions
-  puts "found: #{self.format} -> #{format.to_sym} = #{self.q} -> #{@conversions[format.to_sym]}" if Barometer::debug? && @conversions.has_key?(format.to_sym)
-  # re-constuct converted query
-  if q = @conversions[format.to_sym]
-    converted_query = self.dup
-    converted_query.q = q
-    converted_query.format = format
-    converted_query
-  else
-    nil
   end
-end
 
-  def latitude
-    return nil unless self.format == Query::Format::Coordinates.format
-    Query::Format::Coordinates.parse_latitude(self.q)
-  end
-
-  def longitude
-    return nil unless self.format == Query::Format::Coordinates.format
-    Query::Format::Coordinates.parse_longitude(self.q)
-  end
+  module Query
+    class ConversionNotPossible < StandardError; end
+    class UnsupportedRegion < StandardError; end
 
+    def self.new(*args)
+      Barometer::Query::Base.new(*args)
+    end
   end
 end

data/lib/barometer/query/base.rb

@@ -0,0 +1,88 @@
+module Barometer
+  module Query
+    class Base
+      attr_reader :format, :geo, :units
+
+      def initialize(query, units=:metric)
+        @q = query.dup
+        @units = units
+        @geo = Data::Geo.new
+        detect_format
+        freeze_query
+        @conversions = {}
+      end
+
+      def q
+        @format_klass.convert_query(@q)
+      end
+
+      def add_conversion(format, q)
+        return unless q
+
+        @conversions[format] = q
+        converted_query(q, format)
+      end
+
+      def get_conversion(*formats)
+        converted_format = formats.detect{|f| format == f || @conversions.has_key?(f)}
+        return unless converted_format
+
+        if converted_format == format
+          self
+        else
+          converted_query(@conversions[converted_format], converted_format)
+        end
+      end
+
+      def convert!(*preferred_formats)
+        return self if preferred_formats.include?(format)
+
+        get_conversion(*preferred_formats) ||
+          do_conversion(format, preferred_formats) ||
+          raise(ConversionNotPossible)
+      end
+
+      def metric?
+        units == :metric
+      end
+
+      def to_s
+        q.to_s
+      end
+
+      def geo=(geo)
+        @geo = @geo.merge(geo)
+      end
+
+      private
+
+      def converted_query(q, format)
+        ConvertedQuery.new(q, format, units, geo)
+      end
+
+      def detect_format
+        Format.match?(@q) do |key, klass|
+          @format = key
+          @geo = Data::Geo.new(country_code: klass.country_code(@q))
+          @format_klass = klass
+        end
+      end
+
+      def freeze_query
+        @q.freeze
+        @format.freeze
+        @units.freeze
+      end
+
+      def do_conversion(format, preferred_formats)
+        converters = Converter.find_all(format, preferred_formats)
+        result = converters.map do |converter|
+          to_format = converter.keys.first
+          converter_klass = converter.values.first
+          get_conversion(to_format) || converter_klass.new(self).call
+        end.last
+        get_conversion(*preferred_formats) || result
+      end
+    end
+  end
+end