barometer 0.1.0

data/lib/barometer/data/units.rb

@@ -0,0 +1,55 @@
+module Barometer
+  class Units
+    include Comparable
+    
+    attr_accessor :metric
+    
+    def initialize(metric=true)
+      @metric = metric
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    def metric?; @metric; end
+    def metric!; @metric=true; end
+    def imperial!; @metric=false; end
+
+    # assigns a value to the right attribute based on metric setting    
+    def <<(value)
+      return unless value
+    
+      begin
+        if value.is_a?(Array)
+          value_m = value[0].to_f
+          value_i = value[1].to_f
+          value_b = nil
+        else
+          value_m = nil
+          value_i = nil
+          value_b = value.to_f
+        end
+      rescue
+        # do nothing
+      end
+    
+      if self.metric?
+        self.metric_default = value_m || value_b
+      else
+        self.imperial_default = value_i || value_b
+      end
+    end
+    
+    # STUB: define this method to actually retireve the metric_default
+    def metric_default=(value)
+      raise NotImplementedError
+    end
+
+    # STUB: define this method to actually retireve the imperial_default
+    def imperial_default=(value)
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/barometer/data/zone.rb

@@ -0,0 +1,124 @@
+require 'rubygems'
+require 'tzinfo'
+
+module Barometer
+  #
+  # A simple Zone class
+  # 
+  # Used for building and converting timezone aware date and times
+  # Really, these are just wrappers for TZInfo conversions.
+  #
+  class Zone
+    
+    attr_accessor :timezone, :tz
+    
+    def initialize(timezone)
+      @timezone = timezone
+      @tz = TZInfo::Timezone.get(timezone)
+    end
+    
+    # what is the Timezone Short Code for the current timezone
+    def code
+      return "" unless @tz
+      @tz.period_for_utc(Time.now.utc).zone_identifier.to_s
+    end
+    
+    # is the current timezone in daylights savings mode?
+    def dst?
+      return nil unless @tz
+      @tz.period_for_utc(Time.now.utc).dst?
+    end
+    
+    # return Time.now.utc for the set timezone
+    def now
+      Barometer::Zone.now(@timezone)
+    end
+    
+    # return Date.today for the set timezone
+    def today
+      Barometer::Zone.today(@timezone)
+    end
+    
+    def local_to_utc(local_time)
+      @tz.local_to_utc(local_time)
+    end
+    
+    def utc_to_local(utc_time)
+      @tz.utc_to_local(utc_time)
+    end
+    
+    #
+    # Class Methods
+    #
+    
+    # return the local current time, providing a timezone
+    # (ie 'Europe/Paris') will give the local time for the
+    # timezone, otherwise it will be Time.now
+    def self.now(timezone=nil)
+      if timezone
+        utc = Time.now.utc
+        tz = TZInfo::Timezone.get(timezone)
+        tz.utc_to_local(utc)
+      else
+        Time.now
+      end
+    end
+    
+    # return the local current date, providing a timezone
+    # (ie 'Europe/Paris') will give the local date for the
+    # timezone, otherwise it will be Date.today
+    def self.today(timezone=nil)
+      if timezone
+        utc = Time.now.utc
+        tz = TZInfo::Timezone.get(timezone)
+        now = tz.utc_to_local(utc)
+        Date.new(now.year, now.month, now.day)
+      else
+        Date.today
+      end
+    end
+    
+    # takes a time (any timezone), and a TimeZone Short Code (ie PST) and
+    # converts the time to UTC accorsing to that time_zone
+    # NOTE: No Tests
+    def self.code_to_utc(time, timezone_code)
+      raise ArgumentError unless time.is_a?(Time)
+      offset = Time.zone_offset(timezone_code) || 0
+      
+      Time.utc(
+        time.year, time.month, time.day,
+        time.hour, time.min, time.sec, time.usec
+      ) - offset
+    end
+    
+    # takes a string with TIME only information and merges it with a string that
+    # has DATE only information and creates a UTC TIME object with time and date
+    # info.  if you supply the timezone code (ie PST), it will apply the timezone
+    # offset to the final time
+    def self.merge(time, date, timezone_code=nil)
+      raise ArgumentError unless (time.is_a?(Time) || time.is_a?(String))
+      raise ArgumentError unless (date.is_a?(Time) || date.is_a?(Date) || date.is_a?(String))
+      
+      if time.is_a?(String)
+        reference_time = Time.parse(time)
+      elsif time.is_a?(Time)
+        reference_time = time
+      end
+      
+      if date.is_a?(String)
+        reference_date = Date.parse(date)
+      elsif date.is_a?(Time)
+        reference_date = Date.new(date.year, date.month, date.day)
+      elsif date.is_a?(Date)
+        reference_date = date
+      end
+      
+      new_time = Time.utc(
+        reference_date.year, reference_date.month, reference_date.day,
+        reference_time.hour, reference_time.min, reference_time.sec
+      )
+      timezone_code ? Barometer::Zone.code_to_utc(new_time,timezone_code) : new_time
+    end
+    
+  end
+end

