slack-ruby-bot-boilerplate 0.1.0

data/lib/config/application.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'boot'
+
+Dir[File.expand_path('../../initializers', __FILE__) + '/**/*.rb'].each do |file|
+  require file
+end
+
+require File.expand_path('../application', __FILE__)
+
+require 'slack_ruby_bot'

data/lib/config/boot.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext'
+require 'hashie'
+require 'slack'

data/lib/config/environment.rb

@@ -0,0 +1,3 @@
+ENV['RACK_ENV'] ||= 'development'
+
+require File.expand_path('../application', __FILE__)

data/lib/slack_respondent.rb

@@ -0,0 +1,25 @@
+require 'slack-ruby-client'
+require 'active_support'
+require 'active_support/core_ext'
+
+require_relative 'slack_respondent/support/loggable'
+require_relative 'slack_respondent/commands'
+require_relative 'slack_respondent/reactions'
+require_relative 'slack_respondent/client'
+require_relative 'slack_respondent/config'
+
+module SlackRespondent
+  ABOUT = <<-ABOUT
+    Bot name
+  ABOUT
+
+  class << self
+    def configure
+      block_given? ? yield(Config) : Config
+    end
+
+    def config
+      Config
+    end
+  end
+end

data/lib/slack_respondent/client.rb

@@ -0,0 +1,61 @@
+module SlackRespondent
+  class ClientWrapper
+    include Loggable
+    attr_accessor :aliases
+    attr_accessor :send_gifs
+    attr_accessor :names
+    attr_reader :client
+
+    def initialize
+      @name = []
+
+      response = client.auth_test
+
+      SlackRespondent.configure do |config|
+        config.url = response.url
+        config.team = response.team
+        config.team_id = response.team_id
+        config.user = response.user
+        config.user_id = response.user_id
+        logger.info "Welcome #{response.user} to the #{response.team} team."
+      end
+    end
+
+    def names
+      [
+        SlackRespondent::Config.user,
+        SlackRespondent::Config.aliases ? SlackRespondent::Config.aliases.map(&:downcase) : nil,
+        SlackRespondent::Config.user_id ? "<@#{SlackRespondent::Config.user_id.downcase}>" : nil,
+        SlackRespondent::Config.user_id ? "<@#{SlackRespondent::Config.user_id.downcase}>:" : nil,
+        SlackRespondent::Config.user ? "#{SlackRespondent::Config.user}:" : nil
+      ].compact.flatten
+    end
+
+    def name?(name)
+      name && names.include?(name.downcase)
+    end
+
+    def user_id
+      names.first
+    end
+
+    def name
+      SlackRespondent.config.user || (self.self && self.self.name)
+    end
+
+    def url
+      SlackRespondent.config.url
+    end
+
+    def say(options = {})
+      filtered_options = options.slice(:channel, :text, :attachments)
+      client.chat_postMessage(filtered_options)
+    end
+
+    private
+
+    def client
+      @client ||= Slack::Web::Client.new
+    end
+  end
+end

data/lib/slack_respondent/commands.rb

@@ -0,0 +1,5 @@
+require_relative 'commands/base'
+require_relative 'commands/about'
+require_relative 'commands/help'
+require_relative 'commands/hi'
+require_relative 'commands/unknown'

data/lib/slack_respondent/commands/about.rb

@@ -0,0 +1,15 @@
+module SlackRespondent
+  module Commands
+    class About < Base
+      command 'about'
+
+      def self.call(client, data, _match)
+        client.say(channel: data.channel, text: SlackRespondent::ABOUT)
+      end
+
+      def self.pattern
+        /^#{bot_matcher}$/u
+      end
+    end
+  end
+end

data/lib/slack_respondent/commands/base.rb

