metar-parser 0.1.1

data/lib/metar/parser.rb

@@ -0,0 +1,352 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'aasm'
+require File.join(File.dirname(__FILE__), 'data')
+
+module Metar
+
+  class ParseError < StandardError
+  end
+
+  class Parser
+    include AASM
+
+    aasm_initial_state :start
+
+    aasm_state :start,                                       :after_enter => :seek_location
+    aasm_state :location,                                    :after_enter => :seek_datetime
+    aasm_state :datetime,                                    :after_enter => [:seek_cor_auto, :seek_wind]
+    aasm_state :wind,                                        :after_enter => :seek_variable_wind
+    aasm_state :variable_wind,                               :after_enter => :seek_visibility
+    aasm_state :visibility,                                  :after_enter => :seek_runway_visible_range
+    aasm_state :runway_visible_range,                        :after_enter => :seek_present_weather
+    aasm_state :present_weather,                             :after_enter => :seek_sky_conditions
+    aasm_state :sky_conditions,                              :after_enter => :seek_vertical_visibility
+    aasm_state :vertical_visibility,                         :after_enter => :seek_temperature_dew_point
+    aasm_state :temperature_dew_point,                       :after_enter => :seek_sea_level_pressure
+    aasm_state :sea_level_pressure,                          :after_enter => :seek_remarks
+    aasm_state :remarks,                                     :after_enter => :seek_end
+    aasm_state :end
+
+    aasm_event :location do
+      transitions :from => :start,              :to => :location
+    end
+
+    aasm_event :datetime do
+      transitions :from => :location,           :to => :datetime
+    end
+
+    aasm_event :wind do
+      transitions :from => :datetime,           :to => :wind
+    end
+
+    aasm_event :cavok do
+      transitions :from => :variable_wind,      :to => :sky_conditions
+    end
+
+    aasm_event :variable_wind do
+      transitions :from => :wind,               :to => :variable_wind
+    end
+
+    aasm_event :visibility do
+      transitions :from => [:wind, :variable_wind],  :to => :visibility
+    end
+
+    aasm_event :runway_visible_range do
+      transitions :from => [:visibility],         :to => :runway_visible_range
+    end
+
+    aasm_event :present_weather do
+      transitions :from => [:runway_visible_range],
+                                              :to => :present_weather
+    end
+
+    aasm_event :sky_conditions do
+      transitions :from => [:present_weather, :visibility, :sky_conditions],
+                                                :to => :sky_conditions
+    end
+
+    aasm_event :vertical_visibility do
+      transitions :from => [:present_weather, :visibility, :sky_conditions],
+                                                :to => :vertical_visibility
+    end
+
+    aasm_event :temperature_dew_point do
+      transitions :from => [:wind, :sky_conditions, :vertical_visibility],   :to => :temperature_dew_point
+    end
+
+    aasm_event :sea_level_pressure do
+      transitions :from => :temperature_dew_point,   :to => :sea_level_pressure
+    end
+
+    aasm_event :remarks do
+      transitions :from => [:temperature_dew_point, :sea_level_pressure],
+                                                :to => :remarks
+    end
+
+    aasm_event :done do
+      transitions :from => [:remarks],          :to => :end
+    end
+
+    def Parser.for_cccc(cccc)
+      station = Metar::Station.new(cccc)
+      raw = Metar::Raw.new(station)
+      parser = new(raw)
+      parser.analyze
+      parser
+    end
+
+    attr_reader :station_code, :time, :observer, :wind, :variable_wind, :visibility, :runway_visible_range,
+       :present_weather, :sky_conditions, :vertical_visibility, :temperature, :dew_point, :sea_level_pressure, :remarks
+
+    def initialize(raw)
+      @metar                = raw.metar.clone
+      @time                 = raw.time.clone
+      analyze
+    end
+
+    def attributes
+      h = {
+        :station_code => @location.clone,
+        :time         => @time.to_s,
+        :observer     => Report.symbol_to_s(@observer)
+      }
+      h[:wind]                 = @wind                 if @wind
+      h[:variable_wind]        = @variable_wind.clone  if @variable_wind
+      h[:visibility]           = @visibility           if @visibility
+      h[:runway_visible_range] = @runway_visible_range if @runway_visible_range
+      h[:present_weather]      = @present_weather      if @present_weather
+      h[:sky_conditions]       = @sky_conditions       if @sky_conditions
+      h[:vertical_visibility]  = @vertical_visibility  if @vertical_visibility
+      h[:temperature]          = @temperature
+      h[:dew_point]            = @dew_point
+      h[:sea_level_pressure]   = @sea_level_pressure
+      h[:remarks]              = @remarks.clone        if @remarks
+      h
+    end
+
+    def date
+      Date.new(@time.year, @time.month, @time.day)
+    end
+
+    private
+
+    def analyze
+      @chunks = @metar.split(' ')
+
+      @location             = nil
+      @observer             = :real
+      @wind                 = nil
+      @variable_wind        = nil
+      @visibility           = nil
+      @runway_visible_range = nil
+      @present_weather      = nil
+      @sky_conditions       = nil
+      @vertical_visibility  = nil
+      @temperature          = nil
+      @dew_point            = nil
+      @sea_level_pressure   = nil
+      @remarks              = nil
+
+      aasm_enter_initial_state
+    end
+
+    def seek_location
+      if @chunks[0] =~ /^[A-Z][A-Z0-9]{3}$/
+        @location = @chunks.shift
+      else
+        raise ParseError.new("Expecting location, found '#{ @chunks[0] }'")
+      end
+      location!
+    end
+
+    def seek_datetime
+      case
+      when @chunks[0] =~ /^\d{6}Z$/
+        @datetime = @chunks.shift
+      else
+        raise ParseError.new("Expecting datetime, found '#{ @chunks[0] }'")
+      end
+      datetime!
+    end
+
+    def seek_cor_auto
+      case
+      when @chunks[0] == 'AUTO' # WMO 15.4
+        @chunks.shift
+        @observer = :auto
+      when @chunks[0] == 'COR'
+        @chunks.shift
+        @observer = :corrected
+      end
+    end
+
+    def seek_wind
+      wind = Wind.parse(@chunks[0])
+      if wind
+        @chunks.shift
+        @wind = wind
+      end
+      wind!
+    end
+
+    def seek_variable_wind
+      variable_wind = VariableWind.parse(@chunks[0])
+      if variable_wind
+        @chunks.shift
+        @variable_wind = variable_wind
+      end
+      variable_wind!
+    end
+
+    def seek_visibility
+      if @chunks[0] == 'CAVOK'
+        @chunks.shift
+        @visibility = Visibility.new(M9t::Distance.kilometers(10), nil, :more_than)
+        @present_weather ||= []
+        @present_weather << Metar::WeatherPhenomenon.new('No significant weather')
+        @sky_conditions ||= []
+        @sky_conditions << 'No significant cloud' # TODO: What does NSC stand for?
+        cavok!
+        return
+      end
+
+      if @observer == :auto # WMO 15.4
+        if @chunks[0] == '////'
+          @chunks.shift
+          @visibility = Visibility.new('Not observed')
+          visibility!
+          return
+        end
+      end
+
+      if @chunks[0] == '1' or @chunks[0] == '2'
+        visibility = Visibility.parse(@chunks[0] + ' ' + @chunks[1])
+        if visibility
+          @chunks.shift
+          @chunks.shift
+          @visibility = visibility
+        end
+      else
+        visibility = Visibility.parse(@chunks[0])
+        if visibility
+          @chunks.shift
+          @visibility = visibility
+        end
+      end
+      visibility!
+    end
+
+    def collect_runway_visible_range
+      runway_visible_range = RunwayVisibleRange.parse(@chunks[0])
+      if runway_visible_range
+        @chunks.shift
+        @runway_visible_range ||= []
+        @runway_visible_range << runway_visible_range
+        collect_runway_visible_range
+      end
+    end
+
+    def seek_runway_visible_range
+      collect_runway_visible_range
+      runway_visible_range!
+    end
+
+    def collect_present_weather
+      wtp = WeatherPhenomenon.parse(@chunks[0])
+      if wtp
+        @chunks.shift
+        @present_weather ||= []
+        @present_weather << wtp
+        collect_present_weather
+      end
+    end
+
+    def seek_present_weather
+      if @observer == :auto
+        if @chunks[0] == '//' # WMO 15.4
+          @present_weather ||= []
+          @present_weather << Metar::WeatherPhenomenon.new('not observed')
+          present_weather!
+          return
+        end
+      end
+
+      collect_present_weather
+      present_weather!
+    end
+
+    def collect_sky_conditions
+      sky_condition = SkyCondition.parse(@chunks[0])
+      if sky_condition
+        @chunks.shift
+        @sky_conditions ||= []
+        @sky_conditions << sky_condition
+        collect_sky_conditions
+      end
+    end
+
+    def seek_sky_conditions
+      if @observer == :auto # WMO 15.4
+        if @chunks[0] == '///' or @chunks[0] == '//////'
+          @chunks.shift
+          @sky_conditions ||= []
+          @sky_conditions << 'Not observed'
+          sky_conditions!
+          return
+        end
+      end
+
+      collect_sky_conditions
+      sky_conditions!
+    end
+
+    def seek_vertical_visibility
+      vertical_visibility = VerticalVisibility.parse(@chunks[0])
+      if vertical_visibility
+        @chunks.shift
+        @vertical_visibility = vertical_visibility
+      end
+      vertical_visibility!
+    end
+
+    def seek_temperature_dew_point
+      case
+      when @chunks[0] =~ /^(M?\d+|XX|\/\/)\/(M?\d+|XX|\/\/)?$/
+        @chunks.shift
+        @temperature = Metar::Temperature.parse($1)
+        @dew_point = Metar::Temperature.parse($2)
+      else
+        raise ParseError.new("Expecting temperature/dew point, found '#{ @chunks[0] }'")
+      end
+      temperature_dew_point!
+    end
+
+    def seek_sea_level_pressure
+      sea_level_pressure = Pressure.parse(@chunks[0])
+      if sea_level_pressure
+        @chunks.shift
+        @sea_level_pressure = sea_level_pressure
+      end
+      sea_level_pressure!
+    end
+
+    def seek_remarks
+      if @chunks[0] == 'RMK'
+        @chunks.shift
+      end
+      @remarks ||= []
+      @remarks += @chunks.clone
+      @chunks = []
+      remarks!
+    end
+
+    def seek_end
+      if @chunks.length > 0
+        raise ParseError.new("Unexpected tokens found at end of string: found '#{ @chunks.join(' ') }'")
+      end
+      done!
+    end
+
+  end
+
+end

