metar-parser 1.1.4 → 1.1.5

data/lib/metar/data.rb

@@ -4,14 +4,13 @@ require 'm9t'
 
 module Metar
   locales_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'locales'))
-  I18n.load_path += Dir.glob("#{ locales_path }/*.yml")
+  I18n.load_path += Dir.glob("#{locales_path}/*.yml")
 
   class Distance < M9t::Distance
-
     attr_accessor :units
 
     # nil is taken to mean 'data unavailable'
-    def initialize( meters = nil )
+    def initialize(meters = nil)
       @units = :meters
       if meters
         super
@@ -21,19 +20,19 @@ module Metar
     end
 
     # Handles nil case differently to M9t::Distance
-    def to_s( options = {} )
-      options = { :units       => @units,
-                  :precision   => 0,
-                  :abbreviated => true }.merge( options )
+    def to_s(options = {})
+      options = {
+        :units       => @units,
+        :precision   => 0,
+        :abbreviated => true
+      }.merge(options)
       return I18n.t('metar.distance.unknown') if @value.nil?
-      super( options )
+      super(options)
     end
-
   end
 
   # Adds a parse method to the M9t base class
   class Speed < M9t::Speed
-
     METAR_UNITS = {
       ''    => :kilometers_per_hour,
       'KMH' => :kilometers_per_hour,
@@ -41,43 +40,39 @@ module Metar
       'KT'  => :knots,
     }
 
-    def Speed.parse(s)
+    def self.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 )
+        send(METAR_UNITS[$2], $1.to_i)
       else
         nil
       end
     end
-
   end
 
   # Adds a parse method to the M9t base class
   class Temperature < M9t::Temperature
-
-    def Temperature.parse(s)
+    def self.parse(s)
       if s =~ /^(M?)(\d+)$/
         sign = $1
         value = $2.to_i
         value *= -1 if sign == 'M'
-        new( value )
+        new(value)
       else
         nil
       end
     end
 
-    def to_s( options = {} )
-      options = { :abbreviated => true, :precision => 0 }.merge( options )
-      super( options )
+    def to_s(options = {})
+      options = {:abbreviated => true, :precision => 0}.merge(options)
+      super(options)
     end
-
   end
 
   # Adds a parse method to the M9t base class
   class Pressure < M9t::Pressure
-
-    def Pressure.parse(pressure)
+    def self.parse(pressure)
       case
       when pressure =~ /^Q(\d{4})$/
         hectopascals($1.to_f)
@@ -87,44 +82,34 @@ module Metar
         nil
       end
     end
-
   end
 
   class Direction < M9t::Direction
-    def initialize( direction )
-      direction = M9t::Direction::normalize( direction.to_f )
-      super( direction )
+    def initialize(direction)
+      direction = M9t::Direction::normalize(direction.to_f)
+      super(direction)
     end
   end
 
   class Wind
-    
-    def Wind.parse(s)
+    def self.parse(s)
       case
       when s =~ /^(\d{3})(\d{2}(|MPS|KMH|KT))$/
         return nil if $1.to_i > 360
-        new( Direction.new( $1 ),
-             Speed.parse( $2 ) )
+        new(Direction.new($1), Speed.parse($2))
       when s =~ /^(\d{3})(\d{2})G(\d{2,3}(|MPS|KMH|KT))$/
         return nil if $1.to_i > 360
-        new( Direction.new( $1 ),
-             Speed.parse( $2 + $4 ),
-             Speed.parse( $3 ) )
+        new(Direction.new($1), Speed.parse($2 + $4), Speed.parse($3))
       when s =~ /^VRB(\d{2})G(\d{2,3})(|MPS|KMH|KT)$/
         speed = $1 + $3
         gusts = $2 + $3
-        new( :variable_direction,
-             Speed.parse(speed),
-             Speed.parse(gusts))
+        new(:variable_direction, Speed.parse(speed), Speed.parse(gusts))
       when s =~ /^VRB(\d{2}(|MPS|KMH|KT))$/
-        new( :variable_direction,
-             Speed.parse($1))
+        new(:variable_direction, Speed.parse($1))
       when s =~ /^\/{3}(\d{2}(|MPS|KMH|KT))$/
