pepito 0.0.1

data/lib/pepito/http_api/rack_app.rb

@@ -0,0 +1,27 @@
+require 'rack'
+require 'http_router'
+
+module Pepito
+  module HTTPApi
+    # The rack app for the http api.
+    class RackApp
+      # Router for the rack app.
+      # @return [HttpRouter]
+      attr_reader :router
+
+      # Rack App
+      # @return [Object]
+      attr_reader :app
+
+      # @return [void]
+      def initialize
+        @router = HttpRouter.new
+
+        builder = Rack::Builder.new
+        builder.run(@router)
+
+        @app = builder.to_app
+      end
+    end
+  end
+end

data/lib/pepito/message.rb

@@ -0,0 +1,59 @@
+module Pepito
+  # Message received by an adapter
+  class Message
+    # The source of the message.
+    # @return [Pepito::Source]
+    attr_reader :source
+
+    # The text received.
+    # @return [String]
+    attr_reader :body
+
+    # The command part of the message.
+    # Example: body is -> "pepito info", command is "info".
+    # @return [String, nil] Returns nil if command could not be parsed.
+    attr_reader :command
+
+    # The currently running robot.
+    # @return [Pepito::Robot]
+    attr_reader :robot
+
+    # @param robot [Pepito::Robot] The currently running robot.
+    # @param source [Pepito::Source] The source of the message.
+    # @param body [String] The text received.
+    # @return [void]
+    def initialize(robot, source, body)
+      @robot = robot
+      @source = source
+      @body = body
+
+      @command = parse_command
+    end
+
+    # Returns whether a command exists or not.
+    # @return [Boolean]
+    def command?
+      @command.nil? ? false : true
+    end
+
+    # Returns whether a message matches a route or not
+    # @return [Boolean]
+    def match_route?(route)
+      return true if !route.command && route.pattern.match(body)
+      return true if route.command && command? && route.pattern.match(command)
+      false
+    end
+
+    private
+
+    # Parses the command from the body attribute.
+    # @return [String] The command string
+    def parse_command
+      return nil if @robot.name.nil? || @robot.name.empty?
+
+      command_data = /^#{@robot.name}\s?(?<command>.*)$/.match(@body)
+
+      command_data[:command] unless command_data.nil?
+    end
+  end
+end

data/lib/pepito/robot.rb

