boty 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 232044d6e49a24255c5b5a554a6897ec473cdf1d
-  data.tar.gz: fe980e1c3d03a64200a8d62f2ac8fa52f616aab8
+  metadata.gz: b9959fb9fd1218a64dc671442aef786311c03f10
+  data.tar.gz: bad2921130ae92b79ef775529861fb4c6a204cdf
 SHA512:
-  metadata.gz: c3a0dac85b60abc7aa9c9e58dd2edc1942ced52d729c710ff22330d7d34526ba028c5a64a09b318fd9a715c2d468d4f0a53c1a751d1dfb44a34bbc844760ba59
-  data.tar.gz: 5ab990e551d97057bab55722c61971eae5dd855b75af806ad24d136eb826b8d6c4ef98e20985be4f70845f0861b5476a5b9516ba3a2e16bed6137d2709c2d648
+  metadata.gz: 0052d938808382105c9f4b2e242ca357a01cb7e83c5eead10f05a3225b6a021cf08c24d0de7dfe7d69b3945015f1595ff20291dbc33d41b1e93b758965023fb5
+  data.tar.gz: 2b31a41cb5443d4693728b2a8689b321371424c7a90b84c058a721a545c2cdf17a1feb952e2404b0f302fb403bc13936e3b8f1a957e3a6d4bfc715d7318782d3

data/.gitignore

@@ -15,3 +15,6 @@
 .env.local
 pkg
 /.rspec
+
+/.yardoc
+/docs/api

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boty (0.1.2)
+    boty (0.2.0)
       eventmachine
       faraday
       faye-websocket
@@ -57,6 +57,7 @@ GEM
     websocket-driver (0.6.3)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.2)
+    yard (0.8.7.6)
 
 PLATFORMS
   ruby
@@ -70,6 +71,7 @@ DEPENDENCIES
   rake (~> 10.0)
   rspec
   rubocop
+  yard
 
 BUNDLED WITH
    1.10.6

data/README.md

