slackathon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fcf29e8a5acc45438a8fc54a02f1ea217e44085
+  data.tar.gz: b01ce369c3c331327d2a2351322088417b58dc55
+SHA512:
+  metadata.gz: cd294da8d4605b9aa7a08817e09b91b5775caa0a516585fa732d700ad9a047f4e05a486ad041dc656419ed5d95dca43c05a63a98610c578c3b7ed917d5dd8bb9
+  data.tar.gz: '05856998418c02103a51ae0e37a1cd69796b55d51b813c0788f71bdf908eb6e1ae09b60b0fd8cc996c18aa2610127b522d7e5a55a877945004f36ccf58f86224'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Godfrey Chan
+
+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,187 @@
+# Slackathon
+
+A simple way to build Slack interations inside a Rails app. Check out our
+[blog post](http://blog.skylight.io/the-slackathon) for the story behind
+this gem!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'slackathon'
+```
+
+Also, add this to `config/routes.rb`
+
+```ruby
+mount Slackathon::Engine => "/slack"
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## Development Workflow
+
+### Basic Slack Command
+
+1. Set up https://ngrok.com/
+
+   This gives you a public URL for Slack to reach your development machine.
+   On a Mac, you can also install it via `brew cask install ngrok`.
+
+   Assuming the Rails app is already running on port 3000, you can expose the
+   Rails app with `ngrok http 3000`, which should give you a public URL like
+   `http://00bea6f5.ngrok.io.`
+
+1. Create a Slack app at https://api.slack.com/apps
+
+   The "App Name" will be used as the display name when the app is replying to
+   commands.
+
+   To get everything working perfectly, you probably want to mirror all the
+   settings on the production app, the here are the most important bits.
+
+1. Go to "Your App > Settings > Install App" to add it to your Slack.
+
+1. Create your command under "Your App > Features > Slash Commands"
+
+   - The command is whatever you would type after the "/" in Slack, e.g.
+     `/monkey`.
+   - The request URL should be `http://00bea6f5.ngrok.io/slack/commands`.
+   - You probably want to turn on "Escape channels, users, and links sent to
+     your app" which will make it easier to parse @mentions and #channels.
+
+1. Create a `monkey_command.rb` in `app/slack`
+
+   - The name of the file (`monkey_command.rb`) and the class name (`MonkeyCommand`)
+     has to match the name of the command (`/monkey`).
+   - You should inherit from the `Slackathon::Command` class.
+   - You have access to the `params` hash.
+   - At minimum, you will need to implement the `call` method.
+   - Example:
+     ```ruby
+     class MonkeyCommand < Slackathon::Command
+       def call
+         {
+           response_type: "in_channel",
+           text: "#{user} said #{params[:text]} :see_no_evil:"
+         }
+       end
+
+       private
+
+       def user
+         "<@#{params[:user_id]}>"
+       end
+     end
+     ```
+  - See https://api.slack.com/slash-commands#responding_to_a_command and
+    https://api.slack.com/docs/message-formatting for more documentation about
+    the responses you can send.
+
+### Adding Buttons
+
+In this section, we will modify the `MonkeyBot` and let the user pick which
+monkey emoji to use.
+
+1. Enable "Your App > Features > Interactive Components"
+
+   - This is required to support buttons, menus and dialogs.
+   - The request URL should be `http://00bea6f5.ngrok.io/slack/interactions`.
+   - You probably won't need to worry about "Options Load URL".
+
+1. Instead of immediately posting to the channel, we will reply to the user
+   only, asking for their emoji preference:
+
+   ```ruby
+   class MonkeyCommand < Slackathon::Command
+     def call
+       {
+         response_type: "ephemeral",
+         attachments: [{
+           callback_id: "monkey",
+           text: "Please pick a style",
+           actions: [{
+             type: "button",
+             text: "Click to use :see_no_evil:",
+             name: "post_in_channel",
+             value: "#{params[:text]} :see_no_evil:"
+           }, {
+             type: "button",
+             text: "Click to use :hear_no_evil:",
+             name: "post_in_channel",
+             value: "#{params[:text]} :hear_no_evil:"
+           }, {
+             type: "button",
+             text: "Click to use :speak_no_evil:",
+             name: "post_in_channel",
+             value: "#{params[:text]} :speak_no_evil:"
+           }]
+         }]
+       }
+     end
+
+     def post_in_channel(value)
+       # do something with value, see below...
+     end
+   end
+   ```
+
+   - Here, we are using the `ephemeral` response type (as opposed to `in_channel`
+     as we did previously), which makes the response visible only to the user
+     who sent the command.
+   - In addition to the message text, we are including a few buttons in the
+     `attachments` array.
+   - The `callback_id` need to match the name of your command (e.g. `monkey` in
+     this case).
+   - The `actions` array has the button(s) you want to include.
+   - The `text` is the label of the button (e.g. "Click me!!!").
+   - The `name` is the name of the method to call when the button is clicked
+     (see below).
+   - The `value` is an optional string that will be passed to the method (see
+     below).
+   - See https://api.slack.com/interactive-messages and https://api.slack.com/dialogs
+     for more documentation.
+
+1. When the user clicks on one of the buttons, it will call the method you
+   specified:
+
+   ```ruby
+   class MonkeyCommand < Slackathon::Command
+     # def call ...
+     def post_in_channel(value)
+       {
+         response_type: "in_channel",
+         delete_original: true,
+         text: "<@#{params[:user][:id]}> said #{value}"
+       }
+     end
+   end
+   ```
+
+   Here, `value` is the string that we attached to the original buttons.
+
+## Promoting to Production
+
+1. Remove the command from your development Slack app.
+
+1. Create a production Slack app and your command/interactive component
+   following the instructions above (with the URLs pointing to your
+   production Rails app).
+
+1. Find the "Verification Token" from `https://api.slack.com/apps/<your app>`.
+   Assign its value to the `SLACK_VERIFICATION_TOKEN` ENV variable in
+   your production environment (or set it with `Slackathon.verification_token = ...`).
+
+1. Make sure your Active Job adapter is configured to process the `slack`
+   queue (e.g. `bundle exec sidekiq -q default -q slack ...`). Alternatively,
+   you can change the queue with `Slackathon.queue = ...`.
+
+1. Deploy your changes!
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,36 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Slackathon'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/slackathon/application_controller.rb

@@ -0,0 +1,4 @@
+module Slackathon
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/slackathon/webhooks_controller.rb

@@ -0,0 +1,38 @@
+module Slackathon
+  class WebhooksController < ApplicationController
+    before_action :verify_token
+
+    def command
+      command = payload[:command][1..-1]
+      klass = "#{command}_command".classify.constantize
+
+      SlackCommandJob.perform_later(klass.name, "command", payload.to_unsafe_h)
+
+      head :ok
+    end
+
+    def interaction
+      command = payload[:callback_id]
+      klass = "#{command}_command".classify.constantize
+
+      SlackCommandJob.perform_later(klass.name, "interaction", payload)
+
+      head :ok
+    end
+
+    private
+
+    def payload
+      @payload ||= params[:payload] ? JSON.parse(params[:payload]).with_indifferent_access : params
+    end
+
+    def verify_token
+      expected_token = Slackathon.verification_token
+      actual_token = payload.delete(:token)
+
+      if Rails.env.production? || expected_token
+        raise "Incorrect slack verification token" unless expected_token == actual_token
+      end
+    end
+  end
+end

data/app/jobs/slackathon/application_job.rb

@@ -0,0 +1,4 @@
+module Slackathon
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/slackathon/slack_command_job.rb

@@ -0,0 +1,50 @@
+require "net/http"
+require "uri"
+
+module Slackathon
+  class SlackCommandJob < ApplicationJob
+    queue_as Slackathon.queue
+
+    def perform(name, type, params)
+      klass = name.constantize
+      params = params.with_indifferent_access
+      url = params[:response_url]
+
+      body = case type
+      when "command"
+        klass.dispatch_command(params)
+      when "interaction"
+        klass.dispatch_interaction(params)
+      end
+
+      say(url, body)
+    rescue => e
+      say(url, {
+        response_type: "ephemeral",
+        text: <<~TEXT
+          :mac_bomb: Darn - that slash command (#{name.underscore.gsub("_command", "")}) didn't work
+          ```
+          #{e.class}: #{e.message}
+          #{e.backtrace.take(5).map { |line| line.indent(4) }.join("\n")}
+              ...
+          ```
+        TEXT
+      })
+
+      raise e
+    end
+
+    private
+
+    def say(url, body)
+      uri = URI(url)
+      headers = { "Content-Type" => "application/json" }
+      body = (String === body) ? body : body.to_json
+      response = Net::HTTP.post uri, body, headers
+
+      unless Net::HTTPSuccess === response
+        raise "#{response.code}: #{response.body}"
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+Slackathon::Engine.routes.draw do
+  post "commands" => "webhooks#command"
+  post "interactions" => "webhooks#interaction"
+end

data/lib/slackathon.rb

@@ -0,0 +1,20 @@
+require "slackathon/engine"
+require "slackathon/command"
+
+module Slackathon
+  def self.verification_token
+    @verification_token ||= ENV["SLACK_VERIFICATION_TOKEN"]
+  end
+
+  def self.verification_token=(token)
+    @verification_token = token
+  end
+
+  def self.queue
+    @queue ||= "slack"
+  end
+
+  def self.queue=(queue)
+    @queue = queue
+  end
+end

data/lib/slackathon/command.rb

@@ -0,0 +1,33 @@
+module Slackathon
+  class Command
+    def self.dispatch_command(params)
+      self.new(params).call
+    end
+
+    def self.dispatch_interaction(params)
+      action = params[:actions][0]
+      method = self.new(params).public_method(action[:name])
+      value = action[:value]
+
+      if method.arity == 0
+        method.call
+      else
+        method.call(self.unescape(value))
+      end
+    end
+
+    def self.unescape(message)
+      message.gsub(/&/, "&")
+        .gsub(/&lt;/, "<")
+        .gsub(/&gt;/, ">")
+    end
+
+    def initialize(params)
+      @params = params
+    end
+
+    private
+
+    attr_reader :params
+  end
+end

data/lib/slackathon/engine.rb

@@ -0,0 +1,5 @@
+module Slackathon
+  class Engine < ::Rails::Engine
+    isolate_namespace Slackathon
+  end
+end

data/lib/slackathon/version.rb

@@ -0,0 +1,3 @@
+module Slackathon
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: slackathon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Godfrey Chan
+- Yehuda Katz
+- Krystan HuffMenne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.4
+description: 
+email:
+- godfreykfc@gmail.com
+- wycats@gmail.com
+- krystan@tilde.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/slackathon/application_controller.rb
+- app/controllers/slackathon/webhooks_controller.rb
+- app/jobs/slackathon/application_job.rb
+- app/jobs/slackathon/slack_command_job.rb
+- config/routes.rb
+- lib/slackathon.rb
+- lib/slackathon/command.rb
+- lib/slackathon/engine.rb
+- lib/slackathon/version.rb
+homepage: https://github.com/tildeio/slackathon
+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: A simple way to build Slack interations inside a Rails app.
+test_files: []