nationalweather 0.1.0

data/lib/nationalweather/conditions.rb

@@ -0,0 +1,34 @@
+
+module NationalWeather
+
+  class Conditions
+
+    attr_reader :summary, :values;
+
+    def initialize(summary, values)
+      @summary = summary
+      @values = values
+    end
+
+    def to_s
+      s = @summary
+      vals = Array.new
+      if @values != nil
+        @values.each do |v|
+          # TODO: handle "none" for intensity, ex: "patchy none fog"
+          # TODO: handle "qualifier"
+          if v.has_key?('additive')
+            vals.push("#{v['additive']} #{v['coverage']} #{v['intensity']} #{v['weather-type']}")
+          else
+            vals.push("#{v['coverage']} #{v['intensity']} #{v['weather-type']}")
+          end
+        end
+        s +' (' + vals.join(' ') + ')'
+      else
+        s
+      end
+    end
+
+  end
+
+end

data/lib/nationalweather/current.rb

@@ -0,0 +1,105 @@
+
+module NationalWeather
+
+  class Current
+
+    # if the xml is invalid, subsequent calls to retrieve values will return nil
+    def initialize(xml_string)
+      @xml = REXML::Document.new xml_string
+    end
+
+    def temperature_f
+      value("/current_observation/temp_f").text.to_f
+    end
+
+    def temperature_c
+      value("/current_observation/temp_c").text.to_f
+    end
+
+    def dewpoint_f
+      value("/current_observation/dewpoint_f").text.to_f
+    end
+
+    def dewpoint_c
+      value("/current_observation/dewpoint_c").text.to_f
+    end
+
+    def pressure_mb
+      value("/current_observation/pressure_mb").text.to_f
+    end
+
+    def pressure_inhg
+      value("/current_observation/pressure_in").text.to_f
+    end
+
+    def relative_humidity
+      value("/current_observation/relative_humidity").text.to_i
+    end
+
+    def visibility_miles
+      value("/current_observation/visibility_mi").text.to_f
+    end
+
+    def wind_speed_mph
+      value("/current_observation/wind_mph").text.to_f
+    end
+
+    def wind_speed_knots
+      value("/current_observation/wind_kt").text.to_f
+    end
+
+    def wind_degrees
+      value("/current_observation/wind_degrees").text.to_i
+    end
+
+    def wind_direction
+      value("/current_observation/wind_dir").text
+    end
+
+    def wind_string
+      value("/current_observation/wind_string").text
+    end
+
+    def weather
+      value("/current_observation/weather").text
+    end
+
+    def icon
+      base = value("/current_observation/icon_url_base").text
+      name = value("/current_observation/icon_url_name").text
+      base + name
+    end
+
+    def icon_name
+      value("/current_observation/icon_url_name").text
+    end
+
+    def station_id
+      value("/current_observation/station_id").text
+    end
+
+    def location
+      value("/current_observation/location").text
+    end
+
+    def latitude
+      value("/current_observation/latitude").text.to_f
+    end
+
+    def longitude
+      value("/current_observation/longitude").text.to_f
+    end
+
+    def time
+      value("/current_observation/observation_time_rfc822").text
+    end
+
+    private
+
+    def value(xpath_string)
+      REXML::XPath.first(@xml, xpath_string)
+    end
+
+  end
+
+end

data/lib/nationalweather/day.rb

@@ -0,0 +1,10 @@
+
+module NationalWeather
+
+  class Day
+
+    attr_accessor :high, :low, :start_time, :end_time, :conditions, :icon, :precipitation_probability_day, :precipitation_probability_night;
+
+  end
+
+end

data/lib/nationalweather/forecast.rb

