slack_interactive_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3441dda9fe55fa50b7780ddf42a8695425785bd91dce7d3993c84878cc6edee0
+  data.tar.gz: eca34dfd218a21d82031db317454ebd53f62c1196a0cdb8c9ebc487a64409da6
+SHA512:
+  metadata.gz: 9682852dbf51d73af56389b70816bc50c321a2b61023f3d64abb8082366cfaf2f6b7ed83aef1edf8b9db55d07f16595a2fb77e09bb3a73cba29d7f22d2215c0c
+  data.tar.gz: 775ad4048c834105a706cef29ff8fad6a8eea2779ad4270317dbbb9bfb45eb4281f074c9513f967a3dc3c8734b02c35ff7dfd0cc11f333b384753ee4f012f6a4

data/lib/slack_interactive_client/base_interaction.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'csv'
+require_relative 'concerns/slack_interaction_params'
+require_relative 'concerns/slack_pattern_interaction'
+
+module SlackInteractiveClient
+  class BaseInteraction
+    include ::SlackInteractionParams
+    include ::SlackPatternInteraction
+
+    class << self
+      attr_reader :interaction_config, :interaction_channels, :pattern_string
+
+      # EXAMPLE
+      #
+      # interaction_options can_interact: { only: ['micah.bowie'] }, channels: []
+      def interaction_options(options = {})
+        set_interaction_config(options[:can_interact])
+        @interaction_channels = options[:channels].empty? ? :all : options[:channels]
+      end
+
+      def interaction_pattern(pattern_string = '')
+        @pattern_string = pattern_string.strip.squeeze
+      end
+
+      private
+
+      def set_interaction_config(options)
+        @interaction_config ||= { all: [], only: [], except: [] }
+        return unless options.present?
+
+        if options == :all
+          @interaction_config[:all] << :all
+          return
+        end
+
+        if options[:only] && options.is_a?(Hash)
+          @interaction_config[:only] += Array(options[:only])
+        end
+
+        if options[:except] && options.is_a?(Hash)
+          @interaction_config[:except] += Array(options[:except])
+        end
+      end
+    end
+
+    attr_reader :interaction_params
+    def initialize(webhook_params = {})
+      @interaction_params = webhook_params
+      @pattern = self.class.pattern_string
+      @extracted_values = {}
+      extract_values(slack_message_text)
+    end
+
+    def call
+      unless can_interact?
+        send_message('You are not authorized to interact with this command or interaction is in an invalid channel.')
+        return
+      end
+      execute
+    end
+
+    def execute
+      puts "Method not reimplemented by child"
+    end
+
+    private
+
+    def direct_message?
+      slack_channel_name == ::SlackInteractionParams::DIRECT_MESSAGE_CHANNEL
+    end
+
+    def can_user_interact?
+      # If not configuration is set then we allow any user to interact
+      return true if self.class.interaction_config.nil?
+
+      all_conditions = self.class.interaction_config[:all]
+      only_conditions = self.class.interaction_config[:only]
+      except_conditions = self.class.interaction_config[:except]
+
+      return true if all_conditions.empty? && only_conditions.empty? && except_conditions.empty?
+      return true if all_conditions.include?(:all)
+      return true if only_conditions.include?(slack_user_name)
+      return false if except_conditions.include?(slack_user_name)
+
+      false
+    end
+
+    def interactive_channel?
+      # If not configuration is set then we allow any user to interact
+      return true if self.class.interaction_channels.nil?
+
+      interaction_channels = self.class.interaction_channels
+
+      return true if interaction_channels == :all
+      return true if interaction_channels == :direct_message && direct_message?
+      return false if interaction_channels == :direct_message && !direct_message?
+      return false unless interaction_channels.is_a?(Array)
+      return true if direct_message? && interaction_channels.include?(:direct_message)
+      return true if interaction_channels.include?(slack_channel_name)
+
+      false
+    end
+
+    def can_interact?
+      can_user_interact? && interactive_channel?
+    end
+
+    def send_message(message)
+      ::SlackInteractiveClient::Client.send_message(message, slack_channel_id)
+    end
+
+    def send_csv(csv_data)
+      csv_content ||= CSV.generate do |csv|
+        csv << csv_data.dig(:headers)
+        csv_data.dig(:rows).each { |row| csv << row }
+      end
+      csv_data[:content] = csv_content
+
+      ::SlackInteractiveClient::Client.send_csv(csv_data, slack_channel_id)
+    end
+
+    def send_message_with_template(template, args)
+      ::SlackInteractiveClient::Client.send_message_with_template(template, args.merge(channel: slack_channel_id))
+    end
+  end
+end