-        new( :unknown_direction,
-             Speed.parse($1))
+        new(:unknown_direction, Speed.parse($1))
       when s =~ %r(^/////(|MPS|KMH|KT)$)
-        new( :unknown_direction,
-             :unknown_speed)
+        new(:unknown_direction, :unknown_speed)
       else
         nil
       end
@@ -132,21 +117,25 @@ module Metar
 
     attr_reader :direction, :speed, :gusts
 
-    def initialize( direction, speed, gusts = nil )
+    def initialize(direction, speed, gusts = nil)
       @direction, @speed, @gusts = direction, speed, gusts
     end
 
-    def to_s( options = {} )
-      options = { :direction_units => :compass,
-                  :speed_units     => :kilometers_per_hour }.merge( options )
+    def to_s(options = {})
+      options = {
+        :direction_units => :compass,
+        :speed_units     => :kilometers_per_hour
+      }.merge(options)
       speed =
         case @speed
         when :unknown_speed
           I18n.t('metar.wind.unknown_speed')
         else
-          @speed.to_s( :abbreviated => true,
-                       :precision   => 0,
-                       :units       => options[ :speed_units ] )
+          @speed.to_s(
+            :abbreviated => true,
+            :precision   => 0,
+            :units       => options[:speed_units]
+          )
         end
       direction =
         case @direction
@@ -155,23 +144,23 @@ module Metar
         when :unknown_direction
           I18n.t('metar.wind.unknown_direction')
         else
-          @direction.to_s( :units => options[ :direction_units ] )
+          @direction.to_s(:units => options[:direction_units])
         end
-      s = "#{ speed } #{ direction }"
-      if ! @gusts.nil?
-        g =  @gusts.to_s( :abbreviated => true,
-                          :precision   => 0,
-                          :units       => options[ :speed_units ] )
-        s += " #{ I18n.t('metar.wind.gusts') } #{ g }"
+      s = "#{speed} #{direction}"
+      if not @gusts.nil?
+        g = @gusts.to_s(
+          :abbreviated => true,
+          :precision   => 0,
+          :units       => options[:speed_units]
+        )
+        s += " #{I18n.t('metar.wind.gusts')} #{g}"
       end
       s
     end
-
   end
 
   class VariableWind
-
-    def VariableWind.parse(variable_wind)
+    def self.parse(variable_wind)
       if variable_wind =~ /^(\d+)V(\d+)$/
         new(Direction.new($1), Direction.new($2))
       else
@@ -186,38 +175,36 @@ module Metar
     end
 
     def to_s
-      "#{ @direction1.to_s( :units => :compass ) } - #{ @direction2.to_s( :units => :compass ) }"
+      "#{@direction1.to_s(:units => :compass)} - #{@direction2.to_s(:units => :compass)}"
     end
-
   end
 
   class Visibility
-
-    def Visibility.parse(s)
+    def self.parse(s)
       case
       when s == '9999'
-        new( Distance.new( 10000 ), nil, :more_than )
+        new(Distance.new(10000), nil, :more_than)
       when s =~ /(\d{4})NDV/ # WMO
-        new( Distance.new( $1.to_f ) ) # Assuming meters
+        new(Distance.new($1.to_f)) # Assuming meters
       when (s =~ /^((1|2)\s|)([1357])\/([248]|16)SM$/) # US
         miles          = $1.to_f + $3.to_f / $4.to_f
-        distance       = Distance.miles( miles )
+        distance       = Distance.miles(miles)
         distance.units = :miles
-        new( distance )
+        new(distance)
       when s =~ /^(\d+)SM$/ # US
-        distance       = Distance.miles( $1.to_f )
+        distance       = Distance.miles($1.to_f)
         distance.units = :miles
-        new( distance )
+        new(distance)
       when s == 'M1/4SM' # US
-        distance       = Distance.miles( 0.25 )
+        distance       = Distance.miles(0.25)
         distance.units = :miles
-        new( distance, nil, :less_than )
+        new(distance, nil, :less_than)
       when s =~ /^(\d+)KM$/
-        new( Distance.kilometers( $1 ) )
+        new(Distance.kilometers($1))
       when s =~ /^(\d+)$/ # We assume meters
-        new( Distance.new( $1 ) )
+        new(Distance.new($1))
       when s =~ /^(\d+)(N|NE|E|SE|S|SW|W|NW)$/
-        new( Distance.meters( $1 ), M9t::Direction.compass( $2 ) )
+        new(Distance.meters($1), M9t::Direction.compass($2))
       else
         nil
       end
@@ -229,36 +216,42 @@ module Metar
       @distance, @direction, @comparator = distance, direction, comparator
     end
 
-    def to_s( options = {} )
-      distance_options = { :abbreviated => true,
-                           :precision   => 0,
-                           :units       => :kilometers }.merge( options )
-      direction_options = { :units => :compass }
+    def to_s(options = {})
+      distance_options = {
+        :abbreviated => true,
+        :precision   => 0,
+        :units       => :kilometers
+      }.merge(options)
+      direction_options = {:units => :compass}
       case
-      when ( @direction.nil? and @comparator.nil? )
-        @distance.to_s( distance_options )
+      when (@direction.nil? and @comparator.nil?)
+        @distance.to_s(distance_options)
       when @comparator.nil?
-        "%s %s" % [ @distance.to_s( distance_options ),
-                    @direction.to_s( direction_options ) ]
+        [
+          @distance.to_s(distance_options),
+          @direction.to_s(direction_options)
+        ].join(' ')
       when @direction.nil?
-        "%s %s" % [ I18n.t( 'comparison.' + @comparator.to_s ),
-                    @distance.to_s( distance_options ) ]
+        [
+          I18n.t('comparison.' + @comparator.to_s),
+          @distance.to_s(distance_options)
+        ].join(' ')
       else
-        "%s %s %s" % [ I18n.t( 'comparison.' + @comparator.to_s ),
-                       @distance.to_s( distance_options ),
-                       @direction.to_s( direction_options ) ]
+        [
+          I18n.t('comparison.' + @comparator.to_s),
+          @distance.to_s(distance_options),
+          @direction.to_s(direction_options)
+        ].join(' ')
       end
     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}
 
-    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)
+    def self.parse(runway_visible_range)
       case
       when runway_visible_range =~ /^R(\d+[RLC]?)\/(P|M|)(\d{4})(N|U|D|)(FT|)$/
         designator = $1
@@ -266,7 +259,7 @@ module Metar
         count      = $3.to_f
         tendency   = TENDENCY[$4]
         units      = UNITS[$5]
-        distance   = Distance.send( units, count )
+        distance   = Distance.send(units, count)
         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|)$/
@@ -277,50 +270,50 @@ module Metar
         count2      = $5.to_f
         tendency    = TENDENCY[$6]
         units       = UNITS[$7]
-        distance1   = Distance.send( units, count1 )
-        distance2   = Distance.send( units, count2 )
-        visibility1 = Visibility.new( distance1, nil, comparator1 )
-        visibility2 = Visibility.new( distance2, nil, comparator2 )
-        new( designator, visibility1, visibility2, tendency, units )
+        distance1   = Distance.send(units, count1)
+        distance2   = Distance.send(units, count2)
+        visibility1 = Visibility.new(distance1, nil, comparator1)
+        visibility2 = Visibility.new(distance2, nil, comparator2)
+        new(designator, visibility1, visibility2, tendency, units)
       else
         nil
       end
     end
 
     attr_reader :designator, :visibility1, :visibility2, :tendency
-    def initialize( designator, visibility1, visibility2 = nil, tendency = nil, units = :meters )
+    def initialize(designator, visibility1, visibility2 = nil, tendency = nil, units = :meters)
       @designator, @visibility1, @visibility2, @tendency, @units = designator, visibility1, visibility2, tendency, units
     end
 
     def to_s
-      distance_options = { :abbreviated => true,
-                           :precision   => 0,
-                           :units       => @units }
+      distance_options = {
+        :abbreviated => true,
+        :precision   => 0,
+        :units       => @units
+      }
       s =
         if @visibility2.nil?