@@ -0,0 +1,367 @@
+require 'logger'
+require 'puma'
+require 'rubygems'
+require 'rubygems/dependency_installer'
+
+require_relative 'http_api/rack_app'
+require_relative 'web_app/app'
+require_relative 'handlers/info'
+require_relative 'handlers/extensions_catalog'
+require_relative 'handlers/help'
+require_relative 'handlers/room'
+require_relative 'database'
+require_relative 'adapters'
+require_relative 'errors/required_methods_error'
+require_relative 'errors/missing_configuration_value_error'
+
+module Pepito
+  # The robot component of the bot.
+  class Robot
+    # The running http_api.
+    # @return [Pepito::HTTPApi::RackApp]
+    attr_reader :http_api
+
+    # The thread running the HTTP API.
+    # @return [Thread]
+    attr_reader :http_api_thread
+
+    # The Puma::Server running the HTTP API
+    # @return [Puma::Server]
+    attr_reader :http_api_server
+
+    # The web app.
+    # @return [Pepito::WebApp::App]
+    attr_reader :web_app
+
+    # The thread running the web app.
+    # @return [Thread]
+    attr_reader :web_app_thread
+
+    # The Puma::Server running the Web App
+    # @return [Puma::Server]
+    attr_reader :web_app_server
+
+    # List of running handlers.
+    # @return [Hash] A map of handler's keys to classes.
+    attr_reader :handlers
+
+    # List of running adapters.
+    # @return [Hash] A map of adapter's keys to classes.
+    attr_reader :adapters
+
+    # Name of the bot.
+    # @return [String]
+    attr_reader :name
+
+    # Redis connection
+    # @return [Pepito::Database]
+    attr_reader :database
+
+    # Logger
+    # @return [Logger]
+    attr_reader :logger
+
+    # Default handlers that can't be turned off
+    # @return [Array<String>]
+    attr_reader :default_handlers
+
+    # Default adapters that can't be turned off
+    # @return [Array<String>]
+    attr_reader :default_adapters
+
+    # @return [void]
+    def initialize
+      @logger = Logger.new(ENV['LOG_FILE'] || STDOUT)
+
+      @logger.info('Connecting to the database')
+      @database = Database.new
+
+      @http_api = HTTPApi::RackApp.new
+
+      @web_app = WebApp::App
+
+      @default_handlers = %w(Info Help Room)
+      @handlers = {}
+
+      @default_adapters = []
+      @adapters = {}
+
+      @name = @database.get('name') || 'pepito'
+    end
+
+    # Runs the robot.
+    # @return [void]
+    def run
+      run_http_api
+      run_web_app
+      run_handlers
+      run_adapters
+      begin
+        sleep
+      rescue Interrupt
+        @logger.info('Exiting')
+      end
+    end
+
+    # Helper to receive a message.
+    # @param message [Pepito::Message] A message received by an adapter.
+    # @return [void]
+    def receive_message(message)
+      match = @handlers.dup.map do |_, handler|
+        handler.chat_routes.map do |route|
+          next unless message.match_route?(route)
+          strings = handler.public_send(route.func, message.source, route.pattern.match(message.command || message.body))
+          message.source.adapter.send_messages(message.source, strings) unless strings.nil?
+          true
+        end.any?
+      end.any?
+
+      message.source.adapter.send_messages(message.source, ['No match for command "' + message.command + '"']) if !match && message.command
+    end
+
+    # Retrieve the list of possible handlers to install from server
+    # @return [Array<String>]
+    def handlers_list
+      %w(Info Help ExtensionsCatalog Room)
+    end
+
+    # Retrieve the list of possible adapters to install from server
+    # @return [Array<String>]
+    def adapters_list
+      [
+        {
+          name: 'Slack',
+          gem: 'pepito-slack',
+          configs: [
+            {
+              name: 'SLACK_API_TOKEN',
+              required: true
+            }
+          ]
+        }
+      ]
+    end
+
+    # Starts an handler.
+    # @param handler [String] Name of the handler to start.
+    # @return [Integer]
+    #   0 - If success
+    #   1 - If failed because handler is already running
+    #   2 - If handler can't be found
+    #   3 - Other errors
+    def start_handler(handler)
+      @logger.info('"' + handler.to_s + '" handler starting')
+      if @handlers.key?(handler)
+        @logger.warn('"' + handler.to_s + '" handler is already running')
+        return 1
+      else
+        begin
+          @handlers[handler] = Handlers.const_get(handler).new(self)
+        rescue NameError
+          @logger.error('"' + handler.to_s + '" handler does not exist')
+          return 2
+        rescue => e
+          @logger.error('"' + handler.to_s + '" handler failed to start. Error: ' + e.message.to_s)
+          @logger.error(e)
+          return 3
+        end
+        @http_api.router.uncompile
+        @handlers[handler].run
+        @handlers[handler].start
+        @database.sadd('handlers', handler)
+        @logger.info('"' + handler.to_s + '" handler started successfully')
+        return 0
+      end
+    end
+
+    # Stops an handler.
+    # @param handler [String] Name of the handler to stop. Must match the handler's class name.
+    # @return [Integer]
+    #   0 - If handler stopped
+    #   1 - If it is a default handler
+    #   2 - If it is not running
+    def stop_handler(handler)
+      @logger.info('Stopping "' + handler.to_s + '" handler')
+      if @default_handlers.include?(handler)
+        @logger.error('Can\'t stop "' + handler.to_s + '" because it is a default handler')
+        return 1
+      elsif !@handlers.key?(handler)
+        @logger.warn('"' + handler.to_s + '" handler is not running')
+        return 2
+      else
+        @handlers.delete(handler)
+        @database.srem('handlers', handler)
+        @http_api.router.reset!
+        @handlers.each do |_, h|
+          h.start
+        end
+        @logger.info('"' + handler.to_s + '" handler stopped successfully')
+        return 0
+      end
+    end
+
+    # Checks if an handler is running or not.
+    # @param handler [String] Name of the handler.
+    # @return [Boolean]
+    def handler?(handler)
+      @handlers.key?(handler)
+    end
+
+    # Starts an adapter.
+    # @param adapter [String] Name of the adapter to start. Must match the adapter's class name.
+    # @param gem_name [String] Name of the gem for the adapter
+    # @param config [Hash<String,String>] The config for the adapter
+    # @return [Integer]
+    #   0 - if adapter was started
+    #   1 - if adapter is already running
+    #   2 - if adapter can't be found
+    #   3 - if there are missing methods on the adapter
+    #   4 - if there are missing configuration values
+    #   5 - other errors
+    def start_adapter(adapter, gem_name, config)
+      @logger.info('"' + adapter.to_s + '" adapter starting')
+      if @adapters.key?(adapter)
+        @logger.warn('"' + adapter.to_s + '" adapter already running')
+        return 1
+      else
+        begin
+          require gem_name
+        rescue LoadError
+          begin
+            inst = Gem::DependencyInstaller.new
+            inst.install gem_name
+            require gem_name
+          rescue => e
+            @logger.error(e)
+            return 2
+          end
+        end
+
+        begin
+          adp = Pepito::Adapters.const_get(adapter).new(self, config)
+        rescue NameError => e
+          @logger.error('"' + adapter.to_s + '" adapter could not be found')
+          @logger.error(e)
+          return 2
+        rescue Pepito::Errors::RequiredMethodsError => e
+          @logger.error('"' + adapter.to_s + '" adapter failed to start. ' + e.message + ': ' + e.missing_methods.to_s)
+          return 3
+        rescue Pepito::Errors::MissingConfigurationValueError => e
+          @logger.error('"' + adapter.to_s + '" adapter failed to start. ' + e.message + ': ' + e.configuration_values.to_s)
+          return 4
+        rescue => e
+          @logger.error('"' + adapter.to_s + '" adapter failed to start. Error: ' + e.message.to_s)
+          @logger.error(e)
+          return 5
+        end
+
+        # If it didnt fail, spawn adapter thread
+        @adapters[adapter] = adp
+        @database.sadd('adapters', adapter)
+        # Clear old config in database
+        @database.del(adapter)
+        # Set gem name in database
+        @database.set(adapter + ':gem', gem_name)
+        # Setup new config in database
+        config.each do |key, value|
+          @database.hset(adapter + ':config', key, value)
+        end
+
+        Thread.new do
+          adp.run
+        end
+
+        @logger.info('"' + adapter.to_s + '" adapter started successfully')
+        return 0
+      end
+    end
+
+    # Stops an adapter.
+    # @param adapter [String] Name of the adapter to stop. Must match the adapter's class name.
+    # @return [Integer]
+    #   0 - If successful
+    #   1 - If adapter is default
+    #   2 - If adapter is not running
+    def stop_adapter(adapter)
+      if @default_adapters.include?(adapter)
+        @logger.error('Can\'t stop "' + adapter.to_s + '" adapter because it is a default adapter')
+        return 1
+      elsif !@adapters.key?(adapter)
+        @logger.warn('"' + adapter.to_s + '" adapter is not running')
+        return 2
+      else
+        @adapters[adapter].stop
+        @adapters.delete(adapter)
+        @database.del(adapter + ':config')
+        @database.del(adapter + ':gem')
+        @database.srem('adapters', adapter)
+        @logger.info('"' + adapter.to_s + '" adapter stopped successfully')
+        return 0
+      end
+    end
+
+    # Checks if an adapter is running or not.
+    # @param adapter [String] Name of the adapter.
+    # @return [Boolean]
+    def adapter?(adapter)
+      @adapters.key?(adapter)
+    end
+
+    private
+
+    # Runs the http api in a new thread.
+    # @return [void]
+    def run_http_api
+      @logger.info('Starting the HTTP API')
+      @http_api_thread = Thread.new do
+        @http_api_server = Puma::Server.new(@http_api.app)
+        @http_api_server.add_tcp_listener('127.0.0.1', 8080)
+        @http_api_server.run
+      end
+
+      @http_api_thread.abort_on_exception = true
+    end
+
+    # Runs the web app in a new thread.
+    # @return [void]
+    def run_web_app
+      @logger.info('Starting the web app')
+      @web_app_thread = Thread.new do
+        @web_app.set(:robot, self)
+
+        @web_app_server = Puma::Server.new(@web_app)
+        @web_app_server.add_tcp_listener('127.0.0.1', 4567)
+
+        @web_app_server.run
+      end
+
+      @web_app_thread.abort_on_exception = true
+    end
+
+    # Runs the handlers saved in the database
+    # @return [void]
+    def run_handlers
+      @logger.info('Starting the handlers')
+      @default_handlers.each do |handler|
+        start_handler(handler)
+      end
+
+      @database.smembers('handlers').each do |handler|
+        start_handler(handler) unless @default_handlers.include?(handler)
+      end
+    end
+
+    # Runs the adapters saved in the database
+    # @return [void]
+    def run_adapters
+      @logger.info('Starting the adapters')
+      @default_adapters.each do |adapter, gem_name, configs|
+        start_adapter(adapter, gem_name, configs)
+      end
+
+      @database.smembers('adapters').each do |adapter|
+        start_adapter(adapter, @database.get(adapter + ':gem'), @database.hgetall(adapter + ':config')) unless @default_adapters.include?(adapter)
+      end
+    end
+  end
+end