data/lib/slack_interactive_client/bot.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#  EXAMPLE
+# 
+# SlackInteractiveClient::Bot.define do
+#   interaction :hello_world, HelloWorldInteraction
+# end
+#
+require 'active_support'
+
+module SlackInteractiveClient
+  class Bot
+    class << self
+      attr_reader :interactions
+
+      def define(&block)
+        @interactions ||= HashWithIndifferentAccess.new
+        instance_exec(&block)
+      end
+
+      def interaction(name, interaction_class)
+        @interactions[name] = interaction_class
+      end
+    end
+  end
+end

data/lib/slack_interactive_client/client.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'slack-ruby-client'
+require_relative 'configuration'
+require_relative 'message'
+require_relative 'message_stop_guard'
+
+module SlackInteractiveClient
+  class Client
+    class << self
+
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= ::SlackInteractiveClient::Configuration.new
+      end
+
+      def reset
+        @configuration = nil
+      end
+
+      def configure
+        yield configuration
+        ::Slack.configure do |config|
+          config.token = configuration.auth_token
+          config.logger = configuration.logger_instance
+        end
+        "SlackInteractiveClient::Client Configured!"
+      end
+
+      def send_message_with_template(template_name, args = {})
+        compilation = ::SlackInteractiveClient::Message.compile(template_name, args)
+
+        web_client.chat_postMessage(
+          channel: compilation.channel,
+          blocks: compilation.blocks,
+          as_user: true,
+        )
+
+        if compilation.csv? && compilation.csv_data[:csv][:content]
+          web_client.files_upload(
+            channels: compilation.channel,
+            content: compilation.csv_data[:csv][:content],
+            title: compilation.csv_data[:csv][:title],
+            filename: compilation.csv_data[:csv][:filename],
+            initial_comment: compilation.csv_data[:csv][:comment],
+            as_user: true,
+          )
+        end
+        return "Message sent by: SlackInteractiveClient::Client"
+      rescue ::Slack::Web::Api::Errors::SlackError => e
+        puts "An error occurred when sending the message: #{e.message}"
+      end
+
+      def send_message(message, channel)
+        scrubbed = ::SlackInteractiveClient::MessageStopGuard.scrubber.call(message)
+        web_client.chat_postMessage(
+          channel: channel,
+          blocks: [{ type: 'rich_text', elements: [ type: 'rich_text_section', elements: [ { type: 'text', text: scrubbed } ] ] }],
+          as_user: true,
+        )
+        return "Message sent by: SlackInteractiveClient::Client"
+      rescue ::Slack::Web::Api::Errors::SlackError => e
+        puts "An error occurred when sending the message: #{e.message}"
+      end
+
+      def send_csv(csv_data, channel)
+        web_client.files_upload(
+          channels: channel,
+          content: csv_data[:content],
+          title: csv_data[:title],
+          filename: csv_data[:filename],
+          initial_comment: csv_data[:comment],
+          as_user: true,
+        )
+        return "Message sent by: SlackInteractiveClient::Client"
+      rescue ::Slack::Web::Api::Errors::SlackError => e
+        puts "An error occurred when sending the message: #{e.message}"
+      end
+
+      private
+
+      def web_client
+        ::Slack::Web::Client.new
+      end
+    end
+  end
+end