-          I18n.t( 'metar.runway_visible_range.runway') +
-                  ' '  + @designator +
-                  ': ' + @visibility1.to_s( distance_options )
+          I18n.t('metar.runway_visible_range.runway') +
+          ' '  + @designator +
+          ': ' + @visibility1.to_s(distance_options)
         else
-          I18n.t( 'metar.runway_visible_range.runway') +
-                  ' '  + @designator +
-                  ': ' + I18n.t('metar.runway_visible_range.from') +
-                  ' '  + @visibility1.to_s( distance_options ) +
-                  ' '  + I18n.t('metar.runway_visible_range.to') +
-                  ' '  + @visibility2.to_s( distance_options )
+          I18n.t('metar.runway_visible_range.runway') +
+          ' '  + @designator +
+          ': ' + I18n.t('metar.runway_visible_range.from') +
+          ' '  + @visibility1.to_s(distance_options) +
+          ' '  + I18n.t('metar.runway_visible_range.to') +
+          ' '  + @visibility2.to_s(distance_options)
         end
 
       if ! tendency.nil?
-        s += ' ' + I18n.t( "tendency.#{ tendency }" )
+        s += ' ' + I18n.t("tendency.#{tendency}")
       end
 
       s
     end
-
   end
 
   class WeatherPhenomenon
-
     Modifiers = {
       '+'   => 'heavy',
       '-'   => 'light',
@@ -368,21 +361,21 @@ module Metar
     }
 
     # Accepts all standard (and some non-standard) present weather codes
-    def WeatherPhenomenon.parse(s)
+    def self.parse(s)
       phenomena   = Phenomena.keys.join('|')
       descriptors = Descriptors.keys.join('|')
       modifiers   = Modifiers.keys.join('|')
       modifiers.gsub!(/([\+\-])/) { "\\#$1" }
-      rxp = Regexp.new("^(#{ modifiers })?(#{ descriptors })?((?:#{ phenomena }){1,2})$")
+      rxp = Regexp.new("^(#{modifiers})?(#{descriptors})?((?:#{phenomena}){1,2})$")
       m   = rxp.match(s)
       return nil if m.nil?
 
       modifier_code    = m[1]
       descriptor_code  = m[2]
       phenomena_codes  = m[3].scan(/../)
-      phenomena_phrase = phenomena_codes.map{ |c| Phenomena[c] }.join(' and ')
+      phenomena_phrase = phenomena_codes.map { |c| Phenomena[c] }.join(' and ')
 
-      Metar::WeatherPhenomenon.new(phenomena_phrase, Modifiers[modifier_code], Descriptors[descriptor_code])
+      new(phenomena_phrase, Modifiers[modifier_code], Descriptors[descriptor_code])
     end
 
     attr_reader :phenomenon, :modifier, :descriptor
@@ -393,11 +386,9 @@ module Metar
     def to_s
       I18n.t("metar.present_weather.%s" % [@modifier, @descriptor, @phenomenon].compact.join(' '))
     end
-
   end
 
   class SkyCondition
-
     QUANTITY = {'BKN' => 'broken', 'FEW' => 'few', 'OVC' => 'overcast', 'SCT' => 'scattered'}
     CONDITION = {
       'CB'  => 'cumulonimbus',
@@ -412,22 +403,22 @@ module Metar
       'SKC',
     ]
 
-    def SkyCondition.parse(sky_condition)
+    def self.parse(sky_condition)
       case
-      when CLEAR_SKIES.include?( sky_condition )
+      when CLEAR_SKIES.include?(sky_condition)
         new
       when sky_condition =~ /^(BKN|FEW|OVC|SCT)(\d+|\/{3})(CB|TCU|\/{3}|)?$/
-        quantity = QUANTITY[ $1 ]
+        quantity = QUANTITY[$1]
         height   =
           if $2 == '///'
             nil
           else
-            Distance.new( $2.to_i * 30.48 )
+            Distance.new($2.to_i * 30.48)
           end
-        type = CONDITION[ $3 ]
+        type = CONDITION[$3]
         new(quantity, height, type)
       when sky_condition =~ /^(CB|TCU)$/
-        type = CONDITION[ $1 ]
+        type = CONDITION[$1]
         new(nil, nil, type)
       else
         nil
@@ -452,29 +443,25 @@ module Metar
         I18n.t('metar.sky_conditions.clear skies')
       else
         type = @type ? ' ' + @type : ''
-        I18n.t("metar.sky_conditions.#{ @quantity }#{ type }")
+        I18n.t("metar.sky_conditions.#{@quantity}#{type}")
       end
     end
-
   end
 
   class VerticalVisibility
-
-    def VerticalVisibility.parse( vertical_visibility )
+    def self.parse(vertical_visibility)
       case
       when vertical_visibility =~ /^VV(\d{3})$/
-        Distance.new( $1.to_f * 30.48 )
+        Distance.new($1.to_f * 30.48)
       when vertical_visibility == '///'
         Distance.new
       else
         nil
       end
     end
-
   end
 
   class Remark
-
     PRESSURE_CHANGE_CHARACTER = [
       :increasing_then_decreasing, # 0
       :increasing_then_steady,     # 1
@@ -488,7 +475,7 @@ module Metar
     ]
 
     INDICATOR_TYPE = {
-      'TS' => :thunderstorm_information,
+      'TS'  => :thunderstorm_information,
       'PWI' => :precipitation_identifier,
       'P'   => :precipitation_amount,
     }
@@ -556,89 +543,20 @@ module Metar
     def self.inches_to_meters(digits)
       digits.to_f * 0.000254
     end
-
-  end
-
-  class TemperatureExtreme
-
-    attr_accessor :value
-    attr_accessor :extreme
-
-    def initialize(extreme, value)
-      @extreme, @value = extreme, value
-    end
-
   end
 
-  class PressureTendency
-
-    attr_accessor :value
-    attr_accessor :character
+  TemperatureExtreme = Struct.new(:extreme, :value)
+  PressureTendency = Struct.new(:character, :value)
+  Precipitation = Struct.new(:period, :amount)
+  AutomatedStationType = Struct.new(:type)
+  HourlyTemperaturAndDewPoint = Struct.new(:temperature, :dew_point)
+  SeaLevelPressure = Struct.new(:pressure)
+  SensorStatusIndicator = Struct.new(:type, :state)
+  ColorCode = Struct.new(:code)
 
