metar-parser 0.1.1

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Joe Yates
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,40 @@
+= metar - Downloads and parses weather status
+
+The information comes from the National Oceanic and Atmospheric Association's raw data source.
+
+= Implementation
+
+* Parses METAR strings using a state machine.
+
+= Data format descrition
+
+* WMO
+  * http://www.wmo.int/pages/prog/www/WMOCodes/Manual/Volume-I-selection/Sel2.pdf (pages 27-38)
+  * http://dcaa.slv.dk:8000/icaodocs/Annex%203%20-%20Meteorological%20Service%20for%20International%20Air%20Navigation/Cover%20sheet%20to%20AMDT%2074.pdf (Table A3-2. Template for METAR and SPECI)
+  * http://booty.org.uk/booty.weather/metinfo/codes/METAR_decode.htm
+
+* United states:
+  * http://www.nws.noaa.gov/oso/oso1/oso12/fmh1/fmh1ch12.htm
+  * http://www.ofcm.gov/fmh-1/pdf/FMH1.pdf
+  * http://weather.cod.edu/notes/metar.html
+  * http://www.met.tamu.edu/class/METAR/metar-pg3.html - incomplete
+
+= Other software
+
+Other Ruby libraries offering METAR parsing:
+* ruby-metar - http://github.com/brandonh/ruby-metar
+* ruby-wx - http://hans.fugal.net/src/ruby-wx/doc/
+There are many reports (WMO) that these libraries do not parse.
+
+There are two gems which read the National Oceanic and Atmospheric Association's XML weather data feeds:
+* noaa-weather - Ruby interface to NOAA SOAP interface
+* noaa - http://github.com/outoftime/noaa
+
+Interactive map:
+* http://www.spatiality.at/metarr/frontend/
+
+= Testing
+
+The tests use a local copy of the weather stations list: data/nsd_cccc.txt
+
+If missing, the file gets downloaded before running tests.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/clean'
+
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'metar'
+
+RDOC_OPTS = ['--quiet', '--title', 'METAR Weather Report Parser', '--main', 'README.rdoc', '--inline-source']
+RDOC_PATH = 'doc/rdoc'
+CLEAN.include RDOC_PATH
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name        = 'metar-parser'
+  s.summary     = 'Downloads and parses weather reports'
+  s.description = 'Downloads, parses and presents METAR weather reports'
+  s.version     = Metar::VERSION::STRING
+
+  s.homepage = 'http://github.com/joeyates/metar-parser'
+  s.author   = 'Joe Yates'
+  s.email    = 'joe.g.yates@gmail.com'
+
+  s.files         = ['README.rdoc', 'COPYING', 'Rakefile'] + FileList['{bin,lib,test}/**/*.rb'] + FileList['locales/**/*.{rb,yml}']
+  s.require_paths = ['lib']
+  s.add_dependency('aasm', '>= 2.1.5')
+  s.add_dependency('i18n', '>= 0.3.5')
+  s.add_dependency('m9t', '>= 0.1.11')
+
+  s.has_rdoc = true
+  s.rdoc_options += RDOC_OPTS
+  s.extra_rdoc_files = ['README.rdoc', 'COPYING']
+
+  s.test_file = 'test/all_tests.rb'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/unit/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = RDOC_PATH
+  rdoc.options += RDOC_OPTS
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.add ['README.rdoc', 'COPYING', 'lib/**/*.rb']
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end

data/bin/download_raw.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+=begin
+
+This script downloads the current weather report for each station.
+
+=end
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'yaml'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'metar')
+
+Metar::Station.load_local
+
+('A'..'Z').each do |initial|
+
+  stations = {}
+
+  Metar::Raw.cache_connection
+
+  Metar::Station.all.each do |station|
+
+    next if station.cccc[0, 1] < initial
+    break if station.cccc[0, 1] > initial
+
+    print station.cccc
+    raw = nil
+    begin
+      raw = Metar::Raw.new(station.cccc)
+    rescue Net::FTPPermError => e
+      puts ": Not available - #{ e }"
+      next
+    rescue
+      puts ": Other error - #{ e }"
+      next
+    end
+
+    stations[station.cccc] = raw.raw.clone
+    puts ': OK'
+  end
+
+  filename = File.join(File.expand_path(File.dirname(__FILE__) + '/../data'), "stations.#{ initial }.yml")
+  File.open(filename, 'w') { |fil| fil.write stations.to_yaml }
+
+end
+
+# Merge into one file
+stations = {}
+('A'..'Z').each do |initial|
+  filename = File.join(File.expand_path(File.dirname(__FILE__) + '/../data'), "stations.#{ initial }.yml")
+  next if not File.exist?(filename)
+  h = YAML.load_file(filename)
+  stations.merge!(h)
+end
+
+filename = File.join(File.expand_path(File.dirname(__FILE__) + '/../data'), "stations.yml")
+File.open(filename, 'w') { |fil| fil.write stations.to_yaml }