data/lib/metar/raw.rb

@@ -0,0 +1,49 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'net/ftp'
+
+module Metar
+
+  class Raw
+
+    class << self
+
+      @connection = nil
+
+      def cache_connection
+        @connection = connection
+      end
+
+      def connection
+        return @connection if @connection
+        connection = Net::FTP.new('tgftp.nws.noaa.gov')
+        connection.login
+        connection.chdir('data/observations/metar/stations')
+        connection.passive = true
+        connection
+      end
+
+      def fetch(cccc)
+        s = ''
+        connection.retrbinary("RETR #{ cccc }.TXT", 1024) do |chunk|
+          s << chunk
+        end
+        s
+      end
+
+    end
+
+    attr_reader :cccc, :raw, :metar, :time
+    alias :to_s :metar
+
+    # Station is a string containing the CCCC code, or
+    # an object with a 'cccc' method which returns the code
+    def initialize(station, raw = nil)
+      @cccc = station.respond_to?(:cccc) ? station.cccc : station
+      @raw = raw || Raw.fetch(@cccc)
+      time, @metar = @raw.split("\n")
+      @time = Time.parse(time)
+    end
+
+  end
+
+end

data/lib/metar/report.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+module Metar
+  class Report
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def date
+      I18n.l(@parser.date)
+    end
+
+    def time
+      "%u:%u" % [@parser.time.hour, @parser.time.min]
+    end
+
+    def wind
+      @parser.wind.to_s
+    end
+
+    def variable_wind
+      @parser.variable_wind.to_s
+    end
+
+    def visibility
+      @parser.visibility.to_s
+    end
+
+    def runway_visible_range
+      @parser.runway_visible_range.collect { |rvr| rvr.to_s }.join(', ')
+    end
+
+    def present_weather
+      @parser.present_weather.to_s
+    end
+
+    def sky_conditions
+      @parser.sky_conditions.collect { |sky| sky.to_s }.join(', ')
+    end
+
+    def vertical_visibility
+      @parser.vertical_visibility.to_s
+    end
+
+    def temperature
+      @parser.temperature.to_s
+    end
+
+    def dew_point
+      @parser.dew_point.to_s
+    end
+
+    def sea_level_pressure
+      @parser.sea_level_pressure.to_s
+    end
+
+  end
+end
+
+__END__
+
+
+    def attributes_to_s
+      attrib = attributes
+      texts = {}
+      texts[:wind]                 = attrib[:wind]                            if attrib[:wind]
+      texts[:variable_wind]        = attrib[:variable_wind]                   if attrib[:variable_wind]
+      texts[:visibility]           = "%u meters" % attrib[:visibility].value  if attrib[:visibility]
+      texts[:runway_visible_range] = attrib[:runway_visible_range].join(', ') if attrib[:runway_visible_range]
+      texts[:present_weather]      = attrib[:present_weather].join(', ')      if attrib[:present_weather]
+      texts[:sky_conditions]       = attrib[:sky_conditions].join(', ')       if attrib[:sky_conditions]
+      texts[:temperature]          = "%u celcius" % attrib[:temperature]      if attrib[:temperature]
+      texts[:dew_point]            = "%u celcius" % attrib[:dew_point]        if attrib[:dew_point]
+      texts[:remarks]              = attrib[:remarks].join(', ')              if attrib[:remarks]
+
+      texts
+    end
+
+    def to_s
+      # If attributes supplied an ordered hash, the hoop-jumping below
+      # wouldn't be necessary
+      attr = attributes_to_s
+      [:station_code, :time, :observer, :wind, :variable_wind, :visibility, :runway_visible_range,
+       :present_weather, :sky_conditions, :temperature, :dew_point, :remarks].collect do |key|
+        attr[key] ? self.symbol_to_s(key) + ": " + attr[key] : nil
+      end.compact.join("\n")
+    end
+
+    private
+
+    # :symbol_etc => 'Symbol etc'
+    def self.symbol_to_s(sym)
+      sym.to_s.gsub(/^([a-z])/) {$1.upcase}.gsub(/_([a-z])/) {" #$1"}
+    end