-    def initialize(character, value)
-      @character, @value = character, value
-    end
-
-  end
-
-  class Precipitation
-
-    attr_accessor :period
-    attr_accessor :amount
-
-    def initialize(period, amount)
-      @period, @amount = period, amount
-    end
-
-  end
-
-  class AutomatedStationType
-
-    attr_accessor :type
-
-    def initialize(type)
-      @type = type
-    end
-
-  end
-
-  class HourlyTemperaturAndDewPoint
-
-    attr_accessor :temperature
-    attr_accessor :dew_point
-
-    def initialize(temperature, dew_point)
-      @temperature, @dew_point = temperature, dew_point
-    end
-
-  end
-
-  class SeaLevelPressure
-
-    attr_accessor :pressure
-
-    def initialize(pressure)
-      @pressure = pressure
-    end
-
-  end
-
-  class SensorStatusIndicator
-
-    attr_accessor :type
-    attr_accessor :state
-
-    def initialize(type, state)
-      @type, @state = type, state
-    end
-
-  end
-
-  class MaintenanceNeeded
-  end
+  class MaintenanceNeeded; end
 
   class Lightning
-
     TYPE = {'' => :default}
 
     def self.parse_chunks(chunks)
@@ -695,18 +613,15 @@ module Metar
   end
 
   class VisibilityRemark < Visibility
-
     def self.parse(chunk)
       chunk =~ /^(\d{4})([NESW]?)$/
       distance = Distance.new($1)
 
       new(distance, $2, :more_than)
     end
-
   end
 
   class DensityAltitude
-
     def self.parse(chunk)
       chunk =~ /^(\d+)(FT)$/
       height = Distance.feet($1)
@@ -719,18 +634,6 @@ module Metar
     def initialize(height)
       @height = height
     end
-
-  end
-
-  class ColorCode
-
-    attr_accessor :code
-
-    def initialize(code)
-      @code = code
-    end
-
   end
-
 end
 

data/lib/metar/parser.rb

@@ -301,7 +301,11 @@ module Metar
         break if @chunks.size == 0
         r = Metar::Remark.parse(@chunks[0])
         if r
-          @remarks += [*r]
+          if r.is_a?(Array)
+            @remarks += r
+          else
+            @remarks << r
+          end
           @chunks.shift
           next 
         end

data/lib/metar/report.rb

@@ -40,7 +40,7 @@ module Metar
     end
 
     def time
-      "%u:%u" % [@parser.time.hour, @parser.time.min]
+      "%u:%02u" % [@parser.time.hour, @parser.time.min]
     end
 
     def observer

data/lib/metar/version.rb

@@ -2,7 +2,7 @@ module Metar
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 1
-    TINY  = 4
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/unit/parser_spec.rb

@@ -1,32 +1,28 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+require 'spec_helper'
 
 describe Metar::Parser do
-
-  after :each do
+  after do
     Metar::Parser.compliance = :loose
   end
 
   context '.for_cccc' do
-
     it 'returns a loaded parser' do
-      station = stub( 'station' )
-      raw = stub( 'raw', :metar => "XXXX 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000",
-                         :time  => '2010/02/06 16:10' )
-      Metar::Station.stub!( :new => station )
-      Metar::Raw::Noaa.stub!( :new => raw )
+      station = stub('station')
+      raw = stub('raw', :metar => "XXXX 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000",
+                         :time  => '2010/02/06 16:10')
+      Metar::Station.stub!(:new => station)
+      Metar::Raw::Noaa.stub!(:new => raw)
 
-      parser = Metar::Parser.for_cccc( 'XXXX' )
+      parser = Metar::Parser.for_cccc('XXXX')
 
-      parser.                     should     be_a( Metar::Parser )
-      parser.station_code.        should     == 'XXXX'
+      expect(parser).to be_a(Metar::Parser)
+      expect(parser.station_code).to eq('XXXX')
     end
-         
   end
 
   context 'attributes' do
-
-    before :each do
+    before do
       @call_time = Time.parse('2011-05-06 16:35')
       Time.stub!(:now).and_return(@call_time)
     end
@@ -34,315 +30,262 @@ describe Metar::Parser do
     it '.location missing' do
       expect do
         setup_parser("FUBAR 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000") 
-      end.                        to         raise_error( Metar::ParseError, /Expecting location/ )
+      end.to raise_error(Metar::ParseError, /Expecting location/)
     end
 
     context 'datetime' do
-
       it 'is parsed' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.time.              should     == Time.gm(2011, 05, 06, 16, 10)
+        expect(parser.time).to eq(Time.gm(2011, 05, 06, 16, 10))
       end
 
       it 'throws an error is missing' do
         expect do
           setup_parser("PAIL 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000") 
-        end.                      to         raise_error( Metar::ParseError, /Expecting datetime/ )
+        end.to raise_error(Metar::ParseError, /Expecting datetime/)
       end
 
       context 'in strict mode' do
-
-        before :each do
+        before do
           Metar::Parser.compliance = :strict
         end
 
         it 'less than 6 numerals fails' do
           expect do
             parser = setup_parser('MMCE 21645Z 12010KT 8SM SKC 29/26 A2992 RMK')
-          end.                    to         raise_error(Metar::ParseError, /Expecting datetime/)
+          end.to raise_error(Metar::ParseError, /Expecting datetime/)
         end
-
       end
 
       context 'in loose mode' do
-
         it '5 numerals parses' do
           parser = setup_parser('MMCE 21645Z 12010KT 8SM SKC 29/26 A2992 RMK')
 
-          parser.time.              should     == Time.gm(2011, 05, 02, 16, 45)
+          expect(parser.time).to eq(Time.gm(2011, 05, 02, 16, 45))
         end
 
         it "with 4 numerals parses, takes today's day" do
           parser = setup_parser('HKML 1600Z 19010KT 9999 FEW022 25/22 Q1015')
 
