gull 0.4.0 → 1.0.1

data/lib/gull/polygon.rb

@@ -1,44 +1,28 @@
+# frozen_string_literal: true
+
 module Gull
+  # Represents the geographic boundary of an alert as a series of
+  # lat/lon coordinate pairs. Coordinates are stored in [lat, lon]
+  # order.
   class Polygon
     attr_accessor :coordinates
 
-    def initialize(polygon)
-      self.coordinates = polygon.split(' ')
-                                .map { |point| point.split(',').map(&:to_f) }
-    end
-
-    def image_url(api_key, options = {})
-      options = {
-        width: 640,
-        height: 640,
-        color: '0xff0000',
-        weight: 3,
-        fillcolor: '0xff000060',
-        maptype: 'roadmap'
-      }.merge(options)
-
-      url_base = 'http://maps.googleapis.com/maps/api/staticmap'
-      "#{url_base}?size=#{options[:width]}x#{options[:height]}" \
-      "&maptype=#{options[:maptype]}&path=color:#{options[:color]}" \
-      "|weight:#{options[:weight]}|fillcolor:#{options[:fillcolor]}" \
-      "|#{coordinates_piped}&key=#{api_key}"
+    # Accepts GeoJSON coordinates ([lon, lat]) and stores them as
+    # [lat, lon].
+    def initialize(coords)
+      self.coordinates = coords.map { |point| [point[1], point[0]] }
     end
 
+    # Returns coordinates as "lat,lon lat,lon ..." string.
     def to_s
       coordinates.map { |pair| pair.join(',') }.join(' ')
     end
 
-    # Returns well-known text (WKT) formatted polygon
+    # Returns coordinates in Well-Known Text format.
     def to_wkt
       pairs = coordinates.map { |pair| "#{pair.last} #{pair.first}" }
                          .join(', ')
       "POLYGON((#{pairs}))"
     end
-
-    private
-
-    def coordinates_piped
-      coordinates.map { |pair| pair.join ',' }.join '|'
-    end
   end
 end

data/lib/gull/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gull
-  VERSION = '0.4.0'
+  VERSION = '1.0.1'
 end

data/lib/gull.rb

@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'time'
+require 'uri'
+
 require 'gull/version'
 require 'gull/error'
-require 'gull/client'
-require 'gull/alert'
-require 'gull/polygon'
 require 'gull/geocode'
+require 'gull/polygon'
+require 'gull/alert'
+require 'gull/client'
 
 module Gull
 end

data/spec/alert_spec.rb

@@ -1,116 +1,174 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Gull::Alert do
+  def load_feature(name)
+    JSON.parse(File.read("spec/fixtures/features/#{name}"))
+  end
+
+  def wrap_features(*features)
+    { 'type' => 'FeatureCollection', 'features' => features }.to_json
+  end
+
+  def stub_alerts(json)
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_return(status: 200, body: json, headers: {})
+  end
+
   it 'should initialize with geocode' do
     alert = Gull::Alert.new
     expect(alert.geocode).not_to be_nil
   end
 
-  it 'should fetch parsed alerts' do
-    xml = File.read 'spec/fixtures/alerts.xml'
-
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+  it 'should fetch and parse all alerts' do
+    json = File.read 'spec/fixtures/alerts.json'
+    stub_alerts(json)
 
     alerts = Gull::Alert.fetch
-    expect(alerts.size).to eq(3)
+    expect(alerts.size).to eq(44)
+  end
+
+  it 'should parse alert with polygon and no VTEC' do
+    feature = load_feature('polygon_no_vtec.json')
+    stub_alerts(wrap_features(feature))
 
-    first = alerts.first
-    expect(first.id).to eq 'http://alerts.weather.gov/cap/wwacapget.php?x=CA125171381DD0.HeatAdvisory'
-    expect(first.link).to eq 'http://alerts.weather.gov/cap/wwacapget.php?x=CA125171381DD0.HeatAdvisory'
-    expect(first.alert_type).to eq 'Heat Advisory'
-    expect(first.title).to eq 'Heat Advisory issued October 01 at 8:40AM PDT' \
-      ' until October 03 at 9:00PM PDT by NWS'
-    expect(first.summary).to eq 'SUMMARY TEXT'
+    alert = Gull::Alert.fetch.first
 