data/lib/slack_interactive_client/concerns/slack_interaction_params.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module SlackInteractionParams
+  DIRECT_MESSAGE_CHANNEL = "directmessage".freeze
+
+  def slack_command
+    interaction_params[:command]
+  end
+
+  def slack_user_name
+    interaction_params[:user_name]
+  end
+
+  def slack_token
+    interaction_params[:token]
+  end
+
+  def slack_team_id
+    interaction_params[:team_id]
+  end
+
+  def slack_channel_id
+    interaction_params[:channel_id]
+  end
+
+  def slack_message_text
+    return nil unless interaction_params[:text].present? && interaction_params[:text].is_a?(String)
+
+    interaction_params[:text].strip.squeeze
+  end
+
+  def slack_user_id
+    interaction_params[:user_id]
+  end
+
+  def slack_response_url
+    interaction_params[:response_url]
+  end
+
+  def slack_channel_name
+    interaction_params[:channel_name]
+  end
+
+  def slack_team_domain
+    interaction_params[:team_domain]
+  end
+end

data/lib/slack_interactive_client/concerns/slack_pattern_interaction.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'active_support'
+
+module SlackPatternInteraction
+  def method_missing(method_name, *arguments, &block)
+    if @extracted_values.has_key?(method_name.to_s)
+      @extracted_values[method_name.to_s]
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @extracted_values.has_key?(method_name.to_s) || super
+  end
+
+  private
+
+  def extract_values(string)
+    return {} if string.blank?
+    # Find all dynamic parts of the pattern
+    dynamic_parts = @pattern.scan(/\$\[(.*?)\]/).flatten
+
+    # Create a regex pattern replacing dynamic parts with capture groups
+    regex_pattern = @pattern.gsub(/\$\[.*?\]/, '(\w+)')
+    regex = Regexp.new(regex_pattern)
+
+    # Match the string with the regex
+    match = string.match(regex)
+
+    return unless match
+
+    # Iterate over each capture and store in the hash
+    dynamic_parts.each_with_index do |variable_name, index|
+      @extracted_values[variable_name] = match[index + 1]
+    end
+  end
+end

data/lib/slack_interactive_client/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  class Configuration
+    attr_accessor :auth_token, :redis_instance, :logger_instance, :base_controller_class, :signing_secret
+
+    def initialize
+      @base_controller_class = "ApplicationController"
+    end
+  end
+end

data/lib/slack_interactive_client/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  class Engine < ::Rails::Engine
+    isolate_namespace SlackInteractiveClient
+  end
+end

data/lib/slack_interactive_client/interactions/unknown_command_interaction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../base_interaction"
+
+module SlackInteractiveClient
+  class UnknownCommandInteraction < BaseInteraction
+    interaction_options can_interact: :all, channels: :all
+
+    def execute
+      response = "Hmmm. I don't know that command. If you think I should double check your slack configuration and your interaction definitions"
+      send_message(response)
+    end
+  end
+end

data/lib/slack_interactive_client/message/compilation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  class Message
+    class Compilation
+      attr_reader :payload, :csv_message, :csv_data
+      def initialize(payload, csv_message = false, csv_data = {})
+        @payload = payload
+        @csv_message = csv_message
+        @csv_data = csv_data
+      end
+
+      def blocks
+        payload[:blocks]&.to_json
+      end
+
+      def channel
+        if payload[:channel].is_a?(Array)
+          payload[:channel].first
+        elsif payload[:channel].is_a?(String)
+          payload[:channel]
+        end
+      end
+
+      alias csv? csv_message
+    end
+  end
+end

