grape-slack-bot 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6e6b020caecc8ee5a8520f7f6f76107d006ca88070189e0cf23428bc10d2e7
-  data.tar.gz: 02aa101bb61f5ad8fc96c9d295e75fe032e1d088d90d3d49b008e09551f53b8c
+  metadata.gz: 9361a3a86619e251da1df7649973cdd911619f2b55f18d5d622f8a1e6d5ee707
+  data.tar.gz: ebd8c29c0f6957bbaa0cf1fefbce369f7072b60d4b01cbae4037fa7a5fe3212b
 SHA512:
-  metadata.gz: 3217a763efe6f6b101067c422029450e59efee9ea47d611bef1bd06a166a99404c1243955a3e42a5e9f31a78e9c3cbdd051d324fcd3b0b2414812da3d84f7336
-  data.tar.gz: 3faca964608cb59b26ab6712c4eec82356f0ce761adfb4811d282e7d0051f9cdc58ac6958634feef2e24563b800a38259756a5847e0c6b0d8a3b2b6c62cb74b5
+  metadata.gz: 9f4bf3f86997214af675d7a21c40c4270fbb3e8c93093dbdacabf08da89a4ed054221e27345702e4e48da4c945ec12ef4291c7c46a412ee7a02d82fadd6e1db5
+  data.tar.gz: a2c0ea8a963da6d8aff07dca5bdb90c517e1ae44a64b34b5f1e70903279b33239f6182b1bd8ddef22de17d45c7eb0dda86f101d3ed0cfd4461ea080357e11db2

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # CHANGELOG
 
+## 2.1.0 (2026-07-10)
+
+- Add `block_action` registration for message-level block action buttons outside modal callbacks
+- Add `user_session_resolver` and `event_dispatcher` configuration hooks for session lookup and background event dispatch
+- Acknowledge Slack event retries with an empty 200 response so duplicate deliveries do not run handlers twice
+- Skip `bot_message` event payloads at ingress to avoid handler loops from bot echoes
+- Retry Slack API requests once when rate limited, sleeping at most 3 seconds before the retry
+- Fix `scheduled_messages_list` to send the `channel` argument to the Slack API
+- Fix team verification when `SLACK_TEAM_ID` is unset so requests are rejected instead of matching any team
+- Raise `SlackBot::Errors::ConfigurationError` when required configuration is missing
+- Raise `SlackBot::Errors::BlockActionNotImplemented` when an unregistered block action is submitted
+- Require `faraday` `>= 2.14.3`
+
+## 2.0.1 (2026-05-31)
+
+- Allow `grape` 3.x by expanding the runtime dependency to `< 4.0`
+- Replace SimpleCov and JUnit formatter test wiring with Polyrun coverage and failure reporting
+- Move lint and type-check execution into Polyrun `before_suite` hooks
+- Refresh development and release tooling, CI, and repository maintenance configuration
+
 ## 2.0.0 (2025-11-06)
 
 - Fix status code handling for empty/false responses - ensure 200 OK instead of 204 No Content

data/README.md

@@ -1,6 +1,6 @@
 # grape-slack-bot.rb
 