-    coordinates = [[27.35, -81.79], [27.14, -81.89], [27.04, -81.97],
-                   [27.04, -82.02], [27.14, -81.97], [27.35, -81.86],
-                   [27.35, -81.79]]
-    expect(first.polygon.coordinates).to eq coordinates
+    expect(alert.id).to eq feature['properties']['id']
+    expect(alert.link).to eq feature['properties']['@id']
+    expect(alert.alert_type).to eq 'Special Weather Statement'
+    expect(alert.title).to start_with 'Special Weather Statement'
+    expect(alert.summary).to start_with 'At 748 AM CST'
+    expect(alert.area).to eq 'Sevier; Howard; Hempstead'
 
-    expect(first.effective_at).to eq Time.parse('2014-10-01T08:40:00-07:00')
-    expect(first.expires_at).to eq Time.parse('2014-10-03T21:00:00-07:00')
-    expect(first.updated_at).to eq Time.parse('2014-10-01T08:40:00-07:05')
-    expect(first.published_at).to eq Time.parse('2014-10-01T08:40:00-07:06')
+    expect(alert.effective_at).to eq Time.parse('2026-03-07T07:48:00-06:00')
+    expect(alert.expires_at).to eq Time.parse('2026-03-07T08:15:00-06:00')
+    expect(alert.published_at).to eq Time.parse('2026-03-07T07:48:00-06:00')
+    expect(alert.updated_at).to eq Time.parse('2026-03-07T07:48:00-06:00')
 
-    expect(first.area).to eq 'Southern Salinas Valley, Arroyo Seco and Lake ' \
-      'San Antonio'
-    expect(first.urgency).to eq :expected
-    expect(first.severity).to eq :minor
-    expect(first.certainty).to eq :very_likely
+    expect(alert.urgency).to eq :expected
+    expect(alert.severity).to eq :moderate
+    expect(alert.certainty).to eq :observed
 
-    expect(first.geocode.fips6).to be_nil
-    expect(first.geocode.ugc).to be_nil
+    expect(alert.polygon).not_to be_nil
+    expect(alert.polygon.coordinates.first).to eq [34.21, -93.93]
+    expect(alert.polygon.coordinates.size).to eq 18
 
-    expect(first.vtec).to eq '/O.NEW.KMTR.HT.Y.0002.141002T1900Z-141004T0400Z/'
+    expect(alert.geocode.fips6).to eq '005133 005061 005057'
+    expect(alert.geocode.ugc).to eq 'ARZ050 ARZ051 ARZ060'
 
-    second = alerts[1]
-    expect(second.polygon).to be_nil
+    expect(alert.vtec).to be_nil
+  end
 
-    expect(second.geocode.fips6).to eq '006001 006013 006041 006053 006055 ' \
-      '006069 006075 006081 006085 006087 006097'
-    expect(second.geocode.ugc).to eq 'CAZ006 CAZ505 CAZ506 CAZ507 CAZ508 ' \
-      'CAZ509 CAZ510 CAZ511 CAZ512 CAZ513 CAZ516 CAZ517 CAZ518 CAZ528 ' \
-      'CAZ529 CAZ530'
+  it 'should parse alert with polygon and VTEC' do
+    feature = load_feature('polygon_with_vtec.json')
+    stub_alerts(wrap_features(feature))
 
-    expect(second.vtec).to be_nil
+    alert = Gull::Alert.fetch.first
 
-    third = alerts[2]
-    expect(third.vtec).to be_nil
-    expect(third.link).to be_nil
+    expect(alert.alert_type).to eq 'Severe Thunderstorm Warning'
+    expect(alert.urgency).to eq :immediate
+    expect(alert.severity).to eq :severe
+    expect(alert.certainty).to eq :observed
+    expect(alert.polygon).not_to be_nil
+    expect(alert.polygon.coordinates.size).to eq 5
+    expect(alert.vtec).to eq '/O.NEW.KLZK.SV.W.0013.260307T1328Z-260307T1415Z/'
   end
 
-  it 'should fetch from url in options' do
-    xml = File.read 'spec/fixtures/alerts.xml'
+  it 'should parse alert with null geometry' do
+    feature = load_feature('null_geometry.json')
+    stub_alerts(wrap_features(feature))
 
-    stub_request(:get, 'http://test.url')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    alert = Gull::Alert.fetch.first
 
-    alerts = Gull::Alert.fetch(url: 'http://test.url')
-    expect(alerts.size).to eq(3)
+    expect(alert.alert_type).to eq 'Tornado Watch'
+    expect(alert.urgency).to eq :future
+    expect(alert.severity).to eq :extreme
+    expect(alert.certainty).to eq :possible
+    expect(alert.polygon).to be_nil
+    expect(alert.geocode.ugc).not_to be_nil
+    expect(alert.geocode.fips6).not_to be_nil
+    expect(alert.vtec).to eq '/O.CON.KLZK.TO.A.0022.000000T0000Z-260307T1400Z/'
   end
 