@@ -0,0 +1,161 @@
+
+require 'time'
+
+module NationalWeather
+
+  class Forecast
+
+    def initialize(xml_string)
+      @xml = REXML::Document.new xml_string
+      @values = Hash.new
+    end
+
+    def day(index)
+      days[index]
+    end
+
+    def days
+      if !@values.has_key?('days')
+        days = Array.new
+        length.times do |i|
+          d = NationalWeather::Day.new
+          d.high = high_temperatures[i]
+          d.low = low_temperatures[i]
+          d.start_time = start_times[i]
+          d.end_time = end_times[i]
+          d.conditions = conditions[i]
+          d.icon = icons[i]
+          d.precipitation_probability_day = precipitation_probabilities[i*2]
+          d.precipitation_probability_night = precipitation_probabilities[i*2+1]
+          days.push(d)
+        end
+        @values['days'] = days
+      end
+      @values['days']
+    end
+
+    def length
+      start_times.length
+    end
+
+    def high_temperatures
+      values('/dwml/data[1]/parameters[1]/temperature[@type="maximum"][1]/value', 'high_temperatures') {|node| node.to_i }
+    end
+
+    def low_temperatures
+      values('/dwml/data[1]/parameters[1]/temperature[@type="minimum"][1]/value', 'low_temperatures') {|node| node.to_i }
+    end
+
+    def precipitation_probabilities
+      values('/dwml/data[1]/parameters[1]/probability-of-precipitation[1]/value', 'precipitation_probabilities') {|node| node.to_i }
+    end
+
+    def start_times
+      values('/dwml/data[1]/time-layout[@summarization="24hourly"][1]/start-valid-time', 'start_times') {|node| Time.parse(node) }
+    end
+
+    def end_times
+      values('/dwml/data[1]/time-layout[@summarization="24hourly"][1]/end-valid-time', 'end_times') {|node| Time.parse(node) }
+    end
+
+    def icons
+      values('/dwml/data[1]/parameters[1]/conditions-icon[1]/icon-link', 'icons')
+    end
+
+    # Returns any Hazards (Watches, Warnings, and Advisories) for the forecast time period.
+    #
+    # SINGLE:
+    #   <hazard hazardCode="LW.Y" phenomena="Lake Wind" significance="Advisory" hazardType="long duration">
+    #     <hazardTextURL>http://forecast.weather.gov/wwamap/wwatxtget.php?cwa=usa&amp;wwa=Lake%20Wind%20Advisory</hazardTextURL>
+    #   </hazard>
+    #
+    # EMPTY:
+    #   <hazard-conditions xsi:nil="true"/>
+    def hazards
+      if !@values.has_key?('hazards')
+        @values['hazards'] = REXML::XPath.match(@xml, '/dwml/data[1]/parameters[1]/hazards[1]/hazard-conditions[1]/hazard').map {|node|
+          # handle empty nodes like <hazards-conditions xsi:nil="true" />
+          if node.has_elements?
+            code = node.attributes["hazardCode"]
+            phenomena = node.attributes["phenomena"]
+            significance = node.attributes["significance"]
+            type = node.attributes["hazardType"]
+            url = node.get_elements("hazardTextURL")[0].text
+            NationalWeather::Hazard.new(code, phenomena, significance, type, url)
+          else
+            nil
+          end
+        }
+      end
+      @values['hazards']
+    end
+
+    # Returns all Conditions objects for this forecast
+    #
+    # MULTIPLE:
+    # <weather-conditions weather-summary="Chance Rain Showers">
+    #   <value coverage="chance" intensity="light" weather-type="rain showers" qualifier="none"/>
+    #   <value coverage="patchy" intensity="none" additive="and" weather-type="fog" qualifier="none"/>
+    # </weather-conditions>
+    #
+    # EMPTY:
+    # <weather-conditions weather-summary="Partly Sunny"/>
+    #
+    # SINGLE:
+    # <weather-conditions weather-summary="Chance Rain Showers">
+    #   <value coverage="chance" intensity="light" weather-type="rain showers" qualifier="none"/>
+    # </weather-conditions>
+    #
+    def conditions
+      if !@values.has_key?('conditions')
+        allConditions = Array.new
+        @values['conditions'] = REXML::XPath.match(@xml, '/dwml/data[1]/parameters[1]/weather[1]/weather-conditions').map {|node|
+          # handle weather-conditions with child values
+          if node.has_elements?
+            # Array to hold <value> attributes
+            cValues = Array.new
+            # gather the attributes of each <value> into a Hash
+            node.get_elements("value").each do |v|
+              atts = Hash.new
+              v.attributes.each do |k, v|
+                atts[k] = v.to_s
+              end
+              cValues.push(atts)
+            end
+          end
+          allConditions.push(NationalWeather::Conditions.new(node.attributes["weather-summary"], cValues))
+        }
+        @values['conditions'] = allConditions
+      end
+      @values['conditions']
+    end
+
+    private
+
+    # Returns an Array of values for the given XPath query.
+    # A block to format each value String can be included with the call to this method.
+    # If no block is given the values in the Array will be Strings.
+    # This method cached the result so it doesn't need to query the XML and format the nodes each time it's called
+    def values(xpath_string, key)
+      if !@values.has_key?(key)
+        @values[key] = REXML::XPath.match(@xml, xpath_string).map {|node|
+          # handle empty nodes like <value xsi:nil="true" />
+          if node.has_text?
+            if block_given?
+              # format the String with the supplied block
+              yield(node.text)
+            else
+              # default: return a String
+              node.text
+            end
+          else
+            nil
+          end
+        }
+      end
+      @values[key]
+    end
+
+  end
+
+end

