barometer 0.8.0 → 0.9.0

data/lib/barometer/formats.rb

@@ -1,13 +0,0 @@
-$:.unshift(File.dirname(__FILE__))
-
-# query formats
-#
-require 'formats/format'
-require 'formats/short_zipcode'
-require 'formats/zipcode'
-require 'formats/postalcode'
-require 'formats/weather_id'
-require 'formats/coordinates'
-require 'formats/icao'
-require 'formats/geocode'
-require 'formats/woe_id'

data/lib/barometer/formats/coordinates.rb

@@ -1,57 +0,0 @@
-module Barometer
-  #
-  # Format: Coordinates
-  #
-  # eg. 123.1234,-123.123
-  #
-  # This class is used to determine if a query is a
-  # :coordinates and how to convert to :coordinates.
-  #
-  class Query::Format::Coordinates < Query::Format
-
-    def self.format; :coordinates; end
-    def self.regex; /^[-]?[0-9\.]+[,]{1}\s?[-]?[0-9\.]+$/; end
-    def self.convertable_formats
-      [:short_zipcode, :zipcode, :postalcode, :weather_id, :coordinates, :icao, :geocode, :woe_id]
-    end
-
-    # convert to this format, X -> :coordinates
-    #
-    def self.to(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless converts?(original_query)
-      converted_query = Barometer::Query.new
-
-      # pre-convert
-      #
-      pre_query = nil
-      if original_query.format == :weather_id
-        unless pre_query = original_query.get_conversion(Query::Format::Geocode.format)
-          pre_query = Query::Format::WeatherID.reverse(original_query)
-          original_query.post_conversion(pre_query)
-        end
-      elsif original_query.format == :woe_id
-        pre_query = Query::Format::WoeID.reverse(original_query)
-      end
-
-      # convert & adjust
-      #
-      converted_query = Query::Format::Geocode.geocode(pre_query || original_query)
-      converted_query.q = converted_query.geo.coordinates if converted_query.geo
-      converted_query.format = format
-
-      converted_query
-    end
-
-    def self.parse_latitude(query)
-      coordinates = query.to_s.split(',')
-      coordinates ? coordinates[0] : nil
-    end
-
-    def self.parse_longitude(query)
-      coordinates = query.to_s.split(',')
-      coordinates ? coordinates[1] : nil
-    end
-
-  end
-end

data/lib/barometer/formats/format.rb

@@ -1,64 +0,0 @@
-module Barometer
-  #
-  # Base Format Class
-  #
-  # Fromats are used to determine if a query is of a certain
-  # format, how to convert to and from that format
-  # and what the country_code is for that format (if possible).
-  # Some formats require external Web Services to help
-  # in the converision. (ie :weather_id -> :geocode)
-  #
-  class Query::Format
-
-    @@fixes_file = File.expand_path(
-      File.join(File.dirname(__FILE__), '..', 'translations', 'weather_country_codes.yml'))
-    @@fixes = nil
-
-    # stubs
-    #
-    def self.regex; raise NotImplementedError; end
-    def self.format; raise NotImplementedError; end
-
-    # defaults
-    #
-    def self.to(query=nil,country=nil); nil; end
-    def self.country_code(query=nil); nil; end
-    def self.convertable_formats; []; end
-    def self.convert_query(text); text; end
-
-    # is the query of this format?
-    #
-    def self.is?(query=nil)
-      raise ArgumentError unless query.is_a?(String)
-      return !(query =~ self.regex).nil?
-    end
-
-    # does the format support conversion from the given query?
-    #
-    def self.converts?(query=nil)
-      return false unless is_a_query?(query)
-      self.convertable_formats.include?(query.format)
-    end
-
-    # is the object a Barometer::Query?
-    #
-    def self.is_a_query?(object=nil)
-      return false unless object
-      object.is_a?(Barometer::Query)
-    end
-
-    private
-
-    # fix the country code
-    #
-    # weather.com uses non-standard two letter country codes that
-    # hinder the ability to determine the country or fetch geo_data.
-    # correct these "mistakes"
-    #
-    def self._fix_country(country_code)
-      @@fixes ||= YAML.load_file(@@fixes_file)
-      @@fixes[country_code.upcase.to_s] || country_code
-    end
-
-  end
-end

data/lib/barometer/formats/geocode.rb

@@ -1,60 +0,0 @@
-module Barometer
-  #
-  # Format: Geocode
-  # (not to be confused with the WebService geocode)
-  #
-  # eg. 123 Elm St, Mystery, Alaska, USA
-  #
-  # This class is used to determine if a query is a
-  # :geocode, how to convert to :geocode
-  #
-  class Query::Format::Geocode < Query::Format
-
-    def self.format; :geocode; end
-    def self.is?(query=nil); query.is_a?(String) ? true : false; end
-    def self.convertable_formats
-      [:short_zipcode, :zipcode, :coordinates, :weather_id, :icao, :woe_id]
-    end
-
-    # convert to this format, X -> :geocode
-    #
-    def self.to(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      unless converts?(original_query)
-        return (original_query.format == format ? original_query.dup : nil)
-      end
-
-      unless converted_query = original_query.get_conversion(format)
-        converted_query = Barometer::Query.new
-
-        converted_query = case original_query.format
-        when :weather_id
-          Query::Format::WeatherID.reverse(original_query)
-        when :woe_id
-          Query::Format::WoeID.reverse(original_query)
-        else
-          geocode(original_query)
-        end
-
-        original_query.post_conversion(converted_query) if converted_query
-      end
-      converted_query
-    end
-
-    # geocode the query
-    #
-    def self.geocode(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-
-      converted_query = Barometer::Query.new
-      converted_query.geo = Barometer::WebService::Geocode.fetch(original_query)
-      if converted_query.geo
-        converted_query.country_code = converted_query.geo.country_code
-        converted_query.q = converted_query.geo.to_s
-        converted_query.format = format
-      end
-      converted_query
-    end
-
-  end
-end

data/lib/barometer/formats/icao.rb

@@ -1,37 +0,0 @@
-module Barometer
-  #
-  # Format: ICAO (International Civil Aviation Organization)
-  #
-  # eg. KLAX (Los Angeles Airport)
-  #
-  # This class is used to determine if a query is a
-  # :icao and what the country_code is.
-  #
-  class Query::Format::Icao < Query::Format
-
-    @@codes_file = File.expand_path(
-      File.join(File.dirname(__FILE__), '..', 'translations', 'icao_country_codes.yml'))
-    @@codes = nil
-
-    def self.format; :icao; end
-
-    # call any 3-4 letter query, :icao ... obviously this will have a lot
-    # of false positives.  So far this isn't an issue as all weather services
-    # that take :icao (which is just one, :wunderground) also take what
-    # this would have been if it was not called :icao.
-    #
-    def self.regex; /^[A-Za-z]{3,4}$/; end
-
-    # in some cases the first letter can designate the country
-    #
-    def self.country_code(query=nil)
-      return unless query && query.is_a?(String)
-      $:.unshift(File.dirname(__FILE__))
-      @@codes ||= YAML.load_file(@@codes_file)
-      return unless @@codes && @@codes['one_letter'] && @@codes['two_letter']
-      @@codes['one_letter'][query[0..0].upcase.to_s] ||
-        @@codes['two_letter'][query[0..1].upcase.to_s] || nil
-    end
-
-  end
-end

data/lib/barometer/formats/postalcode.rb

@@ -1,22 +0,0 @@
-module Barometer
-  #
-  # Format: Postal Code
-  #
-  # eg. H0H 0H0
-  #
-  # This class is used to determine if a query is a
-  # :postalcode and what the country_code is.
-  #
-  class Query::Format::Postalcode < Query::Format
-
-    def self.format; :postalcode; end
-    def self.country_code(query=nil); "CA"; end
-    def self.regex
-      # 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}$
-      /^[A-Z]{1}[\d]{1}[A-Z]{1}[ ]?[\d]{1}[A-Z]{1}[\d]{1}$/
-    end
-
-  end
-end

data/lib/barometer/formats/short_zipcode.rb

@@ -1,17 +0,0 @@
-module Barometer
-  #
-  # Format: Zip Code (short)
-  #
-  # eg. 90210
-  #
-  # This class is used to determine if a query is a
-  # :short_zipcode and what the country_code is.
-  #
-  class Query::Format::ShortZipcode < Query::Format
-
-    def self.format; :short_zipcode; end
-    def self.country_code(query=nil); "US"; end
-    def self.regex; /(^[0-9]{5}$)/; end
-
-  end
-end

data/lib/barometer/formats/weather_id.rb

@@ -1,92 +0,0 @@
-module Barometer
-  #
-  # Format: Weather ID (specific to weather.com)
-  #
-  # eg. USGA0028
-  #
-  # This class is used to determine if a query is a
-  # :weather_id, how to convert to and from :weather_id
-  # and what the country_code is.
-  #
-  class Query::Format::WeatherID < Query::Format
-
-    def self.format; :weather_id; end
-    def self.regex; /(^[A-Za-z]{4}[0-9]{4}$)/; end
-    def self.convertable_formats
-      [:short_zipcode, :zipcode, :coordinates, :icao, :geocode]
-    end
-
-    # the first two letters of the :weather_id is the country_code
-    #
-    def self.country_code(query=nil)
-      (query && query.size >= 2) ? _fix_country(query[0..1]) : nil
-    end
-
-    # convert to this format, X -> :weather_id
-    #
-    def self.to(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless converts?(original_query)
-
-      # convert original query to :geocode, as that is the only
-      # format we can convert directly from to weather_id
-      converted_query = Barometer::Query.new
-      converted_query = Query::Format::Geocode.to(original_query)
-      converted_query.q = _search(converted_query)
-      converted_query.format = format
-      converted_query.country_code = country_code(converted_query.q)
-      converted_query
-    end
-
-    # reverse lookup, :weather_id -> (:geocode || :coordinates)
-    #
-    def self.reverse(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless original_query.format == format
-      converted_query = Barometer::Query.new
-      converted_query.q = _reverse(original_query)
-      converted_query.format = Query::Format::Geocode.format
-      converted_query
-    end
-
-    private
-
-    # :geocode -> :weather_id
-    # search weather.com for the given query
-    #
-    def self._search(query=nil)
-      return nil unless query
-      raise ArgumentError unless is_a_query?(query)
-      response = WebService::WeatherID.fetch(query)
-      _parse_weather_id(response)
-    end
-
-    # :weather_id -> :geocode
-    # query yahoo with :weather_id and parse geo_data
-    #
-    def self._reverse(query=nil)
-      return nil unless query
-      raise ArgumentError unless is_a_query?(query)
-      response = WebService::WeatherID.reverse(query)
-      _parse_geocode(response)
-    end
-
-    # match the first :weather_id (from search results)
-    #
-    def self._parse_weather_id(text)
-      return nil unless text
-      match = text.match(/loc id=[\\]?['|""]([0-9a-zA-Z]*)[\\]?['|""]/)
-      match ? match[1] : nil
-    end
-
-    # parse the geo_data
-    #
-    def self._parse_geocode(text)
-      return nil unless text
-      output = [text["city"], text["region"], _fix_country(text["country"])]
-      output.delete("")
-      output.compact.join(', ')
-    end
-
-  end
-end

data/lib/barometer/formats/woe_id.rb

@@ -1,150 +0,0 @@
-module Barometer
-  #
-  # Format: WOEID
-  #   "Where on Earth" ID (by Yahoo!)
-  #
-  # eg. 2459115, 615702 or w90210
-  #
-  # NOTE: zipcodes and WoeIDs can look exactly the same when the WoeID
-  #   is 5 digits long.  For now, a 5 digit number will be detected as
-  #   zipcode.  The way to override this is to prepend a number with the
-  #   letter 'w'.  Therefore 90210 will be a zipcode and w90210 will be
-  #   a WoeID.  In the future, if WoeIDs are moe popular then zipcodes,
-  #   then I will reverse this ...
-  #
-  # This class is used to determine if a query is a
-  # :woe_id and how to convert to a :woe_id.
-  #
-  class Query::Format::WoeID < Query::Format
-
-    def self.format; :woe_id; end
-    def self.regex; /(^[0-9]{4}$)|(^[0-9]{6,7}$)|(^w[0-9]{4,7}$)/; end
-    def self.convertable_formats
-      [:short_zipcode, :zipcode, :weather_id, :coordinates, :icao, :geocode, :postalcode]
-    end
-
-    # remove the 'w' from applicable queries (only needed for detection)
-    #
-    def self.convert_query(text)
-      return nil unless text
-      text.delete('w')
-    end
-
-    # convert to this format, X -> :woeid
-    #
-    def self.to(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless converts?(original_query)
-
-      # pre-convert (:weather_id -> :geocode)
-      #
-      pre_query = nil
-      if original_query.format == :weather_id
-        pre_query = Barometer::Query::Format::WeatherID.reverse(original_query)
-      end
-
-      # pre-convert ([:short_zipcode, :zipcode, :postalcode, :icao] -> :geocode)
-      #
-      unless pre_query
-        if [:short_zipcode, :zipcode, :icao].include?(original_query.format)
-          unless pre_query = original_query.get_conversion(Barometer::Query::Format::Geocode.format)
-            pre_query = Barometer::Query::Format::Geocode.to(original_query)
-          end
-        end
-      end
-
-      converted_query = Barometer::Query.new
-      converted_query.country_code = original_query.country_code if original_query
-
-      # TODO
-      # use Geomojo.com (when no Yahoo! appid)
-      #
-      # if [:coordinates].include?(pre_query ? pre_query.format : original_query.format) &&
-      #   Barometer.yahoo_placemaker_app_id.nil?
-      #   converted_query.q = _query_geomojo(pre_query || original_query)
-      #   converted_query.format = format
-      # end
-
-      # use Yahoo! Placemaker
-      #
-      if [:coordinates, :geocode, :postalcode].include?(pre_query ? pre_query.format : original_query.format) &&
-        !Barometer.yahoo_placemaker_app_id.nil?
-        converted_query.q = _query_placemaker(pre_query || original_query)
-        converted_query.format = format
-      end
-
-      converted_query.geo = pre_query.geo if pre_query
-      converted_query.country_code = pre_query.country_code if pre_query
-      converted_query
-    end
-
-    # reverse lookup, :woe_id -> (:geocode || :coordinates)
-    #
-    def self.reverse(original_query)
-      raise ArgumentError unless is_a_query?(original_query)
-      return nil unless original_query.format == self.format
-      converted_query = Barometer::Query.new
-      converted_query.q = _reverse(original_query)
-      converted_query.format = Barometer::Query::Format::Geocode.format
-      converted_query
-    end
-
-    private
-
-    # Yahoo! Placemaker
-    # [:geocode,:coordinates] -> :woe_id
-    #
-    def self._query_placemaker(query=nil)
-      return nil unless query
-      raise ArgumentError unless is_a_query?(query)
-      doc = Barometer::WebService::Placemaker.fetch(query)
-      _parse_woe_from_placemaker(doc)
-    end
-
-    # Geomojo.com
-    # [:coordinates] -> :woe_id
-    #
-    # def self._query_geomojo(query=nil)
-    #   return nil unless query
-    #   raise ArgumentError unless is_a_query?(query)
-    #   doc = WebService::Geomojo.fetch(query)
-    #   _parse_woe_from_geomojo(doc)
-    # end
-
-    # :woe_id -> :geocode
-    # query yahoo with :woe_id and parse geo_data
-    #
-    def self._reverse(query=nil)
-      return nil unless query
-      raise ArgumentError unless is_a_query?(query)
-      response = Barometer::WebService::Placemaker.reverse(query)
-      _parse_geocode(response)
-    end
-
-    # match the first :woe_id (from search results)
-    #   expects a Nokogiri doc
-    #
-    def self._parse_woe_from_placemaker(doc)
-      return nil unless doc
-      Barometer::WebService::Placemaker.parse_woe_id(doc)
-    end
-
-    # match the first :woe_id (from search results)
-    #   expects a Nokogiri doc
-    #
-    # def self._parse_woe_from_geomojo(doc)
-    #   return nil unless doc
-    #   WebService::Geomojo.parse_woe_id(doc)
-    # end
-
-    # parse the geo_data
-    #
-    def self._parse_geocode(text)
-      return nil unless text
-      output = [text["city"], text["region"], _fix_country(text["country"])]
-      output.delete("")
-      output.compact.join(', ')
-    end
-
-  end
-end