-  it 'should enable strict xml parsing via option' do
-    xml = File.read 'spec/fixtures/bad.xml'
+  it 'should parse flood advisory with minor severity' do
+    feature = load_feature('flood_advisory.json')
+    stub_alerts(wrap_features(feature))
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    alert = Gull::Alert.fetch.first
 
-    expect { Gull::Alert.fetch(strict: true) }
-      .to raise_error(Nokogiri::XML::SyntaxError)
+    expect(alert.alert_type).to eq 'Flood Advisory'
+    expect(alert.severity).to eq :minor
+    expect(alert.polygon).not_to be_nil
+    expect(alert.vtec).not_to be_nil
   end
 
-  it 'should handle empty alerts' do
-    xml = File.read 'spec/fixtures/empty.xml'
+  it 'should parse blizzard warning with extreme severity' do
+    feature = load_feature('blizzard_warning.json')
+    stub_alerts(wrap_features(feature))
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    alert = Gull::Alert.fetch.first
 
-    alerts = Gull::Alert.fetch
-    expect(alerts.size).to eq(0)
+    expect(alert.alert_type).to eq 'Blizzard Warning'
+    expect(alert.severity).to eq :extreme
+    expect(alert.polygon).to be_nil
   end
 
-  it 'should handle bad response' do
-    xml = File.read 'spec/fixtures/bad.xml'
+  it 'should parse MultiPolygon geometry' do
+    feature = load_feature('multipolygon.json')
+    stub_alerts(wrap_features(feature))
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    alert = Gull::Alert.fetch.first
+
+    coordinates = [[34.57, -97.56], [34.77, -97.38],
+                   [34.75, -97.17], [34.57, -97.56]]
+    expect(alert.polygon.coordinates).to eq coordinates
+  end
+
+  it 'should handle empty geocode' do
+    feature = load_feature('empty_geocode.json')
+    stub_alerts(wrap_features(feature))
+
+    alert = Gull::Alert.fetch.first
+
+    expect(alert.geocode.fips6).to be_nil
+    expect(alert.geocode.ugc).to be_nil
+  end
+
+  it 'should fetch with area option' do
+    json = File.read 'spec/fixtures/alerts.json'
+
+    stub_request(:get, 'https://api.weather.gov/alerts/active?area=OK')
+      .to_return(status: 200, body: json, headers: {})
+
+    alerts = Gull::Alert.fetch(area: 'OK')
+    expect(alerts.size).to eq(44)
+  end
+
+  it 'should handle empty alerts' do
+    json = File.read 'spec/fixtures/empty.json'
+    stub_alerts(json)
 
     alerts = Gull::Alert.fetch
     expect(alerts.size).to eq(0)
   end
 
-  it 'should handle missing cap section' do
-    xml = File.read 'spec/fixtures/missing_cap.xml'
+  it 'should handle missing onset time' do
+    feature = load_feature('missing_times.json')
+    stub_alerts(wrap_features(feature))
+
+    alert = Gull::Alert.fetch.first
+
+    expect(alert.effective_at).to be_nil
+    expect(alert.expires_at).to eq Time.parse('2026-03-07T08:15:00-06:00')
+    expect(alert.updated_at).to eq Time.parse('2026-03-07T07:48:00-06:00')
+    expect(alert.published_at).to eq Time.parse('2026-03-07T07:48:00-06:00')
+  end
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+  it 'should handle missing event' do
+    json = File.read 'spec/fixtures/missing_event.json'
+    stub_alerts(json)
 
     alerts = Gull::Alert.fetch
     expect(alerts.size).to eq 0

data/spec/client_spec.rb

@@ -1,45 +1,25 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Gull::Client do
-  it 'should initialize with options' do
-    xml = File.read 'spec/fixtures/alerts.xml'
-    stub_request(:get, 'http://test.url')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
-
-    options = { url: 'http://test.url', strict: true }
-    client = Gull::Client.new(options)
-    alerts = client.fetch
-    expect(alerts.size).to eq 3
-
-    xml = File.read 'spec/fixtures/bad.xml'
-    stub_request(:get, 'http://test.url')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+  it 'should fetch alerts' do
+    json = File.read 'spec/fixtures/alerts.json'
 
