slackrb 0.17.0

data/Rakefile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+require 'bundler/gem_tasks'
+
+Bundler.setup :default, :development
+
+unless ENV['RACK_ENV'] == 'production'
+  require 'rspec/core'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+  end
+
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+
+  task default: %i[rubocop spec]
+end

data/lib/config/application.rb

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

data/lib/config/boot.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext'
+require 'hashie'
+require 'slack'

data/lib/config/environment.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ENV['RACK_ENV'] ||= 'development'
+
+require File.expand_path('application', __dir__)

data/lib/slack-ruby-bot/about.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  ABOUT = <<-ABOUT
+    #{SlackRubyBot::VERSION}
+    https://github.com/slack-ruby/slack-ruby-bot
+    https://twitter.com/dblockdotorg
+  ABOUT
+end

data/lib/slack-ruby-bot/app.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'botwayrb'
+
+module SlackRubyBot
+  class App < Server
+    def config
+      SlackRubyBot.config
+    end
+
+    def self.instance
+      @instance ||= begin
+        configure!
+        new(token: SlackRubyBot.config.token)
+      end
+    end
+
+    def self.configure!
+      SlackRubyBot.configure do |config|
+        bw = Botwayrb::Core.new
+
+        config.token = bw.get_token
+        raise('Missing Slack API Token.') unless config.token.present?
+      end
+      Slack.configure do |config|
+        config.token = SlackRubyBot.config.token
+      end
+    end
+
+    private
+
+    def hello(client, _data)
+      if client.team && client.self
+        SlackRubyBot.configure do |config|
+          config.url = "https://#{client.team.domain}.slack.com"
+          config.team = client.team.name
+          config.team_id = client.team.id
+          config.user = client.self.name
+          config.user_id = client.self.id
+          logger.info "Welcome #{config.user} to the #{config.team} team."
+        end
+      end
+      super
+    end
+
+    def reset!
+      super
+      SlackRubyBot.configure do |config|
+        config.url = nil
+        config.team = nil
+        config.user = nil
+        config.team_id = nil
+        config.user_id = nil
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/bot.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  class Bot < SlackRubyBot::Commands::Base
+    delegate :client, to: :instance
+
+    def self.run
+      instance.run
+    end
+
+    def self.instance
+      SlackRubyBot::App.instance
+    end
+
+    def self.call(client, data, _match)
+      client.say(channel: data.channel, text: "Sorry <@#{data.user}>, I don't understand that command!")
+    end
+  end
+end

data/lib/slack-ruby-bot/client.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  class Client < Slack::RealTime::Client
+    include Loggable
+    attr_accessor :aliases
+    attr_accessor :allow_bot_messages
+    attr_accessor :allow_message_loops
+
+    def initialize(attrs = {})
+      super(attrs)
+      @aliases = attrs[:aliases]
+      @allow_message_loops = attrs[:allow_message_loops]
+      @allow_bot_messages = attrs[:allow_bot_messages]
+    end
+
+    def allow_message_loops?
+      @allow_message_loops.nil? ? SlackRubyBot::Config.allow_message_loops? : !!@allow_message_loops
+    end
+
+    def allow_bot_messages?
+      @allow_bot_messages.nil? ? SlackRubyBot::Config.allow_bot_messages? : !!@allow_bot_messages
+    end
+
+    def message_to_self?(data)
+      !!(self.self && self.self.id == data.user)
+    end
+
+    def bot_message?(data)
+      data.subtype == 'bot_message'
+    end
+
+    def names
+      [
+        SlackRubyBot::Config.user,
+        self.self ? self.self.name : nil,
+        aliases ? aliases.map(&:downcase) : nil,
+        SlackRubyBot::Config.aliases ? SlackRubyBot::Config.aliases.map(&:downcase) : nil,
+        self.self && self.self.id ? "<@#{self.self.id.downcase}>" : nil,
+        SlackRubyBot::Config.user_id ? "<@#{SlackRubyBot::Config.user_id.downcase}>" : nil,
+        self.self && self.self.id ? "<@#{self.self.id.downcase}>:" : nil,
+        SlackRubyBot::Config.user_id ? "<@#{SlackRubyBot::Config.user_id.downcase}>:" : nil,
+        self.self && self.self.name ? "#{self.self.name.downcase}:" : nil,
+        SlackRubyBot::Config.user ? "#{SlackRubyBot::Config.user}:" : nil
+      ].compact.flatten
+    end
+
+    def name?(name)
+      name && names.include?(name.downcase)
+    end
+
+    def name
+      SlackRubyBot.config.user || self.self&.name
+    end
+
+    def url
+      SlackRubyBot.config.url || super
+    end
+
+    def say(options = {})
+      logger.warn '[DEPRECATION] `gif:` is deprecated and has no effect.' if options.key?(:gif)
+      message({ text: '' }.merge(options))
+    end
+  end
+end