data/lib/nationalweather/hazard.rb

@@ -0,0 +1,22 @@
+
+module NationalWeather
+
+  class Hazard
+
+    attr_reader :code, :phenomena, :significance, :type, :url;
+
+    def initialize(code, phenomena, significance, type, url)
+      @code = code
+      @phenomena = phenomena
+      @significance = significance
+      @type = type
+      @url = url
+    end
+
+    def to_s
+      "#{@type} #{@phenomena} #{@significance}"
+    end
+
+  end
+
+end

data/lib/nationalweather.rb

@@ -0,0 +1,60 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'net/http'
+require 'rexml/document'
+require 'nationalweather/current'
+require 'nationalweather/forecast'
+require 'nationalweather/hazard'
+require 'nationalweather/conditions'
+require 'nationalweather/day'
+
+module NationalWeather
+
+  VERSION = '0.1.0'
+
+  # Returns the current weather conditions at the station id specified, or nil if there was an error.
+  # For the station ID see: http://www.weather.gov/xml/current_obs/
+  # XML list of stations: http://www.weather.gov/xml/current_obs/index.xml
+  def NationalWeather::current(station_id)
+    xml = fetch("http://www.weather.gov/xml/current_obs/#{station_id}.xml")
+    NationalWeather::Current.new(xml)
+  end
+
+  # Returns the forecast for the given location, or nil if there was an error.
+  # start_date expected in YYYY-MM-DD format
+  def NationalWeather::forecast(lat, lng, start_date, days)
+    xml = fetch("http://graphical.weather.gov/xml/sample_products/browser_interface/ndfdBrowserClientByDay.php?lat=#{lat.to_s}&lon=#{lng.to_s}&format=24+hourly&numDays=#{days.to_s}&startDate=#{start_date}")
+    NationalWeather::Forecast.new(xml)
+  end
+
+  # raised if there are too many redirects while fetching the weather response
+  class TooManyRedirectsError < StandardError
+  end
+
+  # raised if the API server does not return an HTTP success code
+  class BadHTTPResponseError < StandardError
+  end
+
+  private
+
+  # Returns the XML response string for the given URL, following redirects along the way
+  def NationalWeather::fetch(uri_str, limit = 10)
+
+    # TODO: optional file cache
+
+    raise NationalWeather::TooManyRedirectsError, 'Too many HTTP redirects.' if limit == 0
+
+    response = Net::HTTP.get_response(URI(uri_str))
+
+    case response
+    when Net::HTTPSuccess then
+      response.body.to_s
+    when Net::HTTPRedirection then
+      location = response['location']
+      fetch(location, limit - 1)
+    else
+      raise NationalWeather::BadHTTPResponseError, "Bad return value: #{response.value}"
+    end
+  end
+
+end