data/bin/parse_raw.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+=begin
+
+Use the data downloaded by 'download_raw.rb' to bulk test the Report
+
+=end
+
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'yaml'
+require File.join(File.expand_path(File.dirname(__FILE__) + '/../lib'), 'metar')
+
+filename = File.join(File.expand_path(File.dirname(__FILE__) + '/../data'), "stations.yml")
+stations = YAML.load_file(filename)
+
+stations.each_pair do |cccc, raw_text|
+  raw = Metar::Raw.new(cccc, raw_text)
+  report = nil
+  begin
+    report = Metar::Report.new(raw)
+    $stdout.print '.'
+  rescue => e
+    $stderr.puts "#{ raw.metar }"
+    $stderr.puts "  Error: #{ e }"
+    $stdout.print 'E'
+  end
+  $stdout.flush
+end

data/lib/metar/data.rb

@@ -0,0 +1,374 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'i18n'
+require 'm9t'
+
+module Metar
+  locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'locales'))
+  I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
+
+  # Adds a parse method to the M9t base class
+  class Speed < M9t::Speed
+
+    METAR_UNITS = {
+      'KMH' => :kilometers_per_hour,
+      'MPS' => :meters_per_second,
+      'KT'  => :knots,
+    }
+
+    def Speed.parse(s)
+      case
+      when s =~ /^(\d+)(KT|MPS|KMH)$/
+        # Call the appropriate factory method for the supplied units
+        send(METAR_UNITS[$2], $1.to_i, { :units => METAR_UNITS[$2], :precision => 0 })
+      when s =~ /^(\d+)$/
+        kilometers_per_hour($1.to_i, { :units => :kilometers_per_hour, :precision => 0 })
+      else
+        nil
+      end
+    end
+
+  end
+
+  # Adds a parse method to the M9t base class
+  class Temperature < M9t::Temperature
+
+    def Temperature.parse(s)
+      if s =~ /^(M?)(\d+)$/
+        sign = $1
+        value = $2.to_i
+        value *= -1 if sign == 'M'
+        new(value, { :units => :degrees, :precision => 0, :abbreviated => true })
+      else
+        nil
+      end
+    end
+
+  end
+
+  class Distance < M9t::Distance
+
+    # Subclasses M9t::Distance
+    # Uses kilometers as desired default output unit
+    # nil is taken to mean 'data unavailable'
+    def initialize(meters = nil, options = {})
+      if meters
+        super(meters, { :units => :kilometers, :precision => 0, :abbreviated => true }.merge(options))
+      else
+        @value = nil
+      end
+    end
+
+    # Handles nil case differently to M9t::Distance
+    def to_s
+      return I18n.t('metar.distance.unknown') if @value.nil?
+      super
+    end
+
+  end
+
+  # Adds a parse method to the M9t base class
+  class Pressure < M9t::Pressure
+
+    def Pressure.parse(pressure)
+      case
+      when pressure =~ /^Q(\d{4})$/
+        hectopascals($1.to_f)
+      when pressure =~ /^A(\d{4})$/
+        inches_of_mercury($1.to_f / 100.0)
+      end
+    end
+
+  end
+
+  class Visibility
+
+    def Visibility.parse(s)
+      case
+      when s == '9999'
+        new(Distance.new(10000), nil, :more_than)
+      when s =~ /(\d{4})NDV/ # WMO
+        new(Distance.new($1.to_f)) # Assuming meters
+      when (s =~ /^((1|2)\s|)([13])\/([248])SM$/) # US
+        miles = $1.to_f + $3.to_f / $4.to_f
+        new(Distance.miles(miles, {:units => :miles}))
+      when s =~ /^(\d+)SM$/ # US
+        new(Distance.miles($1.to_f, {:units => :miles}))
+      when s == 'M1/4SM' # US
+        new(Distance.miles(0.25, {:units => :miles}), nil, :less_than)
+      when s =~ /^(\d+)KM$/
+        new(Distance.kilometers($1))
+      when s =~ /^(\d+)$/ # Units?
+        new(Distance.kilometers($1))
+      when s =~ /^(\d+)(N|NE|E|SE|S|SW|W|NW)$/
+        new(Distance.kilometers($1), M9t::Direction.compass($2))
+      else
+        nil
+      end
+    end
+
+    attr_reader :distance, :direction, :comparator
+
+    def initialize(distance, direction = nil, comparator = nil)
+      @distance, @direction, @comparator = distance, direction, comparator
+    end
+
+    def to_s
+      case
+      when (@direction.nil? and @comparator.nil?)
+        @distance.to_s
+      when @comparator.nil?
+        "%s %s" % [@distance.to_s, @direction.to_s]
+      when @direction.nil?
+        "%s %s" % [I18n.t('comparison.' + @comparator.to_s), @distance.to_s]
+      else
+        "%s %s %s" % [I18n.t('comparison.' + @comparator.to_s), @distance.to_s, direction]
+      end
+    end
+  end
+
+  class Wind
+
+    def Wind.parse(s)
+      case
+      when s =~ /^(\d{3})(\d{2}(KT|MPS|KMH|))$/
+        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
+      when s =~ /^(\d{3})(\d{2})G(\d{2,3}(KT|MPS|KMH|))$/
+        new(M9t::Direction.new($1, { :abbreviated => true }), Speed.parse($2))
+      when s =~ /^VRB(\d{2}(KT|MPS|KMH|))$/
+        new('variable direction', Speed.parse($1))
+      when s =~ /^\/{3}(\d{2}(KT|MPS|KMH|))$/
+        new('unknown direction', Speed.parse($1))
+      when s =~ /^\/{3}(\/{2}(KT|MPS|KMH|))$/
+        new('unknown direction', 'unknown')
+      else
+        nil
+      end
+    end
+
+    attr_reader :direction, :speed, :units
+
+    def initialize(direction, speed, units = :kilometers_per_hour)
+      @direction, @speed = direction, speed
+    end
+
+    def to_s
+      "#{ @direction } #{ @speed }"
+    end
+
+  end
+
+  class VariableWind
+
+    def VariableWind.parse(variable_wind)
+      if variable_wind =~ /^(\d+)V(\d+)$/
+        new(M9t::Direction.new($1), M9t::Direction.new($2))
+      else
+        nil
+      end
+    end
+
+    attr_reader :direction1, :direction2
+
+    def initialize(direction1, direction2)
+      @direction1, @direction2 = direction1, direction2
+    end
+
+    def to_s
+      "#{ @direction1 } - #{ @direction2 }"
+    end
+
+  end
+
+  class RunwayVisibleRange
+
+    TENDENCY   = { '' => nil, 'N' => :no_change, 'U' => :improving, 'D' => :worsening }
+    COMPARATOR = { '' => nil, 'P' => :more_than, 'M' => :less_than }
+    UNITS      = { '' => :meters, 'FT' => :feet }
+
+    def RunwayVisibleRange.parse(runway_visible_range)
+      case
+      when runway_visible_range =~ /^R(\d+[RLC]?)\/(P|M|)(\d{4})(N|U|D|)(FT|)$/
+        designator = $1
+        comparator = COMPARATOR[$2]
+        count      = $3.to_f
+        tendency   = TENDENCY[$4]
+        units      = UNITS[$5]
+        distance   = Distance.send(units, count, { :units => units })
+        visibility = Visibility.new(distance, nil, comparator)
+        new(designator, visibility, nil, tendency)
+      when runway_visible_range =~ /^R(\d+[RLC]?)\/(P|M|)(\d{4})V(P|M|)(\d{4})(N|U|D)?(FT)?$/
+        designator  = $1
+        comparator1 = COMPARATOR[$2]
+        count1      = $3.to_f
+        comparator2 = COMPARATOR[$4]
+        count2      = $5.to_f
+        tendency    = TENDENCY[$6]
+        units       = UNITS[$7]
+        distance1   = Distance.send(units, count1, { :units => units })
+        distance2   = Distance.send(units, count2, { :units => units })
+        visibility1 = Visibility.new(distance1, nil, comparator1)
+        visibility2 = Visibility.new(distance2, nil, comparator2)
+        new(designator, visibility1, visibility2, tendency)
+      end
+    end
+
+    attr_reader :designator, :visibility1, :visibility2, :tendency
+    def initialize(designator, visibility1, visibility2 = nil, tendency = nil)
+      @designator, @visibility1, @visibility2, @tendency = designator, visibility1, visibility2, tendency
+    end
+
+    def to_s
+      if @visibility2.nil?
+        I18n.t('metar.runway_visible_range.runway') + ' ' + @designator + ': ' + @visibility1.to_s
+      else
+        I18n.t('metar.runway_visible_range.runway') + ' ' + @designator + ': ' + I18n.t('metar.runway_visible_range.from') + ' ' + @visibility1.to_s + ' ' + I18n.t('metar.runway_visible_range.to') + ' ' + @visibility2.to_s
+      end
+    end
+
+    private
+
+    def RunwayVisibleRange.parse_visibility(distance)
+    end
+
+  end
+
+  class WeatherPhenomenon
+
+    Modifiers = {
+      '\+' => 'heavy',
+      '-'  => 'light',
+      'VC' => 'nearby'
+    }
+
+    Descriptors = {
+      'BC' => 'patches of',
+      'BL' => 'blowing',
+      'DR' => 'low drifting',
+      'FZ' => 'freezing',
+      'MI' => 'shallow',
+      'PR' => 'partial',
+      'SH' => 'shower of',
+      'TS' => 'thunderstorm and',
+    }
+
+    Phenomena = {
+      'BR'   => 'mist',
+      'DU'   => 'dust',
+      'DZ'   => 'drizzle',
+      'FG'   => 'fog',
+      'FU'   => 'smoke',
+      'GR'   => 'hail',
+      'GS'   => 'small hail',
+      'HZ'   => 'haze',
+      'IC'   => 'ice crystals',
+      'PL'   => 'ice pellets',
+      'PO'   => 'dust whirls',
+      'PY'   => 'spray', # US only
+      'RA'   => 'rain',
+      'SA'   => 'sand',
+      'SH'   => 'shower',
+      'SN'   => 'snow',
+      'SG'   => 'snow grains',
+      'SNRA' => 'snow and rain',
+      'SQ'   => 'squall',
+      'UP'   => 'unknown phenomenon', # => AUTO
+      'VA'   => 'volcanic ash',
+      'FC'   => 'funnel cloud',
+      'SS'   => 'sand storm',
+      'DS'   => 'dust storm',
+      'TS'   => 'thunderstorm',
+      'TSGR' => 'thunderstorm and hail',
+      'TSGS' => 'thunderstorm and small hail',
+      'TSRA' => 'thunderstorm and rain',
+      'TSRA' => 'thunderstorm and snow',
+      'TSRA' => 'thunderstorm and unknown phenomenon', # => AUTO
+    }
+
+    # Accepts all standard (and some non-standard) present weather codes
+    def WeatherPhenomenon.parse(s)
+      codes = Phenomena.keys.join('|')
+      descriptors = Descriptors.keys.join('|')
+      modifiers = Modifiers.keys.join('|')
+      rxp = Regexp.new("^(#{ modifiers })?(#{ descriptors })?(#{ codes })$")
+      if rxp.match(s)
+        modifier_code = $1
+        descriptor_code = $2
+        phenomenon_code = $3
+        Metar::WeatherPhenomenon.new(Phenomena[phenomenon_code], Modifiers[modifier_code], Descriptors[descriptor_code])
+      else
+        nil
+      end
+    end
+
+    attr_reader :phenomenon, :modifier, :descriptor
+    def initialize(phenomenon, modifier = nil, descriptor = nil)
+      @phenomenon, @modifier, @descriptor = phenomenon, modifier, descriptor
+    end
+
+    def to_s
+      modifier = @modifier ? @modifier + ' ' : ''
+      descriptor = @descriptor ? @descriptor + ' ' : ''
+      I18n.t("metar.weather.%s%s%s" % [modifier, descriptor, @phenomenon])
+    end
+
+  end
+
+  class SkyCondition
+
+    QUANTITY = {'BKN' => 'broken', 'FEW' => 'few', 'OVC' => 'overcast', 'SCT' => 'scattered'}
+    def SkyCondition.parse(sky_condition)
+      case
+      when (sky_condition == 'NSC' or sky_condition == 'NCD') # WMO
+        new
+      when sky_condition == 'CLR'
+        new
+      when sky_condition == 'SKC'
+        new
+      when sky_condition =~ /^(BKN|FEW|OVC|SCT)(\d+)(CB|TCU|\/{3})?$/
+        quantity = QUANTITY[$1]
+        height = Distance.new($2.to_i * 30.0, { :units => :meters })
+        type = case $3
+               when nil
+                 nil
+               when 'CB'
+                 'cumulonimbus'
+               when 'TCU'
+                 'towering cumulus'
+               when '///'
+                 ''
+               end
+        new(quantity, height, type)
+      end
+    end
+
+    attr_reader :quantity, :height, :type
+    def initialize(quantity = nil, height = nil, type = nil)
+      @quantity, @height, @type = quantity, height, type
+    end
+
+    def to_s
+      if @quantity == nil and @height == nil and @type == nil
+        I18n.t('metar.sky_conditions.clear skies')
+      else
+        type = @type ? ' ' + @type : ''
+        I18n.t("metar.sky_conditions.#{ @quantity }#{ type }") + ' ' + I18n.t('metar.altitude.at') + ' ' + height.to_s
+      end
+    end
+
+  end
+
+  class VerticalVisibility
+
+    def VerticalVisibility.parse(vertical_visibility)
+      case
+      when vertical_visibility =~ /^VV(\d{3})$/
+        Distance.new($1.to_f * 30.0, { :units => :meters })
+      when vertical_visibility == '///'
+        Distance.new
+      end
+    end
+
+  end
+
+end