data/lib/slack-ruby-bot/commands/about.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Commands
+    class Default < Base
+      command 'about'
+      match(/^#{bot_matcher}$/u)
+
+      def self.call(client, data, _match)
+        client.say(channel: data.channel, text: SlackRubyBot::ABOUT)
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/commands/base.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative 'support/match'
+require_relative 'support/help'
+
+module SlackRubyBot
+  module Commands
+    class Base
+      include Loggable
+
+      class << self
+        attr_accessor :command_classes
+
+        def inherited(subclass)
+          SlackRubyBot::Commands::Base.command_classes ||= []
+          SlackRubyBot::Commands::Base.command_classes << subclass
+        end
+
+        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}[[:space:]]+(?<command>#{values})([[:space:]]+(?<expression>.*)|)$", Regexp::IGNORECASE | Regexp::MULTILINE), &block
+        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, options[:block])
+            return true
+          end
+          false
+        end
+
+        def match(match, &block)
+          routes[match] = { match_method: :match, block: block }
+        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, block)
+          if block
+            block.call(client, data, match) if permitted?(client, data, match)
+          elsif 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 != SlackRubyBot.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&.any?
+
+          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-ruby-bot/commands/help.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Commands
+    class Help < Base
+      help do
+        title 'help'
+        desc 'Shows help information.'
+      end
+
+      command 'help' do |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-ruby-bot/commands/hi.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  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-ruby-bot/commands/support/attrs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  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-ruby-bot/commands/support/help.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative 'attrs'
+
+module SlackRubyBot
+  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?(SlackRubyBot::Bot) }
+        end
+
+        def other_commands_help_attrs
+          commands_help_attrs.select { |k| k.klass.ancestors.include?(SlackRubyBot::Commands::Base) && !k.klass.ancestors.include?(SlackRubyBot::Bot) }
+        end
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/commands/support/match.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Commands
+    module Support
+      class Match
+        extend Forwardable
+
+        delegate MatchData.public_instance_methods(false) => :@match_data
+
+        attr_reader :attachment, :attachment_field
+
+        def initialize(match_data, attachment = nil, attachment_field = nil)
+          raise ArgumentError, 'match_data should be a type of MatchData' unless match_data.is_a? MatchData
+
+          @match_data = match_data
+          @attachment = attachment
+          @attachment_field = attachment_field
+        end
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/commands/unknown.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Commands
+    class Unknown < Base
+      match(/^(?<bot>\S*)[\s]*(?<expression>.*)$/)
+
+      def self.call(client, data, _match)
+        client.say(channel: data.channel, text: "Sorry <@#{data.user}>, I don't understand that command!")
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/commands.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'slack-ruby-bot/commands/base'
+require 'slack-ruby-bot/commands/about'
+require 'slack-ruby-bot/commands/help'
+require 'slack-ruby-bot/commands/hi'
+require 'slack-ruby-bot/commands/unknown'

data/lib/slack-ruby-bot/config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Config
+    extend self
+
+    ATTRS = %i[token url aliases user user_id team team_id allow_bot_messages allow_message_loops logger].freeze
+    attr_accessor(*ATTRS)
+
+    def allow_bot_messages?
+      !!allow_bot_messages
+    end
+
+    def allow_message_loops?
+      !!allow_message_loops
+    end
+
+    def reset!
+      ATTRS.each { |attr| send("#{attr}=", nil) }
+    end
+
+    private
+
+    def boolean_from_env(key)
+      value = ENV[key]
+      case value
+      when nil
+        nil
+      when 0, 'false', 'no'
+        false
+      when 1, 'true', 'yes'
+        true
+      else
+        raise ArgumentError, "Invalid value for #{key}: #{value}."
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/hooks/hello.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Hooks
+    class Hello
+      attr_accessor :logger, :connected_at
+
+      def initialize(logger)
+        self.logger = logger
+      end
+
+      def call(client, _data)
+        return unless client&.team
+
+        new_connected_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        log = [
+          'Successfully',
+          connected_at ? 'reconnected' : 'connected',
+          "team #{client.team.name} (#{client.team.id}) to https://#{client.team.domain}.slack.com",
+          connected_at ? "after #{last_connection_till(new_connected_at)}s" : nil
+        ].compact.join(' ') + '.'
+
+        logger.info log
+
+        self.connected_at = new_connected_at
+      end
+
+      private
+
+      def last_connection_till(time)
+        (time - connected_at).round(2)
+      end
+    end
+  end
+end