data/test/test_current.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/nationalweather'
+
+class TestCurrent < Test::Unit::TestCase
+  
+  def test_values
+    cw = NationalWeather::Current.new(File.new(File.dirname(__FILE__) + "/xml/current_KBAF.xml"))
+    
+    assert_equal(62.0, cw.temperature_f)
+    assert_equal(16.7, cw.temperature_c)
+
+    assert_equal(50.0, cw.dewpoint_f)
+    assert_equal(10.0, cw.dewpoint_c)
+
+    assert_equal(1007.2, cw.pressure_mb)
+    assert_equal(29.74, cw.pressure_inhg)
+
+    assert_equal(65, cw.relative_humidity)
+
+    assert_equal(10.0, cw.visibility_miles);
+
+    assert_equal(0.0, cw.wind_speed_mph)
+    assert_equal(0.0, cw.wind_speed_knots)
+    assert_equal(0.0, cw.wind_degrees)
+    assert_equal("North", cw.wind_direction)
+    assert_equal("Calm", cw.wind_string)
+
+    assert_equal("Overcast", cw.weather)
+
+    assert_equal("http://w1.weather.gov/images/fcicons/ovc.jpg", cw.icon)
+    assert_equal("ovc.jpg", cw.icon_name)
+
+    assert_equal("KBAF", cw.station_id)
+
+    assert_equal("Westfield, Barnes Municipal Airport, MA", cw.location)
+
+    assert_equal(42.16, cw.latitude)
+
+    assert_equal(-72.72, cw.longitude)
+
+    assert_equal("Sun, 30 Sep 2012 14:53:00 -0400", cw.time)
+  end
+
+end

data/test/test_forecast.rb