data/lib/pepito/source.rb

@@ -0,0 +1,32 @@
+module Pepito
+  # Source for a message, where it comes from, where it should go
+  class Source
+    # Adapter that received the message.
+    # @return [Pepito::Adapter]
+    attr_reader :adapter
+
+    # User that sent the message.
+    # @return [String]
+    attr_reader :user
+
+    # Room where the message originated
+    # @return [String]
+    attr_reader :room
+
+    # Whether the message is private or not
+    # @return [Boolean]
+    attr_reader :private_message
+
+    # @param adapter [Adapter] The adapter that received the message.
+    # @param user [String] The user that sent the message.
+    # @param room [String] The room where the message was sent from.
+    # @param private_message [Boolean] Whether the message is private or not.
+    # @return [void]
+    def initialize(adapter, user, room, private_message)
+      @adapter = adapter
+      @user = user
+      @room = room
+      @private_message = private_message
+    end
+  end
+end

data/lib/pepito/version.rb

@@ -0,0 +1,4 @@
+module Pepito
+  # The current version of Pepito
+  VERSION = '0.0.1'.freeze
+end

data/lib/pepito/web_app/app.rb

@@ -0,0 +1,41 @@
+require 'sinatra/base'
+require 'tilt/erb'
+
+module Pepito
+  module WebApp
+    # Web App to control the bot
+    class App < Sinatra::Base
+      get '/' do
+        @handlers = settings.robot.handlers_list
+        @adapters = settings.robot.adapters_list
+        erb :index
+      end
+
+      post '/deactivate/handler/:handler' do
+        settings.robot.stop_handler(params['handler'])
+        redirect to('/')
+      end
+
+      post '/activate/handler/:handler' do
+        settings.robot.start_handler(params['handler'])
+        redirect to('/')
+      end
+
+      post '/deactivate/adapter/:adapter' do
+        settings.robot.stop_adapter(params['adapter'])
+        redirect to('/')
+      end
+
+      post '/activate/adapter/:adapter' do
+        c = {}
+        params.each do |key, value|
+          if key.start_with?(params['adapter'] + ':config:')
+            c[key.split(params['adapter'] + ':config:')[1]] = value
+          end
+        end
+        settings.robot.start_adapter(params['adapter'], params[params['adapter'] + ':gem_name'], c)
+        redirect to('/')
+      end
+    end
+  end
+end