@@ -1,5 +1,6 @@
 # Boty
 [<img src="https://travis-ci.org/ricardovaleriano/boty.svg?branch=master" />](https://travis-ci.org/ricardovaleriano/boty)
+[<img src="http://img.shields.io/badge/yard-docs-blue.svg" />](http://www.rubydoc.info/github/ricardovaleriano/boty)
 
 `Boty` is a utilitary to create bots (at this time, specificaly Slack bots).
 
@@ -291,7 +292,7 @@ Before we start to study the "script" way of configuring `command` and
 `listener` binds, let's see how we can use ruby regexps to capture message
 parameters.
 
-##### Regexes - a pattern that allow capture parameters within a message<a name="regexes" />
+#### Regexes - a pattern that allow capture parameters within a message<a name="regexes" />
 
 What is a bot if it can't annoy people when we want it to? So let's teach our
 bot to send private messages to people in the Slack room.
@@ -316,6 +317,29 @@ _command_.
 
 And this is it! :tada:
 
+##### Commands, Listenners and aliases
+
+Both *commands* and *listeners* can be aliased, which means that the same
+`Action` can be triggered by different regexes:
+
+```ruby
+command /hi/i, /hello/i do
+  say "Ohay #{user.name}! Hello there."
+end
+```
+
+    valeriano 12:04 PM
+    @jeeba: hi
+
+    jeeba BOT 12:04 PM
+    Ohay valeriano! Hello there.
+
+    valeriano 12:05 PM
+    @jeeba: hello
+
+    jeeba BOT 12:05 PM
+    Ohay valeriano! Hello there.
+
 ### Adding custom scripts<a name="custom_scripts" />
 
 Now you already know what are [listeners](#listeners) and

data/Rakefile

@@ -1,5 +1,10 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "yard"
 
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
+
+YARD::Rake::YardocTask.new do |t|
+  t.options = ["-odocs/api"]
+end

data/boty.gemspec

@@ -36,4 +36,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "dotenv"
   spec.add_development_dependency "fakefs"
   spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "yard"
 end

data/lib/boty.rb

@@ -1,28 +1,30 @@
-begin
-  require "pp"
-
-  require "dotenv"
-  if defined? Dotenv
-    Dotenv.load
-    Dotenv.overload ".env.local"
-  end
-rescue LoadError
-end
-
 require "faye/websocket"
 require "i18n"
 require "faraday"
+require "dotenv"
+require "pp"
 
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 
+Dotenv.load
+Dotenv.overload ".env.local"
+
+# Namespace for all Boty code.
 module Boty
+  # Public: Reloads the available locale configuration files and set the current
+  # language as the one passed in the paramenter `lang`.
+  #
+  # lang - String or Symbol representing the language that should be set for the
+  # current execution.
+  #
+  # Examples:
+  #
+  #     Boty.locale = :en
+  #
+  # Returns nothing.
   def self.locale=(lang)
     Locale.reload lang
   end
-
-  def self.locale
-    I18n.locale ||= :en
-  end
 end
 
 require "boty/version"
@@ -35,5 +37,6 @@ require "boty/script_loader"
 require "boty/dsl"
 require "boty/locale"
 require "boty/eventable"
+require "boty/match_handler"
 require "boty/bot"
 require "boty/http"

data/lib/boty/action.rb

@@ -1,32 +1,73 @@
 module Boty
-  # Public: Wrap the idea of something that should happen when some regex is
-  # matched.
+  # Public: Wrap the idea of something that should happen when a regex matches.
+  # Actions are the underlying mecanism for store and execute the blocks passed
+  # to `Bot#match` and `Bot#respond` invocations.
   #
+  # Maybe one of the more important things to remember here is that an Action is
+  # executed within the scope of a `Boty::DSL` instance already binded with the
+  # `Bot` of the current `Session` (via `#instance_exec`).
   #
+  # Examples:
+  #
+  #   # some_script.rb
+  #   desc "omg! whoo!"
+  #   hear(/omg/i) do
+  #     im "whoo!"
+  #   end
+  #
+  #   # Will generate an `Action` like this:
+  #   action = Action.new(bot, /omg/i, "omg! whoo!") { im "whoo!" }
+  #
+  #   # Then this can be executed, by `#execute`.
+  #   action.execute "omg! this string triggers the hear block."
+  #
+  #   # If the regex matches the parameter passed to execute, it'll invoke the
+  #   # block passed to `#hear`.
   class Action
     include Boty::Logger
     attr_reader :regex, :desc, :action
 
+    # Public: Initialize an `Action` associated with a specific `Bot`.
+    #
+    # bot     - A Bot that will react to the matches on the regex.
+    # regex   - A Regexp to match against messages received in the bot session.
+    # action  - A Proc that will be executed everytime the regex matches.
     def initialize(bot, regex, description, &action)
-      if description
-        description.regex = regex
-      else
-        description = ActionDescription.new(nil, regex: regex)
-      end
-
       @dsl    = DSL.new bot
       @regex  = regex
-      @desc   = description
       @action = action
+
+      self.desc = description
     end
 
+    # Public: Check if a given Regexp and an optional block were the same used
+    # to build this Action.
+    #
+    # Examples:
+    #
+    #   send_im = -> { im "whoo!" }
+    #   action = Action.new(bot, /omg/i, "omg! whoo!", &send_im)
+    #   action.this? /omg/i, send_im
+    #   # => return true
+    #
+    # regex - A Regexp to be compared against `regex`.
+    # block - An optional Proc to be checked against `action`.
+    #
+    # Returns True or False.
     def this?(regex, block)
       same_regex = regex == self.regex
       block ? same_regex && block == action : same_regex
     end
 
+    # Public: Creates a `Regexp::Match` based on the internal `regex` against a
+    # Slack::Message.
+    # Then pass this match to be used as argument to the action per se.
+    #
+    # message - A Slack::Message object to be matched against the `regex`.
+    #
+    # Returns nothing.
     def execute(message)
-      action_call message.match!(regex)
+      action_call regex.match(message.text)
     rescue => e
       logger.error e.message
       raise e
@@ -34,6 +75,43 @@ module Boty
 
     private
 
+    # Internal: Store the ActionDescription for this action (create a new for it
+    # if a nil value is the parameter).
+    #
+    # To make it possible to create handlers (that will became actions) without
+    # a description, this method can work with a nil parameter. If a nil value
+    # is passed, it creates an `ActionDescription` with only a regex (without a
+    # description text).
+    #
+    # Returns an ActionDescription with the regex associated with this Action.
+    def desc=(description)
+      if description
+        description.regex = regex
+      else
+        description = ActionDescription.new(nil, regex: regex)
+      end
+      @desc = description
+    end
+
+    # Internal: Effectively executes the action.
+    # The regex match created on the `#execute` method will be exploded, so the
+    # matches can be passed as arguments to the block.
+    # Important to remember: the block passed to `Bot#match` or `Bot#respond`
+    # will be executed within the scope of a `Boty::DSL`.
+    #
+    # Examples:
+    #
+    #   # some_script.rb
+    #   hear(/(omg)\s(lol)/i) do |first_match, second_match|
+    #     im "whoo!"
+    #   end
+    #
+    #   # will cause an invocation like this:
+    #   @dsl.instance_exec("omg", "lol") do |first_match, second_match|
+    #     im "whoo!"
+    #   end
+    #
+    # Returns nothing.
     def action_call(match)
       return unless match
       matches = Array(match)

data/lib/boty/action_description.rb

@@ -1,4 +1,26 @@
 module Boty
+  # Public: contains de descriptive information that was associated with an
+  # action via the `Bot#desc` method.
+  #
+  # Besides that also keep tracks of the regex for the associated Action, it is
+  # used to describe the handler in case no command name and/or description was
+  # passed via `Bot#desc`.
+  #
+  # The `ActionDescription` object will be stored inside the `Action#desc`. A
+  # good usage example can be found in the `scripts/knows.rb` script.
+  #
+  # Examples:
+  #
+  #   # scripts/omg.rb
+  #   desc "X omg!", "Make the bot scream X omgs."
+  #   hear(/(\d+ )?omg!/i) do |how_many|
+  #     how_many.times do say "LOL!" end
+  #   end
+  #
+  #   # => generates an action with a description like this:
+  #   ActionDescription.new "X omg!",
+  #                         description: "Make the bot scream X omgs."
+  #                         regex: /(\d+ )?omg!/i
   class ActionDescription
     attr_reader :command, :description
     attr_writer :regex

data/lib/boty/bot.rb

@@ -1,10 +1,11 @@
 module Boty
   class Bot
     include Boty::Eventable
+    include Boty::MatchHandler
     include Boty::Logger
     include Slack
 
-    attr_reader :id, :name, :trigger_message, :brain
+    attr_reader :id, :name, :brain
 
     def initialize(bot_info)
       Locale.reload
@@ -12,42 +13,14 @@ module Boty
       @id       = bot_info["id"]
       @name     = bot_info["name"]
 
-      @listeners ||= []
-      @commands ||= []
       @brain ||= {}
 
       on :message, &method(:message_handler)
       ScriptLoader.new(self).load
     end
 
-    def match(regex, &block)
-      @listeners << create_action(regex, &block)
-    end
-
-    def respond(regex, &block)
-      @commands << create_action(regex, &block)
-    end
-
-    def no_match(regex, &block)
-      remove_action @listeners, regex, block
-    end
-
-    def no_respond(regex, &block)
-      remove_action @commands, regex, block
-    end
-
-    def no(command)
-      remove_action @listeners, command: command
-      remove_action @commands, command: command
-    end
-
-    def desc(command, description = nil)
-      @current_desc = ActionDescription.new command,
-                                            description: description
-    end
-
     def say(message, api_parameters = {})
-      channel = (@trigger_message && @trigger_message.channel) || "#general"
+      channel = (trigger_message && trigger_message.channel) || "#general"
       options = { channel: channel }.merge api_parameters
       post_response = Slack.chat.post_message message, options
       logger.debug { "Post response: #{post_response}." }
@@ -63,41 +36,27 @@ module Boty
       end
     end
 
-    # TODO: return an Action object instead of a hash
     def know_how
-      actions = Array(@commands) + Array(@listeners)
+      actions = Array(commands) + Array(listeners)
       actions.sort_by { |action| action.desc.command || "_" }
     end
 
     private
 
-    def remove_action(collection, regex = nil, block = nil, command: nil)
-      collection.delete_if do |action|
-        action.desc.command == command || action.this?(regex, block)
-      end
-    end
-
     def user_by_name(destiny, to)
       to ||= destiny
       if to
         Slack.users.by_name to
       else
-        @trigger_message.user
+        trigger_message.user
       end
     end
 
-    def create_action(regex, &block)
-      regex = Regexp.new(regex) if regex.is_a? String
-      Boty::Action.new(self, regex, @current_desc, &block).tap {
-        @current_desc = nil
-      }
-    end
-
     def message_from_bot_itself?(data)
       data["user"] == id || data["user"] == name
     end
 
-    def valid_mention?(data)
+    def command?(data)
       return false if message_from_bot_itself? data
 
       if /(<@#{id}|#{name}>)/ =~ data["text"]
@@ -111,17 +70,16 @@ module Boty
       unless data["text"]
         return logger.debug do "Non text message, just ignoring." end
       end
-      actions = valid_mention?(data) ? @commands : @listeners
-      execute_all Message.new(data), actions
+      execute data
     end
 
-    def execute_all(message, actions)
-      @trigger_message = message
-      Array(actions).each do |action|
-        action.execute @trigger_message
+    def execute(data)
+      message = Message.new data
+      if command?(data)
+        execute_commands message
+      else
+        execute_matches message
       end
-    ensure
-      @trigger_message = nil
     end
   end
 end

data/lib/boty/eventable.rb

@@ -1,6 +1,7 @@
 module Boty
   module Eventable
     include Boty::Logger
+
     def events
       @events ||= {}
     end

data/lib/boty/match_handler.rb

@@ -0,0 +1,79 @@
+module Boty
+  module MatchHandler
+    include Boty::Logger
+
+    attr_reader :trigger_message
+
+    def listeners
+      @listeners ||= []
+    end
+
+    def commands
+      @commands ||= []
+    end
+
+    def desc(command, description = nil)
+      @current_desc = ActionDescription.new command,
+                                            description: description
+    end
+
+    def match(*regexes, &block)
+      create_action_on_collection listeners, regexes, &block
+    end
+
+    def respond(*regexes, &block)
+      create_action_on_collection commands, regexes, &block
+    end
+
+    def no_match(regex, &block)
+      remove_action listeners, regex, block
+    end
+
+    def no_respond(regex, &block)
+      remove_action commands, regex, block
+    end
+
+    def no(command)
+      remove_action listeners, command: command
+      remove_action commands, command: command
+    end
+
+    def execute_matches(message)
+      execute_actions message, listeners
+    end
+
+    def execute_commands(message)
+      execute_actions message, commands
+    end
+
+    private
+
+    def create_action_on_collection(collection, regexes, &block)
+      regexes.each do |regex|
+        collection << create_action(regex, &block)
+      end
+    end
+
+    def execute_actions(message, actions)
+      @trigger_message = message
+      Array(actions).each do |action|
+        action.execute @trigger_message
+      end
+    ensure
+      @trigger_message = nil
+    end
+
+    def remove_action(collection, regex = nil, block = nil, command: nil)
+      collection.delete_if do |action|
+        action.desc.command == command || action.this?(regex, block)
+      end
+    end
+
+    def create_action(regex, &block)
+      regex = Regexp.new(regex) if regex.is_a? String
+      Boty::Action.new(self, regex, @current_desc, &block).tap {
+        @current_desc = nil
+      }
+    end
+  end
+end

data/lib/boty/version.rb

@@ -1,3 +1,3 @@
 module Boty
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/boty/action_spec.rb

@@ -0,0 +1,23 @@
+module Boty
+  RSpec.describe Action, :users do
+    let(:bot) { Bot.new("id" => "U1234", "name" => "boty") }
+    let(:event_data) {
+      {
+        "type" => "message",
+        "text" => "omg lol bbq"
+      }
+    }
+
+    subject(:action) {
+      Action.new(bot, /omg/, nil) do nil end
+    }
+
+    it "evals the block in the context of the bot" do
+      dsl = nil
+      bot.match(/omg/) do dsl = self end
+      bot.event event_data
+
+      expect(dsl.bot).to eq bot
+    end
+  end
+end

data/spec/boty/bot_spec.rb

@@ -1,6 +1,5 @@
 module Boty
   RSpec.describe Bot do
-    include Boty
     subject(:bot) { described_class.new bot_info }
 
     let(:bot_info) do
@@ -10,105 +9,9 @@ module Boty
       }
     end
 
-    describe "#on" do
-      it "binds an event `'type'` to a block" do
-        data = {
-          "type" => "omg",
-          "text" => "lol"
-        }
-
-        expect { |b|
-          bot.on :omg, &b
-          bot.event data
-        }.to yield_with_args data
-      end
-    end
-
-    describe "#off" do
-      let(:data) do
-        {
-          "type" => "bbq",
-          "text" => "omg. wtf."
-        }
-      end
-
-      it "unbounds an event by type AND block, just if the block is the same" do
-        @permanent_executed = false
-        permanent_block = ->(_) do @permanent_executed = true end
-        bot.on :bbq, &permanent_block
-
-        @ephemeral_executed = false
-        ephemeral_block = ->(_) do @ephemeral_executed = true end
-        bot.on :bbq, &ephemeral_block
-        bot.off :bbq, &ephemeral_block
-
-        bot.event data
-
-        expect(@permanent_executed).to eq true
-        expect(@ephemeral_executed).to eq false
-      end
-
-      it "unbounds all events by type" do
-        @first_block = @second_block = @third_block = false
-        bot.on(:bbq) do |_| @first_block = true end
-        bot.on(:bbq) do |_| @second_block = true end
-        bot.on(:bbq) do |_| @third_block = true end
-        bot.off(:bbq)
-
-        bot.event data
-
-        expect(@first_block).to eq false
-        expect(@second_block).to eq false
-        expect(@third_block).to eq false
-      end
-    end
-
-    describe "#match", :users do
-      let(:data) do
-        {
-          "type" => "message",
-          "text" => "bbq omg lol"
-        }
-      end
-
-      it "binds a regex to events of `type => message`" do
-        message = nil
-        bot.match(/omg/i) do
-          message = self.message
-        end
-        bot.event data
-
-        expect(message).to be_a Boty::Slack::Message
-        expect(message.text).to eq "bbq omg lol"
-        expect(message.match[0]).to eq "omg"
-      end
-
-      it "binds various actions to events of type message" do
-        iterations = []
-        bot.match(/omg/i) do iterations << "first" end
-        bot.match(/omg/i) do iterations << "second" end
-        bot.event data
-
-        expect(iterations).to eq %w(first second)
-      end
-
-      it "passes the matched strings as parameters to block action" do
-        rspec = self
-        bot.match(/(bbq) omg (lol)/i) do |bbq, lol|
-          rspec.expect(bbq).to rspec.eq "bbq"
-          rspec.expect(lol).to rspec.eq "lol"
-        end
-
-        bot.event data
-      end
-
-      it "evals the block in the context of the bot" do
-        dsl = nil
-        bot.match(/omg/) do dsl = self end
-        bot.event data
-
-        expect(dsl.bot).to eq bot
-      end
+    context "handling message events" do
+      # on message, check if the event is binded, or something...
+      # call execute_actions with a message object
     end
 
     describe "#respond", :users do

data/spec/boty/eventable_spec.rb

@@ -0,0 +1,57 @@
+module Boty
+  RSpec.describe Boty::Eventable do
+    class Client
+      include Eventable
+    end
+
+    subject(:eventable) { Client.new }
+
+    describe "#on" do
+      it "binds an event `'type'` to a block" do
+        expect { |b|
+          eventable.on :omg, &b
+          eventable.event "type" => "omg", "other_field" => "lol"
+        }.to yield_with_args "type" => "omg", "other_field" => "lol"
+      end
+    end
+
+    describe "#off" do
+      let(:data) do
+        {
+          "type" => "bbq",
+          "text" => "omg. wtf."
+        }
+      end
+
+      it "unbounds an event by type AND block, just if the block is the same" do
+        @permanent_executed = false
+        permanent_block = ->(_) do @permanent_executed = true end
+        eventable.on :bbq, &permanent_block
+
+        @ephemeral_executed = false
+        ephemeral_block = ->(_) do @ephemeral_executed = true end
+        eventable.on :bbq, &ephemeral_block
+        eventable.off :bbq, &ephemeral_block
+
+        eventable.event data
+
+        expect(@permanent_executed).to eq true
+        expect(@ephemeral_executed).to eq false
+      end
+
+      it "unbounds all events by type" do
+        @first_block = @second_block = @third_block = false
+        eventable.on(:bbq) do |_| @first_block = true end
+        eventable.on(:bbq) do |_| @second_block = true end
+        eventable.on(:bbq) do |_| @third_block = true end
+        eventable.off(:bbq)
+
+        eventable.event data
+
+        expect(@first_block).to eq false
+        expect(@second_block).to eq false
+        expect(@third_block).to eq false
+      end
+    end
+  end
+end

data/spec/boty/match_handler_spec.rb

@@ -0,0 +1,119 @@
+module Boty
+  RSpec.describe MatchHandler do
+    class Handler
+      include MatchHandler
+    end
+
+    subject(:handler) { Handler.new }
+
+    describe "#match", :users do
+      it "binds a regex to be executed by an Action object" do
+        action_block = ->(*) { "omg" }
+        expect(Boty::Action).to receive(:new)
+          .with(handler, /omg/i, nil, &action_block)
+
+        handler.match(/omg/i, &action_block)
+      end
+
+      it "allows to bind more than one regex with the same action" do
+        counter = 0
+        action_block = ->(*) { counter += 1 }
+        handler.match(/omg/i, /lol/i, /bbq/i, &action_block)
+
+        handler.execute_matches OpenStruct.new(text: "omg")
+        handler.execute_matches OpenStruct.new(text: "lol")
+        handler.execute_matches OpenStruct.new(text: "bbq")
+
+        expect(counter).to eq 3
+      end
+
+      it "passes the matched strings as parameters to the block" do
+        first_match   = nil
+        second_match  = nil
+        handler.match(/(bbq) omg (lol)/i) do |bbq, lol|
+          first_match   = bbq
+          second_match  = lol
+        end
+        handler.execute_matches OpenStruct.new(text: "bbq omg lol")
+
+        expect(first_match).to eq "bbq"
+        expect(second_match).to eq "lol"
+      end
+    end
+
+    describe "#respond" do
+      it "allows to bind more than one regex with the same action" do
+        counter = 0
+        action_block = ->(*) { counter += 1 }
+        handler.respond(/omg/i, /lol/i, /bbq/i, &action_block)
+
+        handler.execute_commands OpenStruct.new(text: "omg")
+        handler.execute_commands OpenStruct.new(text: "lol")
+        handler.execute_commands OpenStruct.new(text: "bbq")
+
+        expect(counter).to eq 3
+      end
+    end
+
+    describe "#execute_matches" do
+      it "executes handler binded to the regex" do
+        executed = false
+        action_block = -> { executed = true }
+        handler.match(/omg/i, &action_block)
+        handler.execute_matches OpenStruct.new(text: "omg")
+
+        expect(executed).to eq true
+      end
+
+      it "repasses the text message holder as a parameter" do
+        message = nil
+        holder = OpenStruct.new(text: "omg")
+        handler.match(/omg/i) do message = self.message end
+        handler.execute_matches holder
+
+        expect(message).to be holder
+      end
+
+      it "executes all handlers when more than one are found" do
+        first_executed = false
+        first_block = -> { first_executed = true }
+        handler.match(/omg/i, &first_block)
+
+        second_executed = false
+        second_block = -> { second_executed = true }
+        handler.match(/omg/i, &second_block)
+
+        handler.execute_matches OpenStruct.new(text: "omg")
+
+        expect(first_executed).to eq true
+        expect(second_executed).to eq true
+      end
+    end
+
+    describe "#execute_commands" do
+      it "executes the command binded to the regex" do
+        executed = false
+        action_block = -> { executed = true }
+        handler.respond(/lol/i, &action_block)
+        handler.execute_commands OpenStruct.new(text: "lol")
+
+        expect(executed).to eq true
+      end
+
+      it "executes all commands when more than one are found" do
+        first_executed = false
+        first_block = -> { first_executed = true }
+        handler.respond(/lol/i, &first_block)
+
+        second_executed = false
+        second_block = -> { second_executed = true }
+        handler.respond(/lol/i, &second_block)
+
+        handler.execute_commands OpenStruct.new(text: "lol")
+
+        expect(first_executed).to eq true
+        expect(second_executed).to eq true
+      end
+    end
+  end
+end

data/spec/script/i18n_spec.rb

@@ -10,9 +10,8 @@ RSpec.describe "I18n on default scripts", :session do
       know_how = self.know_how
     end
 
-    actions = know_how.reduce({}) { |hsh, action|
+    actions = know_how.each_with_object({}) { |action, hsh|
       hsh[action.desc.command] = action.desc.description
-      hsh
     }
 
     expect(actions["knows"]).to eq "List all the commands known by this bot."
@@ -26,9 +25,8 @@ RSpec.describe "I18n on default scripts", :session do
       know_how = self.know_how
     end
 
-    actions = know_how.reduce({}) { |hsh, action|
+    actions = know_how.each_with_object({}) { |action, hsh|
       hsh[action.desc.command] = action.desc.description
-      hsh
     }
 
     expect(actions["knows"]).to eq "Lista os comandos conhecidos por esse bot."

data/spec/script/knows_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe "script/knows", :session do
 
     bot.know_how.each { |action|
       next if action.desc.command == "knows" ||
-                action.desc.command == "pug me"
+              action.desc.command == "pug me"
       bot.no action.desc.command
     }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: boty
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Ricardo Valeriano
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-18 00:00:00.000000000 Z
+date: 2015-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: |-
   Boty is intendted to be a framework for construction of
                            automated Slack Bots for your needs.
@@ -204,6 +218,7 @@ files:
 - lib/boty/http.rb
 - lib/boty/locale.rb
 - lib/boty/logger.rb
+- lib/boty/match_handler.rb
 - lib/boty/rspec.rb
 - lib/boty/script_loader.rb
 - lib/boty/session.rb
@@ -224,11 +239,14 @@ files:
 - script/knows.rb
 - script/pug.rb
 - script/remember.rb
+- spec/boty/action_spec.rb
 - spec/boty/bot_spec.rb
 - spec/boty/cli_spec.rb
 - spec/boty/dsl_spec.rb
+- spec/boty/eventable_spec.rb
 - spec/boty/http_spec.rb
 - spec/boty/logger_spec.rb
+- spec/boty/match_handler_spec.rb
 - spec/boty/rspec_spec.rb
 - spec/boty/script_loader_spec.rb
 - spec/boty/session_spec.rb
@@ -293,3 +311,4 @@ signing_key:
 specification_version: 4
 summary: Boty is a pretty bot specially tailored for Slack.
 test_files: []
+has_rdoc: