boty 0.0.17.1 → 0.1.0

data/bin/bot

@@ -1,22 +1,19 @@
 #!/usr/bin/env ruby
 require "./lib/boty"
 
-def set_locale(locale)
-  begin
-    Boty.locale = locale || :en
-  rescue I18n::InvalidLocale
-    Boty.locale = :en
-  end
-  Boty::Locale.reload
-end
+Boty.locale = ARGV.pop || :en
 
-set_locale ARGV.pop
+Boty::Logger.adapter = Boty::Logger::Multi.new([
+  Logger.new(STDOUT),
+  Logger.new("log/output.log", "daily")
+])
 
 session = Boty::Session.new
-session.start do |bot|
-  bot.desc bot.name, I18n.t("template.presence", bot_name: bot.name)
-  bot.hear(/#{bot.name}/i) do
+session.start do
+  desc name, I18n.t("template.presence", bot_name: name)
+  hear(/#{name}/i) do
     next if message_from_me?
-    say I18n.t "template.hello", user_name: message.user.name
+    logger.debug "saying hello"
+    say I18n.t "template.hello", user_name: user.name
   end
 end

data/lib/boty/action.rb

@@ -39,7 +39,7 @@ module Boty
     end
 
     def execute(bot, message)
-      dsl = ScriptDSL.new(bot)
+      dsl = DSL.new(bot)
       if match = message.match!(regex)
         matches = Array(match)
         matches.shift

data/lib/boty/bot.rb

@@ -1,109 +1,88 @@
 module Boty
   class Bot
+    include Boty::Eventable
     include Boty::Logger
-    attr_reader :id, :name, :trigger_message
+    include Slack
 
-    def initialize(bot_info, session)
+    attr_reader :id, :name, :trigger_message, :brain
+
+    def initialize(bot_info)
       Locale.reload
       @raw_info, @id, @name = bot_info, bot_info["id"], bot_info["name"]
-      @handlers ||= []
+      @listeners ||= []
       @commands ||= []
-      @events = {}
-      ScriptLoader.new(self).load
+      @brain ||= {}
       on :message, &method(:message_handler)
-    end
-
-    def event(data)
-      return unless type = event_type(data)
-
-      @events[type].each do |action|
-        action.call data
-      end
-    end
-
-    def on(event_type, &block)
-      @events[event_type.to_sym] ||= []
-      @events[event_type.to_sym] << block
-    end
-
-    def off(event_type, &block)
-      if block_given?
-        @events[event_type].delete_if { |b| b == block }
-      else
-        @events[event_type] = []
-      end
+      ScriptLoader.new(self).load
     end
 
     def match(regex, &block)
-      @handlers << create_action(regex, &block)
-    end
-
-    def no_match(regex, &block)
-      @handlers.delete_if do |action|
-        action.is_this? regex, block
-      end
+      @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)
-      @commands.delete_if do |action|
-        action.is_this? regex, block
-      end
+      remove_action @commands, regex, block
     end
 
     def no(command)
-      @handlers.delete_if do |action|
-        action.desc.command == command
-      end
+      remove_action @listeners, command: command
+      remove_action @commands, command: command
+    end
 
-      @commands.delete_if do |action|
-        action.desc.command == command
-      end
+    def desc(command, description = nil)
+      @current_desc = { command: 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}" }
+      logger.debug { "Post response: #{post_response}." }
     end
 
-    def desc(command, description = nil)
-      @current_desc = { command: command, description: description }
+    def im(text, destiny: nil, to: nil, user_id: nil)
+      if destiny = User(user_id) || user_by_name(destiny, to)
+        logger.debug { "Sending #{text} to #{destiny.name}." }
+        Slack.chat.post_im destiny.id, text
+      else
+        logger.debug { "User not found, refusing to send im." }
+      end
     end
 
+    # TODO: return an Action object instead of a hash
     def know_how
-      descriptions = (Array(@commands) + Array(@handlers)).compact.map(&:desc)
+      descriptions = (Array(@commands) + Array(@listeners)).compact.map(&:desc)
       descriptions.inject({}) { |hsh, desc|
         hsh.merge!(desc.command => desc.description)
       }
     end
 
-    def im(message)
-      logger.debug { "sending im messge to #{@trigger_message.user.name}" }
-      Slack.chat.post_im @trigger_message.user.id, message
-    end
+    private
 
-    def brain
-      @brain ||= {}
+    def remove_action(collection, regex = nil, block = nil, command: nil)
+      collection.delete_if do |action|
+        action.desc.command == command || action.is_this?(regex, block)
+      end
     end
 
-    private
-
-    def event_type(data)
-      type = data["type"].to_sym
-      logger.debug { "bot specifc event[#{type}] arrived: #{data}" }
-      unless @events[type]
-        logger.debug "no action binded to #{type}"
-        return
+    def user_by_name(destiny, to)
+      if _to = to || destiny
+        Slack.users.by_name _to
+      else
+        @trigger_message.user
       end
-      type
     end
 
     def create_action(regex, &block)
+      regex = Regexp.new(regex) if regex.is_a? String
       Boty::Action.new(regex, @current_desc, &block).tap {
         @current_desc = nil
       }
@@ -119,7 +98,11 @@ module Boty
     end
 
     def message_handler(data)
-      actions = has_valid_mention?(data) ? @commands : @handlers
+      unless data["text"]
+        return logger.debug "Non text message, just ignoring."
+      end
+
+      actions = has_valid_mention?(data) ? @commands : @listeners
       @trigger_message = Message.new data
       begin
         Array(actions).each do |action|

data/lib/boty/dsl.rb

@@ -0,0 +1,52 @@
+require "forwardable"
+
+module Boty
+  class DSL
+    include Boty::Logger
+
+    INSTANCES = {}
+    private_constant :INSTANCES
+    class << self
+      alias original_constructor new
+    end
+
+    attr_accessor :bot
+
+    extend Forwardable
+    def_delegators :bot, :desc, :respond, :name, :brain, :know_how, :im, :say,
+                         :match
+    def_delegators :message, :user, :channel
+
+    def self.new(bot)
+      INSTANCES[bot] ||= original_constructor bot
+    end
+
+    def initialize(bot)
+      @bot = bot
+    end
+
+    def message
+      @bot.trigger_message
+    end
+
+    def message_from_me?
+      message.from? @bot
+    end
+
+    def hear(*args, &block)
+      match(*args, &block)
+    end
+
+    def command(*args, &block)
+      respond(*args, &block)
+    end
+
+    def match_im(*args, &block)
+      command(*args, &block)
+    end
+
+    def http
+      @http ||= Boty::HTTP.new
+    end
+  end
+end

data/lib/boty/eventable.rb

@@ -0,0 +1,41 @@
+module Boty
+  module Eventable
+    include Boty::Logger
+    def events
+      @events ||= {}
+    end
+
+    def event(data)
+      return unless type = event_type(data)
+
+      events[type].each do |action|
+        action.call data
+      end
+    end
+
+    def on(event_type, &block)
+      events[event_type.to_sym] ||= []
+      events[event_type.to_sym] << block
+    end
+
+    def off(event_type, &block)
+      if block_given?
+        events[event_type].delete_if { |b| b == block }
+      else
+        events[event_type] = []
+      end
+    end
+
+    private
+
+    def event_type(data)
+      type = data["type"].to_sym
+      logger.debug { "event[#{type}] arrived: #{data}" }
+      unless events[type]
+        logger.debug "no action binded to #{type}"
+        return
+      end
+      type
+    end
+  end
+end

data/lib/boty/http.rb

@@ -0,0 +1,33 @@
+module Boty
+  class HTTP
+    attr_reader :response # available in case of non 2XX responses...
+
+    [:get, :post, :put, :delete, :head, :patch, :options].each do |verb|
+      define_method verb do |url, params = {}|
+        @response = connection verb, url, params
+        handle_response
+      end
+    end
+
+    private
+
+    def connection(verb, url, params)
+      uri = URI url
+      Faraday.new(url: "#{uri.scheme}://#{uri.host}") { |builder|
+        builder.adapter(*Faraday.default_adapter)
+      }.public_send(verb) { |req|
+        req.url uri.path, params
+      }
+    end
+
+    def handle_response
+      # TODO: use a response parser accordingly to the
+      body = response.body
+      if /application\/json/.match response.headers["Content-Type"]
+        JSON.parse body
+      else
+        body
+      end
+    end
+  end
+end

data/lib/boty/locale.rb

@@ -1,11 +1,24 @@
 module Boty
   class Locale
-    def self.reload
+    def self.reload(locale = nil)
+      _locale = new
+      I18n.load_path = _locale.locales_paths.uniq
+      I18n.available_locales = I18n::Backend::Simple.new.available_locales
+      _locale.set_locale locale if locale
+    end
+
+    def locales_paths
       default_locales_path = File.expand_path("../../../locale/**/*.yml", __FILE__)
-      locales = (Dir["locale/**/*.yml"] + Dir[default_locales_path]).
+      (Dir["locale/**/*.yml"] + Dir[default_locales_path]).
         map { |file| File.expand_path file }
-      I18n.load_path = locales.uniq
-      I18n.available_locales = I18n::Backend::Simple.new.available_locales
+    end
+
+    def set_locale(locale)
+      begin
+        I18n.locale = locale
+      rescue I18n::InvalidLocale
+        I18n.locale = :en
+      end
     end
   end
 end

data/lib/boty/logger.rb

@@ -17,8 +17,22 @@ module Boty
       Logger.adapter
     end
 
-    def log_level(level)
-      logger.level = level
+    class Multi < ::Logger
+      def initialize(adapters)
+        @adapters = adapters
+      end
+
+      def level=(level)
+        @adapters.each do |adapter|
+          adapter.level = level
+        end
+      end
+
+      def add(*args, &block)
+        @adapters.each do |adapter|
+          adapter.add(*args, &block)
+        end
+      end
     end
 
     class Memory < ::Logger
@@ -29,8 +43,11 @@ module Boty
       end
 
       def add(*args, &block)
-        _, _, message = args
-        @logs << message
+        @logs << if block_given?
+                   block.call
+                 else
+                   args[2]
+                 end
       end
     end
 

data/lib/boty/rspec.rb

@@ -9,8 +9,7 @@ module Boty
 
           before do
             @_bot = Boty::Bot.new(
-              {"id" => "1234", "name" => "bot"},
-              Boty::Session.new
+              {"id" => "1234", "name" => "bot"}
             )
 
             class << Boty::Slack.chat
@@ -24,7 +23,7 @@ module Boty
           end
 
           let(:bot) {
-            Boty::ScriptDSL.new @_bot
+            Boty::DSL.new @_bot
           }
         end
       end

data/lib/boty/script_loader.rb

@@ -1,7 +1,7 @@
 module Boty
   class ScriptLoader
     def initialize(bot)
-      @dsl = ScriptDSL.new bot
+      @dsl = DSL.new bot
     end
 
     def load

data/lib/boty/session.rb

@@ -10,49 +10,53 @@ module Boty
       EM.run do
         login
         @bot = initialize_bot(&block)
-        stablish_connection do |ws|
-          ws.on :message do |event|
-            begin
-              on_message event, @bot
-            rescue StandardError => e
-              logger.error "Message #{event} could not be processed. #{e.message}"
-            end
-          end
-        end
+        stablish_connection
       end
       self
     end
 
     private
 
+    def on_connect(ws)
+      ws.on :message do |event|
+        begin
+          on_message event, @bot
+        rescue StandardError => e
+          logger.error "Message #{event} could not be processed. #{e.message}"
+          logger.debug e.backtrace.reduce("") { |msg, line| msg << "#{line}\n" }
+        end
+      end
+    end
+
     def login
-      logger.debug { "logging in against slack right now" }
+      logger.debug { "Logging in against slack right now" }
       @slack_info = Slack.rtm.start
       logger.debug { "yep! logged in!" }
       @session_url = @slack_info["url"]
     end
 
     def initialize_bot(&block)
-      Bot.new(@slack_info["self"], self).tap { |bot|
-        block.call ScriptDSL.new(bot) if block_given?
-        logger.debug { "bot is configured and ready to go!" }
+      Bot.new(@slack_info["self"]).tap { |bot|
+        DSL.new(bot).instance_eval(&block) if block_given?
+        logger.debug { "Bot is configured and ready to go!" }
       }
     end
 
     def on_message(event, bot)
-      logger.debug { "message arrived #{event.data}" }
+      logger.debug { "Message arrived. Creating bot event" }
       bot.event JSON.parse(event.data)
     end
 
     def on_close
-      logger.debug { "bye byeb." }
+      logger.debug { "bye bye" }
+      #todo try to reconnect (stablish_connection) unless is an em interrupt
     end
 
     def stablish_connection
-      logger.debug { "starting to listen on #{@session_url}" }
+      logger.debug { "Starting to listen on #{@session_url}" }
       ws = Faye::WebSocket::Client.new @session_url
       ws.on :close do on_close end
-      yield ws if block_given?
+      on_connect ws
     end
   end
 end

data/lib/boty/slack/chat.rb

@@ -15,8 +15,8 @@ module Boty
         URL.get parameterize(defaults.merge parameters)
       end
 
-      def post_im(user, message)
-        channel = im.open user
+      def post_im(user_id, message)
+        channel = im.open user_id
         post_message message, channel: channel.id
       end
     end

data/lib/boty/slack/message.rb

@@ -0,0 +1,29 @@
+module Boty
+  module Slack
+    class Message
+      attr_accessor :text, :user, :channel, :ts, :team
+      attr_reader :match
+
+      def initialize(data, match: nil)
+        @text = data["text"]
+        @user = Slack.users.info data["user"]
+        @channel = data["channel"]
+        @ts = data["ts"]
+        @team = data["team"]
+        @match = match
+      end
+
+      def match!(regex)
+        @match = regex.match @text
+      end
+
+      def from?(author)
+        if author.respond_to? :id
+          @user.id == author.id
+        else
+          @user.id == author
+        end
+      end
+    end
+  end
+end

data/lib/boty/slack/users.rb

@@ -10,6 +10,19 @@ module Boty
         info = URL.get url
         Slack::User.new info["user"]
       end
+
+      def list(parameters = {})
+        # TODO: this call should be cached.
+        url = parameterize parameters, path: ".list"
+        users = URL.get url
+        users["members"].map { |info|
+          Slack::User.new info
+        }
+      end
+
+      def by_name(name)
+        list.select { |user| user.name == name }.first
+      end
     end
   end
 end

data/lib/boty/slack.rb

@@ -5,6 +5,7 @@ require "boty/slack/user"
 require "boty/slack/users"
 require "boty/slack/chat"
 require "boty/slack/rtm"
+require "boty/slack/message"
 
 module Boty
   module Slack
@@ -13,5 +14,10 @@ module Boty
       def rtm; @rtm ||= RTM.new end
       def users; @users ||= Users.new end
     end
+
+    def User(user_id)
+      return unless user_id
+      Boty::Slack::User.new "id" => user_id
+    end
   end
 end

data/lib/boty/version.rb

@@ -1,3 +1,3 @@
 module Boty
-  VERSION = "0.0.17.1"
+  VERSION = "0.1.0"
 end

data/lib/boty.rb

@@ -17,8 +17,7 @@ $:.unshift File.expand_path("../../lib", __FILE__)
 
 module Boty
   def self.locale=(lang)
-    Locale.reload
-    I18n.locale = lang
+    Locale.reload lang
   end
 
   def self.locale
@@ -30,9 +29,10 @@ require "boty/version"
 require "boty/logger"
 require "boty/slack"
 require "boty/session"
-require "boty/message"
 require "boty/action"
 require "boty/script_loader"
-require "boty/script_dsl"
+require "boty/dsl"
 require "boty/locale"
+require "boty/eventable"
 require "boty/bot"
+require "boty/http"