data/lib/pepito/web_app/views/index.erb

@@ -0,0 +1,69 @@
+<h1><%= settings.robot.name.capitalize %> bot!</h1>
+
+<h3>Handlers List</h3>
+<table border=1 style="text-align: left; min-width: 200px">
+  <tr>
+    <th>Handler</th>
+    <th>Action</th>
+  </tr>
+  <% settings.robot.default_handlers.each do |handler| %>
+    <tr>
+      <td><%= handler.to_s %></td>
+      <td>Default Handler, can not be deactivated.</td>
+    </tr>
+  <% end %>
+  <% @handlers.each do |handler| %>
+    <% if !settings.robot.default_handlers.include?(handler) %>
+      <tr>
+        <td><%= handler.to_s %></td>
+        <td>
+          <% if settings.robot.handlers.keys.include?(handler) %>
+            <form action="/deactivate/handler/<%= handler.to_s %>" method="POST">
+              <input type="submit" value="Deactivate">
+            </form>
+          <% else %>
+            <form action="/activate/handler/<%= handler.to_s %>" method="POST">
+              <input type="submit" value="Activate">
+            </form>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>
+</table>
+
+<h3>Adapters List</h3>
+<table border=1 style="text-align: left; min-width: 200px;">
+  <tr>
+    <th>Handler</th>
+    <th>Action</th>
+  </tr>
+  <% settings.robot.default_adapters.each do |adapter| %>
+    <tr>
+      <td><%= adapter[:name].to_s %></td>
+      <td>Default Adapter, can not be deactivated.</td>
+    </tr>
+  <% end %>
+  <% @adapters.each do |adapter| %>
+    <% if !settings.robot.default_adapters.include?(adapter[:name]) %>
+      <tr>
+        <td><%= adapter[:name].to_s %></td>
+        <td>
+          <% if settings.robot.adapters.keys.include?(adapter[:name]) %>
+            <form action="/deactivate/adapter/<%= adapter[:name].to_s %>" method="POST">
+              <input type="submit" value="Deactivate">
+            </form>
+          <% else %>
+            <form action="/activate/adapter/<%= adapter[:name].to_s %>" method="POST">
+              <input type="hidden" name="<%= adapter[:name].to_s %>:gem_name" value="<%= adapter[:gem].to_s %>">
+              <% adapter[:configs].each do |c| %>
+                <%= c[:name].to_s %><% if !c[:required] %>(optional)<% end %>: <input type="text" name="<%= adapter[:name].to_s %>:config:<%= c[:name].to_s %>"><br>
+              <% end %>
+              <input type="submit" value="Activate">
+            </form>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>
+</table>