@@ -0,0 +1,152 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/nationalweather'
+
+class TestForecast < Test::Unit::TestCase
+  
+  def test_7day
+    f = NationalWeather::Forecast.new(File.new(File.dirname(__FILE__) + "/xml/forecast_7day.xml"))
+    
+    # length of forecast
+    assert_equal(7, f.length)
+
+    # high temps
+    expectedHighs = [38, 29, 33, 20, 37, 18, 14]
+    assert_equal(expectedHighs, f.high_temperatures)
+
+    # low temps
+    expectedLows = [17, 19, 20, 14, 14, 2, nil]
+    assert_equal(expectedLows, f.low_temperatures)
+
+    # precipitation
+    expectedPrecipitation = [27, 19, 56, 33, 30, 27, 20, 7, 10, 16, 26, 12, 11, nil]
+    assert_equal(expectedPrecipitation, f.precipitation_probabilities)
+
+    # icons
+    expectedIcons = [
+      'http://www.nws.noaa.gov/weather/images/fcicons/sn30.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/sn60.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/sn30.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/sn20.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/bkn.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/sn30.jpg',
+      'http://www.nws.noaa.gov/weather/images/fcicons/bkn.jpg'
+    ]
+    assert_equal(expectedIcons, f.icons)
+
+    # start times
+    expectedStartTimes = [
+      '2008-12-05T06:00:00-07:00',
+      '2008-12-06T06:00:00-07:00',
+      '2008-12-07T06:00:00-07:00',
+      '2008-12-08T06:00:00-07:00',
+      '2008-12-09T06:00:00-07:00',
+      '2008-12-10T06:00:00-07:00',
+      '2008-12-11T06:00:00-07:00'
+    ].map {|t| Time.parse(t) }
+    assert_equal(expectedStartTimes, f.start_times)
+
+    # end times
+    expectedEndTimes = [
+      '2008-12-06T06:00:00-07:00',
+      '2008-12-07T06:00:00-07:00',
+      '2008-12-08T06:00:00-07:00',
+      '2008-12-09T06:00:00-07:00',
+      '2008-12-10T06:00:00-07:00',
+      '2008-12-11T06:00:00-07:00',
+      '2008-12-12T06:00:00-07:00'
+    ].map {|t| Time.parse(t) }
+    assert_equal(expectedEndTimes, f.end_times)
+
+    # hazards
+    expectedHazard = NationalWeather::Hazard.new(
+      "LW.Y",
+      "Lake Wind",
+      "Advisory",
+      "long duration",
+      "http://forecast.weather.gov/wwamap/wwatxtget.php?cwa=usa&wwa=Lake%20Wind%20Advisory"
+    )
+    # returns an array, but there's only one in this test
+    hazard = f.hazards[0]
+    assert_equal(expectedHazard.code, hazard.code)
+    assert_equal(expectedHazard.phenomena, hazard.phenomena)
+    assert_equal(expectedHazard.significance, hazard.significance)
+    assert_equal(expectedHazard.type, hazard.type)
+    assert_equal(expectedHazard.url, hazard.url)
+    assert_equal("long duration Lake Wind Advisory", hazard.to_s)
+
+    # conditions
+    expectedConditionsSummaries = [
+      'Snow Likely',
+      'Snow Likely',
+      'Chance Snow',
+      'Slight Chance Snow',
+      'Mostly Cloudy',
+      'Chance Snow',
+      'Mostly Cloudy'
+    ]
+    expectedConditionsStrings = [
+      'Snow Likely (likely light snow)',
+      'Snow Likely (likely light snow)',
+      'Chance Snow (chance light snow)',
+      'Slight Chance Snow (slight chance light snow)',
+      'Mostly Cloudy',
+      'Chance Snow (chance light snow)',
+      'Mostly Cloudy'
+    ]
+    i = 0
+    f.conditions.each do |c|
+      assert_equal(expectedConditionsSummaries[i], c.summary)
+      assert_equal(expectedConditionsStrings[i], c.to_s)
+      i += 1
+    end
+
+    # days
+    7.times do |i|
+      day = f.day(i)
+      assert_not_nil(day)
+      assert_equal(expectedHighs[i], day.high)
+      assert_equal(expectedLows[i], day.low)
+      assert_equal(expectedIcons[i], day.icon)
+      assert_equal(expectedStartTimes[i], day.start_time)
+      assert_equal(expectedEndTimes[i], day.end_time)
+      assert_equal(expectedConditionsSummaries[i], day.conditions.summary)
+      assert_equal(expectedConditionsStrings[i], day.conditions.to_s)
+      assert_equal(expectedPrecipitation[i*2], day.precipitation_probability_day)
+      assert_equal(expectedPrecipitation[i*2+1], day.precipitation_probability_night)
+    end
+
+  end
+
+  def test_conditions
+
+    f = NationalWeather::Forecast.new(File.new(File.dirname(__FILE__) + "/xml/forecast_conditions.xml"))
+
+    # conditions
+    expectedConditionsSummaries = [
+      'Chance Rain Showers',
+      'Partly Sunny',
+      'Chance Rain Showers',
+      'Chance Rain Showers',
+      'Slight Chance Rain Showers',
+      'Slight Chance Rain Showers',
+      'Slight Chance Rain Showers'
+    ]
+    expectedConditionsStrings = [
+      'Chance Rain Showers (chance light rain showers and patchy none fog)',
+      'Partly Sunny',
+      'Chance Rain Showers (chance light rain showers)',
+      'Chance Rain Showers (chance light rain showers)',
+      'Slight Chance Rain Showers (slight chance light rain showers)',
+      'Slight Chance Rain Showers (slight chance light rain showers)',
+      'Slight Chance Rain Showers (slight chance light rain showers)'
+    ]
+    i = 0
+    f.conditions.each do |c|
+      assert_equal(expectedConditionsSummaries[i], c.summary)
+      assert_equal(expectedConditionsStrings[i], c.to_s)
+      i += 1
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: nationalweather
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew M. Whalen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-04 00:00:00.000000000 Z
+dependencies: []
+description: NationalWeather is a Ruby client library for the National Oceanic and
+  Atmospheric Administration's (NOAA) National Weather Service (NWS) forecast and
+  current weather REST web services.
+email: nationalweather-ruby@amwhalen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nationalweather.rb
+- lib/nationalweather/conditions.rb
+- lib/nationalweather/current.rb
+- lib/nationalweather/day.rb
+- lib/nationalweather/forecast.rb
+- lib/nationalweather/hazard.rb
+- test/test_current.rb
+- test/test_forecast.rb
+homepage: http://rubygems.org/gems/nationalweather
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Client library for NOAA's forecast and current weather services.
+test_files:
+- test/test_current.rb
+- test/test_forecast.rb