data/lib/slack_interactive_client/message.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'slack-ruby-client'
+require_relative './message/compilation'
+require_relative 'message_stop_guard'
+
+module SlackInteractiveClient
+  class Message
+    class << self
+      def define(&block)
+        @templates ||= {}
+        instance_exec(&block)
+      end
+
+      def compile(template_name, args = {})
+        template = @templates.fetch(template_name) do
+          raise ArgumentError, "Template #{template_name} not defined"
+        end
+        template.reset_message_blocks
+        template.compile(args)
+      end
+
+      def template(name, &block)
+        instance = new
+        instance.instance_eval(&block)
+        @templates[name] = instance
+      end
+    end
+
+    attr_reader :name, :blocks, :environment, :channels, :tagged_users
+
+    def initialize
+      @blocks = []
+      @environment = nil
+      @channels = []
+      @tagged_users = []
+      @csv_data_block = []
+      @list_items = []
+    end
+
+    def template(name, &block)
+      @name = name
+      instance_eval(&block) if block_given?
+    end
+
+    def text(text = nil , &block)
+      @text_block = text.nil? ? block : Proc.new {|x| text  }
+    end
+
+    def title(title = nil , &block)
+      @title_block = title.nil? ? block : Proc.new {|x| title  }
+    end
+
+    def markdown_section(markdown = nil, &block)
+      @markdown_block = markdown.nil? ? block : Proc.new {|x| markdown  }
+    end
+
+    def list_section(&block)
+      @list_block = block
+    end
+
+    def list_item(item)
+      @list_items << item
+    end
+
+    def environment(env)
+      @environment = env
+    end
+
+    def channel(channel)
+      @channels << channel
+    end
+
+    def mention(*users)
+      # Format the user mention strings
+      @tagged_users = users.flatten
+      @user_mentions = users.flatten.join(' ')
+    end
+
+    def csv_data(bool = false)
+      @include_csv_data = bool
+    end
+
+    def compile(args = {})
+      construct_environment_block if @environment
+      construct_title_block(args) if @title_block
+      construct_text_block(args) if @text_block
+      construct_markdown_block(args) if @markdown_block
+      construct_list_block(args) if @list_block
+      construct_csv(args) if @include_csv_data
+      add_user_mentions if @tagged_users.any?
+
+      message_payload = {
+        blocks: @blocks,
+        channel: args[:channel] || @channels,
+      }
+
+      ::SlackInteractiveClient::Message::Compilation.new(
+        message_payload,
+        @include_csv_data,
+        @csv_data
+      )
+    end
+
+    def reset_message_blocks
+      @blocks = []
+      @list_items = []
+    end
+
+    private
+
+    def construct_environment_block
+      env = @environment.upcase
+      scrubbed = ::SlackInteractiveClient::MessageStopGuard.scrubber.call(env)
+      add_block(type: 'section', text: { type: 'mrkdwn', text: "Environment: [#{scrubbed}] \n" })
+    end
+
+    def construct_title_block(args)
+      text_content = @title_block.call(args)
+      scrubbed = ::SlackInteractiveClient::MessageStopGuard.scrubber.call(text_content)
+      add_block(type: 'header', text: { type: 'plain_text', text: scrubbed })
+    end
+
+    def construct_text_block(args)
+      text_content = @text_block.call(args)
+      scrubbed = ::SlackInteractiveClient::MessageStopGuard.scrubber.call(text_content)
+      add_block(type: 'rich_text', elements: [ type: 'rich_text_section', elements: [ { type: 'text', text: scrubbed } ] ])
+    end
+
+    def construct_markdown_block(args)
+      markdown_content = @markdown_block.call(args)
+      scrubbed = MessageStopGuard.scrubber.call(markdown_content)
+      add_block(type: 'section', text: { type: 'mrkdwn', text: "```#{scrubbed}```" })
+    end
+
+    def construct_list_block(args)
+      @list_block.call(args)
+      list_elements_content = construct_list_items_block
+      add_block(type: 'rich_text', elements: [{ type: "rich_text_list", style: "bullet", elements: list_elements_content }])
+    end
+
+    def construct_list_items_block
+      @list_items.map do |list_item|
+        scrubbed = ::SlackInteractiveClient::MessageStopGuard.scrubber.call(list_item)
+        {
+          "type": "rich_text_section",
+          "elements": [
+            {
+              "type": "text",
+              "text": scrubbed
+            },
+          ]
+        }
+      end
+    end
+
+    def add_user_mentions
+      unless @tagged_users.empty?
+        # Format a string that includes all user mentions with Slack mention syntax
+        user_mentions = @tagged_users.map { |user| "<#{user}>" }.join(' ')
+
+        # Create a context block with all user mentions in one line
+        add_block({
+          type: 'context',
+          elements: [{ type: 'mrkdwn', text: "CC: #{user_mentions}" }]
+        })
+      end
+    end
+
+    def construct_csv(args)
+      return unless @include_csv_data
+
+      data = args.slice(:csv)
+      @csv_content ||= CSV.generate do |csv|
+        csv << args.dig(:csv, :headers)
+        args.dig(:csv, :rows).each { |row| csv << row }
+      end
+      data[:csv][:content] = @csv_content
+      @csv_data = data
+    end
+
+    def add_block(block)
+      @blocks << block
+    end
+  end
+end