-    expect { client.fetch }
-      .to raise_error(Nokogiri::XML::SyntaxError)
-  end
-
-  it 'should fetch alerts without options' do
-    xml = File.read 'spec/fixtures/alerts.xml'
-
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_return(status: 200, body: json, headers: {})
 
     client = Gull::Client.new
     alerts = client.fetch
-    expect(alerts.size).to eq 3
+    expect(alerts.size).to eq 44
     expect(client.errors.size).to eq 0
   end
 
-  it 'should handle incomplete entries in xml' do
-    xml = File.read 'spec/fixtures/missing_cap.xml'
+  it 'should handle features with missing event' do
+    json = File.read 'spec/fixtures/missing_event.json'
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_return(status: 200, body: xml, headers: {})
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_return(status: 200, body: json, headers: {})
 
     client = Gull::Client.new
     alerts = client.fetch
@@ -47,41 +27,25 @@ describe Gull::Client do
     expect(client.errors.size).to eq 1
   end
 
-  it 'should raise own error if timeout occurs' do
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_timeout
+  it 'should raise error on non-success response' do
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_return(status: 503, body: '{"title":"Service Unavailable"}', headers: {})
 
-    message = 'Timeout while connecting to NWS web service'
     client = Gull::Client.new
-    expect { client.fetch }.to raise_error(Gull::TimeoutError, message)
+    expect { client.fetch }.to raise_error(Gull::HttpError, 'NWS API returned 503')
   end
 
-  it 'should raise own error if http errors occur' do
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_raise(HTTPClient::KeepAliveDisconnected)
-
-    message = 'Could not connect to NWS web service'
-    client = Gull::Client.new
-    expect { client.fetch }.to raise_error(Gull::HttpError, message) do |error|
-      expect(error.original).to be_a(HTTPClient::KeepAliveDisconnected)
-    end
-
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
-      .to_raise(HTTPClient::BadResponseError)
+  it 'should raise own error if timeout occurs' do
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_timeout
 
-    message = 'Could not connect to NWS web service'
+    message = 'Timeout while connecting to NWS web service'
     client = Gull::Client.new
-    expect { client.fetch }.to raise_error(Gull::HttpError, message) do |error|
-      expect(error.original).to be_a(HTTPClient::BadResponseError)
-    end
+    expect { client.fetch }.to raise_error(Gull::TimeoutError, message)
   end
 
   it 'should raise own error if connection errors occur' do
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
       .to_raise(SocketError)
 
     message = 'Could not connect to NWS web service'
@@ -90,24 +54,43 @@ describe Gull::Client do
       expect(error.original).to be_a(SocketError)
     end
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
       .to_raise(Errno::ECONNREFUSED)
 
-    message = 'Could not connect to NWS web service'
     client = Gull::Client.new
     expect { client.fetch }.to raise_error(Gull::HttpError, message) do |error|
       expect(error.original).to be_a(Errno::ECONNREFUSED)
     end
 
-    stub_request(:get, 'http://alerts.weather.gov/cap/us.php?x=1')
-      .with(headers: { 'Accept' => '*/*' })
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
       .to_raise(Errno::ECONNRESET)
 
-    message = 'Could not connect to NWS web service'
     client = Gull::Client.new
     expect { client.fetch }.to raise_error(Gull::HttpError, message) do |error|
       expect(error.original).to be_a(Errno::ECONNRESET)
     end
   end
+
+  it 'should raise error on malformed JSON response' do
+    stub_request(:get, 'https://api.weather.gov/alerts/active')
+      .to_return(status: 200, body: '<html>Bad Gateway</html>',
+                 headers: {})
+
+    client = Gull::Client.new
+    expect { client.fetch }
+      .to raise_error(Gull::HttpError, /Unexpected response/) do |e|
+        expect(e.original).to be_a(JSON::ParserError)
+      end
+  end
+
+  it 'should filter by area' do
+    json = File.read 'spec/fixtures/alerts.json'
+
+    stub_request(:get, 'https://api.weather.gov/alerts/active?area=OK')
+      .to_return(status: 200, body: json, headers: {})
+
+    client = Gull::Client.new(area: 'OK')
+    alerts = client.fetch
+    expect(alerts.size).to eq 44
+  end
 end

data/spec/error_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Gull::HttpError do
   it 'should instantiate and set original with current exception' do
     error = StandardError.new 'inner'
     begin
-      fail error
+      raise error
     rescue StandardError
       http_error = Gull::HttpError.new 'test'
       expect(http_error.original).to eq error
-      expect(http_error.original.message). to eq 'inner'
+      expect(http_error.original.message).to eq 'inner'
     end
   end
 end