weather_gov 0.1.0

data/lib/weather_gov/client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "weather_gov/office"
+require "weather_gov/observation_station"
+require "weather_gov/observation_station_collection"
+require "weather_gov/point"
+require "weather_gov/gridpoint"
+require "weather_gov/alert_collection"
+require "weather_gov/forecast"
+require "weather_gov/zone"
+require "weather_gov/product"
+require "weather_gov/product_list"
+
+module WeatherGov
+  class Client
+    attr_reader :api
+
+    def initialize(user_agent:)
+      @api = API.new(user_agent: user_agent)
+    end
+
+    def json_for(response)
+      return response.parsed_response unless response.parsed_response.include?("status")
+
+      raise response.parsed_response.fetch("title", "Unknown Error")
+    end
+
+    def stations(data: nil, uri: nil)
+      return ObservationStationCollection.new(client: self, data: data) if data
+      return ObservationStationCollection.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+
+      # In theory an "all stations" query is okay, but in practice it seems to time out.
+
+      raise ArgumentError, "data or uri parameter required"
+    end
+
+    def station(data: nil, uri: nil, id: nil)
+      return ObservationStation.new(client: self, data: data) if data
+      return ObservationStation.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+      return ObservationStation.new(client: self, data: -> { json_for(api.station(id: id)) }) if id
+
+      raise ArgumentError, "data or id parameter required"
+    end
+
+    def office(data: nil, uri: nil, id: nil)
+      return Office.new(client: self, data: data) if data
+      return Office.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+      return Office.new(client: self, data: -> { json_for(api.office(id: id)) }) if id
+
+      raise ArgumentError, "data, uri, or id parameter required"
+    end
+
+    def point(data: nil, uri: nil, lat: nil, lon: nil)
+      return Point.new(client: self, data: data) if data
+      return Point.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+      return Point.new(client: self, data: -> { json_for(api.point(lat: lat, lon: lon)) }) if lat && lon
+
+      raise ArgumentError, "data, uri, or lat and lon parameters required"
+    end
+
+    def gridpoint(data: nil, uri: nil)
+      return Gridpoint.new(client: self, data: data) if data
+      return Gridpoint.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+
+      raise ArgumentError, "data, uri, or lat and lon parameters required"
+    end
+
+    def alerts_active(data: nil, zone: nil, area: nil, region: nil)
+      return AlertCollection.new(client: self, data: data) if data
+
+      if zone || area || region
+        return AlertCollection.new(
+          client: self,
+          data: -> { json_for(api.alerts_active(zone: zone, area: area, region: region)) }
+        )
+      end
+
+      raise ArgumentError, "data, zone, area, or region parameter required"
+    end
+
+    def zone(data: nil, uri: nil, type: nil, id: nil)
+      return Zone.new(client: self, data: data) if data
+      return Zone.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+      return Zone.new(client: self, data: -> { json_for(api.zone(type: type, id: id)) }) if type && id
+
+      raise ArgumentError, "data, uri, or type and id parameter required"
+    end
+
+    def forecast(data: nil, uri: nil)
+      return Forecast.new(client: self, data: data) if data
+      return Forecast.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+
+      raise ArgumentError, "data or uri parameter required"
+    end
+
+    def products(data: nil, uri: nil, type: nil, location: nil)
+      return ProductList.new(client: self, data: data) if data
+      return ProductList.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+
+      if type && location
+        return ProductList.new(client: self, data: -> { json_for(api.products(type: type, location: location)) })
+      end
+
+      raise ArgumentError, "data, uri, or type and location parameters required"
+    end
+
+    def product(data: nil, uri: nil, id: nil)
+      return Product.new(client: self, data: data) if data
+      return Product.new(client: self, data: -> { json_for(api.get(uri: uri)) }) if uri
+      return Product.new(client: self, data: -> { json_for(api.product(id: id)) }) if id
+
+      raise ArgumentError, "data, uri, or id parameter required"
+    end
+  end
+end

data/lib/weather_gov/feature.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module WeatherGov
+  class Feature
+    attr_reader :client
+
+    def initialize(client:, data:)
+      @client = client
+      if data.respond_to?(:call)
+        @data_proc = data
+      else
+        @data = data
+      end
+    end
+
+    def data
+      @data ||= @data_proc.call
+    end
+
+    def context
+      data.fetch("@context", nil)
+    end
+
+    def id
+      data.fetch("id")
+    end
+
+    def type
+      data.fetch("type")
+    end
+
+    def geometry
+      data.fetch("geometry", nil)
+    end
+
+    def properties
+      data.fetch("properties", nil)
+    end
+  end
+end

data/lib/weather_gov/feature_collection.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "weather_gov/feature"
+require "forwardable"
+
+module WeatherGov
+  class FeatureCollection < Feature
+    extend Forwardable
+
+    def self.feature_class
+      Feature
+    end
+
+    def features
+      @features ||= data.fetch("features").map { |feature| self.class.feature_class.new(client: client, data: feature) }
+    end
+
+    def_delegators :features, :[], :size, :each, :first, :last, :map
+  end
+end

data/lib/weather_gov/forecast.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "weather_gov/forecast_period"
+
+module WeatherGov
+  class Forecast < Feature
+    def update_time
+      @update_time ||= Time.parse(properties.fetch("updateTime"))
+    end
+
+    def valid_time
+      @valid_time ||= ValidTime.parse(properties.fetch("validTimes"))
+    end
+
+    def valid?
+      valid_time.valid?
+    end
+
+    def periods
+      properties.fetch("periods").map { |period| ForecastPeriod.new(data: period) }
+    end
+
+    def current
+      periods.find { |p| (p.start_time...p.end_time).include?(Time.now) }
+    end
+  end
+end

