Class: Metar::Data::Visibility

Inherits:
Base
  • Object
show all
Defined in:
lib/metar/data/visibility.rb

Direct Known Subclasses

VisibilityRemark

Instance Attribute Summary collapse

Attributes inherited from Base

#raw

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#value

Constructor Details

#initialize(raw, distance:, direction: nil, comparator: nil) ⇒ Visibility

Returns a new instance of Visibility.



67
68
69
70
71
72
 
# File 'lib/metar/data/visibility.rb', line 67

def initialize(raw, distance:, direction: nil, comparator: nil)
  @raw = raw
  @distance = distance
  @direction = direction
  @comparator = comparator
end

Instance Attribute Details

#comparator ⇒ Object (readonly)

Returns the value of attribute comparator.



65
66
67
 
# File 'lib/metar/data/visibility.rb', line 65

def comparator
  @comparator
end

#direction ⇒ Object (readonly)

Returns the value of attribute direction.



65
66
67
 
# File 'lib/metar/data/visibility.rb', line 65

def direction
  @direction
end

#distance ⇒ Object (readonly)

Returns the value of attribute distance.



65
66
67
 
# File 'lib/metar/data/visibility.rb', line 65

def distance
  @distance
end

Class Method Details

.parse(raw) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/metar/data/visibility.rb', line 6

def self.parse(raw)
  return nil if !raw

  if raw == '9999'
    return new(
      raw,
      distance: Metar::Data::Distance.new(10_000),
      comparator: :more_than
    )
  end

  m1 = raw.match(/(\d{4})NDV/) # WMO
  if m1
    return new(
      raw, distance: Metar::Data::Distance.new(m1[1].to_f)
    ) # Assuming meters
  end

  m2 = raw.match(%r{^((1|2)\s|)([1357])/([248]|16)SM$}) # US
  if m2
    numerator = m2[3].to_f
    denominator = m2[4].to_f
    miles = m2[1].to_f + numerator / denominator
    distance = Metar::Data::Distance.miles(miles)
    distance.serialization_units = :miles
    return new(raw, distance: distance)
  end

  m3 = raw.match(/^(\d+)SM$/) # US
  if m3
    distance = Metar::Data::Distance.miles(m3[1].to_f)
    distance.serialization_units = :miles
    return new(raw, distance: distance)
  end

  if raw == 'M1/4SM' # US
    distance = Metar::Data::Distance.miles(0.25)
    distance.serialization_units = :miles
    return new(raw, distance: distance, comparator: :less_than)
  end

  m4 = raw.match(/^(\d+)KM$/)
  return new(raw, distance: Metar::Data::Distance.kilometers(m4[1])) if m4

  m5 = raw.match(/^(\d+)$/) # We assume meters
  return new(raw, distance: Metar::Data::Distance.new(m5[1])) if m5

  m6 = raw.match(/^(\d+)(N|NE|E|SE|S|SW|W|NW)$/)
  if m6
    return new(
      raw,
      distance: Metar::Data::Distance.meters(m6[1]),
      direction: M9t::Direction.compass(m6[2])
    )
  end

  nil
end

Instance Method Details

#to_s(options = {}) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/metar/data/visibility.rb', line 74

def to_s(options = {})
  distance_options = {
    abbreviated: true,
    precision: 0,
    units: :kilometers
  }.merge(options)

  direction_options = {units: :compass}

  case
  when @direction.nil? && @comparator.nil?
    @distance.to_s(distance_options)
  when @comparator.nil?
    [
      @distance.to_s(distance_options),
      @direction.to_s(direction_options)
    ].join(' ')
  when @direction.nil?
    [
      I18n.t('comparison.' + @comparator.to_s),
      @distance.to_s(distance_options)
    ].join(' ')
  else
    [
      I18n.t('comparison.' + @comparator.to_s),
      @distance.to_s(distance_options),
      @direction.to_s(direction_options)
    ].join(' ')
  end
end