data/lib/metar/station.rb

@@ -0,0 +1,176 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'open-uri'
+
+# A Station can be created without downloading data from the Internet.
+# The class downloads and caches the NOAA station list when it is first requested.
+# As soon of any of the attributes are read, the data is downloaded (if necessary), and attributes are set.
+
+module Metar
+
+  class Station
+    NOAA_STATION_LIST_URL = 'http://weather.noaa.gov/data/nsd_cccc.txt'
+
+    class << self
+
+      @nsd_cccc = nil # Contains the text of the station list
+      attr_accessor :nsd_cccc # Allow tests to run from local file
+
+      def download_local
+        nsd_cccc = Metar::Station.download_stations
+        File.open(Metar::Station.local_nsd_path, 'w') do |fil|
+          fil.write nsd_cccc
+        end
+      end
+
+      # Load local copy of the station list
+      # and download it first if  missing
+      def load_local
+        download_local if not File.exist?(Metar::Station.local_nsd_path)
+        @nsd_cccc = File.open(Metar::Station.local_nsd_path) do |fil|
+          fil.read
+        end
+      end
+
+      def all
+        all_structures.collect do |h|
+          options = h.clone
+          cccc = options.delete(:cccc)
+          new(cccc, h)
+        end
+      end
+
+      def find_by_cccc(cccc)
+        all.find { |station| station.cccc == cccc }
+      end
+      
+      # Does the given CCCC code exist?
+      def exist?(cccc)
+        not find_data_by_cccc(cccc).nil?
+      end
+
+      def to_longitude(s)
+        s =~ /^(\d+)-(\d+)([EW])/ or return nil
+        ($3 == 'E' ? 1.0 : -1.0) * ($1.to_f + $2.to_f / 60.0)
+      end
+
+      def to_latitude(s)
+        s =~ /^(\d+)-(\d+)([SN])/ or return nil
+        ($3 == 'N' ? 1.0 : -1.0) * ($1.to_f + $2.to_f / 60.0)
+      end
+    end
+
+    attr_reader :cccc, :loaded
+    alias :code :cccc
+    # loaded? indicates whether the data has been collected from the Web
+    alias :loaded? :loaded
+
+    # No check is made on the existence of the station
+    def initialize(cccc, options = {})
+      raise "Station identifier must not be nil" if cccc.nil?
+      raise "Station identifier must be a text" if not cccc.respond_to?('to_s')
+      @cccc      = cccc
+      @name      = options[:name]
+      @state     = options[:state]
+      @country   = options[:country]
+      @longitude = options[:longitude]
+      @latitude  = options[:latitude]
+      @raw       = options[:raw]
+      @loaded    = false
+    end
+
+    # Lazy loaded attributes
+    ## TODO: DRY this up by generating these methods
+    def name
+      load! if not @loaded
+      @name
+    end
+
+    def state
+      load! if not @loaded
+      @state
+    end
+
+    def country
+      load! if not @loaded
+      @country
+    end
+
+    def latitude
+      load! if not @loaded
+      @latitude
+    end
+
+    def longitude
+      load! if not @loaded
+      @longitude
+    end
+
+    def raw
+      load! if not @loaded
+      @raw
+    end
+
+    def exist?
+      Station.exist?(@cccc)
+    end
+
+    private
+
+    class << self
+
+      @structures = nil
+
+      def download_stations
+        open(NOAA_STATION_LIST_URL) { |fil| fil.read }
+      end
+
+      # Path for saving a local copy of the nsc_cccc station list
+      def local_nsd_path
+        File.join(File.expand_path(File.dirname(__FILE__) + '/../../'), 'data', 'nsd_cccc.txt')
+      end
+
+      def all_structures
+        return @structures if @structures
+
+        @nsd_cccc ||= download_stations
+        @structures = []
+
+        @nsd_cccc.each_line do |station|
+          fields = station.split(';')
+          @structures << {
+            :cccc      => fields[0],
+            :name      => fields[3],
+            :state     => fields[4],
+            :country   => fields[5],
+            :latitude  => fields[7],
+            :longitude => fields[8],
+            :raw       => station.clone
+          }
+        end
+
+        @structures
+      end
+
+      def find_data_by_cccc(cccc)
+        all_structures.find { |station| station[:cccc] == cccc }
+      end
+
+    end
+
+    # Get data from the NOAA data file (very slow on first call!)
+    def load!
+      noaa_data  = Station.find_data_by_cccc(@cccc)
+      raise "Station identifier '#{ @cccc }' not found" if noaa_data.nil?
+      @name      = noaa_data[:name]
+      @state     = noaa_data[:state]
+      @country   = noaa_data[:country]
+      @longitude = Station.to_longitude(noaa_data[:longitude])
+      @latitude  = Station.to_latitude(noaa_data[:latitude])
+      @raw       = noaa_data[:raw]
+      @loaded    = true
+      self
+    end
+
+  end
+
+end

data/lib/metar.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), 'metar', 'raw')
+require File.join(File.dirname(__FILE__), 'metar', 'station')
+require File.join(File.dirname(__FILE__), 'metar', 'parser')
+require File.join(File.dirname(__FILE__), 'metar', 'report')
+
+module Metar
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY = 1
+ 
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+end