data/lib/weather_gov/forecast_period.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module WeatherGov
+  class ForecastPeriod
+    attr_reader :data
+
+    def initialize(data:)
+      @data = data
+    end
+
+    def number
+      data.fetch("number")
+    end
+
+    def name
+      data.fetch("name")
+    end
+
+    def start_time
+      @start_time ||= Time.parse(data.fetch("startTime"))
+    end
+
+    def end_time
+      @end_time ||= Time.parse(data.fetch("endTime"))
+    end
+
+    def daytime?
+      data.fetch("isDaytime")
+    end
+
+    def temperature
+      data.fetch("temperature")
+    end
+
+    def temperature_unit
+      data.fetch("temperatureUnit")
+    end
+
+    def temperature_trend
+      data.fetch("temperatureTrend")
+    end
+
+    def wind_speed
+      data.fetch("windSpeed")
+    end
+
+    def wind_direction
+      data.fetch("windDirection")
+    end
+
+    def icon
+      data.fetch("icon")
+    end
+
+    def short_forecast
+      data.fetch("shortForecast")
+    end
+
+    def detailed_forecast
+      data.fetch("detailedForecast")
+    end
+  end
+end

data/lib/weather_gov/gridpoint.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "weather_gov/valid_duration_value"
+
+module WeatherGov
+  class Gridpoint < Feature
+    def update_time
+      @update_time ||= Time.parse(properties.fetch("updateTime"))
+    end
+
+    def forecast_office
+      @forecast_office ||= Identifier::Office.new(properties.fetch("forecastOffice"))
+    end
+
+    def temperature_unit
+      @temperature_unit ||= properties.dig("temperature", "uom").split(":").last
+    end
+
+    def temperature
+      @temperature ||= properties.dig("temperature", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: temperature_unit)
+      end
+    end
+
+    def dewpoint_unit
+      @dewpoint_unit ||= properties.dig("dewpoint", "uom").split(":").last
+    end
+
+    def dewpoint
+      @dewpoint ||= properties.dig("dewpoint", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: dewpoint_unit)
+      end
+    end
+
+    def min_temperature_unit
+      @min_temperature_unit ||= properties.dig("minTemperature", "uom").split(":").last
+    end
+
+    def min_temperature
+      @min_temperature ||= properties.dig("minTemperature", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: min_temperature_unit)
+      end
+    end
+
+    def max_temperature_unit
+      @max_temperature_unit ||= properties.dig("maxTemperature", "uom").split(":").last
+    end
+
+    def max_temperature
+      @max_temperature ||= properties.dig("maxTemperature", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: max_temperature_unit)
+      end
+    end
+
+    def apparent_temperature_unit
+      @apparent_temperature_unit ||= properties.dig("apparentTemperature", "uom").split(":").last
+    end
+
+    def apparent_temperature
+      @apparent_temperature ||= properties.dig("apparentTemperature", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: apparent_temperature_unit)
+      end
+    end
+
+    def relative_humidity_unit
+      @relative_humidity_unit ||= properties.dig("relativeHumidity", "uom").split(":").last
+    end
+
+    def relative_humidity
+      @relative_humidity ||= properties.dig("relativeHumidity", "values").map do |data|
+        ValidDurationValue.new(data: data, unit: relative_humidity_unit)
+      end
+    end
+  end
+end

data/lib/weather_gov/identifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module WeatherGov
+  class Identifier
+    attr_reader :uri
+
+    def self.parse(uri)
+      TYPES.each do |type|
+        return type.new(uri) if uri.start_with?(type.base_uri)
+      end
+
+      nil
+    end
+
+    def self.base_uri
+      API_BASE_URI
+    end
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def to_s
+      id
+    end
+
+    def id
+      uri.sub(/^#{self.class.base_uri}/, "")
+    end
+  end
+end
+
+require "weather_gov/identifier/alert"
+require "weather_gov/identifier/county_zone"
+require "weather_gov/identifier/fire_zone"
+require "weather_gov/identifier/forecast_zone"
+require "weather_gov/identifier/gridpoint"
+require "weather_gov/identifier/office"
+require "weather_gov/identifier/point"
+require "weather_gov/identifier/problem"
+require "weather_gov/identifier/station"
+
+module WeatherGov
+  class Identifier
+    TYPES = constants.map { |c| const_get(c) }.select { |c| c.superclass == self }
+  end
+end

data/lib/weather_gov/identifier/alert.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "weather_gov/identifier"
+
+module WeatherGov
+  class Identifier
+    class Alert < Identifier
+      def self.base_uri
+        URI.join(super, "/alerts/").to_s
+      end
+    end
+  end
+end

data/lib/weather_gov/identifier/county_zone.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "weather_gov/identifier"
+
+module WeatherGov
+  class Identifier
+    class CountyZone < Identifier
+      def self.base_uri
+        URI.join(super, "/zones/county/").to_s
+      end
+    end
+  end
+end

data/lib/weather_gov/identifier/fire_zone.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "weather_gov/identifier"
+
+module WeatherGov
+  class Identifier
+    class FireZone < Identifier
+      def self.base_uri
+        URI.join(super, "/zones/fire/").to_s
+      end
+    end
+  end
+end

data/lib/weather_gov/identifier/forecast_zone.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "weather_gov/identifier"
+
+module WeatherGov
+  class Identifier
+    class ForecastZone < Identifier
+      def self.base_uri
+        URI.join(super, "/zones/forecast/").to_s
+      end
+    end
+  end
+end