data/lib/barometer/extensions/graticule.rb

@@ -0,0 +1,50 @@
+module Graticule
+  class Location
+    
+    attr_accessor :country_code
+    
+    def attributes
+      [:latitude, :longitude, :street, :locality, :region, :postal_code, :country, :precision, :cuntry_code].inject({}) do |result,attr|
+        result[attr] = self.send(attr) unless self.send(attr).blank?
+        result
+      end
+    end
+    
+  end
+  
+  module Geocoder
+    
+    class Google < Rest
+      
+      # Locates +address+ returning a Location
+      # add ability to bias towards a country
+      def locate(address, country_bias=nil)
+        get :q => (address.is_a?(String) ? address : location_from_params(address).to_s),
+          :gl => country_bias
+      end
+      
+      private
+      
+      # Extracts a Location from +xml+.
+      def parse_response(xml) #:nodoc:
+        longitude, latitude, = xml.elements['/kml/Response/Placemark/Point/coordinates'].text.split(',').map { |v| v.to_f }
+        returning Location.new(:latitude => latitude, :longitude => longitude) do |l|
+          address = REXML::XPath.first(xml, '//xal:AddressDetails',
+            'xal' => "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0")
+ 
+          if address
+            l.street = value(address.elements['.//ThoroughfareName/text()'])
+            l.locality = value(address.elements['.//LocalityName/text()'])
+            l.region = value(address.elements['.//AdministrativeAreaName/text()'])
+            l.postal_code = value(address.elements['.//PostalCodeNumber/text()'])
+            l.country = value(address.elements['.//CountryName/text()'])
+            l.country_code = value(address.elements['.//CountryNameCode/text()'])
+            l.precision = PRECISION[address.attribute('Accuracy').value.to_i] || :unknown
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/barometer/extensions/httparty.rb

@@ -0,0 +1,21 @@
+#
+# extends HTTParty by adding configurable timeout support
+#
+module HTTParty
+  class Request
+    
+    private
+    
+      def http
+        http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+        http.use_ssl = (uri.port == 443)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        if options[:timeout] && options[:timeout].is_a?(Integer)
+          http.open_timeout = options[:timeout]
+          http.read_timeout = options[:timeout]
+        end
+        http
+      end
+    
+  end
+end

data/lib/barometer/query.rb