-          parser.time.              should     == Time.gm(2011, 05, 06, 16, 00)
+          expect(parser.time).to eq(Time.gm(2011, 05, 06, 16, 00))
         end
-
       end
-
     end
 
     context '.observer' do
-
       it 'real' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.observer.          should     == :real
+        expect(parser.observer).to eq(:real)
       end
 
       it 'auto' do
         parser = setup_parser("CYXS 151034Z AUTO 09003KT 1/8SM FZFG VV001 M03/M03 A3019 RMK SLP263 ICG")
 
-        parser.observer.          should     == :auto
+        expect(parser.observer).to eq(:auto)
       end
 
       it 'corrected' do
         parser = setup_parser("PAIL 061610Z COR 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.observer.          should     == :corrected
+        expect(parser.observer).to eq(:corrected)
       end
 
       it 'corrected (Canadian)' do
         parser = setup_parser('CYZU 310100Z CCA 26004KT 15SM FEW009 BKN040TCU BKN100 OVC210 15/12 A2996 RETS RMK SF1TCU4AC2CI1 SLP149')
 
-        parser.observer.          should     == :corrected
+        expect(parser.observer).to eq(:corrected)
       end
-      
     end
 
     it 'wind' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-      parser.wind.direction.value.should     be_within( 0.0001 ).of( 240 )
-      parser.wind.speed.to_knots. should     be_within( 0.0001 ).of( 6 )
+      expect(parser.wind.direction.value).to be_within(0.0001).of(240)
+      expect(parser.wind.speed.to_knots).to be_within(0.0001).of(6)
     end
 
     it 'variable_wind' do
       parser = setup_parser("LIRQ 061520Z 01007KT 350V050 9999 SCT035 BKN080 08/02 Q1005")
 
-      parser.variable_wind.direction1.value.
-                                  should     be_within( 0.0001 ).of( 350 )
-      parser.variable_wind.direction2.value.
-                                  should     be_within( 0.0001 ).of( 50 )
+      expect(parser.variable_wind.direction1.value).to be_within(0.0001).of(350)
+      expect(parser.variable_wind.direction2.value).to be_within(0.0001).of(50)
     end
 
     context '.visibility' do
       it 'CAVOK' do
         parser = setup_parser("PAIL 061610Z 24006KT CAVOK M17/M20 A2910 RMK AO2 P0000")
 
-        parser.visibility.distance.value.
-                                  should     be_within( 0.01 ).of( 10000.00 )
-        parser.visibility.comparator.
-                                  should     == :more_than
-        parser.present_weather.size.
-                                  should     == 1
-        parser.present_weather[ 0 ].phenomenon.
-                                  should     == 'No significant weather'
-        parser.sky_conditions.size.
-                                  should     == 1
-        parser.sky_conditions[ 0 ].type.
-                                  should     == nil
+        expect(parser.visibility.distance.value).to be_within(0.01).of(10000.00)
+        expect(parser.visibility.comparator).to eq(:more_than)
+        expect(parser.present_weather.size).to eq(1)
+        expect(parser.present_weather[0].phenomenon).to eq('No significant weather')
+        expect(parser.sky_conditions.size).to eq(1)
+        expect(parser.sky_conditions[0].type).to eq(nil)
       end
 
       it 'visibility_miles_and_fractions' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.visibility.distance.to_miles.
-                                  should     be_within( 0.01 ).of( 1.75 )
+        expect(parser.visibility.distance.to_miles).to be_within(0.01).of(1.75)
       end
 
       it 'in meters' do
         parser = setup_parser('VABB 282210Z 22005KT 4000 HZ SCT018 FEW025TCU BKN100 28/25 Q1003 NOSIG')
 
-        parser.visibility.distance.value.
-                                  should     be_within(0.01).of(4000)
+        expect(parser.visibility.distance.value).to be_within(0.01).of(4000)
        end
 
       it '//// with automatic observer' do
         parser = setup_parser("CYXS 151034Z AUTO 09003KT //// FZFG VV001 M03/M03 A3019 RMK SLP263 ICG")
 
-        parser.visibility.        should     be_nil
+        expect(parser.visibility).to be_nil
       end
     end
 
     it 'runway_visible_range' do
       parser = setup_parser("ESSB 151020Z 26003KT 2000 R12/1000N R30/1500N VV002 M07/M07 Q1013 1271//55")
-      parser.runway_visible_range.length.
-                                  should     == 2
-      parser.runway_visible_range[0].designator.
-                                  should     == '12'
-      parser.runway_visible_range[0].visibility1.distance.value.
-                                  should     == 1000
-      parser.runway_visible_range[0].tendency.
-                                  should     == :no_change
+      expect(parser.runway_visible_range.size).to eq(2)
+      expect(parser.runway_visible_range[0].designator).to eq('12')
+      expect(parser.runway_visible_range[0].visibility1.distance.value).to eq(1000)
+      expect(parser.runway_visible_range[0].tendency).to eq(:no_change)
     end
 
     it 'runway_visible_range_defaults_to_empty_array' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-      parser.runway_visible_range.length.
-                                  should     == 0
+      expect(parser.runway_visible_range.size).to eq(0)
     end
 
     it 'runway_visible_range_variable' do
       parser = setup_parser("KPDX 151108Z 11006KT 1/4SM R10R/1600VP6000FT FG OVC002 05/05 A3022 RMK AO2")
 
-      parser.runway_visible_range[0].visibility1.distance.to_feet.
-                                  should     == 1600.0
-      parser.runway_visible_range[0].visibility2.distance.to_feet.
-                                  should     == 6000.0
+      expect(parser.runway_visible_range[0].visibility1.distance.to_feet).to eq(1600.0)
+      expect(parser.runway_visible_range[0].visibility2.distance.to_feet).to eq(6000.0)
     end
 
     context '.present_weather' do
-
       it 'normal' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.present_weather.size.
-                                  should     == 1
-        parser.present_weather[0].modifier.
-                                  should     == 'light'
-        parser.present_weather[0].phenomenon.
-                                  should     == 'snow'
+        expect(parser.present_weather.size).to eq(1)
+        expect(parser.present_weather[0].modifier).to eq('light')
+        expect(parser.present_weather[0].phenomenon).to eq('snow')
       end
 
       it 'auto + //' do
         parser = setup_parser("PAIL 061610Z AUTO 24006KT 1 3/4SM // BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.present_weather.size.
-                                  should     == 1
-        parser.present_weather[0].phenomenon.
-                                  should     == 'not observed'
+        expect(parser.present_weather.size).to eq(1)
+        expect(parser.present_weather[0].phenomenon).to eq('not observed')
       end
-
     end
 
     it 'present_weather_defaults_to_empty_array' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
-      parser.present_weather.length.
-                                  should     == 0
+      expect(parser.present_weather.size).to eq(0)
     end
 
     context '.sky_conditions' do
-
       it 'normal' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.sky_conditions.size.
-                                  should     == 2
-        parser.sky_conditions[0].quantity.
-                                  should     == 'broken'
-        parser.sky_conditions[0].height.value.
-                                  should     == 487.68
-        parser.sky_conditions[1].quantity.
-                                  should     == 'overcast'
-        parser.sky_conditions[1].height.value.
-                                  should     == 914.40
+        expect(parser.sky_conditions.size).to eq(2)
+        expect(parser.sky_conditions[0].quantity).to eq('broken')
+        expect(parser.sky_conditions[0].height.value).to eq(487.68)
+        expect(parser.sky_conditions[1].quantity).to eq('overcast')
+        expect(parser.sky_conditions[1].height.value).to eq(914.40)
       end
 
       it 'auto + ///' do
         parser = setup_parser("PAIL 061610Z AUTO 24006KT 1 3/4SM /// M17/M20 A2910 RMK AO2 P0000")
 
-        parser.sky_conditions.size.
-                                  should     == 0
+        expect(parser.sky_conditions.size).to eq(0)
       end
-
     end
 
     it 'sky_conditions_defaults_to_empty_array' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN M17/M20 A2910 RMK AO2 P0000")
-      parser.sky_conditions.length.
-                                  should     == 0
+      expect(parser.sky_conditions.size).to eq(0)
     end
 
     it 'vertical_visibility' do
       parser = setup_parser("CYXS 151034Z AUTO 09003KT 1/8SM FZFG VV001 M03/M03 A3019 RMK SLP263 ICG")
-      parser.vertical_visibility.value.
-                                  should     == 30.48
+      expect(parser.vertical_visibility.value).to eq(30.48)
     end
 
     it 'temperature' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
-      parser.temperature.value.   should     == -17
+      expect(parser.temperature.value).to eq(-17)
     end
 
     it 'dew_point' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
-      parser.dew_point.value.     should     == -20
+      expect(parser.dew_point.value).to eq(-20)
     end
 
     it 'sea_level_pressure' do
       parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
-      parser.sea_level_pressure.to_inches_of_mercury.
-                                  should     == 29.10
+      expect(parser.sea_level_pressure.to_inches_of_mercury).to eq(29.10)
     end
 
     it 'recent weather' do
       parser = setup_parser("CYQH 310110Z 00000KT 20SM SCT035CB BKN050 RETS RMK CB4SC1")
 
-      parser.recent_weather.      should    be_a Array
-      parser.recent_weather.size. should    == 1
-      parser.recent_weather[0].phenomenon.
-                                  should    == 'thunderstorm'
+      expect(parser.recent_weather).to be_a Array
+      expect(parser.recent_weather.size).to eq(1)
+      expect(parser.recent_weather[0].phenomenon).to eq('thunderstorm')
     end
 
     context 'remarks' do
-
       it 'are collected' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 RMK AO2 P0000")
 
-        parser.remarks.             should     be_a Array
-        parser.remarks.size.        should     == 2
+        expect(parser.remarks).to be_a Array
+        expect(parser.remarks.size).to eq(2)
       end
 
       it 'remarks defaults to empty array' do
         parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910")
 
-        parser.remarks.             should     be_a Array
-        parser.remarks.length.      should     == 0
+        expect(parser.remarks).to be_a Array
+        expect(parser.remarks.size).to eq(0)
       end
 
       it 'parses known remarks' do
         parser = setup_parser('CYZT 052200Z 31010KT 20SM SKC 17/12 A3005 RMK SLP174 20046')
 
-        parser.remarks[0].        should    be_a(Metar::SeaLevelPressure)
-        parser.remarks[1].        should    be_temperature_extreme(:minimum, 4.6)
+        expect(parser.remarks[0]).to be_a(Metar::SeaLevelPressure)
+        expect(parser.remarks[1]).to be_temperature_extreme(:minimum, 4.6)
       end
 
       context 'in strict mode' do
-
-        before :each do
+        before do
           Metar::Parser.compliance = :strict
         end
 
         it 'unparsed data causes an error' do
           expect do
             setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 FOO RMK AO2 P0000")
-          end.                    to        raise_error(Metar::ParseError, /Unparsable text found/)
+          end.to raise_error(Metar::ParseError, /Unparsable text found/)
         end
-
       end
 
       context 'in loose mode' do
-
         it 'unparsed data is collected' do
           parser = setup_parser("PAIL 061610Z 24006KT 1 3/4SM -SN BKN016 OVC030 M17/M20 A2910 FOO RMK AO2 P0000")
 
-          parser.unparsed.        should    == ['FOO']
-          parser.remarks.size.    should    == 2
+          expect(parser.unparsed).to eq(['FOO'])
+          expect(parser.remarks.size).to eq(2)
         end
-
       end
-
     end
   
     def setup_parser(metar)
       raw = Metar::Raw::Data.new(metar)
       Metar::Parser.new(raw)
     end
-
   end
-
 end
 

data/spec/unit/report_spec.rb

@@ -49,6 +49,12 @@ describe Metar::Report do
 
     context '#time' do
       specify { subject.time.     should     == @metar_time }
+
+      it 'zero-pads single figure minutes' do
+        @parser.stub(:time => Time.parse('10:02'))
+
+        expect(subject.time).to eq('10:02')
+      end
     end
 
     context '#observer' do

data/spec/unit/wind_spec.rb

@@ -1,9 +1,9 @@
 # encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
+load File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
 
-RSpec::Matchers.define :be_wind do | direction, speed, gusts |
-  match do | wind |
-    if wind.nil?              && [ direction, speed, gusts ].all?( &:nil? )
+RSpec::Matchers.define :be_wind do |direction, speed, gusts|
+  match do |wind|
+    if wind.nil?              && [direction, speed, gusts].all?(&:nil?)
       true
     elsif wind.nil?
       false
@@ -13,15 +13,15 @@ RSpec::Matchers.define :be_wind do | direction, speed, gusts |
       false
     elsif wind.gusts.nil?     != gusts.nil?
       false
-    elsif direction.is_a?( Symbol )         && wind.direction != direction
+    elsif direction.is_a?(Symbol)         && wind.direction != direction
       false
-    elsif direction.is_a?( M9t::Direction ) && (wind.direction.value - direction).abs > 0.01
+    elsif direction.is_a?(M9t::Direction) && (wind.direction.value - direction).abs > 0.01
       false
-    elsif speed.is_a?( Symbol )             && wind.speed     != speed
+    elsif speed.is_a?(Symbol)             && wind.speed     != speed
        false
-    elsif speed.is_a?( Metar::Speed )       && (wind.speed.value - speed).abs > 0.01
+    elsif speed.is_a?(Metar::Speed)       && (wind.speed.value - speed).abs > 0.01
       false
-    elsif ! wind.gusts.nil?                 && (wind.gusts.value - gusts).abs > 0.01
+    elsif ! wind.gusts.nil?               && (wind.gusts.value - gusts).abs > 0.01
        false
     else
       true
@@ -30,52 +30,48 @@ RSpec::Matchers.define :be_wind do | direction, speed, gusts |
 end
 
 describe Metar::Wind do
-
   context '.parse' do
-
     [
       # Direction and speed
-      [ 'treats 5 digits as degrees and kilometers per hour', '12345',       [ 123.0, 12.50, nil   ] ],
-      [ 'understands 5 digits + KMH',                         '12345KMH',    [ 123.0, 12.50, nil   ] ],
-      [ 'understands 5 digits + MPS',                         '12345MPS',    [ 123.0, 45.00, nil   ] ],
-      [ 'understands 5 digits + KT',                          '12345KT',     [ 123.0, 23.15, nil   ] ],
-      [ 'rounds 360 down to 0',                               '36045KT',     [   0.0, 23.15, nil   ] ],
-      [ 'returns nil for directions outside 0 to 360',        '88845KT',     [ nil,   nil,   nil   ] ],
+      ['treats 5 digits as degrees and kilometers per hour', '12345',       [123.0, 12.50, nil]],
+      ['understands 5 digits + KMH',                         '12345KMH',    [123.0, 12.50, nil]],
+      ['understands 5 digits + MPS',                         '12345MPS',    [123.0, 45.00, nil]],
+      ['understands 5 digits + KT',                          '12345KT',     [123.0, 23.15, nil]],
+      ['rounds 360 down to 0',                               '36045KT',     [  0.0, 23.15, nil]],
+      ['returns nil for directions outside 0 to 360',        '88845KT',     [nil,   nil,   nil]],
       # +gusts
-      [ 'understands 5 digits + G + 2 digits',                '12345G67',    [ 123.0, 12.50, 18.61 ] ],
-      [ 'understands 5 digits + G + 2 digits + KMH',          '12345G67KMH', [ 123.0, 12.50, 18.61 ] ],
-      [ 'understands 5 digits + G + 2 digits + MPS',          '12345G67MPS', [ 123.0, 45.00, 67.00 ] ],
-      [ 'understands 5 digits + G + 2 digits + KT',           '12345G67KT',  [ 123.0, 23.15, 34.47 ] ],
+      ['understands 5 digits + G + 2 digits',                '12345G67',    [123.0, 12.50, 18.61]],
+      ['understands 5 digits + G + 2 digits + KMH',          '12345G67KMH', [123.0, 12.50, 18.61]],
+      ['understands 5 digits + G + 2 digits + MPS',          '12345G67MPS', [123.0, 45.00, 67.00]],
+      ['understands 5 digits + G + 2 digits + KT',           '12345G67KT',  [123.0, 23.15, 34.47]],
       # Variable direction
-      [ 'understands VRB + 2 digits'                          'VRB12',       [ :variable_direction,  3.33, nil ] ],
-      [ 'understands VRB + 2 digits + KMH',                   'VRB12KMH',    [ :variable_direction,  3.33, nil ] ],
-      [ 'understands VRB + 2 digits + MPS',                   'VRB12MPS',    [ :variable_direction, 12.00, nil ] ],
-      [ 'understands VRB + 2 digits + KT',                    'VRB12KT',     [ :variable_direction,  6.17, nil ] ],
+      ['understands VRB + 2 digits',                         'VRB12',       [:variable_direction,  3.33, nil]],
+      ['understands VRB + 2 digits + KMH',                   'VRB12KMH',    [:variable_direction,  3.33, nil]],
+      ['understands VRB + 2 digits + MPS',                   'VRB12MPS',    [:variable_direction, 12.00, nil]],
+      ['understands VRB + 2 digits + KT',                    'VRB12KT',     [:variable_direction,  6.17, nil]],
       # + gusts
-      [ 'understands VRB + 2 digits + G + 2 digits',          'VRB45G67',    [ :variable_direction, 12.50, 18.61 ] ],
-      [ 'understands VRB + 2 digits + G + 2 digits + KMH',    'VRB45G67KMH', [ :variable_direction, 12.50, 18.61 ] ],
-      [ 'understands VRB + 2 digits + G + 2 digits + MPS',    'VRB45G67MPS', [ :variable_direction, 45.00, 67.00 ] ],
-      [ 'understands VRB + 2 digits + G + 2 digits + KT',     'VRB45G67KT',  [ :variable_direction, 23.15, 34.47 ] ],
+      ['understands VRB + 2 digits + G + 2 digits',          'VRB45G67',    [:variable_direction, 12.50, 18.61]],
+      ['understands VRB + 2 digits + G + 2 digits + KMH',    'VRB45G67KMH', [:variable_direction, 12.50, 18.61]],
+      ['understands VRB + 2 digits + G + 2 digits + MPS',    'VRB45G67MPS', [:variable_direction, 45.00, 67.00]],
+      ['understands VRB + 2 digits + G + 2 digits + KT',     'VRB45G67KT',  [:variable_direction, 23.15, 34.47]],
       # Unknown direction
-      [ 'understands /// + 2 digits',                         '///12',       [ :unknown_direction,   3.33, nil ] ],
-      [ 'understands /// + 2 digits + KMH',                   '///12KMH',    [ :unknown_direction,   3.33, nil ] ],
-      [ 'understands /// + 2 digits + MPS',                   '///12MPS',    [ :unknown_direction,  12.00, nil ] ],
-      [ 'understands /// + 2 digits + KT',                    '///12KT',     [ :unknown_direction,   6.17, nil ] ],
+      ['understands /// + 2 digits',                         '///12',       [:unknown_direction,  3.33, nil]],
+      ['understands /// + 2 digits + KMH',                   '///12KMH',    [:unknown_direction,  3.33, nil]],
+      ['understands /// + 2 digits + MPS',                   '///12MPS',    [:unknown_direction, 12.00, nil]],
+      ['understands /// + 2 digits + KT',                    '///12KT',     [:unknown_direction,  6.17, nil]],
       # Unknown direction and speed
-      [ 'understands /////',                                  '/////',       [ :unknown_direction, :unknown_speed, nil ] ],
+      ['understands /////',                                  '/////',       [:unknown_direction, :unknown_speed, nil]],
       # Bad data
-      [ 'returns nil for badly formatted values',             'XYZ12KT',     [ nil, nil, nil ] ],
-      [ 'returns nil for nil',                                nil,           [ nil, nil, nil ] ],
-    ].each do | docstring, raw, expected |
+      ['returns nil for badly formatted values',             'XYZ12KT',     [nil, nil, nil]],
+      ['returns nil for nil',                                nil,           [nil, nil, nil]],
+    ].each do |docstring, raw, expected|
       example docstring do
-        Metar::Wind.parse( raw ).should be_wind( *expected )
+        Metar::Wind.parse(raw).should be_wind(*expected)
       end
     end
-
   end
 
   context '#to_s' do
-
     before :each do
       @locale = I18n.locale
       I18n.locale = :it
@@ -86,28 +82,26 @@ describe Metar::Wind do
     end
 
     [
-      [ 'should format speed and direction', :en, [ nil,                 nil,            nil ],                     '443km/h ESE' ],
-      [ 'should handle variable_direction',  :en, [ :variable_direction, nil,            nil ],                     '443km/h variable direction' ],
-      [ 'should handle unknown_direction',   :en, [ :unknown_direction,  nil,            nil ],                     '443km/h unknown direction' ],
-      [ 'should handle unknown_speed',       :en, [ nil,                 :unknown_speed, nil ],                     'unknown speed ESE' ],
-      [ 'should include gusts',              :en, [ nil,                 nil,            Metar::Speed.new( 123 ) ], '443km/h ESE gusts 443km/h' ],
-      [ 'should format speed and direction', :it, [ nil,                 nil,            nil ],                     '443km/h ESE' ],
-      [ 'should handle variable_direction',  :it, [ :variable_direction, nil,            nil ],                     '443km/h direzione variabile' ],
-      [ 'should handle unknown_direction',   :it, [ :unknown_direction,  nil,            nil ],                     '443km/h direzione sconosciuta' ],
-      [ 'should handle unknown_speed',       :it, [ nil,                 :unknown_speed, nil ],                     'velocità sconosciuta ESE' ],
-      [ 'should include gusts',              :it, [ nil,                 nil,            Metar::Speed.new( 123 ) ], '443km/h ESE folate di 443km/h' ],
-    ].each do | docstring, locale, ( direction, speed, gusts ), expected |
-      direction ||= M9t::Direction.new( 123 )
-      speed     ||= Metar::Speed.new( 123 )
+      ['should format speed and direction', :en, [nil,                 nil,            nil                  ], '443km/h ESE'                  ],
+      ['should handle variable_direction',  :en, [:variable_direction, nil,            nil                  ], '443km/h variable direction'   ],
+      ['should handle unknown_direction',   :en, [:unknown_direction,  nil,            nil                  ], '443km/h unknown direction'    ],
+      ['should handle unknown_speed',       :en, [nil,                 :unknown_speed, nil                  ], 'unknown speed ESE'            ],
+      ['should include gusts',              :en, [nil,                 nil,            Metar::Speed.new(123)], '443km/h ESE gusts 443km/h'    ],
+      ['should format speed and direction', :it, [nil,                 nil,            nil                  ], '443km/h ESE'                  ],
+      ['should handle variable_direction',  :it, [:variable_direction, nil,            nil                  ], '443km/h direzione variabile'  ],
+      ['should handle unknown_direction',   :it, [:unknown_direction,  nil,            nil                  ], '443km/h direzione sconosciuta'],
+      ['should handle unknown_speed',       :it, [nil,                 :unknown_speed, nil                  ], 'velocità sconosciuta ESE'     ],
+      ['should include gusts',              :it, [nil,                 nil,            Metar::Speed.new(123)], '443km/h ESE folate di 443km/h'],
+    ].each do |docstring, locale, (direction, speed, gusts), expected|
+      direction ||= M9t::Direction.new(123)
+      speed     ||= Metar::Speed.new(123)
 
       example docstring + " (#{locale})" do
         I18n.locale = locale
-        Metar::Wind.new( direction, speed, gusts ).to_s.
+        Metar::Wind.new(direction, speed, gusts).to_s.
                                   should     == expected
       end
     end
-
   end
-
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metar-parser
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-24 00:00:00.000000000 Z
+date: 2013-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -194,7 +194,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 256504047505018704
+      hash: 2864761200794302878
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -203,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 256504047505018704
+      hash: 2864761200794302878
 requirements: []
 rubyforge_project: nowarning
 rubygems_version: 1.8.23