data/lib/pepito.rb

@@ -0,0 +1,21 @@
+require_relative 'pepito/http_api/rack_app'
+require_relative 'pepito/robot'
+
+# Pepito's main namespace
+module Pepito
+  # Name for redis table
+  REDIS_NAMESPACE = :pepito
+
+  class << self
+    # Running robot
+    # @return [Pepito::Robot]
+    attr_reader :robot
+
+    # Initializes the robot and runs it.
+    def run
+      @robot = Pepito::Robot.new
+
+      @robot.run
+    end
+  end
+end

data/pepito.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require File.expand_path('../lib/pepito/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'pepito'
+  s.version     = Pepito::VERSION
+  s.authors     = ['Olivier']
+  s.email       = ['olivier@yafoy.com']
+  s.summary     = 'Pepito is your very own corporate bot'
+  s.description = 'Integrate a bot in your company with custom extensions'
+  s.homepage    = 'https://github.com/yafoy/pepito'
+  s.license     = 'MIT'
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_runtime_dependency 'redis-namespace', '~> 1.5', '>= 1.5.2'
+  s.add_runtime_dependency 'multi_json', '~> 1.11', '>= 1.11.2'
+  s.add_runtime_dependency 'rack', '~> 1.6', '>= 1.6.4'
+  s.add_runtime_dependency 'eventmachine', '~> 1.0.8', '>= 1.0.8'
+  s.add_runtime_dependency 'http_router', '~> 0.11.2', '>= 0.11.2'
+  s.add_runtime_dependency 'sinatra', '~> 1.4.6', '>= 1.4.6'
+  s.add_runtime_dependency 'tilt', '~> 2.0.2', '>= 2.0.2'
+  s.add_runtime_dependency 'puma', '~> 2.15.3', '>= 2.15.3'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rubocop', '~> 0.37'
+end

data/test/pepito/handler/test_chat_router.rb

@@ -0,0 +1,37 @@
+require 'minitest/autorun'
+require 'pepito/handler/chat_router'
+
+class Stub
+  include Pepito::Handler::ChatRouter
+end
+
+class TestPepitoHandlerChatRouter < MiniTest::Test
+  def test_emtpy_routes
+    stub = Stub.new
+    assert_empty stub.chat_routes
+  end
+
+  def test_add_route
+    stub = Stub.new
+    stub.chat_route(/test/, :func_sym, command: true, help: 'help')
+
+    assert_equal stub.chat_routes[0].pattern, /test/
+    assert_equal stub.chat_routes[0].func, :func_sym
+    assert_equal stub.chat_routes[0].command, true
+    assert_equal stub.chat_routes[0].help, 'help'
+  end
+
+  def test_add_route_no_command
+    stub = Stub.new
+    stub.chat_route(/test/, :func_sym)
+
+    assert_equal stub.chat_routes[0].command, false
+  end
+
+  def test_add_route_no_help
+    stub = Stub.new
+    stub.chat_route(/test/, :func_sym)
+
+    assert_nil stub.chat_routes[0].help
+  end
+end