stormglass 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82b85c3b145480cb967b4138502dff4b3459c959
+  data.tar.gz: 263aa703403641202b4b7bbeec493012439af742
+SHA512:
+  metadata.gz: '09229ef4fda64e6b36c9ee45d7483b1d41eee15b002c725a526bd7e5be99d61f3d3d508aa2e0d95660833c36c02805f0d9114490d9b90fda8de6c2b56af12651'
+  data.tar.gz: 7a0bbedde8f5df9ecabfcf2f8b2bac33adc00765edddeb50c2344e89acbc628868b262f656c755a8388747a670398079f71b1063a484f19116956f22319d31a3

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-version

@@ -0,0 +1 @@
+2.4.2

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.4
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in stormglass.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    Stormglass (0.1.0)
+      geocoder
+      rest-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    domain_name (0.5.20180417)
+      unf (>= 0.0.5, < 1.0.0)
+    geocoder (1.5.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.2.2)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2018.0812)
+    minitest (5.10.3)
+    netrc (0.11.0)
+    rake (10.5.0)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  Stormglass!
+  bundler (~> 1.16)
+  minitest (~> 5.3)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Russell Jennings
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# Stormglass
+
+Ruby gem for access to the [Stormglass](https://stormglass.io/) Weather forecast API.
+
+# Overview
+
+This gem augments the Stormglass API responses to make consuming the API more accessible for ruby developers.
+
+- Provides weather lookup for address and lat/lng
+- Provides units and descriptions for all forecast types (from API docs)
+- Specify start/end as DateTime
+- specify `hours` to calcuate end offset from start (default 12)
+- Creates alternative representations of values (such as Fahrenheit, or knots)
+- Specify default units and sources via `Stormglass.configure` block, or override at method invocation
+
+For more information, visit [Stormglass API docs](https://docs.stormglass.io/)
+
+*Note: this gem currently only implements the `point` API endpoint. Accepting pull requests!*
+
+# Installation
+
+```
+gem install stormglass
+```
+
+or in your gemfile
+
+```
+gem 'stormglass'
+```
+
+# API Key
+
+To use Stormglass you'll need to provide an API key, which can be configured a number of ways:
+
+1. Enviroment variable `STORMGLASS_API_KEY`
+2. within a `Stormglass.configure` block (more on that below)
+3. with Rails secret `stormglass_api_key`
+4. at request invocation by passing `key`
+
+# Configuration
+
+You can configure the gem with the following block
+```
+Stormglass.configure do |config|
+  config.units = {air_temperature: 'F', gust: 'knot'}
+  config.api_key = 'abcd-abcd-abcd'
+  config.source = 'sg'
+end
+```
+
+# Walkthrough
+
+First, let's query the stormglass API for an address. This will look up via `Geocoder` and then call `Stormglass.for_lat_lng` for us with the first result.
+```
+response = Stormglass.for_address('123 broad street philadelphia pa', hours: 24)
+=> #<Stormglass::Response remaining_requests=31,
+hours=[#<Stormglass::Hour time='2018-12-12 21:00:00 +0000'> ...]>
+```
+The methods we can call are underscored variants of what the camelCaps API returns. Taken from `stormglass/hour.rb`
+```
+ VALUES = [:air_temperature,:cloud_cover,:current_direction,:current_speed,:gust,:humidity,
+            :precipitation,:pressure,:sea_level,:swell_direction,:swell_height,:swell_period,
+            :visibility,:water_temperature,:wave_direction,:wave_height,:wave_period,
+            :wind_direction,:wind_speed,:wind_wave_direction,:wind_wave_height,:wind_wave_period]
+```
+Let's see the first hour's air_temperature.
+```
+response.hours.first.air_temperature
+=> #<Stormglass::Value value=44.91, unit='C', description='Air temperature as degrees Celsius',
+unit_type='C', unit_types=["C", "F"], data_source='sg',
+data_sources=["sg", "dwd", "noaa", "wrf"]>
+```
+we can also call `response.first.air_temperature` or even `response.air_temperature` and it will defer to the first hour result.
+
+But what if we don't want the first hour? In addition to calling `response.hours.select{...}`, you can use `#find` with your local timezone and it will convert to UTC for lookup
+```
+response.find('7AM EST').air_temperature
+=> #<Stormglass::Value value=44.91, unit='C', description='Air temperature as degrees Celsius',
+unit_type='C', unit_types=["C", "F"], data_source='sg', data_sources=["sg", "dwd", "noaa", "wrf"]>
+```
+we can work with the `response.find('7AM EST').air_temperature.value` directly (a Float), or call `to_s` for a pretty string
+
+```
+response.air_temperature.to_s
+=> "4.91 C"
+```
+
+What if we want air temperature in Fahrenheit instead? No need to whip out the calculator, we've
+got you covered!
+
+```
+response.air_temperature(unit_type: 'F')
+=> #<Stormglass::Value value=44.91, unit='F', description='Air temperature as degrees Fahrenheit',
+unit_type='F', unit_types=["C", "F"], data_source='sg', data_sources=["sg", "dwd", "noaa", "wrf"]>
+```
+
+Or we can reference a different data source than the default
+```
+response.air_temperature(unit_type: 'F', data_source: 'noaa')
+=> #<Stormglass::Value value=45.33, unit='F', description='Air temperature as degrees Fahrenheit',
+unit_type='F', unit_types=["C", "F"], data_source='noaa', data_sources=["sg", "dwd", "noaa", "wrf"]>
+```
+
+# Structure
+
+There are a few primary classes involved:
+1. `Stormglass::Response` represents the result from stormglass, wrapping `hours` and `meta` responses.
+Calling something like `#air_temperature` on this delegates to `#hours.first`
+2. `Stormglass::Hour` represents an hour portion of the API response
+3. `Stormglass::Value` represents a particular forecast value. along with the numeric `value` it also exposes
+the `description` and `unit` used. It is just a wrapper to the collection of `Stormglass::Subvalue`'s and defers to the preferred/specified one.
+4. `Stormglass::Subvalue` represents a particular variant of forecast value, such as `air_temperature` in Celsius or in Fahrenheit.
+
+For any of the above instances, you can call `#src` to access the raw (usually JSON) data that was passed in to populate it.
+
+Because each forecast type has different sources and units, `Stormglass::Value` instances exposes the progmatic
+available options `data_sources` and `unit_types` you can reference for alternatives to provide.
+
+```
+response.air_temperature(unit_type: 'C')
+=> #<Stormglass::Value value=7.17, unit='C', description='Air temperature as degrees Celsius',
+unit_type='C', unit_types=["C", "F"], data_source='sg', data_sources=["sg", "dwd", "noaa", "wrf"]>
+
+response.air_temperature(unit_type: 'C', data_source: 'wrf')
+=> #<Stormglass::Value value=8.34, unit='C', description='Air temperature as degrees Celsius',
+unit_type='C', unit_types=["C", "F"], data_source='noaa', data_sources=["sg", "dwd", "noaa", "wrf"]>
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "stormglass"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/stormglass.rb

@@ -0,0 +1,103 @@
+require "stormglass/version"
+require 'restclient'
+require 'date'
+require 'json'
+require 'forwardable'
+require 'geocoder'
+require 'stormglass/configuration'
+require 'stormglass/hour'
+require 'stormglass/response'
+require 'stormglass/string'
+require 'stormglass/result_dict'
+require 'stormglass/value'
+require 'stormglass/subvalue'
+require 'stormglass/alternate_values'
+
+Dir[File.join(__dir__, 'stormglass', 'alternate_values', '*.rb')].each { |file| require file }
+
+
+module Stormglass
+  class Error < StandardError; end
+  class ConnectionError < StandardError; end
+  class ExceededLimitError < StandardError; end
+
+
+  class << self
+    attr_accessor :settings
+
+    def configure
+      self.settings ||= Configuration.new
+      yield(settings)
+    end
+
+    def set_settings
+      self.settings = Configuration.new
+    end
+  end
+
+  # lookup an address (such as city + zip) and get the coordinates for the first match
+  def self.for_address(address_string, params={})
+    if results = Geocoder.search(address_string)
+      lat,lng = results.first.coordinates
+      self.for_lat_lng(lat: lat, lng: lng, params: params)
+    else
+      raise Error, 'Could not find address'
+    end
+  end
+
+  # query StormGlass given lat/lng.
+  # params:
+  #  :lat - dateTime (default Now)
+  #  :lng - Datetime (default 12 hours from :start)
+  #  :params - additional params available to self.reqest
+  def self.for_lat_lng(lat:, lng:, params: {})
+    self.request(params: {lat: lat, lng: lng}.merge(params))
+  end
+
+  # Primary interface to StormGlass.
+  # params:
+  #  :start - dateTime (default Now)
+  #  :end - Datetime (default 12 hours from :start)
+  #  :hours - number of hours to determine end (default 12)
+  #  :key - API key (default to api_key method )
+  def self.request(endpoint: 'point', params: {})
+    hours = (params.delete(:hours) || 11) - 1
+    params[:key] ||= api_key
+    params[:start] ||= DateTime.now
+    params[:end] ||= hours_offset(params[:start], hours)
+    params[:start] = query_time_string(params[:start])
+    params[:end] = query_time_string(params[:end])
+    key = params.delete(:key)
+    begin
+      body = RestClient.get("https://api.stormglass.io/#{endpoint}", {params: params,  'Authorization' => key}).body
+    rescue SocketError => msg
+      puts msg
+      raise ConnectionError, 'error connecting to stormglass'
+    rescue RestClient::PaymentRequired => msg
+      puts msg
+      raise ExceededLimitError, 'exceeded limit. payment required for additional daily requests'
+    end
+    Stormglass::Response.new(body)
+  end
+
+  # API key for stormglass. key is sourced:
+  # - if set via enviroment variable
+  # - if set in configuration block
+  # - if defined in Rails secrets
+  # - when passed directly to parameters
+  def self.api_key
+    key = Stormglass.settings.api_key
+    key ||= Rails.application.secrets[:stormglass_api_key] if Gem.loaded_specs.has_key?('rails')
+    key
+  end
+
+  def self.hours_offset(start_time, hours=12)
+    (start_time + (Rational(1,24) * hours))
+  end
+
+  def self.query_time_string(datetime)
+    datetime.new_offset(0).iso8601
+  end
+
+end
+Stormglass.set_settings

data/lib/stormglass/alternate_values.rb

@@ -0,0 +1,32 @@
+class Stormglass::AlternateValues
+
+  def self.perform(subvalues)
+    @original = subvalues.first
+    case subvalues.first[:unit_type]
+      when "Ms" then self::MetersSec.perform(subvalues)
+      when "M"  then self::Meters.perform(subvalues)
+      when "C" then self::Celsius.perform(subvalues)
+      when "Km" then self::Kilometers.perform(subvalues)
+      when 'Kgm2' then self::Kgm2.perform(subvalues)
+      when 'Deg' then self::Degrees.perform(subvalues)
+    end
+  end
+
+  def self.meters_sec(subvalues)
+
+  end
+
+  def self.meters(subvalues)
+
+  end
+
+  def self.c(subvalues)
+
+  end
+
+  def self.km(subvalues)
+
+  end
+
+
+end

data/lib/stormglass/alternate_values/celsius.rb

@@ -0,0 +1,13 @@
+class Stormglass::AlternateValues::Celsius
+
+  def self.perform(subvalues)
+    inject_fahrenheit(subvalues)
+  end
+
+  private
+
+  def self.inject_fahrenheit(subvalues)
+    subvalues << {unit_type: 'F', value: (subvalues.first[:value] * 1.8 + 32).round(2), unit: 'F', description: subvalues.first[:description], unit_description: 'degrees Fahrenheit'}
+  end
+
+end

data/lib/stormglass/alternate_values/degrees.rb

@@ -0,0 +1,16 @@
+class Stormglass::AlternateValues::Degrees
+
+  POINTS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW']
+
+  def self.perform(subvalues)
+    inject_compass_points(subvalues)
+  end
+
+  private
+
+  def self.inject_compass_points(subvalues)
+    compass_point = Geocoder::Calculations.compass_point(subvalues.first[:value], POINTS)
+    subvalues << {unit_type: 'compass', value: compass_point, unit: '', description: subvalues.first[:description], unit_description: 'From 16 shorthand compass points'}
+  end
+
+end

data/lib/stormglass/alternate_values/kgm2.rb

@@ -0,0 +1,12 @@
+class Stormglass::AlternateValues::Kgm2
+
+  def self.perform(subvalues)
+    inject_inches(subvalues)
+  end
+
+  private
+
+  def self.inject_inches(subvalues)
+    subvalues << {unit_type: 'inches', unit: 'in', value: (subvalues.first[:value] * 0.039370).round(2), description: subvalues.first[:description], unit_description: 'inches'}
+  end
+end

data/lib/stormglass/alternate_values/kilometers.rb

@@ -0,0 +1,12 @@
+class Stormglass::AlternateValues::Kilometers
+
+  def self.perform(subvalues)
+    inject_miles(subvalues)
+  end
+
+  private
+
+  def self.inject_miles(subvalues)
+    subvalues << {unit_type: 'miles', unit: 'mi', value: (subvalues.first[:value] / 1.609344).round(2), description: subvalues.first[:description], unit_description: 'miles'}
+  end
+end

data/lib/stormglass/alternate_values/meters.rb

@@ -0,0 +1,12 @@
+class Stormglass::AlternateValues::Meters
+
+  def self.perform(subvalues)
+    inject_feet(subvalues)
+  end
+
+  private
+
+  def self.inject_feet(subvalues)
+    subvalues << {unit_type: 'feet', unit: 'ft', value: (subvalues.first[:value] / 0.3048).round(2), description: subvalues.first[:description], unit_description: 'feet'}
+  end
+end

data/lib/stormglass/alternate_values/meters_sec.rb

@@ -0,0 +1,17 @@
+class Stormglass::AlternateValues::MetersSec
+
+  def self.perform(subvalues)
+    inject_knots(subvalues)
+    inject_mph(subvalues)
+  end
+
+  private
+
+  def self.inject_knots(subvalues)
+    subvalues << {unit_type: 'knot', unit: 'Kn', value: (subvalues.first[:value] * 1.9438445).round(2), description: subvalues.first[:description], unit_description: 'nautical knots'}
+  end
+
+  def self.inject_mph(subvalues)
+    subvalues << {unit_type: 'MPH', unit: 'MPH', value: (subvalues.first[:value] * 2.236936).round(2), description: subvalues.first[:description], unit_description: 'miles per hour'}
+  end
+end

data/lib/stormglass/configuration.rb

@@ -0,0 +1,9 @@
+class Configuration
+  attr_accessor :units, :api_key, :source
+
+  def initialize
+    @units = {}
+    @api_key = ENV['STORMGLASS_API_KEY']
+    @source = 'sg'
+  end
+end

data/lib/stormglass/hour.rb

@@ -0,0 +1,61 @@
+# represents an hour result from Stormglass
+# VALUES represent callable methods
+class Stormglass::Hour
+
+  VALUES = [:air_temperature,:cloud_cover,:current_direction,:current_speed,:gust,:humidity,
+            :precipitation,:pressure,:sea_level,:swell_direction,:swell_height,:swell_period,
+            :visibility,:water_temperature,:wave_direction,:wave_height,:wave_period,
+            :wind_direction,:wind_speed,:wind_wave_direction,:wind_wave_height,:wind_wave_period]
+
+  def initialize(src)
+    @src = src
+  end
+
+  def src
+    @src
+  end
+
+  def time
+    Time.parse(src["time"])
+  end
+
+  def values
+    src.keys.collect(&:underscore)
+  end
+
+  def method_missing(method, *args)
+    if VALUES.include?(method)
+      get_value(method, args)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    VALUES.include?(method_name) || super
+  end
+
+  def inspect
+    "#<#{self.class.to_s} time='#{time}'> "
+  end
+
+  # handler for each VALUES method (such as air_temperature)
+  # takes two optional arguments:
+  # data_source: - data source to use. (default 'sg')
+  # unit_type:   - preferred unit type (default API result)
+  def get_value(attribute,args)
+    vals = fetch_value(args.first ? {attribute: attribute}.merge(args.first) : {attribute: attribute})
+    @src.keys.collect(&:underscore).zip(vals).to_h[attribute.to_s]
+  end
+
+  def fetch_value(data_source: nil, attribute:, unit_type: nil)
+    data_source ||= Stormglass.settings.source
+    @src.values.collect do |val|
+      if val.is_a?(String)
+        val
+      else
+        Stormglass::Value.new(attribute, val, data_source, unit_type)
+      end
+    end
+  end
+end

data/lib/stormglass/response.rb

@@ -0,0 +1,52 @@
+# Responses from Stormglass API are wrapped in this class
+class Stormglass::Response
+  extend Forwardable
+
+  # convenience delegate calls (like air_temperature)
+  # to the first hour returned
+  def_delegators :first, *Stormglass::Hour::VALUES
+
+
+  def initialize(src)
+    @src = JSON.parse(src)
+  end
+
+  # an array of Stormglass::Hour instances
+  def hours
+    @hours ||= []
+    return @hours if !@hours.empty?
+    src['hours'].each{|h| @hours << Stormglass::Hour.new(h) }
+    @hours
+  end
+
+  def src
+    @src
+  end
+
+  def inspect
+    string = '#<' + "#{self.class.to_s} remaining_requests=#{remaining_requests}, "
+    string +="hours=#{hours.to_s}> "
+    string
+  end
+
+  def first
+    hours.first
+  end
+
+  def last
+    hours.last
+  end
+
+  # takes a string like "7PM EST" and returns the relevant hour if found
+  def find(string)
+    hours.find{|h| h.time == Time.parse(string)}
+  end
+
+  def meta
+    src['meta']
+  end
+
+  def remaining_requests
+     meta['dailyQuota'] - meta['requestCount']
+  end
+end

data/lib/stormglass/result_dict.rb

@@ -0,0 +1,29 @@
+module Stormglass
+
+RESULT_DICT= {
+  :air_temperature    =>{:unit_type => "C",     :unit=>"C",      :description=>"Air temperature as",                         :unit_description =>"degrees Celsius"},
+  :air_pressure       =>{:unit_type => "hPa",   :unit=>"hPa",    :description=>"Air pressure as",                            :unit_description =>"hectopascal"},
+  :cloud_cover        =>{:unit_type => "%",     :unit=>"%",      :description=>"Total cloud coverage as",                    :unit_description =>"percent"},
+  :current_direction  =>{:unit_type => "Deg",   :unit=>"°",      :description=>"Direction of current",                       :unit_description =>"0° indicates coming from north"},
+  :current_speed      =>{:unit_type => "Ms",    :unit=>"M/s",    :description=>"Speed of current as",                        :unit_description =>"meters per second"},
+  :gust               =>{:unit_type => "Ms",    :unit=>"M/s",    :description=>"Wind gust as",                               :unit_description =>"meters per second"},
+  :humidity           =>{:unit_type => "%",     :unit=>"%",      :description=>"Relative humidity as",                       :unit_description => "percent"},
+  :ice_cover          =>{:unit_type => "/1",    :unit=>"/1",     :description=>"Proportion",                                 :unit_description=> "over 1"},
+  :precipitation      =>{:unit_type => "Kgm2",  :unit=>"kg/m²",  :description=>"Mean precipitation as",                      :unit_description => "kilogram per square meter"},
+  :sea_level          =>{:unit_type => "M",     :unit=>"M",      :description=>"Height of sea level as",                     :unit_description =>"meters"},
+  :snow_depth         =>{:unit_type => "M",     :unit=>"M",      :description=>"Depth of snow as",                           :unit_description =>"meters"},
+  :swell_direction    =>{:unit_type => "Deg",   :unit=>"°",      :description=>"Direction of swell waves.",                  :unit_description => "0° indicates coming from north"},
+  :swell_height       =>{:unit_type => "M",     :unit=>"M",      :description=>"Height of swell waves as",                   :unit_description =>"meters"},
+  :swell_period       =>{:unit_type => "Sec",   :unit=>"s",      :description=>"Period of swell waves as",                   :unit_description =>"seconds"},
+  :visibility         =>{:unit_type => "Km",    :unit=>"km",     :description=>"Horizontal visibility as",                   :unit_description =>"Kilometer"},
+  :water_temperature  =>{:unit_type => "C",     :unit=>"C",      :description=>"Water temperature as",                       :unit_description =>"degrees Celsius"},
+  :wave_direction     =>{:unit_type => "Deg",   :unit=>"°",      :description=>"Direction of combined wind and swell waves.",:unit_description => "0° indicates coming from north"},
+  :wave_height        =>{:unit_type => "M",     :unit=>"M",      :description=>"Height of combined wind and swell waves as", :unit_description =>"meters"},
+  :wave_period        =>{:unit_type => "Sec",   :unit=>"s",      :description=>"Period of combined wind and swell waves as", :unit_description =>"seconds"},
+  :wind_wave_direction=>{:unit_type => "Deg",   :unit=>"°",      :description=>"Direction of wind waves.",                   :unit_description => "0° indicates coming from north"},
+  :wind_wave_height   =>{:unit_type => "M",     :unit=>"M",      :description=>"Height of wind waves as",                    :unit_description =>"meters"},
+  :wind_wave_period   =>{:unit_type => "Sec",   :unit=>"s",      :description=>"Period of wind waves as",                    :unit_description =>"seconds"},
+  :wind_direction     =>{:unit_type => "Deg",   :unit=>"°",      :description=>"Direction of wind.",                         :unit_description => "0° indicates coming from north"},
+  :wind_speed         =>{:unit_type => "Ms",    :unit=>"M/s",    :description=>"Speed of wind as",                           :unit_description =>"meters per second"}
+}
+end

data/lib/stormglass/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/stormglass/subvalue.rb

@@ -0,0 +1,21 @@
+class Stormglass::Subvalue < OpenStruct
+
+  def initialize(src)
+    @src = src
+    super
+  end
+
+  def to_s
+    "#{@src[:value]} #{@src[:unit]}"
+  end
+
+
+  def description
+    "#{@src[:description]} #{@src[:unit_description]}"
+  end
+
+  def src
+    @src
+  end
+
+end

data/lib/stormglass/value.rb

@@ -0,0 +1,78 @@
+# represents a value for a stormglass prediction source with prefered unit_type
+# contains a collection of Stormglass::Subvalue's, which represent a particular unit of measurement
+# for example, a Stormglass::Value for air_temperature would have Stormglass::Subvalue's for Celsius and Fahrenheit
+class Stormglass::Value
+   extend Forwardable
+
+  def_delegators :preffered_subvalue, :unit, :unit_type, :description, :unit_description
+
+
+  def initialize(attribute, src, data_source, unit_type)
+    @attribute = attribute
+    @src = src
+    @data_source = data_source
+    @unit_type = unit_type
+  end
+
+  def data_source
+    @data_source
+  end
+
+  def for_source
+    @src.collect do |v|
+      v['value'] if (!v['source'].nil? && v['source'] == data_source)
+    end.compact.first
+  end
+
+  # returns the sources available for this value
+  def data_sources
+    src.collect{|v| v['source']}
+  end
+
+  def to_s
+    preffered_subvalue.to_s
+  end
+
+  def attribute
+    @attribute
+  end
+
+  def src
+    @src
+  end
+
+  def inspect
+    string = "#<#{self.class.to_s} "
+    string +="value=#{preffered_subvalue.value}, unit='#{preffered_subvalue.unit}', description='#{preffered_subvalue.description}', "
+    string +="unit_type='#{preffered_subvalue.unit_type}', unit_types=#{unit_types.to_s}, data_source='#{@data_source}', data_sources=#{data_sources}>"
+    string
+  end
+
+  def unit_types
+    subvalues.collect(&:unit_type)
+  end
+
+  def preffered_subvalue
+    if @unit_type
+      subvalues.find{|subvalue| subvalue.unit_type == @unit_type}
+    elsif setting_key = Stormglass.settings.units[@attribute]
+      subvalues.find{|subvalue| subvalue.unit_type == setting_key}
+    else
+      subvalues.first
+    end
+  end
+
+  def dict
+    Stormglass::RESULT_DICT[attribute]
+  end
+
+  def subvalues
+    subvals = []
+    raw_val = for_source()
+    subvals << {value: raw_val}.merge(dict)
+    Stormglass::AlternateValues.perform(subvals)
+    subvals.collect{|subvalue| Stormglass::Subvalue.new(subvalue) }
+  end
+
+
+end

data/lib/stormglass/version.rb

@@ -0,0 +1,3 @@
+module Stormglass
+  VERSION = "0.1.1"
+end

data/stormglass.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "stormglass/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "stormglass"
+  spec.version       = Stormglass::VERSION
+  spec.authors       = ["Russell Jennings"]
+  spec.email         = ["violentpurr@gmail.com"]
+
+  spec.summary       = %q{Ruby client for the Stormglass weather API}
+  spec.homepage      = "https://github.com/meesterdude/stormglass"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+
+  spec.add_dependency("rest-client")
+  spec.add_dependency("geocoder")
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.3"
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: stormglass
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Russell Jennings
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: geocoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+description: 
+email:
+- violentpurr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/stormglass.rb
+- lib/stormglass/alternate_values.rb
+- lib/stormglass/alternate_values/celsius.rb
+- lib/stormglass/alternate_values/degrees.rb
+- lib/stormglass/alternate_values/kgm2.rb
+- lib/stormglass/alternate_values/kilometers.rb
+- lib/stormglass/alternate_values/meters.rb
+- lib/stormglass/alternate_values/meters_sec.rb
+- lib/stormglass/configuration.rb
+- lib/stormglass/hour.rb
+- lib/stormglass/response.rb
+- lib/stormglass/result_dict.rb
+- lib/stormglass/string.rb
+- lib/stormglass/subvalue.rb
+- lib/stormglass/value.rb
+- lib/stormglass/version.rb
+- stormglass.gemspec
+homepage: https://github.com/meesterdude/stormglass
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Ruby client for the Stormglass weather API
+test_files: []