@@ -0,0 +1,228 @@
+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 in Googles geocoding service using
+  #   the Graticule gem).  Worst case scenario is that the Weather API will
+  #   not accept the query string.
+  #
+  class Query
+    
+    # OPTIONAL: key required by Google for geocoding
+    @@google_geocode_key = nil
+    def self.google_geocode_key; @@google_geocode_key || Barometer.google_geocode_key; end;
+    def self.google_geocode_key=(key); @@google_geocode_key = key; end;
+    
+    attr_reader   :format
+    attr_accessor :q, :preferred, :country_code, :geo
+    
+    def initialize(query=nil)
+      @q = query
+      self.analyze!
+    end
+    
+    # analyze the saved query to determine the format.  for the format of
+    # :zipcode and :postalcode the country_code can also be set
+    def analyze!
+      return unless @q
+      if Barometer::Query.is_us_zipcode?(@q)
+        @format = :zipcode
+      elsif Barometer::Query.is_canadian_postcode?(@q)
+        @format = :postalcode
+      elsif Barometer::Query.is_coordinates?(@q)
+        @format = :coordinates
+      else
+        @format = :geocode
+      end
+      @country_code = Barometer::Query.format_to_country_code(@format)
+    end
+    
+    # take a list of acceptable (and ordered by preference) formats and convert
+    # the current query (q) into the most preferred and acceptable format. as a
+    # side effect of some conversions, the country_code might be known, then save it
+    def convert!(preferred_formats=nil)
+      raise ArgumentError unless (preferred_formats && preferred_formats.size > 0)
+      # reset preferred
+      @preferred = nil
+      
+      # go through each acceptable format and try to convert to that
+      converted = false
+      geocoded = false
+      preferred_formats.each do |preferred_format|
+        # we are already in this format, return this
+        if preferred_format == @format
+          converted = true
+          @preferred ||= @q
+        end
+        
+        unless converted
+          case preferred_format
+          when :coordinates
+            geocoded = true
+            @preferred, @country_code, @geo = Barometer::Query.to_coordinates(@q, @format)
+          when :geocode
+            geocoded = true
+            @preferred, @country_code, @geo = Barometer::Query.to_geocode(@q, @format)
+          end
+        end
+      end
+      
+      # if we haven't already geocoded and we are forcing it, do it now
+      if !geocoded && Barometer.force_geocode
+        not_used_coords, not_used_code, @geo = Barometer::Query.to_coordinates(@q, @format)
+      end
+      
+      @preferred
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    def zipcode?; @format == :zipcode; end
+    def postalcode?; @format == :postalcode; end
+    def coordinates?; @format == :coordinates; end
+    def geocode?; @format == :geocode; end
+    
+    def self.is_us_zipcode?(query)
+      us_zipcode_regex = /(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)/
+      return !(query =~ us_zipcode_regex).nil?
+    end
+    
+    def self.is_canadian_postcode?(query)
+      # Rules: no D, F, I, O, Q, or U anywhere
+      # Basic validation: ^[ABCEGHJ-NPRSTVXY]{1}[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[ ]?[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[0-9]{1}$
+      # Extended validation: ^(A(0[ABCEGHJ-NPR]|1[ABCEGHK-NSV-Y]|2[ABHNV]|5[A]|8[A])|B(0[CEHJ-NPRSTVW]|1[ABCEGHJ-NPRSTV-Y]|2[ABCEGHJNRSTV-Z]|3[ABEGHJ-NPRSTVZ]|4[ABCEGHNPRV]|5[A]|6[L]|9[A])|C(0[AB]|1[ABCEN])|E(1[ABCEGHJNVWX]|2[AEGHJ-NPRSV]|3[ABCELNVYZ]|4[ABCEGHJ-NPRSTV-Z]|5[ABCEGHJ-NPRSTV]|6[ABCEGHJKL]|7[ABCEGHJ-NP]|8[ABCEGJ-NPRST]|9[ABCEGH])|G(0[ACEGHJ-NPRSTV-Z]|1[ABCEGHJ-NPRSTV-Y]|2[ABCEGJ-N]|3[ABCEGHJ-NZ]|4[ARSTVWXZ]|5[ABCHJLMNRTVXYZ]|6[ABCEGHJKLPRSTVWXZ]|7[ABGHJKNPSTXYZ]|8[ABCEGHJ-NPTVWYZ]|9[ABCHNPRTX])|H(0[HM]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NPRSTV-Z]|4[ABCEGHJ-NPRSTV-Z]|5[AB]|7[ABCEGHJ-NPRSTV-Y]|8[NPRSTYZ]|9[ABCEGHJKPRSWX])|J(0[ABCEGHJ-NPRSTV-Z]|1[ACEGHJ-NRSTXZ]|2[ABCEGHJ-NRSTWXY]|3[ABEGHLMNPRTVXYZ]|4[BGHJ-NPRSTV-Z]|5[ABCJ-MRTV-Z]|6[AEJKNRSTVWYXZ]|7[ABCEGHJ-NPRTV-Z]|8[ABCEGHLMNPRTVXYZ]|9[ABEHJLNTVXYZ])|K(0[ABCEGHJ-M]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-MPRSTVW]|4[ABCKMPR]|6[AHJKTV]|7[ACGHK-NPRSV]|8[ABHNPRV]|9[AHJKLV])|L(0[[ABCEGHJ-NPRS]]|1[ABCEGHJ-NPRSTV-Z]|2[AEGHJMNPRSTVW]|3[BCKMPRSTVXYZ]|4[ABCEGHJ-NPRSTV-Z]|5[ABCEGHJ-NPRSTVW]|6[ABCEGHJ-MPRSTV-Z]|7[ABCEGJ-NPRST]|8[EGHJ-NPRSTVW]|9[ABCGHK-NPRSTVWYZ])|M(1[BCEGHJ-NPRSTVWX]|2[HJ-NPR]|3[ABCHJ-N]|4[ABCEGHJ-NPRSTV-Y]|5[ABCEGHJ-NPRSTVWX]|6[ABCEGHJ-NPRS]|7[AY]|8[V-Z]|9[ABCLMNPRVW])|N(0[ABCEGHJ-NPR]|1[ACEGHKLMPRST]|2[ABCEGHJ-NPRTVZ]|3[ABCEHLPRSTVWY]|4[BGKLNSTVWXZ]|5[ACHLPRV-Z]|6[ABCEGHJ-NP]|7[AGLMSTVWX]|8[AHMNPRSTV-Y]|9[ABCEGHJKVY])|P(0[ABCEGHJ-NPRSTV-Y]|1[ABCHLP]|2[ABN]|3[ABCEGLNPY]|4[NPR]|5[AEN]|6[ABC]|7[ABCEGJKL]|8[NT]|9[AN])|R(0[ABCEGHJ-M]|1[ABN]|2[CEGHJ-NPRV-Y]|3[ABCEGHJ-NPRSTV-Y]|4[AHJKL]|5[AGH]|6[MW]|7[ABCN]|8[AN]|9[A])|S(0[ACEGHJ-NP]|2[V]|3[N]|4[AHLNPRSTV-Z]|6[HJKVWX]|7[HJ-NPRSTVW]|9[AHVX])|T(0[ABCEGHJ-MPV]|1[ABCGHJ-MPRSV-Y]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NPRZ]|4[ABCEGHJLNPRSTVX]|5[ABCEGHJ-NPRSTV-Z]|6[ABCEGHJ-NPRSTVWX]|7[AENPSVXYZ]|8[ABCEGHLNRSVWX]|9[ACEGHJKMNSVWX])|V(0[ABCEGHJ-NPRSTVWX]|1[ABCEGHJ-NPRSTV-Z]|2[ABCEGHJ-NPRSTV-Z]|3[ABCEGHJ-NRSTV-Y]|4[ABCEGK-NPRSTVWXZ]|5[ABCEGHJ-NPRSTV-Z]|6[ABCEGHJ-NPRSTV-Z]|7[ABCEGHJ-NPRSTV-Y]|8[ABCGJ-NPRSTV-Z]|9[ABCEGHJ-NPRSTV-Z])|X(0[ABCGX]|1[A])|Y(0[AB]|1[A]))[ ]?[0-9]{1}[ABCEGHJ-NPRSTV-Z]{1}[0-9]{1}$
+      ca_postcode_regex = /^[A-Z]{1}[\d]{1}[A-Z]{1}[ ]?[\d]{1}[A-Z]{1}[\d]{1}$/
+      return !(query =~ ca_postcode_regex).nil?
+    end
+
+    def self.is_coordinates?(query)
+      coordinates_regex = /^[-]?[0-9\.]+[,]{1}[-]?[0-9\.]+$/
+      return !(query =~ coordinates_regex).nil?
+    end
+    
+    #
+    # CONVERTERS
+    #
+    
+    # this will take all query formats and convert them to coordinates
+    # accepts- :zipcode, :postalcode, :geocode
+    # returns- :coordinates
+    # if the conversion fails, return nil
+    def self.to_coordinates(query, format)
+      country_code = self.format_to_country_code(format)
+      geo = self.geocode(query, country_code)
+      country_code ||= geo.country_code if geo
+      return nil unless geo && geo.longitude && geo.latitude
+      ["#{geo.latitude},#{geo.longitude}", country_code, geo]
+    end
+    
+    # this will take all query formats and convert them to coorinates
+    # accepts- :zipcode, :postalcode, :coordinates
+    # returns- :geocode
+    def self.to_geocode(query, format)
+      perform_geocode = false
+      perform_geocode = true if self.has_geocode_key?
+      
+      # some formats can't convert, no need to geocode then
+      skip_formats = [:postalcode]
+      perform_geocode = false if skip_formats.include?(format)
+      
+      country_code = self.format_to_country_code(format)
+      if perform_geocode
+        geo = self.geocode(query, country_code)
+        country_code ||= geo.country_code if geo
+        return nil unless geo && geo.locality && geo.region && geo.country
+        return ["#{geo.locality}, #{geo.region}, #{geo.country}", country_code, geo]
+      else
+        # without geocoding, the best we can do is just make use the given query as
+        # the query for the "geocode" format
+        return [query, country_code, nil]
+      end
+      return nil
+    end
+
+    #
+    # --- TODO ---
+    # The following methods need more coverage tests
+    #
+
+    def self.has_geocode_key?
+      # quick check to see that the Google API key exists for geocoding
+      self.google_geocode_key && !self.google_geocode_key.nil?
+    end
+    
+    # if Graticule exists, use it, otherwise use HTTParty
+    def self.geocode(query, country_code=nil)   
+      use_graticule = false
+      unless Barometer::skip_graticule
+        begin
+          require 'rubygems'
+          require 'graticule'
+          $:.unshift(File.dirname(__FILE__))
+          # load some changes to Graticule
+          # TODO: attempt to get changes into Graticule gem
+          require 'extensions/graticule'
+          use_graticule = true
+        rescue LoadError
+          # do nothing, we will use HTTParty
+        end
+      end
+  
+      if use_graticule
+        geo = self.geocode_graticule(query, country_code)
+      else
+        geo = self.geocode_httparty(query, country_code)
+      end
+      geo
+    end
+    
+    def self.geocode_graticule(query, country_code=nil)
+      return nil unless self.has_geocode_key?
+      geocoder = Graticule.service(:google).new(self.google_geocode_key)
+      location = geocoder.locate(query, country_code)
+      geo = Barometer::Geo.new(location)
+    end
+
+    def self.geocode_httparty(query, country_code=nil)
+      return nil unless self.has_geocode_key?
+      location = Barometer::Service.get(
+        "http://maps.google.com/maps/geo",
+        :query => {
+          :gl => country_code,
+          :key => self.google_geocode_key,
+          :output => "xml",
+          :q => query
+        },
+        :format => :xml
+      )['kml']['Response']
+      #puts location.inspect
+      geo = Barometer::Geo.new(location)
+    end
+    
+    def self.format_to_country_code(format)
+      return nil unless format
+      case format
+      when :zipcode
+        country_code = "US"
+      when :postalcode
+        country_code = "CA"
+      else
+        country_code = nil
+      end
+      country_code
+    end
+
+  end
+end