lita-onewheel-forecast-io 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3dbf02360cbc737e4e2a5b496143ea702619dcd8
+  data.tar.gz: e840358c5319946eef3de1fac1b9841a8be18f41
+SHA512:
+  metadata.gz: 2a035aca2c39995766079cd2d4e0ae7fed07ca2b7a901dac531542708301afc25d33bbaa7e72d4110d89d5f2ca4900fc7c6caf376f087d07fddb631dd9bef508
+  data.tar.gz: 085c4b590e1f0f3833e85dfaf668642c71752d69dda1b82bf12689c9a30143a452a0495c51afea0ece4aea519ba93677b1f94e4886b5f29ed2ab9a7aaca37c7d

data/.gitignore

@@ -0,0 +1,19 @@
+.idea
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lita_config.rb

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.1.5
+  - 2.0.0
+script: bundle exec rake
+sudo: false
+before_install:
+  - gem update --system
+services:
+  - redis-server
+notifications:
+  email:
+    - andrew.kreps@gmail.com

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Andrew Kreps
+
+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,37 @@
+# lita-onewheel-forecast-io
+
+[![Build Status](https://travis-ci.org/onewheelskyward/lita-onewheel-forecast-io.png?branch=master)](https://travis-ci.org/onewheelskyward/lita-onewheel-forecast-io)
+[![Coverage Status](https://coveralls.io/repos/onewheelskyward/lita-onewheel-forecast-io/badge.svg)](https://coveralls.io/r/onewheelskyward/lita-onewheel-forecast-io)
+[![Documentation Status](https://readthedocs.org/projects/lita-onewheel-forecast-io/badge/?version=latest)](https://readthedocs.org/projects/lita-onewheel-forecast-io/?badge=latest)
+
+This Lita handler takes location-based queries and returns interesting data about the weather.  Temperatures, rain chance and intensity, and wind speeds are all included.  But wait, there's more!  if you download now, you also get 8-ball style replies with `!rain` and `!snow`!
+
+## Installation
+
+Add lita-onewheel-forecast-io to your Lita instance's Gemfile, from github since it's currently unpublished:
+
+``` ruby
+gem 'lita-onewheel-forecast-io', github: 'onewheelskyward/lita-onewheel-forecast-io', branch: :master
+```
+
+## Configuration
+
+``` ruby
+Lita.configure do |config|
+  config.handlers.onewheel_forecast_io.api_key = 'yourforecastiokey'
+  config.handlers.onewheel_forecast_io.api_uri = 'https://api.forecast.io/forecast/'
+  config.handlers.onewheel_forecast_io.colors = true
+end
+```
+Register at https://developer.forecast.io/ to receive an API key (1000 calls/day for free). Once you have your key go ahead and toss if into your config block. Set colors to bool option of your liking. Enjoy!
+
+## Usage
+
+!rain, !snow and other fine things.
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)
+
+# hmm
+	☀ ☀ 🔥 🔥 ☼  ☼  ☼

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita-onewheel-forecast-io.rb

@@ -0,0 +1,7 @@
+require 'lita'
+
+Lita.load_locales Dir[File.expand_path(
+  File.join('..', '..', 'locales', '*.yml'), __FILE__
+)]
+
+require 'lita/handlers/onewheel_forecast_io'

data/lib/lita/handlers/constants.rb

@@ -0,0 +1,137 @@
+module ForecastIo
+  module Constants
+    def scale
+      'f'
+    end
+
+    def ansi_chars
+      %w[_ ▁ ▃ ▅ ▇ █]   # Thx, agj #pdxtech
+    end
+
+    def ozone_chars
+      %w[・ o O @ ◎ ◉]
+    end
+
+    def ascii_chars
+      %w[_ . - ~ * ']
+    end
+
+    # Based on the chance of precipitation.
+    def get_rain_range_colors
+      { 0..0.10    => :blue,
+        0.11..0.20 => :purple,
+        0.21..0.30 => :teal,
+        0.31..0.40 => :green,
+        0.41..0.50 => :lime,
+        0.51..0.60 => :aqua,
+        0.61..0.70 => :yellow,
+        0.71..0.80 => :orange,
+        0.81..0.90 => :red,
+        0.91..1    => :pink
+      }
+    end
+
+    # Based on the precipIntensity field, tested mostly on Portland data.  YIMV.
+    def get_rain_intensity_range_colors
+      { 0..0.0050      => :blue,
+        0.0051..0.0100 => :purple,
+        0.0101..0.0130 => :teal,
+        0.0131..0.0170 => :green,
+        0.0171..0.0220 => :lime,
+        0.0221..0.0280 => :aqua,
+        0.0281..0.0330 => :yellow,
+        0.0331..0.0380 => :orange,
+        0.0381..0.0430 => :red,
+        0.0431..5      => :pink
+      }
+    end
+
+    # Based on the temp in F.
+    def get_temp_range_colors
+      # Absolute zero?  You never know.
+      { -459.7..24.99 => :blue,
+        25..31.99     => :purple,
+        32..38        => :teal,
+        38..45        => :green,
+        45..55        => :lime,
+        55..65        => :aqua,
+        65..75        => :yellow,
+        75..85        => :orange,
+        85..95        => :red,
+        95..99.999    => :brown,
+        100..159.3    => :pink
+      }
+    end
+
+    # Based on the wind ground speed in mph.
+    def get_wind_range_colors
+      {   0..3    => :blue,
+          3..6    => :purple,
+          6..9    => :teal,
+          9..12   => :aqua,
+          12..15  => :yellow,
+          15..18  => :orange,
+          18..21  => :red,
+          21..999 => :pink,
+      }
+    end
+
+    # Based on the chance of sun.
+    def get_sun_range_colors
+      { 0..0.20    => :green,
+        0.21..0.50 => :lime,
+        0.51..0.70 => :orange,
+        0.71..1    => :yellow
+      }
+    end
+
+    # Based on the percentage of relative humidity.
+    def get_humidity_range_colors
+      {   0..0.12    => :blue,
+          0.13..0.25 => :purple,
+          0.26..0.38 => :teal,
+          0.39..0.5  => :aqua,
+          0.51..0.63 => :yellow,
+          0.64..0.75 => :orange,
+          0.76..0.88 => :red,
+          0.89..1    => :pink,
+      }
+    end
+
+    # IRC colors.
+    def colors
+      { :white  => '00',
+        :black  => '01',
+        :blue   => '02',
+        :green  => '03',
+        :red    => '04',
+        :brown  => '05',
+        :purple => '06',
+        :orange => '07',
+        :yellow => '08',
+        :lime   => '09',
+        :teal   => '10',
+        :aqua   => '11',
+        :royal  => '12',
+        :pink   => '13',
+        :grey   => '14',
+        :silver => '15'
+      }
+    end
+
+    # I have no use for these yet, and yet they're handy to know.
+    # def attributes
+    #   { :bold       => 2.chr,
+    #     :underlined => 31.chr,
+    #     :underline  => 31.chr,
+    #     :reversed   => 22.chr,
+    #     :reverse    => 22.chr,
+    #     :italic     => 22.chr,
+    #     :reset      => 15.chr,
+    #   }
+    # end
+
+    # End constants
+
+  end
+end

data/lib/lita/handlers/forecasts.rb

@@ -0,0 +1,376 @@
+module ForecastIo
+  module Forecasts
+    def ascii_rain_forecast(forecast)
+      str = do_the_rain_chance_thing(forecast, ascii_chars, 'precipProbability')
+      "rain probability #{(Time.now).strftime('%H:%M').to_s}|#{str}|#{(Time.now + 3600).strftime('%H:%M').to_s}"
+    end
+
+    def ansi_rain_forecast(forecast)
+      str = do_the_rain_chance_thing(forecast, ansi_chars, 'precipProbability') #, 'probability', get_rain_range_colors)
+      max_str = get_max_rain_chance(forecast)
+      "rain probability #{(Time.now).strftime('%H:%M').to_s}|#{str}|#{(Time.now + 3600).strftime('%H:%M').to_s} #{max_str}"
+    end
+
+    def ansi_rain_intensity_forecast(forecast)
+      str = do_the_rain_intensity_thing(forecast, ansi_chars, 'precipIntensity') #, 'probability', get_rain_range_colors)
+      "rain intensity #{(Time.now).strftime('%H:%M').to_s}|#{str}|#{(Time.now + 3600).strftime('%H:%M').to_s}"
+    end
+
+    def ansi_humidity_forecast(forecast)
+      do_the_humidity_thing(forecast, ansi_chars, 'humidity') #, 'probability', get_rain_range_colors)
+    end
+
+    def get_max_rain_chance(forecast, key = 'minutely')
+      unless forecast[key].nil?
+        data_points = []
+        forecast[key]['data'].each do |data_point|
+          data_points.push data_point['precipProbability']
+        end
+        "max #{data_points.max * 100}%"
+      end
+    end
+
+    def do_the_rain_chance_thing(forecast, chars, key, use_color = config.colors, minute_limit = nil)
+      if forecast['minutely'].nil?
+        return 'No minute-by-minute data available.'
+      end
+
+      i_can_has_snow = false
+      data_points = []
+      data = forecast['minutely']['data']
+
+      data.each do |datum|
+        data_points.push datum[key]
+        if datum['precipType'] == 'snow'
+          i_can_has_snow = true
+        end
+      end
+
+      if minute_limit
+        data = condense_data(data, minute_limit)
+      end
+
+      str = get_dot_str(chars, data, 0, 1, key)
+
+      if i_can_has_snow
+        data.each_with_index do |datum, index|
+          if datum['precipType'] == 'snow'
+            str[index] = '☃'
+          end
+        end
+      end
+
+      if use_color
+        str = get_colored_string(data, key, str, get_rain_range_colors)
+      end
+
+      str
+    end
+
+    def do_the_rain_intensity_thing(forecast, chars, key) #, type, range_colors = nil)
+      if forecast['minutely'].nil?
+        return 'No minute-by-minute data available.'  # The "Middle of Nowhere" case.
+      end
+
+      data_points = []
+      data = forecast['minutely']['data']
+
+      data.each do |datum|
+        data_points.push datum[key]
+      end
+
+      # Fixed range graph- 0-0.11.
+      str = get_dot_str(chars, data, 0, 0.11, key)
+
+      if config.colors
+        str = get_colored_string(data, key, str, get_rain_intensity_range_colors)
+      end
+      str
+    end
+
+    def do_the_humidity_thing(forecast, chars, key) #, type, range_colors = nil)
+      data_points = []
+      data = forecast['hourly']['data']
+
+      data.each do |datum|
+        data_points.push datum[key]
+      end
+
+      str = get_dot_str(chars, data, 0, 1, key)
+
+      if config.colors
+        str = get_colored_string(data, key, str, get_humidity_range_colors)
+      end
+      "#{get_humidity data_points.first}|#{str}|#{get_humidity data_points.last} range: #{get_humidity data_points.min}-#{get_humidity data_points.max}"
+    end
+
+    def ansi_temp_forecast(forecast, hours = 24)
+      str, temperature_data = do_the_temp_thing(forecast, ansi_chars, hours)
+      "#{hours} hr temps: #{get_temperature temperature_data.first.round(1)} |#{str}| #{get_temperature temperature_data.last.round(1)}  Range: #{get_temperature temperature_data.min.round(1)} - #{get_temperature temperature_data.max.round(1)}"
+    end
+
+    def ascii_temp_forecast(forecast, hours = 24)
+      str, temperature_data = do_the_temp_thing(forecast, ascii_chars, hours)
+      "#{hours} hr temps: #{get_temperature temperature_data.first.round(1)} |#{str}| #{get_temperature temperature_data.last.round(1)}  Range: #{get_temperature temperature_data.min.round(1)} - #{get_temperature temperature_data.max.round(1)}"
+    end
+
+    def do_the_temp_thing(forecast, chars, hours)
+      temps = []
+      data = forecast['hourly']['data'].slice(0,hours - 1)
+      key = 'temperature'
+
+      data.each_with_index do |datum, index|
+        temps.push datum[key]
+        break if index == hours - 1 # We only want (hours) 24hrs of data.
+      end
+
+      differential = temps.max - temps.min
+
+      # Hmm.  There's a better way.
+      dot_str = get_dot_str(chars, data, temps.min, differential, key)
+
+      if config.colors
+        dot_str = get_colored_string(data, key, dot_str, get_temp_range_colors)
+      end
+
+      return dot_str, temps
+    end
+
+    def ansi_wind_direction_forecast(forecast)
+      str, data = do_the_wind_direction_thing(forecast, ansi_wind_arrows)
+      "48h wind direction #{get_speed data.first}|#{str}|#{get_speed data.last} Range: #{get_speed(data.min)} - #{get_speed(data.max)}"
+    end
+
+    def ascii_wind_direction_forecast(forecast)
+      str, data = do_the_wind_direction_thing(forecast, ascii_wind_arrows)
+      "48h wind direction #{get_speed data.first}|#{str}|#{get_speed data.last} Range: #{get_speed(data.min)} - #{get_speed(data.max)}"
+    end
+
+    def do_the_wind_direction_thing(forecast, wind_arrows, hours = 48)
+      key = 'windBearing'
+      data = forecast['hourly']['data'].slice(0,hours - 1)
+      str = ''
+      data_points = []
+
+      data.each_with_index do |datum, index|
+        wind_arrow_index = get_cardinal_direction_from_bearing(datum[key])
+        str << wind_arrows[wind_arrow_index].to_s
+        data_points.push datum['windSpeed']
+        break if index == hours - 1 # We only want (hours) of data.
+      end
+
+      if config.colors
+        str = get_colored_string(data, 'windSpeed', str, get_wind_range_colors)
+      end
+
+      return str, data_points
+    end
+
+    def do_the_sun_thing(forecast)
+      key = 'cloudCover'
+      data_points = []
+      data = forecast['daily']['data']
+
+      data.each do |datum|
+        data_points.push (1 - datum[key]).to_f  # It's a cloud cover percentage, so let's inverse it to give us sun cover.
+        datum[key] = (1 - datum[key]).to_f      # Mod the source data for the get_dot_str call below.
+      end
+
+      differential = data_points.max - data_points.min
+
+      str = get_dot_str(ansi_chars, data, data_points.min, differential, key)
+
+      if config.colors
+        str = get_colored_string(data, key, str, get_sun_range_colors)
+      end
+
+      "8 day sun forecast |#{str}|"
+    end
+
+    def do_the_cloud_thing(forecast)
+      # O ◎ ]
+      data = forecast['hourly']['data'].slice(0,23)
+
+      str = get_dot_str(ansi_chars, data, 0, 1, 'cloudCover')
+
+      "24h cloud cover |#{str}|"
+    end
+
+    def do_the_sunrise_thing(forecast)
+      t = Time.at(fix_time(forecast['daily']['data'][0]['sunriseTime'], forecast['offset']))
+      t.strftime("%H:%M:%S")
+    end
+
+    def do_the_sunset_thing(forecast)
+      t = Time.at(fix_time(forecast['daily']['data'][0]['sunsetTime'], forecast['offset']))
+      t.strftime("%H:%M:%S")
+    end
+
+    def conditions(forecast)
+      temp_str, temps = do_the_temp_thing(forecast, ansi_chars, 8)
+      wind_str, winds = do_the_wind_direction_thing(forecast, ansi_wind_arrows, 8)
+      rain_str, rains = do_the_rain_chance_thing(forecast, ansi_chars, 'precipProbability', config.colors, 15)
+
+      sun_chance = ((1 - forecast['daily']['data'][0]['cloudCover']) * 100).round
+      "#{get_temperature temps.first.round(2)} |#{temp_str}| #{get_temperature temps.last.round(2)} "\
+        "/ #{get_speed(winds.first)} |#{wind_str}| #{get_speed(winds.last)} "\
+        "/ #{sun_chance}% chance of sun / 60m precip |#{rain_str}|"
+    end
+
+    def do_the_seven_day_thing(forecast)
+      mintemps = []
+      maxtemps = []
+
+      data = forecast['daily']['data']
+      data.each do |day|
+        mintemps.push day['temperatureMin']
+        maxtemps.push day['temperatureMax']
+      end
+
+      differential = maxtemps.max - maxtemps.min
+      max_str = get_dot_str(ansi_chars, data, maxtemps.min, differential, 'temperatureMax')
+
+      differential = mintemps.max - mintemps.min
+      min_str = get_dot_str(ansi_chars, data, mintemps.min, differential, 'temperatureMin')
+
+      if config.colors
+        max_str = get_colored_string(data, 'temperatureMax', max_str, get_temp_range_colors)
+        min_str = get_colored_string(data, 'temperatureMin', min_str, get_temp_range_colors)
+      end
+
+      "7day high/low temps #{get_temperature maxtemps.first.to_f.round(1)} |#{max_str}| #{get_temperature maxtemps.last.to_f.round(1)} "\
+        "/ #{get_temperature mintemps.first.to_f.round(1)} |#{min_str}| #{get_temperature mintemps.last.to_f.round(1)} "\
+        "Range: #{get_temperature mintemps.min} - #{get_temperature maxtemps.max}"
+    end
+
+    def do_the_seven_day_rain_thing(forecast)
+      precip_type = 'rain'
+      rains = []
+
+      data = forecast['daily']['data']
+      data.each do |day|
+        if day['precipType'] == 'snow'
+          precip_type = 'snow'
+        end
+        rains.push day['precipProbability']
+      end
+
+      str = get_dot_str(ansi_chars, data, 0, 1, 'precipProbability')
+
+      if config.colors
+        str = get_colored_string(data, 'precipProbability', str, get_rain_range_colors)
+      end
+
+      "7day #{precip_type}s |#{str}|"
+    end
+
+    def do_the_daily_rain_thing(forecast)
+      precip_type = 'rain'
+      rains = []
+
+      data = forecast['hourly']['data']
+      data.each do |day|
+        if day['precipType'] == 'snow'
+          precip_type = 'snow'
+        end
+        rains.push day['precipProbability']
+      end
+
+      str = get_dot_str(ansi_chars, data, 0, 1, 'precipProbability')
+
+      if config.colors
+        str = get_colored_string(data, 'precipProbability', str, get_rain_range_colors)
+      end
+
+      max_str = get_max_rain_chance(forecast, 'hourly')
+
+      "48 hr #{precip_type}s |#{str}| #{max_str}"
+    end
+
+    def do_the_daily_wind_thing(forecast)
+      winds = []
+
+      data = forecast['daily']['data']
+      data.each do |day|
+        winds.push day['windSpeed']
+      end
+
+      str = get_dot_str(ansi_chars, data, 0, winds.max, 'windSpeed')
+
+      if config.colors
+        str = get_colored_string(data, 'windSpeed', str, get_wind_range_colors)
+      end
+
+      "7day winds #{get_speed winds.first}|#{str}|#{get_speed winds.last} range #{get_speed winds.min}-#{get_speed winds.max}"
+    end
+
+    def do_the_daily_humidity_thing(forecast)
+      humidities = []
+
+      data = forecast['daily']['data']
+      data.each do |day|
+        humidities.push day['humidity']
+      end
+
+      str = get_dot_str(ansi_chars, data, 0, 1, 'humidity')
+
+      if config.colors
+        str = get_colored_string(data, 'humidity', str, get_wind_range_colors)
+      end
+
+      "7day humidity #{get_humidity humidities.first}|#{str}|#{get_humidity humidities.last} "\
+        "range #{get_humidity humidities.min}-#{get_humidity humidities.max}"
+    end
+
+    def do_the_ozone_thing(forecast)
+      # O ◎ ]
+      data = forecast['hourly']['data']
+
+      str = get_dot_str(ozone_chars, data, 280, 350-280, 'ozone')
+
+      "ozones #{data.first['ozone']} |#{str}| #{data.last['ozone']} [24h forecast]"
+    end
+
+    def do_the_pressure_thing(forecast)
+      data = forecast['hourly']['data']
+      key = 'pressure'
+      boiled_data = []
+
+      data.each do |d|
+        boiled_data.push d[key]
+      end
+
+      str = get_dot_str(ansi_chars, data, boiled_data.min, boiled_data.max - boiled_data.min, key)
+
+      "pressure #{data.first[key]} hPa |#{str}| #{data.last[key]} hPa range: #{boiled_data.min}-#{boiled_data.max} hPa [48h forecast]"
+    end
+
+    def do_the_daily_pressure_thing(forecast)
+      # O ◎ ]
+      data = forecast['daily']['data']
+      key = 'pressure'
+      boiled_data = []
+
+      data.each do |d|
+        boiled_data.push d[key]
+      end
+
+      str = get_dot_str(ansi_chars, data, boiled_data.min, boiled_data.max - boiled_data.min, key)
+
+      "pressure #{data.first[key]} hPa |#{str}| #{data.last[key]} hPa range: #{boiled_data.min}-#{boiled_data.max} hPa [8 day forecast]"
+    end
+
+    def get_alerts(forecast)
+      str = ''
+      forecast['alerts'].each do |alert|
+        alert['description'].match /\.\.\.(\w+)\.\.\./
+        str += "#{alert['uri']}\n"
+      end
+      str
+    end
+
+    def do_the_nearest_storm_thing(forecast)
+      return forecast['currently']['nearestStormDistance'], forecast['currently']['nearestStormBearing']
+    end
+  end
+end