slackrb 0.17.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Hooks
+    module HookSupport
+      def self.included(base)
+        base.cattr_accessor :hook_blocks
+
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def on(event_name, &block)
+          self.hook_blocks ||= {}
+
+          self.hook_blocks[event_name] ||= []
+          self.hook_blocks[event_name] << block
+        end
+      end
+
+      def on(event_name, handler)
+        _hooks.add(event_name, handler)
+      end
+
+      def flush_hook_blocks
+        return nil unless self.class.hook_blocks
+
+        add_hook_handlers(self.class.hook_blocks)
+      end
+
+      # TODO: This should be deprecated in favor of `on`
+      def add_hook_handlers(handler_hash)
+        handler_hash.each do |hook, handlers|
+          Array(handlers).each { |handler| on(hook, handler) }
+        end
+      end
+
+      # Temp use this method in order to deprecate `hooks` and revisit
+      def _hooks
+        @hooks ||= SlackRubyBot::Hooks::Set.new
+      end
+      private :_hooks
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Hooks
+    class Message
+      def call(client, data)
+        return if !client.allow_message_loops? && client.message_to_self?(data)
+        return if !client.allow_bot_messages? && client.bot_message?(data)
+
+        prepare!(data)
+
+        result = child_command_classes.detect { |d| d.invoke(client, data) }
+        result ||= built_in_command_classes.detect { |d| d.invoke(client, data) }
+        result ||= SlackRubyBot::Commands::Unknown.tap { |d| d.invoke(client, data) }
+        result
+      end
+
+      private
+
+      def prepare!(data)
+        data.text = data.text.strip if data.text
+      end
+
+      #
+      # All commands.
+      #
+      # @return [Array] Descendants of SlackRubyBot::Commands::Base.
+      #
+      def command_classes
+        SlackRubyBot::Commands::Base.command_classes
+      end
+
+      #
+      # All non-built-in, ie. custom commands.
+      #
+      # @return [Array] Non-built-in descendants of SlackRubyBot::Commands::Base.
+      #
+      def child_command_classes
+        command_classes.reject do |k|
+          k.name&.starts_with?('SlackRubyBot::Commands::')
+        end
+      end
+
+      #
+      # All built-in commands.
+      #
+      # @return [Array] Built-in descendants of SlackRubyBot::Commands::Base.
+      #
+      def built_in_command_classes
+        command_classes.select do |k|
+          k.name&.starts_with?('SlackRubyBot::Commands::') && k != SlackRubyBot::Commands::Unknown
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module Hooks
+    class Set
+      attr_accessor :handlers, :client
+
+      def initialize(client = nil)
+        self.handlers = {}
+        self.client = client
+
+        @pending_flush = client.blank?
+      end
+
+      def add(hook_name, handler)
+        handlers[hook_name] ||= ::Set.new
+        handlers[hook_name] << handler
+
+        register_callback(hook_name)
+      end
+
+      def client=(client)
+        @client = client
+
+        flush_handlers if @pending_flush
+      end
+
+      protected
+
+      def register_callback(hook_name)
+        return unless client # We'll delay this until client is set
+
+        client.on hook_name do |data|
+          handlers[hook_name].each do |handler|
+            handler.call(client, data)
+          end
+        end
+      end
+
+      def flush_handlers
+        handlers.each_key { |hook| register_callback(hook) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'slack-ruby-bot/hooks/set'
+require 'slack-ruby-bot/hooks/hello'
+require 'slack-ruby-bot/hooks/message'
+require 'slack-ruby-bot/hooks/hook_support'

data/lib/slack-ruby-bot/mvc/controller/base.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module MVC
+    module Controller
+      class Base
+        include ActiveSupport::Callbacks
+
+        class << self
+          attr_reader :abstract
+          alias abstract? abstract
+
+          def controllers
+            get_or_set_ivar(:@controllers, [])
+          end
+
+          def command_class
+            get_or_set_ivar(:@command_class, Class.new(SlackRubyBot::Commands::Base))
+          end
+
+          def aliases
+            get_or_set_ivar(:@aliases, Hash.new { |h, k| h[k] = [] })
+          end
+
+          def get_or_set_ivar(name, value)
+            unless (ivar = Base.instance_variable_get(name))
+              ivar = value
+              Base.instance_variable_set(name, ivar)
+            end
+            ivar
+          end
+
+          def reset!
+            # Remove any earlier anonymous classes from prior calls so we don't leak them
+            Commands::Base.command_classes.delete(Controller::Base.command_class) if Base.command_class
+
+            Base.instance_variable_set(:@command_class, nil)
+            Base.instance_variable_set(:@controllers, nil)
+          end
+
+          # Define a controller as abstract. See internal_methods for more
+          # details.
+          def abstract!
+            @abstract = true
+          end
+
+          def inherited(klass) # :nodoc:
+            # Define the abstract ivar on subclasses so that we don't get
+            # uninitialized ivar warnings
+            klass.instance_variable_set(:@abstract, false) unless klass.instance_variable_defined?(:@abstract)
+            super
+          end
+
+          def register_controller(controller)
+            # Only used to keep a reference around so the instance object doesn't get garbage collected
+            controllers << controller
+            klass = controller.class
+
+            methods = (klass.public_instance_methods(true) -
+                       # Except for public instance methods of Base and its ancestors
+                       internal_methods(klass) +
+                       # Be sure to include shadowed public instance methods of this class
+                       klass.public_instance_methods(false)).uniq.map(&:to_s)
+
+            methods.each do |name|
+              next if name[0] == '_'
+
+              commands = lookup_command_name(name)
+
+              # Generates a command for each controller method *and* its aliases
+              commands.each do |command_string|
+                # sprinkle a little syntactic sugar on top of existing `command` infrastructure
+                command_class.class_eval do
+                  command command_string do |client, data, match|
+                    controller.use_args(client, data, match)
+                    controller.call_command
+                  end
+                end
+              end
+            end
+          end
+
+          # A list of all internal methods for a controller. This finds the first
+          # abstract superclass of a controller, and gets a list of all public
+          # instance methods on that abstract class. Public instance methods of
+          # a controller would normally be considered action methods, so methods
+          # declared on abstract classes are being removed.
+          # (Controller::Base is defined as abstract)
+          def internal_methods(controller)
+            controller = controller.superclass until controller.abstract?
+            controller.public_instance_methods(true)
+          end
+
+          # Maps a controller method name to an alternate command name. Used in cases where
+          # a command can be called via multiple text strings.
+          #
+          # Call this method *after* defining the original method.
+          #
+          #  Class.new(SlackRubyBot::MVC::Controller::Base) do
+          #    def quxo_foo_bar
+          #      client.say(channel: data.channel, text: "quxo foo bar: #{match[:expression]}")
+          #    end
+          #    # setup alias name after original method definition
+          #    alternate_name :quxo_foo_bar, :another_text_string
+          #  end
+          #
+          # This is equivalent to:
+          #
+          # e.g.
+          #  command 'quxo foo bar', 'another text string' do |*args|
+          #    ..
+          #  end
+          def alternate_name(original_name, *alias_names)
+            command_name = convert_method_name_to_command_string(original_name)
+            command_aliases = alias_names.map do |name|
+              convert_method_name_to_command_string(name)
+            end
+
+            aliases[command_name] += command_aliases
+
+            alias_names.each { |alias_name| alias_method(alias_name, original_name) }
+          end
+
+          private
+
+          def lookup_command_name(name)
+            name = convert_method_name_to_command_string(name)
+            [name] + aliases[name]
+          end
+
+          def convert_method_name_to_command_string(name)
+            name.to_s.tr('_', ' ')
+          end
+        end
+
+        abstract!
+        reset!
+
+        attr_reader :model, :view, :client, :data, :match
+
+        def initialize(model, view)
+          @model = model
+          @view = view
+          self.class.register_controller(self)
+        end
+
+        # Hand off the latest updated objects to the +model+ and +view+ and
+        # update our +client+, +data+, and +match+ accessors.
+        def use_args(client, data, match)
+          @client = client
+          @data = data
+          @match = match
+          model.use_args(client, data, match)
+          view.use_args(client, data, match)
+        end
+
+        # Determine the command issued and call the corresponding instance method
+        def call_command
+          verb = match.captures[match.names.index('command')]
+          verb = normalize_command_string(verb)
+          public_send(verb)
+        end
+
+        private
+
+        def normalize_command_string(string)
+          string.downcase.tr(' ', '_')
+        end
+      end
+    end
+  end
+end

data/lib/slack-ruby-bot/mvc/model/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module MVC
+    module Model
+      class Base
+        include ActiveSupport::Callbacks
+
+        class << self
+          def inherited(klass) # :nodoc:
+            super
+          end
+        end
+
+        attr_reader :client, :data, :match
+
+        # Hand off the latest updated objects to the +model+ and +view+ and
+        # update our +client+, +data+, and +match+ accessors.
+        def use_args(client, data, match)
+          @client = client
+          @data = data
+          @match = match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../mvc/controller/base'
+
+require_relative '../mvc/model/base'
+
+require_relative '../mvc/view/base'

data/lib/slack-ruby-bot/mvc/view/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module MVC
+    module View
+      class Base
+        include ActiveSupport::Callbacks
+        extend Forwardable
+
+        class << self
+          def inherited(klass) # :nodoc:
+            super
+          end
+        end
+
+        attr_reader :client, :data, :match
+
+        def_delegators :@client, :say
+
+        # Hand off the latest updated objects to the +model+ and +view+ and
+        # update our +client+, +data+, and +match+ accessors.
+        def use_args(client, data, match)
+          @client = client
+          @data = data
+          @match = match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'slack-ruby-bot/mvc/mvc'

data/lib/slack-ruby-bot/rspec/support/bots_for_tests.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Testing
+  class WeatherBot < SlackRubyBot::Bot
+    help do
+      title 'Weather Bot'
+      desc 'This bot tells you the weather.'
+
+      command 'clouds' do
+        desc 'Tells you how many clouds there\'re above you.'
+      end
+
+      command '' do
+        desc 'empty description'
+      end
+
+      command 'command_without_description' do
+      end
+
+      command 'What\'s the weather in <city>?' do
+        desc 'Tells you the weather in a <city>.'
+        long_desc "Accurate 10 Day Weather Forecasts for thousands of places around the World.\n" \
+          'We provide detailed Weather Forecasts over a 10 day period updated four times a day.'
+      end
+    end
+  end
+
+  class HelloCommand < SlackRubyBot::Commands::Base
+    help do
+      title 'hello'
+      desc 'Says hello.'
+      long_desc 'The long description'
+    end
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/it_behaves_like_a_slack_bot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+shared_examples 'a slack ruby bot' do
+  context 'not configured' do
+    before do
+      @slack_api_token = ENV.delete('SLACK_API_TOKEN')
+      SlackRubyBot.configure { |config| config.token = nil }
+    end
+    after do
+      ENV['SLACK_API_TOKEN'] = @slack_api_token
+    end
+    it 'requires SLACK_API_TOKEN' do
+      expect { described_class.instance }.to raise_error RuntimeError, 'Missing Slack API Token.'
+    end
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/not_respond.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :not_respond do
+  match do |actual|
+    client = respond_to?(:client) ? send(:client) : SlackRubyBot::Client.new
+
+    message_command = SlackRubyBot::Hooks::Message.new
+    channel, user, message, attachments = parse(actual)
+
+    expect(client).not_to receive(:message)
+    message_command.call(client, Hashie::Mash.new(text: message, channel: channel, user: user, attachments: attachments))
+    true
+  end
+
+  private
+
+  def parse(actual)
+    actual = { message: actual } unless actual.is_a?(Hash)
+    attachments = actual[:attachments]
+    attachments = [attachments] unless attachments.nil? || attachments.is_a?(Array)
+    [actual[:channel] || 'channel', actual[:user] || 'user', actual[:message], attachments]
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/respond_with_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :respond_with_error do |error, error_message|
+  match do |actual|
+    client = respond_to?(:client) ? send(:client) : SlackRubyBot::Client.new
+
+    message_command = SlackRubyBot::Hooks::Message.new
+    channel, user, message, attachments = parse(actual)
+
+    begin
+      expect do
+        message_command.call(client, Hashie::Mash.new(text: message, channel: channel, user: user, attachments: attachments))
+      end.to raise_error error, error_message
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      @error_message = e.message
+      raise e
+    end
+    true
+  end
+
+  failure_message do |actual|
+    _, _, message = parse(actual)
+    @error_message || "expected for '#{message}' to fail with '#{expected}'"
+  end
+
+  private
+
+  def parse(actual)
+    actual = { message: actual } unless actual.is_a?(Hash)
+    attachments = actual[:attachments]
+    attachments = [attachments] unless attachments.nil? || attachments.is_a?(Array)
+    [actual[:channel] || 'channel', actual[:user] || 'user', actual[:message], attachments]
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/respond_with_slack_message.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :respond_with_slack_message do |expected|
+  include SlackRubyBot::SpecHelpers
+
+  match do |actual|
+    client = respond_to?(:client) ? send(:client) : SlackRubyBot::Client.new
+
+    message_command = SlackRubyBot::Hooks::Message.new
+    channel, user, message, attachments = parse(actual)
+
+    allow(client).to receive(:message) do |options|
+      @messages ||= []
+      @messages.push options
+    end
+
+    message_command.call(client, Hashie::Mash.new(text: message, channel: channel, user: user, attachments: attachments))
+
+    matcher = have_received(:message).once
+    matcher = matcher.with(hash_including(channel: channel, text: expected)) if channel && expected
+
+    expect(client).to matcher
+
+    true
+  end
+
+  failure_message do |_actual|
+    message = "expected to receive message with text: #{expected} once,\n received:"
+    message += @messages&.any? ? @messages.inspect : 'none'
+    message
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/respond_with_slack_messages.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :respond_with_slack_messages do |expected|
+  include SlackRubyBot::SpecHelpers
+
+  match do |actual|
+    raise ArgumentError, 'respond_with_slack_messages expects an array of ordered responses' if expected && !expected.respond_to?(:each)
+
+    client = respond_to?(:client) ? send(:client) : SlackRubyBot::Client.new
+
+    message_command = SlackRubyBot::Hooks::Message.new
+    channel, user, message, attachments = parse(actual)
+
+    @messages ||= []
+    allow(client).to receive(:message) do |options|
+      @messages.push options
+    end
+
+    message_command.call(client, Hashie::Mash.new(text: message, channel: channel, user: user, attachments: attachments))
+
+    @responses = []
+
+    if expected&.any?
+      expected.each do |exp|
+        @responses.push(expect(client).to(have_received(:message).with(hash_including(channel: channel, text: exp)).once))
+      end
+    else
+      expect(@messages.size).to be > 1
+    end
+
+    true
+  end
+
+  failure_message do |_actual|
+    if expected&.any?
+      expected.map do |exp|
+        "Expected text: #{exp}, got #{@messages[expected.index(exp)] || 'none'}" unless @responses[expected.index(exp)]
+      end.compact.join("\n")
+    else
+      "Expected to receive multiple messages, got #{@messages.any? ? @messages.size : 'none'}"
+    end
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack-ruby-bot/start_typing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :start_typing do |expected|
+  include SlackRubyBot::SpecHelpers
+
+  match do |actual|
+    client = respond_to?(:client) ? send(:client) : SlackRubyBot::Client.new
+
+    message_command = SlackRubyBot::Hooks::Message.new
+
+    allow(client).to receive(:typing) do |options|
+      @test_options = options
+    end
+
+    channel, user, message, attachments = parse(actual)
+    message_command.call(client, Hashie::Mash.new(text: message, channel: channel, user: user, attachments: attachments))
+
+    matcher = have_received(:typing).once
+    matcher = matcher.with(expected) if expected&.any?
+    expect(client).to matcher
+
+    true
+  end
+
+  failure_message do |_actual|
+    message = "expected to receive typing with: #{expected} once,\n received:"
+    message += @test_options&.any? ? @test_options.inspect : ' none'
+    message
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack_api_key.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'botwayrb'
+
+RSpec.configure do |config|
+  bw = Botwayrb::Core.new
+
+  config.before :each do
+    bw.get_token ||= 'test'
+  end
+end

data/lib/slack-ruby-bot/rspec/support/slack_ruby_bot_configure.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.before :each do
+    SlackRubyBot.configure do |c|
+      c.token = 'testtoken'
+      c.user = 'rubybot'
+      c.user_id = 'DEADBEEF'
+    end
+  end
+
+  config.after :each do
+    SlackRubyBot::Config.reset!
+  end
+end

data/lib/slack-ruby-bot/rspec/support/spec_helpers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SlackRubyBot
+  module SpecHelpers
+    private
+
+    def parse(actual)
+      actual = { message: actual } unless actual.is_a?(Hash)
+      attachments = actual[:attachments]
+      attachments = [attachments] unless attachments.nil? || attachments.is_a?(Array)
+      [actual[:channel] || 'channel', actual[:user] || 'user', actual[:message], attachments]
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'rubygems'
+require 'rspec'
+require 'rack/test'
+
+require 'config/environment'
+require 'slack-ruby-bot'
+
+Dir[File.join(File.dirname(__FILE__), 'rspec/support', '**/*.rb')].sort.each do |file|
+  require file
+end