weatherbug 0.0.1

data/lib/weatherbug.rb

@@ -0,0 +1,117 @@
+
+require 'rubygems'
+require 'nokogiri'
+require 'open-uri'
+
+module WeatherBug
+
+  require 'weatherbug/hash_methods'
+  require 'weatherbug/transformable_data'
+  autoload :Station, 'weatherbug/station'
+  autoload :StationHint, 'weatherbug/station_hint'
+  autoload :LiveObservation, 'weatherbug/live_observation'
+  autoload :Forecast, 'weatherbug/forecast'
+
+  API_URL = 'datafeed.weatherbug.com'
+
+
+  # Set your application's partner ID 
+  def self.partner_id=(partner_id)
+    @partner_id = partner_id
+  end
+
+  # Get the 25 closest stations, or less in less dense areas
+  def self.nearby_stations(lookup_options)
+    HashMethods.valid_keys(lookup_options, [:zip_code, :city_code, :postal_code, :include_pws])
+    HashMethods.valid_one_only(lookup_options, [:zip_code, :city_code])
+    HashMethods.valid_one_only(lookup_options, [:postal_code, :city_code])
+    HashMethods.valid_needs(lookup_options, :zip_code, :postal_code) if lookup_options.has_key?(:postal_code)
+    response = make_request('StationList', HashMethods.convert_symbols(lookup_options))
+
+    response.xpath('/aws:weather/aws:station').map { |station| WeatherBug::Station.from_document(station) }
+  end
+
+  def self.closest_station(lookup_options)
+    HashMethods.valid_keys(lookup_options, [:zip_code, :city_code, :postal_code, :include_pws])
+    HashMethods.valid_one_only(lookup_options, [:zip_code, :city_code])
+    HashMethods.valid_one_only(lookup_options, [:postal_code, :city_code])
+    HashMethods.valid_needs(lookup_options, :zip_code, :postal_code) if lookup_options.has_key?(:postal_code)
+    params = HashMethods.convert_symbols(lookup_options)
+    params['ListType'] = '1'
+    response = make_request('StationList', params)
+
+    WeatherBug::Station.from_document response.xpath('/aws:weather/aws:station').first 
+  end
+
+  def self.get_station(station_id)
+    params = {'StationId' => station_id}
+    response = make_request('StationInfo', params)
+
+    WeatherBug::Station.from_document response.xpath('/aws:weather/aws:station').first
+  end
+
+  def self.live_observation(station, unit_type = :f)
+    station_id = station.is_a?(WeatherBug::Station) ? station.station_id : station
+    params = {'StationId' => station_id}
+    params['UnitType'] = '1' if unit_type == :c
+    response = make_request('LiveObservations', params)
+
+    live_observation = WeatherBug::LiveObservation.from_document response.xpath('/aws:weather/aws:ob').first
+    live_observation.send(:station_reference=, station) if station.is_a?(WeatherBug::Station)
+    live_observation
+  end
+
+  # Get the list of stations in a bounding box
+  # Does not return full stations
+  def self.stations_in_box(top_right_lat, top_right_lng, bot_left_lat, bot_left_lng)
+    params = {
+      'LatitudeTopRight' => top_right_lat,
+      'LongitudeTopRight' => top_right_lng,
+      'LatitudeBottomLeft' => bot_left_lat,
+      'LongitudeBottomLeft' => bot_left_lng
+    }
+    response = make_request('StationListByLatLng', params)
+    
+    station_data = response.xpath('/aws:weather/aws:stations/aws:station')
+    return nil unless station_data 
+
+    station_data.map do |sdata|
+      WeatherBug::StationHint.from_document(sdata)
+    end
+  end
+
+  def self.forecast(options)
+    self.retrieve_forecast(1, options)
+  end
+
+  private
+
+  # TODO add validation for fields
+  def self.retrieve_forecast(forecast_type, options)
+    HashMethods.valid_keys(options, [:latitude, :longitude])
+    params = HashMethods.convert_symbols(options)
+    params['ForecastType'] = forecast_type
+    response = make_request(options.has_key?(:longitude) ? 'ClosestForecastByLatLng' : 'Forecast', params)
+
+    forecast_data = response.xpath('/aws:weather/aws:forecasts/aws:forecast')
+    return nil unless forecast_data
+
+    forecast_data.map do |fdata|
+      WeatherBug::Forecast.from_document(fdata)
+    end
+  end
+
+  # Make the actual request, unwrap it and send it back
+  # Handles errors that may come up
+  def self.make_request(method, params)
+    params['RequestType'] = method
+    params['PartnerId'] = @partner_id
+    data = open("http://#{API_URL}/GetXml.aspx?#{params.map { |k, v| "#{k}=#{v}" }.join('&')}")
+    raise Exception.new("Unexpected exception - empty response") unless data
+    Nokogiri::XML(data)
+  end
+
+end
+
+WeatherBug.partner_id = 'f0c313fe-fffe-4f5d-96dc-5a5d6ec9eb30'
+stations = WeatherBug::nearby_stations(:zip_code => '08005')

data/lib/weatherbug/forecast.rb

@@ -0,0 +1,18 @@
+module WeatherBug
+
+  class Forecast < TransformableData
+
+    register_transformer 'aws:title', :required => true   
+    register_transformer 'aws:city'
+    register_transformer 'aws:short-title'
+    register_transformer 'aws:icon'
+    register_transformer 'aws:description'
+    register_transformer 'aws:prediction'
+    register_transformer 'aws:lo', :name => :temp_low, :transform => :to_i
+    register_transformer 'aws:hi', :name => :temp_high, :transform => :to_i
+    register_transformer 'aws:hi/@units', :name => :temp_units
+    register_transformer 'aws:prob-of-precip', :name => :probability_of_precipitation
+
+  end
+
+end

data/lib/weatherbug/hash_methods.rb

@@ -0,0 +1,40 @@
+module WeatherBug
+
+  class HashMethods
+
+    WB_MAPPING = {
+      :zip_code => 'ZipCode',
+      :city_code => 'CityCode',
+      :postal_code => 'PostalCode',
+      :include_pws => 'IncludePWS',
+      :latitude => 'Latitude',
+      :longitude => 'Longitude'
+    }
+
+    # Raise an argument error if we get invalid keys at all
+    def self.valid_keys(hash, allowed)
+      invalids = nil
+      hash.keys.each { |key| (invalids ||= []; invalids << key) unless allowed.include?(key) }
+      raise ArgumentError.new("Invalid options: #{invalids.join(', ')}") unless invalids.nil?
+    end
+
+    def self.valid_one_only(hash, conflictions)
+      conflicts = []
+      conflictions.each { |c| conflicts << c if hash.keys.include?(c) }
+      raise ArgumentError.new("Cannot combine options: #{conflicts.join(', ')}") if conflicts.size > 1
+    end
+
+    def self.valid_needs(hash, key, key_for)
+      raise ArgumentError.new("You must supply option #{key} to use #{key_for}") unless hash.has_key?(key)
+    end
+
+    def self.convert_symbols(hash)
+      hash.inject({}) do |rhash, (original_key, value)|
+        rhash[WB_MAPPING.fetch(original_key, original_key)] = value
+        rhash
+      end
+    end
+
+  end
+
+end

data/lib/weatherbug/live_observation.rb

@@ -0,0 +1,34 @@
+module WeatherBug
+
+  class LiveObservation < TransformableData
+
+    register_transformer 'aws:station-id'
+    register_transformer 'aws:station', :name => :station_name
+    register_transformer 'aws:temp-high/@units', :name => :temp_units
+    register_transformer 'aws:temp-high', :name => :temp_high, :transform => :to_i
+    register_transformer 'aws:temp-low', :name => :temp_low, :transform => :to_i
+    register_transformer 'aws:dew-point', :transform => :to_i
+    register_transformer 'aws:elevation', :transform => :to_i
+    register_transformer 'aws:feels-like', :transform => :to_i
+    register_transformer 'aws:humidity', :transform => :to_i
+    register_transformer 'aws:wind-direction'
+    register_transformer 'aws:wind-speed', :transform => :to_i
+    register_transformer 'aws:pressure', :transform => :to_f
+
+    def self.from_document(document)
+      lops = super
+      raise ArgumentError.new('No such station') if lops.station_id.empty?
+      lops
+    end
+
+    def station
+      @station_reference ||= WeatherBug.get_station(self.station_id)
+    end
+
+    private
+
+    attr_writer :station_reference
+
+  end
+
+end

data/lib/weatherbug/station.rb

@@ -0,0 +1,33 @@
+module WeatherBug
+
+  class Station < TransformableData
+
+    register_transformer '@id', :name => :station_id
+    register_transformer '@name'
+    register_transformer '@distance', :transform => :to_f
+    register_transformer '@zipcode', :name => :zip_code
+    register_transformer '@city-code', :transform => :to_i
+    register_transformer '@station-type'
+    register_transformer '@city'
+    register_transformer '@state'
+    register_transformer '@country'
+    register_transformer '@latitude', :transform => :to_f
+    register_transformer '@longitude', :transform => :to_f  
+
+    def self.from_document(document)
+      station = super
+      raise ArgumentError.new('No such station') if station.station_id.empty?
+      station
+    end
+
+    def live_observation(unit = :f)
+      WeatherBug.live_observation(self, unit)
+    end
+
+    def forecast
+      WeatherBug.forecast(:latitude => latitude, :longitude => longitude)
+    end
+
+  end
+
+end

data/lib/weatherbug/station_hint.rb

@@ -0,0 +1,14 @@
+module WeatherBug
+
+  class StationHint < TransformableData
+
+    register_transformer '@id', :name => :station_id
+    register_transformer '@name'
+
+    def station
+      @station ||= WeatherBug.get_station(station_id)
+    end
+
+  end
+
+end

data/lib/weatherbug/transformable_data.rb

@@ -0,0 +1,31 @@
+module WeatherBug
+  
+  # This is a super-convenient class for transorming data and requiring things in the 
+  # different associated WeatherBug data classes
+  class TransformableData
+
+    def self.register_transformer(name, options = {})
+      @transformers ||= {}
+      options[:name] = name.split(/[:@]/).last.gsub('-', '_').to_sym unless options.has_key?(:name)
+      private; attr_writer options[:name]
+      public;  attr_reader options[:name]
+      @transformers[name] = options
+    end
+
+    def self.from_document(document)
+      object = self.new
+      @transformers.each do |key, options|
+        value = document.xpath(key).text
+        # If this thing is empty, skip it
+        next if value.nil?
+        # If this thing needs to be transformed, transform it (from a string)
+        value = value.send(options[:transform]) if options.has_key?(:transform)
+        # Assign it on the class
+        object.send("#{options[:name]}=", value)
+      end
+      object
+    end
+
+  end
+
+end

data/lib/weatherbug/version.rb

@@ -0,0 +1,9 @@
+module WeatherBug
+
+  VERSION = [0, 0, 1]
+
+  def self.version
+    VERSION.join('.')
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: weatherbug
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- John Crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Light Wrapper for the WeatherBug partner API
+email: john.crepezzi@patch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/weatherbug/forecast.rb
+- lib/weatherbug/hash_methods.rb
+- lib/weatherbug/live_observation.rb
+- lib/weatherbug/station.rb
+- lib/weatherbug/station_hint.rb
+- lib/weatherbug/transformable_data.rb
+- lib/weatherbug/version.rb
+- lib/weatherbug.rb
+has_rdoc: true
+homepage: http://github.com/seejohnrun/weatherbug
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: weatherbug
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby WeatherBug partner API
+test_files: []
+