-[![Gem Version](https://badge.fury.io/rb/grape-slack-bot.svg)](https://badge.fury.io/rb/grape-slack-bot) [![Test Status](https://github.com/amkisko/grape-slack-bot.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/grape-slack-bot.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/grape-slack-bot.rb/graph/badge.svg?token=VIZ94XFOR3)](https://codecov.io/gh/amkisko/grape-slack-bot.rb)
+[![Gem Version](https://badge.fury.io/rb/grape-slack-bot.svg)](https://badge.fury.io/rb/grape-slack-bot) [![Test Status](https://github.com/amkisko/grape-slack-bot.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/grape-slack-bot.rb/actions/workflows/test.yml)
 
 Extensible Slack bot implementation gem for [ruby-grape](https://github.com/ruby-grape/grape) with support for slash commands, interactive components, events, and views.
 
@@ -55,10 +55,18 @@ SlackBot::DevConsole.enabled = Rails.env.development?
 SlackBot::Config.configure do
   callback_storage Rails.cache
   callback_user_finder ->(id) { User.active.find_by(id: id) }
+  user_session_resolver ->(team_id, user_id) do
+    uid = OmniAuth::Strategies::SlackOpenid.generate_uid(team_id, user_id)
+    UserSession.find_by(uid: uid, provider: UserSession.slack_openid_provider)
+  end
+  event_dispatcher ->(handler:, params:, current_user:) do
+    SlackEventJob.perform_later(handler.name, params.deep_stringify_keys, current_user&.id)
+  end
 
   # Register event handlers
   event :app_home_opened, MySlackBot::AppHomeOpenedEvent
   interaction MySlackBot::AppHomeInteraction
+  block_action :approve_request, MySlackBot::ApproveRequestInteraction
 
   # Register slash command handlers
   slash_command_endpoint :game, MySlackBot::Game::MenuCommand do
@@ -74,11 +82,6 @@ class SlackBotApi < Grape::API
       SlackBot::Config.current_instance
     end
 
-    def resolve_user_session(team_id, user_id)
-      uid = OmniAuth::Strategies::SlackOpenid.generate_uid(team_id, user_id)
-      UserSession.find_by(uid: uid, provider: UserSession.slack_openid_provider)
-    end
-
     def current_user_session
       # NOTE: fetch_team_id and fetch_user_id are provided by SlackBot::GrapeHelpers
       @current_user_session ||=
@@ -509,11 +512,16 @@ The gem implements Slack's signature verification with the following security fe
 
 ## Development
 
-```bash
+```sh
 bundle install
-bundle exec rspec
-bundle exec rbs validate
-bundle exec standardrb --fix
+bundle exec polyrun hook run before_suite
+bundle exec polyrun parallel-rspec --workers 1 --merge-failures
+```
+
+To generate a local coverage report with Polyrun:
+
+```sh
+POLYRUN_COVERAGE=1 bundle exec polyrun parallel-rspec --workers 1 --merge-failures
 ```
 
 For development and testing purposes you can use [Cloudflare Argo Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps) to expose your local development environment to the internet.
@@ -528,7 +536,7 @@ For easiness of getting information, most of endpoints have `SlackBot::DevConsol
 
 ### Code Quality
 
-The gem uses [StandardRB](https://github.com/standardrb/standard) for consistent code style. Run `bundle exec standardrb --fix` to automatically fix style issues.
+The gem uses a StandardRB-compatible RuboCop configuration for consistent code style, with Polyrun orchestrating the lint and type-check hooks. Run `bundle exec polyrun hook run before_suite` to execute the configured checks.
 
 The gem includes [RBS](https://github.com/ruby/rbs) type signatures in the `sig/` directory for better type checking and IDE support. Type signatures are included in the gem package.
 
@@ -557,7 +565,7 @@ gem push grape-slack-bot-*.gem
 Or use the release script:
 
 ```sh
-usr/bin/release.sh
+usr/bin/release.rb
 ```
 
 ## License

data/grape-slack-bot.gemspec

@@ -23,26 +23,29 @@ Gem::Specification.new do |gem|
     "rubygems_mfa_required" => "true"
   }
 
-  gem.executables = Dir.glob("bin/*").map { |f| File.basename(f) }
-  gem.files = Dir.glob("lib/**/*.rb") + Dir.glob("bin/**/*") + Dir.glob("sig/**/*.rbs") + root_files
+  gem.files = Dir.glob("lib/**/*.rb") + Dir.glob("sig/**/*.rbs") + root_files
 
   gem.required_ruby_version = ">= 3"
   gem.require_paths = ["lib"]
 
   gem.add_runtime_dependency "rack", "~> 3.0"
-  gem.add_runtime_dependency "grape", ">= 1.6", "< 3.0"
-  gem.add_runtime_dependency "faraday", "~> 2.0"
+  gem.add_runtime_dependency "grape", ">= 1.6", "< 4.0"
+  gem.add_runtime_dependency "faraday", ">= 2.14.3", "< 3.0"
   gem.add_runtime_dependency "activesupport", ">= 6.1", "< 9.0"
 
-  gem.add_development_dependency "rspec", "~> 3.12"
+  gem.add_development_dependency "rspec", "~> 3"
+  gem.add_development_dependency "polyrun", "~> 1.5.0"
   gem.add_development_dependency "webmock", "~> 3"
-  gem.add_development_dependency "rake", "~> 13.0"
-  gem.add_development_dependency "simplecov", "~> 0.21"
-  gem.add_development_dependency "rspec_junit_formatter", "~> 0.6"
-  gem.add_development_dependency "simplecov-cobertura", "~> 3"
-  gem.add_development_dependency "standard", "~> 1.0"
-  gem.add_development_dependency "appraisal", "~> 2.4"
-  gem.add_development_dependency "memory_profiler", "~> 1.0"
-  gem.add_development_dependency "rbs", "~> 3.0"
-  gem.add_development_dependency "rack-test", "~> 2.0"
+  gem.add_development_dependency "rake", "~> 13"
+  gem.add_development_dependency "standard", "~> 1.52"
+  gem.add_development_dependency "standard-custom", "~> 1.0"
+  gem.add_development_dependency "standard-performance", "~> 1.8"
+  gem.add_development_dependency "standard-rspec", "~> 0.3"
+  gem.add_development_dependency "rubocop-rspec", "~> 3.8"
+  gem.add_development_dependency "rubocop-thread_safety", "~> 0.7"
+  gem.add_development_dependency "appraisal", "~> 2"
+  gem.add_development_dependency "bundler-audit", "~> 0.9"
+  gem.add_development_dependency "memory_profiler", "~> 1"
+  gem.add_development_dependency "rbs", "~> 3"
+  gem.add_development_dependency "rack-test", "~> 2"
 end

data/lib/slack_bot/api_client.rb

@@ -2,7 +2,23 @@ require "faraday"
 
 module SlackBot
   class ApiResponse
+    # Cap in-request sleep so rate-limit retries do not hold web workers for Slack's default Retry-After.
+    RATE_LIMIT_RETRY_SLEEP_SECONDS = 3
+
     attr_reader :response
+
+    def self.from_request(&block)
+      response = new(&block)
+      return response unless response.rate_limited?
+
+      Kernel.sleep(rate_limit_retry_sleep_seconds(response.retry_after))
+      new(&block)
+    end
+
+    def self.rate_limit_retry_sleep_seconds(retry_after)
+      [retry_after.to_i, RATE_LIMIT_RETRY_SLEEP_SECONDS].min
+    end
+
     def initialize(&block)
       @response = block.call
       SlackBot::DevConsole.log_output "#{self.class.name}: #{response.body}"
@@ -47,76 +63,37 @@ module SlackBot
     REQUEST_TIMEOUT = 30
     # Connection timeout in seconds
     CONNECTION_TIMEOUT = 10
+    TOKEN_FORMAT = /\Axox[bpa]-/
 
     attr_reader :client
-    def initialize(authorization_token: ENV["SLACK_BOT_API_TOKEN"])
-      authorization_token_available = !authorization_token.nil? && authorization_token.is_a?(String) && !authorization_token.empty?
-      unless authorization_token_available
-        raise SlackBot::Errors::SlackApiError.new("Slack bot API token is not set")
-      end
-
-      # Validate token format
-      # Bot tokens: xoxb-, User tokens: xoxp-, App tokens: xoxa-
-      # For this gem, we primarily expect bot tokens (xoxb-)
-      # Allow test tokens (starting with "test_") for testing purposes
-      unless authorization_token.start_with?("test_") || authorization_token.match?(/\Axox[bpa]-/)
-        raise SlackBot::Errors::SlackApiError.new("Invalid Slack API token format")
-      end
 
-      @client =
-        Faraday.new do |conn|
-          conn.request :url_encoded
-          conn.adapter Faraday.default_adapter
-          conn.url_prefix = SLACK_API_BASE_URL
-          conn.headers["Content-Type"] = "application/json; charset=utf-8"
-          conn.headers["Authorization"] = "Bearer #{authorization_token}"
-          conn.options.timeout = REQUEST_TIMEOUT
-          conn.options.open_timeout = CONNECTION_TIMEOUT
-        end
+    def initialize(authorization_token: ENV["SLACK_BOT_API_TOKEN"])
+      validate_authorization_token!(authorization_token)
+      @client = build_client(authorization_token)
     end
 
     def views_open(trigger_id:, view:)
-      ApiResponse.new do
-        client.post("views.open", {trigger_id: trigger_id, view: view}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("views.open", {trigger_id: trigger_id, view: view}.to_json) }
     end
 
     def views_update(view_id:, view:)
-      ApiResponse.new do
-        client.post("views.update", {view_id: view_id, view: view}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("views.update", {view_id: view_id, view: view}.to_json) }
     end
 
     def chat_post_message(channel:, text:, blocks:)
-      ApiResponse.new do
-        client.post("chat.postMessage", {channel: channel, text: text, blocks: blocks}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.postMessage", {channel: channel, text: text, blocks: blocks}.to_json) }
     end
 
     def chat_update(channel:, ts:, text:, blocks:)
-      ApiResponse.new do
-        client.post("chat.update", {channel: channel, ts: ts, text: text, blocks: blocks}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.update", {channel: channel, ts: ts, text: text, blocks: blocks}.to_json) }
     end
 
     def chat_delete(channel:, ts:)
-      ApiResponse.new do
-        client.post("chat.delete", {channel: channel, ts: ts}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.delete", {channel: channel, ts: ts}.to_json) }
     end
 
     def chat_unfurl(channel:, ts:, unfurls:, source: nil, unfurl_id: nil, user_auth_blocks: nil, user_auth_message: nil, user_auth_required: nil, user_auth_url: nil)
-      ApiResponse.new do
+      perform_request do
         client.post("chat.unfurl", {
           channel: channel,
           ts: ts,
@@ -128,98 +105,92 @@ module SlackBot
           user_auth_required: user_auth_required,
           user_auth_url: user_auth_url
         }.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
       end
     end
 
     def chat_schedule_message(channel:, text:, post_at:, blocks: nil)
-      ApiResponse.new do
-        client.post("chat.scheduleMessage", {channel: channel, text: text, post_at: post_at, blocks: blocks}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.scheduleMessage", {channel: channel, text: text, post_at: post_at, blocks: blocks}.to_json) }
     end
 
     def scheduled_messages_list(channel: nil, cursor: nil, latest: nil, limit: nil, oldest: nil, team_id: nil)
-      ApiResponse.new do
-        client.post("scheduled_messages.list", {
-          channel: channel,
-          cursor: cursor,
-          latest: latest,
-          limit: limit,
-          oldest: oldest,
-          team_id: team_id
-        }.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      args = compact_payload(channel: channel, cursor: cursor, limit: limit, latest: latest, oldest: oldest, team_id: team_id)
+      perform_request { client.post("scheduled_messages.list", args.to_json) }
     end
 
     def chat_delete_scheduled_message(channel:, scheduled_message_id:)
-      ApiResponse.new do
-        client.post("chat.deleteScheduledMessage", {channel: channel, scheduled_message_id: scheduled_message_id}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.deleteScheduledMessage", {channel: channel, scheduled_message_id: scheduled_message_id}.to_json) }
     end
 
     def chat_get_permalink(channel:, message_ts:)
-      ApiResponse.new do
-        client.post("chat.getPermalink", {channel: channel, message_ts: message_ts}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("chat.getPermalink", {channel: channel, message_ts: message_ts}.to_json) }
     end
 
     def users_info(user_id:)
-      ApiResponse.new do
-        client.post("users.info", {user: user_id}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("users.info", {user: user_id}.to_json) }
     end
 
     def views_publish(user_id:, view:)
-      ApiResponse.new do
-        client.post("views.publish", {user_id: user_id, view: view}.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      perform_request { client.post("views.publish", {user_id: user_id, view: view}.to_json) }
     end
 
     def users_list(cursor: nil, limit: 200, include_locale: nil, team_id: nil)
-      args = {}
-      args[:cursor] = cursor if cursor
-      args[:limit] = limit if limit
-      args[:include_locale] = include_locale if include_locale
-      args[:team_id] = team_id if team_id
-      ApiResponse.new do
-        client.post("users.list", args.to_json)
-      rescue Faraday::Error => e
-        raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
-      end
+      args = compact_payload(cursor: cursor, limit: limit, include_locale: include_locale, team_id: team_id)
+      perform_request { client.post("users.list", args.to_json) }
     end
 
     def chat_post_ephemeral(channel:, user:, text:, as_user: nil, attachments: nil, blocks: nil, icon_emoji: nil, icon_url: nil, link_names: nil, parse: nil, thread_ts: nil, username: nil)
-      args = {}
-      args[:channel] = channel
-      args[:user] = user
-      args[:text] = text if text
-      args[:as_user] = as_user if as_user
-      args[:attachments] = attachments if attachments
-      args[:blocks] = blocks if blocks
-      args[:icon_emoji] = icon_emoji if icon_emoji
-      args[:icon_url] = icon_url if icon_url
-      args[:link_names] = link_names if link_names
-      args[:parse] = parse if parse
-      args[:thread_ts] = thread_ts if thread_ts
-      args[:username] = username if username
-      ApiResponse.new do
-        client.post("chat.postEphemeral", args.to_json)
+      args = compact_payload(
+        channel: channel,
+        user: user,
+        text: text,
+        as_user: as_user,
+        attachments: attachments,
+        blocks: blocks,
+        icon_emoji: icon_emoji,
+        icon_url: icon_url,
+        link_names: link_names,
+        parse: parse,
+        thread_ts: thread_ts,
+        username: username
+      )
+      perform_request { client.post("chat.postEphemeral", args.to_json) }
+    end
+
+    private
+
+    def perform_request(&block)
+      ApiResponse.from_request do
+        block.call
       rescue Faraday::Error => e
         raise SlackBot::Errors::SlackApiError.new("Network error: #{e.message}")
       end
     end
+
+    def validate_authorization_token!(authorization_token)
+      raise SlackBot::Errors::SlackApiError.new("Slack bot API token is not set") unless valid_authorization_token?(authorization_token)
+      return if authorization_token.start_with?("test_") || authorization_token.match?(TOKEN_FORMAT)
+
+      raise SlackBot::Errors::SlackApiError.new("Invalid Slack API token format")
+    end
+
+    def valid_authorization_token?(authorization_token)
+      authorization_token.is_a?(String) && !authorization_token.empty?
+    end
+
+    def build_client(authorization_token)
+      Faraday.new do |conn|
+        conn.request :url_encoded
+        conn.adapter Faraday.default_adapter
+        conn.url_prefix = SLACK_API_BASE_URL
+        conn.headers["Content-Type"] = "application/json; charset=utf-8"
+        conn.headers["Authorization"] = "Bearer #{authorization_token}"
+        conn.options.timeout = REQUEST_TIMEOUT
+        conn.options.open_timeout = CONNECTION_TIMEOUT
+      end
+    end
+
+    def compact_payload(**payload)
+      payload.compact
+    end
   end
 end

data/lib/slack_bot/callback.rb

@@ -94,7 +94,7 @@ module SlackBot
     def user
       @user ||= begin
         user_id = data&.dig(:user_id)
-        config.callback_user_finder_method.call(user_id) if user_id.present?
+        config.callback_user_finder!.call(user_id) if user_id.present?
       end
     end
 
@@ -137,7 +137,7 @@ module SlackBot
 
     def handler_class=(handler_class)
       new_class_name = handler_class&.name
-      config.find_handler_class(class_name)
+      config.find_handler_class(new_class_name)
 
       self.class_name = new_class_name
     end
@@ -162,7 +162,7 @@ module SlackBot
     def read_view_callback_id
       return if view_id.blank?
 
-      config.callback_storage_instance.read(view_storage_key)
+      config.callback_storage!.read(view_storage_key)
     end
 
     private
@@ -196,18 +196,18 @@ module SlackBot
     end
 
     def read_data
-      config.callback_storage_instance.read(storage_key)
+      config.callback_storage!.read(storage_key)
     end
 
     def write_data(data, expires_in: nil)
       expires_in ||= CALLBACK_RECORD_EXPIRES_IN
-      config.callback_storage_instance.write(view_storage_key, id, expires_in: expires_in) if view_id.present?
-      config.callback_storage_instance.write(storage_key, data, expires_in: expires_in)
+      config.callback_storage!.write(view_storage_key, id, expires_in: expires_in) if view_id.present?
+      config.callback_storage!.write(storage_key, data, expires_in: expires_in)
     end
 
     def delete_data
-      config.callback_storage_instance.delete(view_storage_key) if view_id.present?
-      config.callback_storage_instance.delete(storage_key)
+      config.callback_storage!.delete(view_storage_key) if view_id.present?
+      config.callback_storage!.delete(storage_key)
     end
   end
 end

data/lib/slack_bot/config.rb

@@ -17,11 +17,45 @@ module SlackBot
       @callback_storage_instance = klass
     end
 
+    def callback_storage!
+      return @callback_storage_instance if @callback_storage_instance
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "callback_storage is not configured; call SlackBot::Config.configure { |config| config.callback_storage ... }"
+      )
+    end
+
     attr_reader :callback_user_finder_method
     def callback_user_finder(method_lambda)
       @callback_user_finder_method = method_lambda
     end
 
+    def callback_user_finder!
+      return @callback_user_finder_method if @callback_user_finder_method
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "callback_user_finder is not configured; call SlackBot::Config.configure { |config| config.callback_user_finder ... }"
+      )
+    end
+
+    attr_reader :user_session_resolver_method
+    def user_session_resolver(method_lambda)
+      @user_session_resolver_method = method_lambda
+    end
+
+    def user_session_resolver!
+      return @user_session_resolver_method if @user_session_resolver_method
+
+      raise SlackBot::Errors::ConfigurationError.new(
+        "user_session_resolver is not configured; call SlackBot::Config.configure { |config| config.user_session_resolver ... }"
+      )
+    end
+
+    attr_reader :event_dispatcher_method
+    def event_dispatcher(method_lambda)
+      @event_dispatcher_method = method_lambda
+    end
+
     def interaction(interaction_klass, handler_name: nil)
       handler_name ||= interaction_klass.name
       handler_class(handler_name, interaction_klass)
@@ -78,6 +112,17 @@ module SlackBot
       @menu_options[action_id.to_sym]
     end
 
+    def block_action(action_id, interaction_klass, handler_name: nil)
+      @block_actions ||= {}
+      @block_actions[action_id.to_sym] = interaction_klass
+      interaction(interaction_klass, handler_name: handler_name)
+    end
+
+    def find_block_action(action_id)
+      @block_actions ||= {}
+      @block_actions[action_id.to_sym]
+    end
+
     def handler_class(class_name, klass)
       @handler_classes ||= {}
       return if class_name.nil?
@@ -130,7 +175,10 @@ module SlackBot
     end
 
     def find_command_config(text)
-      route_key = text.scan(/^(#{routes.keys.join("|")})(?:\s|$)/).flatten.first
+      return if routes.blank?
+
+      route_pattern = routes.keys.map { |route_key| Regexp.escape(route_key) }.join("|")
+      route_key = text.scan(/^(#{route_pattern})(?:\s|$)/).flatten.first
       return if route_key.blank?
 
       routes[route_key]

data/lib/slack_bot/errors.rb

@@ -18,6 +18,12 @@ module SlackBot
     class MenuOptionsNotImplemented < SlackBot::Error
     end
 
+    class BlockActionNotImplemented < SlackBot::Error
+      def initialize
+        super("Block action is not implemented")
+      end
+    end
+
     class CallbackNotFound < SlackBot::Error
     end
 
@@ -82,5 +88,8 @@ module SlackBot
 
     class NotImplementedError < SlackBot::Error
     end
+
+    class ConfigurationError < SlackBot::Error
+    end
   end
 end