@@ -0,0 +1,140 @@
+require_relative 'support/match'
+require_relative 'support/help'
+
+module SlackRespondent
+  module Commands
+    class Base
+      include Loggable
+
+      class << self
+        def help(&block)
+          Support::Help.instance.capture_help(self, &block)
+        end
+
+        def command_name_from_class
+          name ? name.split(':').last.downcase : object_id.to_s
+        end
+
+        def operator(*values, &block)
+          values = values.map { |value| Regexp.escape(value) }.join('|')
+          match Regexp.new("^(?<operator>#{values})(?<expression>.*)$", Regexp::IGNORECASE), &block
+        end
+
+        def command(*values, &block)
+          values = values.map { |value| value.is_a?(Regexp) ? value.source : Regexp.escape(value) }.join('|')
+          match Regexp.new("^#{bot_matcher}[\\s]+(?<command>#{values})([\\s]+(?<expression>.*)|)$", Regexp::IGNORECASE | Regexp::MULTILINE)
+        end
+
+        def invoke(client, data)
+          finalize_routes!
+          expression, text = parse(client, data)
+          return false unless expression || data.attachments
+          routes.each_pair do |route, options|
+            match_method = options[:match_method]
+            case match_method
+            when :match
+              next unless expression
+              match = route.match(expression)
+              match ||= route.match(text) if text
+              next unless match
+              next if match.names.include?('bot') && !client.name?(match['bot'])
+              match = Support::Match.new(match)
+            # when :scan
+            #   next unless expression
+            #   match = expression.scan(route)
+            #   next unless match.any?
+            # when :attachment
+            #   next unless data.attachments && !data.attachments.empty?
+            #   match, attachment, field = match_attachments(data, route, options[:fields_to_scan])
+            #   next unless match
+            #   match = Support::Match.new(match, attachment, field)
+            end
+            call_command(client, data, match)
+            return true
+          end
+          false
+        end
+
+        def match(match)
+          routes[match] = { match_method: :match }
+        end
+
+        # def scan(match, &block)
+        #   routes[match] = { match_method: :scan, block: block }
+        # end
+
+        def attachment(match, fields_to_scan = nil, &block)
+          fields_to_scan = [fields_to_scan] unless fields_to_scan.nil? || fields_to_scan.is_a?(Array)
+          routes[match] = {
+            match_method: :attachment,
+            block: block,
+            fields_to_scan: fields_to_scan
+          }
+        end
+
+        def bot_matcher
+          '(?<bot>\S*)'
+        end
+
+        def routes
+          @routes ||= ActiveSupport::OrderedHash.new
+        end
+
+        private
+
+        def call_command(client, data, match)
+          if respond_to?(:call)
+            send(:call, client, data, match) if permitted?(client, data, match)
+          else
+            raise NotImplementedError, data.text
+          end
+        end
+
+        def parse(client, data)
+          text = data.text
+          return text unless direct_message?(data) && message_from_another_user?(data)
+          return text if message_begins_with_bot_mention?(text, client.names)
+          ["#{client.name} #{text}", text]
+        end
+
+        def direct_message?(data)
+          data.channel && data.channel[0] == 'D'
+        end
+
+        def message_from_another_user?(data)
+          data.user && data.user != SlackRespondent.config.user_id
+        end
+
+        def message_begins_with_bot_mention?(text, bot_names)
+          bot_names = bot_names.join('|')
+          !!text.downcase.match(/\A(#{bot_names})\s|\A(#{bot_names})\z/)
+        end
+
+        def finalize_routes!
+          # return if routes && routes.any?
+          routes.clear
+          match(self.pattern) if respond_to?(:pattern)
+          command command_name_from_class
+        end
+
+        def match_attachments(data, route, fields_to_scan = nil)
+          fields_to_scan ||= %i[pretext text title]
+          data.attachments.each do |attachment|
+            fields_to_scan.each do |field|
+              next unless attachment[field]
+              match = route.match(attachment[field])
+              return match, attachment, field if match
+            end
+          end
+          false
+        end
+
+        # Intended to be overridden by subclasses to hook in an
+        # authorization mechanism.
+        def permitted?(_client, _data, _match)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/slack_respondent/commands/help.rb

@@ -0,0 +1,42 @@
+module SlackRespondent
+  module Commands
+    class Help < Base
+      help do
+        title 'help'
+        desc 'Shows help information.'
+      end
+
+      def self.call(client, data, match)
+
+        command = match[:expression]
+
+        text = if command.present?
+                 Support::Help.instance.command_full_desc(command)
+               else
+                 general_text
+               end
+
+        client.say(channel: data.channel, text: text)
+      end
+
+      class << self
+        private
+
+        def general_text
+          bot_desc = Support::Help.instance.bot_desc_and_commands
+          other_commands_descs = Support::Help.instance.other_commands_descs
+          <<TEXT
+#{bot_desc.join("\n")}
+
+*Other commands:*
+#{other_commands_descs.join("\n")}
+
+For getting description of the command use: *help <command>*
+
+For more information see https://github.com/slack-ruby/slack-ruby-bot, please.
+TEXT
+        end
+      end
+    end
+  end
+end

data/lib/slack_respondent/commands/hi.rb

@@ -0,0 +1,14 @@
+module SlackRespondent
+  module Commands
+    class Hi < Base
+      help do
+        title 'hi'
+        desc 'Says hello.'
+      end
+
+      def self.call(client, data, _match)
+        client.say(channel: data.channel, text: "Hi <@#{data.user}>!")
+      end
+    end
+  end
+end

data/lib/slack_respondent/commands/support/attrs.rb

@@ -0,0 +1,34 @@
+module SlackRespondent
+  module Commands
+    module Support
+      class Attrs
+        attr_accessor :command_name, :command_desc, :command_long_desc
+        attr_reader :klass, :commands
+
+        def initialize(klass)
+          @klass = klass
+          @commands = []
+        end
+
+        def title(title)
+          self.command_name = title
+        end
+
+        def desc(desc)
+          self.command_desc = desc
+        end
+
+        def long_desc(long_desc)
+          self.command_long_desc = long_desc
+        end
+
+        def command(title, &block)
+          @commands << self.class.new(klass).tap do |k|
+            k.title(title)
+            k.instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack_respondent/commands/support/help.rb

@@ -0,0 +1,81 @@
+require 'singleton'
+require_relative 'attrs'
+
+module SlackRespondent
+  module Commands
+    module Support
+      class Help
+        include Singleton
+        attr_reader :commands_help_attrs
+
+        def initialize
+          @commands_help_attrs = []
+        end
+
+        def capture_help(klass, &block)
+          k = Commands::Support::Attrs.new(klass)
+          k.instance_eval(&block)
+          @commands_help_attrs << k
+        end
+
+        def bot_desc_and_commands
+          collect_help_attrs(bot_help_attrs) do |help_attrs|
+            bot_commands_descs = collect_name_and_desc(help_attrs.commands)
+            "#{command_name_and_desc(help_attrs)}\n\n*Commands:*\n#{bot_commands_descs.join("\n")}"
+          end
+        end
+
+        def other_commands_descs
+          collect_name_and_desc(other_commands_help_attrs)
+        end
+
+        def command_full_desc(name)
+          unescaped_name = Slack::Messages::Formatting.unescape(name)
+          help_attrs = find_command_help_attrs(unescaped_name)
+          return "There's no command *#{unescaped_name}*" unless help_attrs
+          return "There's no description for command *#{unescaped_name}*" if help_attrs.command_long_desc.blank?
+          "#{command_name_and_desc(help_attrs)}\n\n#{help_attrs.command_long_desc}"
+        end
+
+        def find_command_help_attrs(name)
+          help_attrs = commands_help_attrs.find { |k| k.command_name == name }
+          return help_attrs if help_attrs
+          commands_help_attrs.each { |k| k.commands.each { |c| return c if c.command_name == name } }
+          nil
+        end
+
+        private
+
+        def collect_help_attrs(help_attrs)
+          help_attrs_with_present_names(help_attrs).map do |ha|
+            yield(ha)
+          end
+        end
+
+        def collect_name_and_desc(help_attrs)
+          collect_help_attrs(help_attrs) do |ha|
+            command_name_and_desc(ha)
+          end
+        end
+
+        def command_name_and_desc(help_attrs)
+          desc = help_attrs.command_desc.present? ? " - #{help_attrs.command_desc}" : ''
+          "*#{help_attrs.command_name}*#{desc}"
+        end
+
+        def help_attrs_with_present_names(help_attrs)
+          help_attrs.select { |k| k.command_name.present? }
+        end
+
+        def bot_help_attrs
+          commands_help_attrs #.select { |k| k.klass.ancestors.include?(SlackRespondent::Bot) }
+        end
+
+        def other_commands_help_attrs
+          []
+          # commands_help_attrs.select { |k| k.klass.ancestors.include?(SlackRespondent::Commands::Base) && !k.klass.ancestors.include?(SlackRespondent::Bot) }
+        end
+      end
+    end
+  end
+end