data/lib/slack_interactive_client/message_stop_guard.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  class MessageStopGuard
+    FILTERED_SUBSTITUTION = '[FILTERED]'
+
+    SENSITIVE_KEY_SUFFIXES = %w[
+      number numbers ssn email date_of_birth secret token salt identity identity_fingerprint
+    ].freeze
+
+    # Builds a list of regex patterns for sensitive values
+    def self.build_sensitive_value_patterns
+      SENSITIVE_KEY_SUFFIXES.map do |key_suffix|
+        /(?<key>#{key_suffix}[:\\'"=>\s]*)(?<value>[\w-]+)/i
+      end
+    end
+
+    # Returns a lambda that scrubs sensitive information from a message
+    def self.scrubber
+      pii_patterns = build_sensitive_value_patterns
+
+      lambda do |raw_msg|
+        pii_patterns.reduce(raw_msg) do |msg, pii_regex|
+          msg.gsub(pii_regex) { |m| $~[:key] + FILTERED_SUBSTITUTION }
+        end
+      end
+    end
+  end
+end

data/lib/slack_interactive_client/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/slack_interactive_client/response_client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module SlackInteractiveClient
+  class ResponseClient
+    class << self
+      # { "response_type": "in_channel", "response_type": "ephemeral" }
+      # { "text": "text" }
+      # { "blocks": [ ] }
+      # { "replace_original": false" },
+      def respond(response_url, body)
+        ::HTTParty.post(response_url, 
+                      body: body.to_json, 
+                      headers: { 'Content-Type' => 'application/json' }
+                    )
+      end
+    end
+  end
+end

data/lib/slack_interactive_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SlackInteractiveClient
+  VERSION = "0.1.0"
+end

data/lib/slack_interactive_client.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/all'
+
+require_relative "slack_interactive_client/configuration"
+require_relative "slack_interactive_client/message_stop_guard"
+require_relative "slack_interactive_client/client"
+require_relative "slack_interactive_client/message/compilation"
+require_relative "slack_interactive_client/message"
+require_relative "slack_interactive_client/bot"
+require_relative "slack_interactive_client/railtie"
+require_relative "slack_interactive_client/response_client"
+require_relative "slack_interactive_client/interactions/unknown_command_interaction"
+require_relative "slack_interactive_client/base_interaction"
+require_relative "slack_interactive_client/engine"

data/spec/base_interaction_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+RSpec.describe SlackInteractiveClient::BaseInteraction do
+  class TestInteraction < ::SlackInteractiveClient::BaseInteraction
+    interaction_pattern "to $[name] the state $[state_name]"
+
+    def execute
+      return "hey #{name} welcome to #{state_name}"
+    end
+  end
+  let(:interaction_params) { { text: "to micah the state TEXAS"} }
+  let(:interaction_class) { TestInteraction.new(interaction_params) }
+
+  describe '#call' do
+    it 'stores the interactions' do
+      expect(interaction_class.call).to eq("hey micah welcome to TEXAS")
+    end
+  end
+end

data/spec/bot_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe SlackInteractiveClient::Bot do
+  let(:message) { described_class.new }
+
+  class HelloWorldInteraction; end
+
+  describe '#define' do
+    before do
+      described_class.define do
+        interaction :hello_world, HelloWorldInteraction
+      end
+    end
+
+    it 'stores the interactions' do
+      expect(described_class.interactions.size).to eq(1)
+      expect(described_class.interactions[:hello_world]).to eq(HelloWorldInteraction)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RSpec.describe SlackInteractiveClient::Client do
+  after do
+    described_class.reset
+  end
+
+  describe '#configuration' do
+    it 'creates a new instance of Configuration' do
+      expect(described_class.configuration).to be_instance_of(SlackInteractiveClient::Configuration)
+    end
+  end
+
+  describe '#reset' do
+    it 'creates and assigns a new instance of Configuration' do
+      configuration = described_class.configuration
+      described_class.reset
+      expect(described_class.configuration).not_to eq(configuration)
+    end
+  end
+
+  describe '#configure' do
+    let(:configuration_params) do
+      { auth_token: "a-token", logger_instance: 'Rails logger' }
+    end
+
+    it 'creates a new instance of Configuration from block' do
+      described_class.configure do |config|
+        config.auth_token = configuration_params[:auth_token]
+        config.logger_instance = configuration_params[:logger_instance]
+      end
+
+      expect(described_class.configuration.auth_token).to eq(configuration_params[:auth_token])
+      expect(described_class.configuration.logger_instance).to eq(configuration_params[:logger_instance])
+    end
+  end
+
+  describe '#version' do
+    it 'has a version number' do
+      expect(SlackInteractiveClient::VERSION).not_to be nil
+    end
+  end
+
+  describe '#send_message' do
+    let(:template_name) { :test_template }
+    let(:args) { { some: 'argument' } }
+    let(:compilation) do
+      instance_double("SlackInteractiveClient::Message::Compilation", 
+                      channel: 'C1234567890', 
+                      blocks: [], 
+                      csv?: false)
+    end
+
+    before do
+      allow(SlackInteractiveClient::Message).to receive(:compile).and_return(compilation)
+      allow_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage)
+      allow_any_instance_of(Slack::Web::Client).to receive(:files_upload)
+    end
+
+    it 'compiles the message and sends it to Slack' do
+      expect(SlackInteractiveClient::Message).to receive(:compile).with(template_name, args)
+      expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with(hash_including(:channel, :blocks, :as_user))
+      described_class.send_message(template_name, args)
+    end
+
+    context 'when the compilation includes csv data' do
+      let(:csv_data) do
+        {
+          csv: {
+            content: 'id,name\n1,Test',
+            title: 'Test CSV',
+            filename: 'test.csv',
+            comment: 'Here is your CSV!'
+          }
+        }
+      end
+
+      let(:compilation_with_csv) do
+        instance_double("SlackInteractiveClient::Message::Compilation",
+                        channel: 'C1234567890',
+                        blocks: [],
+                        csv?: true,
+                        csv_data: csv_data)
+      end
+
+      it 'uploads a CSV file along with the message' do
+        allow(SlackInteractiveClient::Message).to receive(:compile).and_return(compilation_with_csv)
+        expect_any_instance_of(Slack::Web::Client).to receive(:files_upload).with(hash_including(:channels, :content, :title, :filename, :initial_comment, :as_user))
+        described_class.send_message(template_name, args)
+      end
+    end
+
+    context 'when Slack::Web::Api::Errors::SlackError is raised' do
+      it 'rescues from Slack::Web::Api::Errors::SlackError' do
+        allow(SlackInteractiveClient::Message).to receive(:compile).and_raise(Slack::Web::Api::Errors::SlackError.new('Error'))
+        expect { described_class.send_message(template_name, args) }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/message/compilation_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SlackInteractiveClient::Message::Compilation do
+  let(:payload) { { blocks: [{ type: 'section', text: { type: 'mrkdwn', text: 'Test message' } }], channel: ['#general'] } }
+  let(:csv_message) { true }
+  let(:csv_data) { { header: ['Column1', 'Column2'], rows: [['Data1', 'Data2'], ['Data3', 'Data4']] } }
+
+  subject(:compilation) { described_class.new(payload, csv_message, csv_data) }
+
+  describe '#initialize' do
+    it 'initializes with payload, csv_message, and csv_data' do
+      expect(compilation.payload).to eq(payload)
+      expect(compilation.csv_message).to be(csv_message)
+      expect(compilation.csv_data).to eq(csv_data)
+    end
+  end
+
+  describe '#blocks' do
+    context 'when blocks are present in payload' do
+      it 'returns a JSON representation of blocks' do
+        expect(compilation.blocks).to eq(payload[:blocks].to_json)
+      end
+    end
+
+    context 'when blocks are absent in payload' do
+      let(:payload) { {} }
+
+      it 'returns nil' do
+        expect(compilation.blocks).to be_nil
+      end
+    end
+  end
+
+  describe '#channel' do
+    it 'returns the first channel from the payload' do
+      expect(compilation.channel).to eq(payload[:channel].first)
+    end
+  end
+
+  describe '#csv?' do
+    context 'when csv_message is true' do
+      it 'returns true' do
+        expect(compilation.csv?).to be_truthy
+      end
+    end
+
+    context 'when csv_message is false' do
+      let(:csv_message) { false }
+
+      it 'returns false' do
+        expect(compilation.csv?).to be_falsey
+      end
+    end
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+RSpec.describe SlackInteractiveClient::Message do
+  let(:message) { described_class.new }
+
+  describe '#define' do
+    it 'defines a new template with the given block' do
+      block_called = false
+      described_class.define { block_called = true }
+      expect(block_called).to be(true)
+    end
+  end
+
+  describe '#compile' do
+    before do
+      described_class.define do
+        template :test_template do
+          text 'Test message'
+        end
+      end
+    end
+
+    it 'compiles the given template with arguments' do
+      expect { described_class.compile(:test_template) }.not_to raise_error
+    end
+
+    it 'raises an error for an undefined template' do
+      expect { described_class.compile(:undefined_template) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#template' do
+    it 'creates a new template with the given name and block' do
+      block_called = false
+      described_class.template(:new_template) { block_called = true }
+      expect(block_called).to be(true)
+    end
+  end
+
+  describe '#template' do
+    it 'assigns a name and evaluates the block' do
+      message.template(:test) { text 'Testing' }
+      expect(message.name).to eq(:test)
+    end
+  end
+
+  describe '#text' do
+    it 'sets a text block' do
+      message.text 'Hello world'
+      compiled_message = message.compile
+
+      expect(compiled_message.blocks).to include('Hello world')
+    end
+  end
+
+  describe '#title' do
+    it 'sets a title block' do
+      message.title 'Title'
+      compiled_message = message.compile
+
+      expect(compiled_message.blocks).to include('*Title*')
+    end
+  end
+
+  describe '#markdown_section' do
+    it 'sets a markdown section block' do
+      message.markdown_section 'Some *markdown* content'
+      compiled_message = message.compile
+
+      expect(compiled_message.blocks).to include('Some *markdown* content')
+    end
+  end
+
+  describe '#environment' do
+    it 'sets the environment' do
+      message.environment('development')
+
+      expect(message.instance_variable_get(:@environment)).to eq('development')
+    end
+  end
+
+  describe '#channel' do
+    it 'adds channels to the message' do
+      message.channel('#general')
+      message.channel('#random')
+  
+      expect(message.channels).to contain_exactly('#general', '#random')
+    end
+  end
+
+  describe '#mention' do
+    it 'formats user mentions' do
+      message.mention('user1', 'user2')
+      compiled_message = message.compile
+
+      expect(compiled_message.payload[:blocks][0][:elements][0][:text]).to include('<user1> <user2>')
+    end
+  end
+
+  describe '#csv_data' do
+    it 'includes csv data when set to true' do
+      message.csv_data(true)
+      compiled_message = message.compile(csv: { headers: ['one', 'two'], rows: [['1', '2'], ['3', '4']] })
+
+      expect(compiled_message.csv_data).to include(:csv)
+    end
+  end
+
+  describe '#compile' do
+    it 'compiles the message with blocks, channels, and tagged users' do
+      message.text 'Hello world'
+      message.channel '#general'
+      message.mention 'user1'
+
+      compiled_message = message.compile
+
+      expect(compiled_message).to be_a(SlackInteractiveClient::Message::Compilation)
+      expect(compiled_message.channel).to eq('#general')
+    end
+  end
+
+  describe '#reset_message_blocks' do
+    it 'clears all message blocks' do
+      message.text 'Hello world'
+      message.compile
+
+      expect(message.blocks).not_to be_empty
+
+      message.reset_message_blocks
+
+      expect(message.blocks).to be_empty
+    end
+  end
+
+  describe '#compile' do
+    subject(:message) { described_class.new }
+
+    let(:args) do
+      {
+        text: 'Hello, World!',
+        title: 'Test Message',
+        markdown: 'Some *markdown* content',
+        channel: '#general',
+        users: ['@user1', '@user2'],
+        csv: {
+          headers: ['header1', 'header2'],
+          rows: [['row1data1', 'row1data2'], ['row2data1', 'row2data2']],
+        }
+      }
+    end
+
+    before do
+      message.environment('test')
+      message.channel(args[:channel])
+      message.mention(args[:users])
+      message.text(args[:text])
+      message.title(args[:title])
+      message.markdown_section(args[:markdown])
+      message.csv_data(true)
+    end
+
+    it 'compiles the message payload with given arguments' do
+      compilation = message.compile(args)
+
+      expect(compilation).to be_an_instance_of(SlackInteractiveClient::Message::Compilation)
+      expect(compilation.blocks).to include('Hello, World!')
+      expect(compilation.blocks).to include('Test Message')
+      expect(compilation.blocks).to include('Some *markdown* content')
+      expect(compilation.csv_data).to match(hash_including(:csv))
+      expect(compilation.channel).to eq(args[:channel])
+    end
+  end
+end

data/spec/message_stop_guard_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe SlackInteractiveClient::MessageStopGuard do
+  let(:interaction_params) { { text: "to micah the state TEXAS"} }
+  let(:interaction_class) { TestInteraction.new(interaction_params) }
+
+  describe '#scrubber' do
+    it 'filters out the value' do
+      scrubbed = described_class.scrubber.call(%(ssn: 1234))
+
+      expect(scrubbed).to include("[FILTERED]")
+      expect(scrubbed).not_to include("1234")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+require "byebug"
+require 'rails'
+
+require "slack_interactive_client"
+
+ENV['RAILS_ENV'] ||= 'test'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: slack_interactive_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Micah Bowie
+- Code Cowboy
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: httparty
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interact with your Rails app through Slack by defining dynamic Slack
+  slash commands, using a reusable message DSL, slack client, and more.
+email:
+- micahbowie20@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/slack_interactive_client.rb
+- lib/slack_interactive_client/base_interaction.rb
+- lib/slack_interactive_client/bot.rb
+- lib/slack_interactive_client/client.rb
+- lib/slack_interactive_client/concerns/slack_interaction_params.rb
+- lib/slack_interactive_client/concerns/slack_pattern_interaction.rb
+- lib/slack_interactive_client/configuration.rb
+- lib/slack_interactive_client/engine.rb
+- lib/slack_interactive_client/interactions/unknown_command_interaction.rb
+- lib/slack_interactive_client/message.rb
+- lib/slack_interactive_client/message/compilation.rb
+- lib/slack_interactive_client/message_stop_guard.rb
+- lib/slack_interactive_client/railtie.rb
+- lib/slack_interactive_client/response_client.rb
+- lib/slack_interactive_client/version.rb
+- spec/base_interaction_spec.rb
+- spec/bot_spec.rb
+- spec/client_spec.rb
+- spec/message/compilation_spec.rb
+- spec/message_spec.rb
+- spec/message_stop_guard_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Interact with your Rails app through Slack by defining dynamic Slack slash
+  commands, using a reusable message DSL, slack client, and more.
+test_files: []