slackify 0.1.4 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 481a11f7bd67bbd0dade00117995381beb8719b0aba7f4b886372be0fb169d57
-  data.tar.gz: 6d2fad59ffe6938d3bf0f3ba9bf754218faf1cfdeb7f64ed3fd5c586535f465f
+  metadata.gz: d5f1105d73a8943514708110e7b544fbaf8e300770f902103dcca4da95bfc9fa
+  data.tar.gz: b4a2b7dd7fcffed2cce55214fb96d2d09ea6ff40513d0360900187118857b6b8
 SHA512:
-  metadata.gz: eec68d6c75d8537cc74036921025d68d14475d5f7f84b3d50d918d33a4f5dec96e2b2080956da0bf52717a24ee882282fd9eaced48f00abfefc30df843d7c0af
-  data.tar.gz: 6e9888657a4a3ec71b86ed7714f21cfc275b9b1e90d0d1136ecba01dfc41853e9cc8b2a0dc58c15f8d8cbc35c3df77d6ea183190add7a2149b2bd759852ba3c2
+  metadata.gz: a80fbbb042403ae528e9563c7d3cdaec8462e30a6aaf033d1c93c804b9e78cb58e1b03cbd1c324cab8329eb697da35fe5d81e47dffe633643fd39192d507a802
+  data.tar.gz: f822f3cf7448b07f946f3a7d07b644d1ae70a57ee9cc8a9f06996c2de20f36561b4894294f5c350ab5c7a44394e75aed1e2a5ef1f127e1ee47cdac000975edbd

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## V0.3.2
+
+* Add support for interactive block payloads ([b6cf1db](https://github.com/jusleg/slackify/commit/b6cf1dbb47b832037ebff56054efa27c9e3251dc)) by [@drose-shopify](https://github.com/drose-shopify)
+
+## V0.3.0
+
+* Add code documentation and improve exception message
+* Add whitelisting of bot ids in the configuration through `whitelisted_bot_ids=`
+* Refactored Handler configuration into `Slackify::Router` and `Slackify::Handlers::Factory`
+* Improved testing
+* Remove the need to perform `Slackify.load_handler`
+* **Breaking change:** Given that we now load the handlers on `Slack.configure`, the configuration step done in `config/application.rb` will have to be done in an initializer to have all the handler class loaded. 
+
+## V0.2.0
+
+Update `custom_event_subtype_handlers` to `custom_message_subtype_handlers` and add support for `custom_event_type_handlers`. This is a breaking change since we rename the field that was previously used. To fix, update any calls from `custom_event_subtype_handlers` to `custom_message_subtype_handlers` and you should be good to go.
+
+## V0.1.5
+
+Update how the `bot_id` is set in the handler configuration. You can disable the slack auth test (which is used to obtain the bot_id) by setting `SLACK_AUTH_SKIP=1` in your environment variables. If you are running in a Rails environment other than production, development or staging and would like to use the bot for real requests, you can trigger a manual auth test by calling `Slackify.configuration.handlers.bot_auth_test`. Gemfile.lock was removed.
+
 ## V0.1.4
 
 Custom unhandled_handler configuration fix. It wouldn't let you set a custom one as the validation was checking for `is_a?` instead of `<`

data/README.md

@@ -1,4 +1,4 @@
-# Slackify [![Build Status](https://travis-ci.org/jusleg/slackify.svg?branch=master)](https://travis-ci.org/jusleg/slackify) [![Gem Version](https://badge.fury.io/rb/slackify.svg)](https://badge.fury.io/rb/slackify)
+# Slackify [![Tests 🧪](https://github.com/jusleg/slackify/workflows/Tests%20%F0%9F%A7%AA/badge.svg)](https://github.com/jusleg/slackify/actions?query=workflow%3A%22Tests+%F0%9F%A7%AA%22) [![Lint 💎](https://github.com/jusleg/slackify/workflows/Lint%20%F0%9F%92%8E/badge.svg)](https://github.com/jusleg/slackify/actions?query=workflow%3A%22Lint+%F0%9F%92%8E%22) [![Gem Version](https://badge.fury.io/rb/slackify.svg)](https://badge.fury.io/rb/slackify) ![Gem downloads](https://img.shields.io/gem/dt/slackify)
 
 Slackify is a gem that allows to build slackbots on Rails using the [Event API](https://api.slack.com/events-api) from Slack.
 
@@ -8,7 +8,8 @@ Slackify is a gem that allows to build slackbots on Rails using the [Event API](
     * [Plain messages](#handling-plain-messages)
     * [Interactive messages](#handling-interactive-messages)
     * [Slash Command](#handling-slash-commands)
-    * [Custom handler for event subtypes](#custom-handler-for-event-subtypes)
+    * [Custom handler for message subtypes](#custom-handler-for-message-subtypes)
+    * [Custom handler for event types](#custom-handler-for-event-types)
     * [Custom unhandled handler](#custom-unhandled-handler)
   * [Slack client](#slack-client)
     * [Sending a simple message](#sending-a-simple-message)
@@ -85,17 +86,29 @@ class DummyHandler < Slackify::Handlers::Base
 end
 ```
 
-### Custom handler for event subtypes
+### Custom handler for message subtypes
 
-If you wish to add more functionalities to your bot, you can specify define new behaviours for different event subtypes. You can specify a hash with the event subtype as a key and the handler class as the value. Slackify will call `.handle_event` on your class and pass the controller params as parameters.
+If you wish to add more functionalities to your bot, you can specify define new behaviours for different message subtypes. You can specify a hash with the event subtype as a key and the handler class as the value. Slackify will call `.handle_event` on your class and pass the controller params as parameters.
 
 ```ruby
-Slackify.configuration.custom_event_subtype_handlers = {
+Slackify.configuration.custom_message_subtype_handlers = {
+  file_share: MessageImageHandler
+}
+```
+
+In this example, all message of subtype `file_share` will be sent to the `MessageImageHandler` class.
+
+### Custom handler for event types
+
+If you wish to add more functionalities to your bot, you can specify define new behaviours for different event types. You can specify a hash with the event type as a key and the handler class as the value. Slackify will call `.handle_event` on your class and pass the controller params as parameters.
+
+```ruby
+Slackify.configuration.custom_event_type_handlers = {
   file_share: ImageHandler
 }
 ```
 
-In this example, all events of subtype `file_share` will be sent to the `ImageHandler` class.
+In this example, all events of type `file_share` will be sent to the `ImageHandler` class.
 
 ### Custom unhandled handler
 
@@ -205,29 +218,45 @@ First, you'll need to create a new app on slack. Head over to [slack api](https:
     Under the setting section, click "install app" and proceed to install the app to the workspace. Once the app is installed, go back to the "install app" page and copy the Bot User OAuth Access Token.
 
 6. **Configure Slackify**
+Add a new initializer with the following code
+
 ```ruby
+# config/initializers/slackify.rb
 Slackify.configure do |config|
   config.slack_bot_token = "xoxb-sdkjlkjsdflsd..."
   config.slack_secret_token = "1234dummysecret"
 end
 ```
 
-7. **Add an initializer**
+7. **Define handlers specific subtypes** (Optional)
+You can set custom [message subtype](https://api.slack.com/events/message) handlers or custom [event type](https://api.slack.com/events) handlers inside your configuration
+
 ```ruby
 # config/initializers/slackify.rb
-Slackify.load_handlers
+Slackify.configure do |config|
+  config.slack_bot_token = "xoxb-sdkjlkjsdflsd..."
+  config.slack_secret_token = "1234dummysecret"
+  config.custom_message_subtype_handlers = {
+    file_share: ImageHandler,
+    channel_join: JoinHandler,
+    ...
+  }
+  config.custom_event_type_handlers = {
+    app_mention: ...
+  }
+end
 ```
 
-8. **Define handlers specific subtypes** (Optional)
+8. **Handle bot messages** (Highly optional)
+If you want your bot to accept other bot messages (which you probably should not do), you can. In the configuration step, you can set an array of whitelisted bot ids.
 
 ```ruby
 # config/initializers/slackify.rb
-Slackify.load_handlers
-Slackify.configuration.custom_event_subtype_handlers = {
-  file_share: ImageHandler,
-  channel_join: JoinHandler,
-  ...
-}
+Slackify.configure do |config|
+...
+config.whitelisted_bot_ids = ['abc123', 'def456']
+...
+end
 ```
 
 **At this point, you are ready to go 😄**

data/app/controllers/slackify/slack_controller.rb

@@ -9,6 +9,8 @@ module Slackify
     def event_callback
       if params[:type] == "url_verification"
         render plain: params["challenge"]
+      elsif Slackify.configuration.custom_event_type_handlers[params[:event][:type]]
+        handle_custom_event_type
       elsif params[:event][:type] == "message"
         handle_direct_message_event
         head :ok
@@ -19,7 +21,14 @@ module Slackify
 
     def interactive_callback
       parsed_payload = JSON.parse(params[:payload])
-      response = handler_from_callback_id(parsed_payload["callback_id"]).call(parsed_payload)
+
+      callback_id = if parsed_payload.key?('view')
+                      parsed_payload.dig('view', 'callback_id')
+                    else
+                      parsed_payload['callback_id']
+                    end
+
+      response = handler_from_callback_id(callback_id).call(parsed_payload)
       if !response.nil?
         Timeout.timeout(SLACK_TIMEOUT_SECONDS) do
           render json: response
@@ -28,7 +37,7 @@ module Slackify
         head :ok
       end
     rescue Timeout::Error
-      raise Timeout::Error, "Slack interactive callback timed out for #{parsed_payload['callback_id']}"
+      raise Timeout::Error, "Slack interactive callback timed out for #{callback_id}"
     end
 
     def slash_command_callback
@@ -51,25 +60,33 @@ module Slackify
     private
 
     def handle_direct_message_event
-      if handler = Slackify.configuration.custom_event_subtype_handlers[params[:event][:subtype]]
+      if handler = Slackify.configuration.custom_message_subtype_handlers[params[:event][:subtype]]
         handler.handle_event(params[:slack])
         head :ok
         return
       end
 
-      return if params[:event][:subtype] == "bot_message" || params[:event].key?(:bot_id) || params[:event][:hidden]
+      return if (params[:event][:subtype] == "bot_message" ||
+        params[:event].key?(:bot_id) ||
+        params[:event][:hidden]) &&
+                Slackify.configuration.whitelisted_bot_ids.exclude?(params.dig(:event, :bot_id))
 
       command = params[:event][:text]
-      Slackify.configuration.handlers.call_command(command, params[:slack])
+      Slackify::Router.call_command(command, params[:slack])
     rescue RuntimeError => e
       raise e unless e.message == "Component not found for a command message"
     end
 
+    def handle_custom_event_type
+      Slackify.configuration.custom_event_type_handlers[params[:event][:type]].handle_event(params[:slack])
+      head :ok
+    end
+
     def handler_from_callback_id(callback_id)
       class_name, method_name = callback_id.split('#')
       class_name = class_name.camelize
 
-      raise Exceptions::HandlerNotSupported, class_name unless
+      raise Exceptions::HandlerNotSupported, "#{class_name} is not a subclass of Slackify::Handlers::Base" unless
         Handlers::Base.supported_handlers.include?(class_name)
 
       class_name.constantize.method(method_name)
@@ -78,7 +95,7 @@ module Slackify
     def verify_handler_slash_permission(handler_class, handler_method)
       handler_class = handler_class.camelize
 
-      raise Exceptions::HandlerNotSupported, handler_class unless
+      raise Exceptions::HandlerNotSupported, "#{handler_class} is not a subclass of Slackify::Handlers::Base" unless
         Handlers::Base.supported_handlers.include?(handler_class)
 
       handler = handler_class.constantize

data/lib/slackify.rb

@@ -4,6 +4,7 @@ require 'slackify/configuration'
 require 'slackify/engine'
 require 'slackify/exceptions'
 require 'slackify/handlers'
+require 'slackify/router'
 
 module Slackify
   class << self
@@ -19,9 +20,5 @@ module Slackify
     def configure
       yield(configuration)
     end
-
-    def load_handlers
-      @configuration.handlers = Handlers::Configuration.new
-    end
   end
 end

data/lib/slackify/configuration.rb

@@ -3,37 +3,75 @@
 require 'slack'
 
 module Slackify
+  # Where the configuration for Slackify lives
   class Configuration
-    attr_reader :custom_event_subtype_handlers, :slack_bot_token, :unhandled_handler
-    attr_accessor :handlers, :slack_secret_token, :slack_client
+    attr_reader :custom_message_subtype_handlers, :slack_bot_token, :unhandled_handler, :custom_event_type_handlers
+    attr_accessor :handlers, :slack_secret_token, :slack_client, :whitelisted_bot_ids
 
     def initialize
       @slack_bot_token = nil
       @slack_secret_token = nil
-      @handlers = nil
+      @handlers = generate_handlers
       @slack_client = nil
-      @custom_event_subtype_handlers = {}
+      @custom_message_subtype_handlers = {}
+      @custom_event_type_handlers = {}
       @unhandled_handler = Handlers::UnhandledHandler
+      @whitelisted_bot_ids = []
     end
 
+    # Set your own unhandled handler
     def unhandled_handler=(handler)
-      raise Exceptions::InvalidHandler, "#{handler.class} is not a subclass of Slackify::Handlers::Base" unless
+      raise HandlerNotSupported, "#{handler.class} is not a subclass of Slackify::Handlers::Base" unless
         handler < Handlers::Base
 
       @unhandled_handler = handler
     end
 
+    # Remove unhandled handler. The bot will not reply if the message doesn't
+    # match any regex
     def remove_unhandled_handler
       @unhandled_handler = nil
     end
 
+    # Set the token that we will use to connect to slack
     def slack_bot_token=(token)
       @slack_bot_token = token
       @slack_client = Slack::Web::Client.new(token: token).freeze
     end
 
-    def custom_event_subtype_handlers=(event_subtype_hash)
-      @custom_event_subtype_handlers = event_subtype_hash.with_indifferent_access
+    # Set a handler for a specific message subtype
+    # That handler will have to implement `self.handle_event(params)`
+    # see https://api.slack.com/events/message
+    def custom_message_subtype_handlers=(event_subtype_hash)
+      @custom_message_subtype_handlers = event_subtype_hash.with_indifferent_access
+    end
+
+    # Set a handler for a event type
+    # That handler will have to implement `self.handle_event(params)`
+    # see https://api.slack.com/events
+    def custom_event_type_handlers=(event_type_hash)
+      @custom_event_type_handlers = event_type_hash.with_indifferent_access
+    end
+
+    private
+
+    # Convert a hash to a list of lambda functions that will be called to handle
+    # the user messages
+    def generate_handlers
+      generated_handlers = []
+      read_handlers_yaml.each do |handler_hash|
+        handler = Handlers::Factory.for(handler_hash)
+        generated_handlers << handler
+      end
+
+      generated_handlers
+    end
+
+    # Reads the config/handlers.yml configuration
+    def read_handlers_yaml
+      raise 'config/handlers.yml does not exist' unless File.exist?("#{Rails.root}/config/handlers.yml")
+
+      YAML.load_file("#{Rails.root}/config/handlers.yml") || []
     end
   end
 end

data/lib/slackify/engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Slackify
+  # Makes the whole thing work. Adds the routes for slackify.
   class Engine < Rails::Engine
     isolate_namespace Slackify
   end

data/lib/slackify/exceptions.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
 module Slackify
+  # When things go boom, we need these.
   module Exceptions
+    # You tried to call a class that was not extending the base handler
     class HandlerNotSupported < StandardError; end
+    # You handler is failing validations
     class InvalidHandler < StandardError; end
+    # The handler method was not whitelisted to be a slash command
     class MissingSlashPermission < StandardError; end
   end
 end

data/lib/slackify/handlers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'handlers/base'
-require_relative 'handlers/configuration'
+require_relative 'handlers/factory'
 require_relative 'handlers/unhandled_handler'
 require_relative 'handlers/validator'
 

data/lib/slackify/handlers/base.rb

@@ -2,16 +2,25 @@
 
 module Slackify
   module Handlers
+    # Base handler class that any user defined handlers must inherit from
     class Base
       @@supported_handlers = []
 
       class << self
         attr_reader :allowed_slash_methods
 
+        # Get the slack client that you can use to perform slack api calls
+        # @see https://github.com/slack-ruby/slack-ruby-client
         def slack_client
           Slackify.configuration.slack_client
         end
 
+        # Enables a method to be called for a slash command.
+        #
+        # More context:
+        # Slash commands have extra validations. To call a slash command, it
+        # needs to call a method on a supported handler and that handler needs
+        # to explicitly specify which methods are for slash command.
         def allow_slash_method(element)
           if @allowed_slash_methods
             @allowed_slash_methods.push(*element)
@@ -20,10 +29,14 @@ module Slackify
           end
         end
 
+        # Any class inheriting from Slackify::Handler::Base will be added to
+        # the list of supported handlers
         def inherited(subclass)
           @@supported_handlers.push(subclass.to_s)
         end
 
+        # Show a list of the handlers supported by the app. Since we do
+        # metaprogramming, we want to ensure we can only call defined handlers
         def supported_handlers
           @@supported_handlers
         end

data/lib/slackify/handlers/factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Slackify
+  module Handlers
+    # Creates the handler structs
+    class Factory
+      def self.for(configuration)
+        Validator.verify_handler_integrity(configuration)
+
+        handler = OpenStruct.new
+        handler.name = configuration.keys.first
+        handler.commands = []
+
+        configuration[handler.name]['commands']&.each do |command|
+          built_command = OpenStruct.new
+          built_command.regex = command['regex']
+          built_command.handler = handler.name.camelize.constantize.method(command['action'])
+          built_command.description = command['description']
+          handler.commands << built_command.freeze
+        end
+
+        handler.commands.freeze
+        handler.freeze
+      end
+    end
+  end
+end

data/lib/slackify/handlers/unhandled_handler.rb

@@ -2,6 +2,10 @@
 
 module Slackify
   module Handlers
+    # Default handler for any text message that is not handler by other handlers
+    # This can easily be replaced by setting you own unhandled handler when
+    # configuring slackify. Use `#unhandled_handler=` to set it. Your handler
+    # must implement a `self.unhandled` method.
     class UnhandledHandler < Base
       def self.unhandled(params)
         slack_client.chat_postMessage(

data/lib/slackify/handlers/validator.rb

@@ -2,7 +2,10 @@
 
 module Slackify
   module Handlers
+    # Simple validator for handlers. It will blow your app up on the
+    # configuration step instead of crashing when handling production requests.
     class Validator
+      # Checks if your handler hash is valid. It's pass or raise 🧨💥
       def self.verify_handler_integrity(handler)
         handler_name = handler.keys.first
         handler_class = handler_name.camelize.constantize

data/lib/slackify/router.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Slackify
+  # In charge of routing a message to its proper handler
+  class Router
+    class << self
+      # List all available commands
+      def all_commands
+        Slackify.configuration.handlers.collect(&:commands).flatten
+      end
+
+      # Find the matching command based on the message string
+      def matching_command(message)
+        all_commands.each { |command| return command if command.regex.match? message }
+        nil
+      end
+
+      # Call command based on message string
+      def call_command(message, params)
+        command = matching_command(message)
+        if command.nil?
+          return unless Slackify.configuration.unhandled_handler
+
+          Slackify.configuration.unhandled_handler.unhandled(params)
+        else
+          new_params = params.merge(command_arguments: command.regex.match(message).named_captures)
+          command.handler.call(new_params)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slackify
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.2
 platform: ruby
 authors:
 - Justin Leger
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-17 00:00:00.000000000 Z
+date: 2019-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -114,9 +114,10 @@ files:
 - lib/slackify/exceptions.rb
 - lib/slackify/handlers.rb
 - lib/slackify/handlers/base.rb
-- lib/slackify/handlers/configuration.rb
+- lib/slackify/handlers/factory.rb
 - lib/slackify/handlers/unhandled_handler.rb
 - lib/slackify/handlers/validator.rb
+- lib/slackify/router.rb
 homepage: https://github.com/jusleg/slackify
 licenses:
 - MIT
@@ -138,8 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Slackbot framework for Rails using the Events API

data/lib/slackify/handlers/configuration.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-
-module Slackify
-  module Handlers
-    class Configuration
-      attr_reader :bot_id
-      attr_accessor :handlers
-      delegate :each, to: :@handlers
-
-      def initialize
-        @handlers = []
-
-        read_handlers_yaml.each do |handler_yaml|
-          handler = generate_handler_from_yaml(handler_yaml)
-          @handlers << handler
-        end
-
-        environment_configurations
-      end
-
-      def all_commands
-        @handlers.collect(&:commands).flatten
-      end
-
-      def matching_command(message)
-        all_commands.each { |command| return command if command.regex.match? message }
-        nil
-      end
-
-      def call_command(message, params)
-        return if params.dig(:event, :user) == @bot_id || params.dig(:event, :message, :user) == @bot_id
-
-        command = matching_command(message)
-        if command.nil?
-          return unless Slackify.configuration.unhandled_handler
-
-          Slackify.configuration.unhandled_handler.unhandled(params)
-        else
-          new_params = params.merge(command_arguments: command.regex.match(message).named_captures)
-          command.handler.call(new_params)
-        end
-      end
-
-      private
-
-      def environment_configurations
-        @bot_id =
-          case Rails.env
-          when 'production', 'staging', 'development'
-            Slackify.configuration.slack_client.auth_test['user_id']
-          when 'test'
-            ''
-          end
-      end
-
-      def read_handlers_yaml
-        raise 'config/handlers.yml does not exist' unless File.exist?("#{Rails.root}/config/handlers.yml")
-
-        YAML.load_file("#{Rails.root}/config/handlers.yml") || []
-      end
-
-      def generate_handler_from_yaml(handler_yaml)
-        Validator.verify_handler_integrity(handler_yaml)
-
-        handler = OpenStruct.new
-        handler.name = handler_yaml.keys.first
-        handler.commands = []
-
-        handler_yaml[handler.name]['commands']&.each do |command|
-          built_command = OpenStruct.new
-          built_command.regex = command['regex']
-          built_command.handler = handler.name.camelize.constantize.method(command['action'])
-          built_command.description = command['description']
-          handler.commands << built_command.freeze
-        end
-
-        handler.commands.freeze
-        handler.freeze
-      end
-    end
-  end
-end