pepito 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ee1cd04819c4677c99a67c3b2bed1e4d389ce13
+  data.tar.gz: 6e3e17405867abdfd067fd27a3eeb196169f57c6
+SHA512:
+  metadata.gz: bee249611a496e8334bfb1fde82aa8334d2cd18108d05f08fe2208fd5b28314e35602d4b0ec65966eebcea4889a48151d9acbedc46f31827bd4dfa27eda0ecea
+  data.tar.gz: a4f45329a147ef5d609b27e5dd511d46858599a5cee2915ed6f4cda5b946c376ef9885a79597fe61181417a05cfda20ecfcf926e533a3458d6ba0228dea9453e

data/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all logfiles and tempfiles.
+/log/*
+!/log/.keep
+/tmp
+config/database.yml
+public/assets/
+.rvmrc
+/public/cache
+/public/system/*
+.DS_Store
+**/.DS_Store
+config/application.yml
+.ruby-gemset
+.ruby-version
+dump.rdb
+Gemfile.lock
+
+# Documentation
+doc
+.yardoc
+
+# Vim
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+# Pepito Lock
+pepito.gemspec.lock
+pepito-*.gem

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/LineLength:
+  Max: 150
+Metrics/MethodLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,26 @@
+# Pepito
+
+[![Build Status](https://semaphoreci.com/api/v1/projects/a4218e38-25b8-49e4-9bec-c2875845577b/620655/badge.svg)](https://semaphoreci.com/olimart/pepito)
+
+## Getting started
+
+### Development
+* Clone
+* Make sure all dependencies are installed by running 
+```
+bundle install
+```
+* Create an alias to easily run the command
+```bash
+alias devpepito="ruby -I /path/to/pepito/lib /path/to/pepito/bin/pepito"
+```
+* To start, start a redis server and afterwards run
+```
+devpepito
+
+or if you want to specify a redis_url do
+
+REDIS_URL="redis://:p4ssw0rd@10.0.1.1:6380/15" devpepito
+```
+* By defaults all handlers and adapters are turned off, go to http://localhost:4567 to start activating them
+* After activating the Help handler run `pepito help` to see available commands

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/**/test_*.rb'
+end
+
+RuboCop::RakeTask.new
+
+task default: [:test, :rubocop]

data/bin/pepito

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'pepito'
+
+Pepito.run

data/lib/pepito/adapter.rb

@@ -0,0 +1,101 @@
+require_relative 'errors/required_methods_error'
+require_relative 'errors/missing_configuration_value_error'
+
+module Pepito
+  # Parent class for any adapter
+  # Adapters allow to communicate with the bot from differente platforms.
+  class Adapter
+    class << self
+      # Configs for the adapter, override this method in the adapter
+      # @return [Array<Hash>] Array of strings with the config parameters
+      def configs
+        [{}]
+      end
+    end
+
+    # List of required methods for adapters
+    REQUIRED_METHODS = %i(
+      run
+      send_messages
+      topic
+      stop
+    ).freeze
+
+    # @!method run
+    # Runs the adapter
+    # @return [void]
+    # @abstract This should be implemented by the adapter
+
+    # @!method send_messages
+    # Sends a message to the service
+    # @param target [Pepito::Source] The target to send the message to
+    # @param strings [Array<String>] Array of strings to send
+    # @return [void]
+    # @abstract This should be implemented by the adapter
+
+    # @!method topic
+    # Sets the topic of the channel
+    # @param topic [String] the new topic
+    # @return [void]
+    # @abstract This should be implemented by the adapter
+
+    # @!method stop
+    # Stops the adapter
+    # @return [void]
+    # @abstract This should be implemented by the adapter
+
+    # The currently running robot
+    # @return [Pepito::Robot]
+    attr_reader :robot
+
+    # Config hash for the adapter
+    # @return [Hash<String,String>]
+    attr_reader :config
+
+    # Initializes the Adapter class
+    # @param robot [Pepito::Robot] The currently running robot
+    # @param config [Hash<String,String>] The config for the adapter
+    # @return [void]
+    def initialize(robot, config)
+      @robot = robot
+      @config = config
+
+      begin
+        missing_methods
+        missing_configuration_values
+      rescue => e
+        raise e
+      end
+    end
+
+    private
+
+    # Check whether all required methods are implemented
+    # Raises a [Pepito::Errors::RequiredMethodsError] if methods are missing
+    # @return [void]
+    def missing_methods
+      methods = []
+      REQUIRED_METHODS.each do |method|
+        methods << method unless self.methods.include?(method)
+      end
+      raise Errors::RequiredMethodsError.new(methods), 'missing required methods' unless methods.empty?
+    end
+
+    # Check whether all required configuration values exist
+    # Raises a [Pepito::Errors::MissingConfigurationValueError] if methods are missing
+    # @return [void]
+    def missing_configuration_values
+      confs = []
+      self.class.configs.each do |c|
+        confs << c[:name] if c[:required] && !configuration_value?(c[:name])
+      end
+      raise Errors::MissingConfigurationValueError.new(confs), 'missing required configuration values' unless confs.empty?
+    end
+
+    # Whether a configuration_value is present or not.
+    # @return [Boolean] True if is present, False otherwise.
+    def configuration_value?(name)
+      !@config.nil? && @config.keys.include?(name) && !@config[name].nil? && !@config[name].empty?
+    end
+  end
+end

data/lib/pepito/adapters.rb

@@ -0,0 +1,4 @@
+module Pepito
+  module Adapters
+  end
+end

data/lib/pepito/database.rb

@@ -0,0 +1,14 @@
+require 'redis-namespace'
+
+module Pepito
+  # Database for pepito configurations
+  class Database < Redis::Namespace
+    attr_reader :redis
+
+    # @return [void]
+    def initialize
+      @redis = Redis.new
+      super(Pepito::REDIS_NAMESPACE, redis: @redis)
+    end
+  end
+end

data/lib/pepito/errors/missing_configuration_value_error.rb

@@ -0,0 +1,15 @@
+module Pepito
+  module Errors
+    # An error to return when an adapter is missing required methods
+    class MissingConfigurationValueError < StandardError
+      # @return [Array<String>] Array of missing configuration values.
+      attr_reader :configuration_values
+
+      # @param configuration_values [Array<String>] Array of missing configuration values.
+      # @return [void]
+      def initialize(configuration_values)
+        @configuration_values = configuration_values
+      end
+    end
+  end
+end

data/lib/pepito/errors/required_methods_error.rb

@@ -0,0 +1,15 @@
+module Pepito
+  module Errors
+    # An error to return when an adapter is missing required methods
+    class RequiredMethodsError < StandardError
+      # @return [Array<String>] Array of missing methods.
+      attr_reader :missing_methods
+
+      # @param missing_methods [Array<String>] Array of missing methods.
+      # @return [void]
+      def initialize(missing_methods)
+        @missing_methods = missing_methods
+      end
+    end
+  end
+end

data/lib/pepito/handler/chat_router.rb

@@ -0,0 +1,36 @@
+module Pepito
+  class Handler
+    # Router for chat messages.
+    module ChatRouter
+      # A struct representing the route.
+      ChatRoute = Struct.new(
+        :pattern,
+        :func,
+        :command,
+        :help
+      )
+
+      # Add a Pepito::Handler::ChatRoute struct to the chat_routes array.
+      # @param pattern [Regexp] Pattern for the chat route.
+      # @param func [Symbol] The name of the function to call.
+      # @param options [Hash]
+      #   command [Boolean] Whether the route is a command or not.
+      #   help [String] The string for the help menu.
+      # @return [void]
+      def chat_route(pattern, func, options = {})
+        chat_routes << ChatRoute.new(
+          pattern,
+          func,
+          options.delete(:command) || false,
+          options.delete(:help) || nil
+        )
+      end
+
+      # List of chat routes.
+      # @return [Array<Pepito::Handler::ChatRouter::ChatRoute>]
+      def chat_routes
+        @chat_routes ||= []
+      end
+    end
+  end
+end

data/lib/pepito/handler/http_router.rb

@@ -0,0 +1,30 @@
+require 'http_router'
+
+require_relative '../http_api/http_route'
+
+module Pepito
+  class Handler
+    # Routes for the http api
+    module HTTPRouter
+      # Add an http route to the http_routes array.
+      # @param method [String] HTTP method for this route. Example: "GET".
+      # @param path [String] Path for the http api. Example: "/info".
+      # @param cb [Symbol] Callback function.
+      # @return [void]
+      def http_route(method, path, cb)
+        http_routes << HTTPApi::HTTPRoute.new(
+          @robot,
+          self,
+          method,
+          path,
+          cb)
+      end
+
+      # List of http routes.
+      # @return [Array<Pepito::HTTPApi::HTTPRoute>]
+      def http_routes
+        @http_routes ||= []
+      end
+    end
+  end
+end

data/lib/pepito/handler.rb

@@ -0,0 +1,38 @@
+require_relative 'handler/http_router'
+require_relative 'handler/chat_router'
+
+module Pepito
+  # Parent class for any handler
+  # Handlers implement the logic for chat and http routes for the robot
+  class Handler
+    include Handler::HTTPRouter
+    include Handler::ChatRouter
+
+    # Currently running robot
+    # @return [Pepito::Robot]
+    attr_reader :robot
+
+    # Initializes the Adapter class
+    # @param robot [Pepito::Robot] The currently running robot
+    # @return [void]
+    def initialize(robot)
+      @robot = robot
+    end
+
+    # Starts the handler
+    # @return [void]
+    def start
+      register_http_routes
+    end
+
+    private
+
+    # Registers handler's http routes to the http_api
+    # @return [void]
+    def register_http_routes
+      @http_routes.each do |route|
+        @robot.http_api.router.add_route(route.route)
+      end if @http_routes
+    end
+  end
+end

data/lib/pepito/handlers/extensions_catalog.rb

@@ -0,0 +1,108 @@
+require 'multi_json'
+
+require_relative '../handler'
+
+module Pepito
+  module Handlers
+    # Handler to manage (start, stop, status) the extensions.
+    class ExtensionsCatalog < Handler
+      # Run the extensions handler.
+      # @return [void]
+      def run
+        http_route('GET', '/extensions', :extensions_web)
+        http_route('GET', '/handlers', :handlers_web)
+        http_route('GET', '/adapters', :adapters_web)
+        http_route('GET', '/routes', :routes_web)
+
+        chat_route(/^handlers list$/i, :handlers_chat, command: true, help: 'handlers list -> show list of active handlers')
+        chat_route(/^adapters list$/i, :adapters_chat, command: true, help: 'adapters list -> show list of active adapters')
+        chat_route(/^routes list$/i, :routes_chat, command: true, help: 'routes list -> show list of active api routes')
+      end
+
+      # HTTP API List the running handlers and adapters.
+      # @param _request [Rack::Request]
+      # @param response [Rack::Response]
+      # @return [void]
+      def extensions_web(_request, response)
+        response.headers['Content-Type'] = 'application/json'
+        json = MultiJson.dump(
+          handlers: @robot.handlers.keys,
+          adapters: @robot.adapters.keys
+        )
+        response.write(json)
+      end
+
+      # HTTP API List the running handlers.
+      # @param _request [Rack::Request]
+      # @param response [Rack::Response]
+      # @return [void]
+      def handlers_web(_request, response)
+        response.headers['Content-Type'] = 'application/json'
+        json = MultiJson.dump(
+          handlers: @robot.handlers.keys
+        )
+        response.write(json)
+      end
+
+      # HTTP API List the running adapters.
+      # @param _request [Rack::Request]
+      # @param response [Rack::Response]
+      # @return [void]
+      def adapters_web(_request, response)
+        response.headers['Content-Type'] = 'application/json'
+        json = MultiJson.dump(
+          adapters: @robot.adapters.keys
+        )
+        response.write(json)
+      end
+
+      # HTTP API List the active http routes.
+      # @param _request [Rack::Request]
+      # @param response [Rack::Response]
+      # @return [void]
+      def routes_web(_request, response)
+        response.headers['Content-Type'] = 'application/json'
+        json = MultiJson.dump(
+          routes: api_routes
+        )
+        response.write(json)
+      end
+
+      # Get a list of the currently running handlers.
+      # @param _source [Pepito::Source] Source of the message. Not used.
+      # @param _match_data [MatchData] Match Data. Not used.
+      # @return [Array<String>]
+      def handlers_chat(_source, _match_data)
+        @robot.handlers.keys
+      end
+
+      # Get a list of the currently running adapters.
+      # @param _source [Pepito::Source] Source of the message. Not used.
+      # @param _match_data [MatchData] Match Data. Not used.
+      # @return [Array<String>]
+      def adapters_chat(_source, _match_data)
+        @robot.adapters.keys
+      end
+
+      # Get a list of the currently active http routes.
+      # @param _source [Pepito::Source] Source of the message. Not used.
+      # @param _match_data [MatchData] Match Data. Not used.
+      # @return [Array<String>]
+      def routes_chat(_source, _match_data)
+        api_routes
+      end
+
+      private
+
+      # Get the http routes in the form of an array of strings.
+      # @return [Array<String>]
+      def api_routes
+        routes = []
+        @robot.http_api.router.routes.each do |route|
+          routes << route.path_for_generation
+        end
+        routes
+      end
+    end
+  end
+end

data/lib/pepito/handlers/help.rb

@@ -0,0 +1,36 @@
+require_relative '../handler'
+
+module Pepito
+  module Handlers
+    # Handler to give an help command.
+    class Help < Handler
+      # Run the handler.
+      # @return [void]
+      def run
+        chat_route(/^help$/i, :chat_help, command: true, help: 'help -> show this screen')
+      end
+
+      # Return the help strings.
+      # @param _source [Pepito::Source] Source of the message. Not used.
+      # @param _match_data [MatchData] Match Data. Not used.
+      # @return [Array<String>]
+      def chat_help(_source, _match_data)
+        strings = []
+        @robot.handlers.each do |_, handler|
+          handler.chat_routes.each do |route|
+            next if route.help.nil?
+            strings << help_string(route)
+          end
+        end
+        strings
+      end
+
+      private
+
+      def help_string(route)
+        return @robot.name + ' ' + route.help if route.command
+        route.help
+      end
+    end
+  end
+end

data/lib/pepito/handlers/info.rb

@@ -0,0 +1,40 @@
+require 'multi_json'
+
+require_relative '../version'
+require_relative '../handler'
+
+module Pepito
+  module Handlers
+    # Handler to give the bot's info.
+    class Info < Handler
+      # Run the handler.
+      # @return [void]
+      def run
+        http_route('GET', '/info', :web)
+        chat_route(/^info$/i, :chat, command: true, help: "info -> show bot's info")
+      end
+
+      # Info for the http api.
+      # @param _request [Rack::Request]
+      # @param response [Rack::Response]
+      # @return [void]
+      def web(_request, response)
+        response.headers['Content-Type'] = 'application/json'
+        json = MultiJson.dump(
+          pepito_version: Pepito::VERSION
+        )
+        response.write(json)
+      end
+
+      # Info for the chat
+      # @param _source [Pepito::Source] Source of the message. Not used.
+      # @param _match_data [MatchData] Match Data. Not used.
+      # @return [Array<String>]
+      def chat(_source, _match_data)
+        strings = []
+        strings << 'Pepito Version: ' + Pepito::VERSION
+        strings
+      end
+    end
+  end
+end

data/lib/pepito/handlers/room.rb

@@ -0,0 +1,23 @@
+require_relative '../handler'
+
+module Pepito
+  module Handlers
+    # Handler to manage rooms options
+    class Room < Handler
+      # Run the handler.
+      # @return [void]
+      def run
+        chat_route(/^set topic (?<topic>.*)$/i, :chat_set_topic, command: true, help: "set topic [topic] -> change the channel's topic")
+      end
+
+      # Set topic
+      # @param source [Pepito::Source] Where the message came from
+      # @param match_data [MatchData] Match data for the regexp pattern.
+      # @return [nil]
+      def chat_set_topic(source, match_data)
+        source.adapter.topic(source, match_data['topic'])
+        nil
+      end
+    end
+  end
+end

data/lib/pepito/http_api/http_callback.rb

@@ -0,0 +1,49 @@
+require 'rack'
+
+module Pepito
+  module HTTPApi
+    # Class to help callback functions for the http routes
+    class HTTPCallback
+      # Currently running robot
+      # @return [Pepito::Robot]
+      attr_reader :robot
+
+      # The class to call the function
+      # @return [Pepito::Handler]
+      attr_reader :klass
+
+      # The function to call
+      # @return [Symbol]
+      attr_reader :func
+
+      # @param robot [Pepito::Robot] The currently running robot.
+      # @param klass [Pepito::Handler] The class where to call the function.
+      # @param func [Symbol] The function to call.
+      # @return [void]
+      def initialize(robot, klass, func)
+        @robot = robot
+        @klass = klass
+        @func = func
+      end
+
+      # Call method
+      # @param env [Object] The environment of the request
+      # @return [void]
+      def call(env)
+        request = Rack::Request.new(env)
+        response = Rack::Response.new
+
+        if request.head?
+          response.status = 204
+        else
+          begin
+            @klass.public_send(@func, request, response)
+            response.finish
+          rescue => e
+            puts e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pepito/http_api/http_route.rb

@@ -0,0 +1,48 @@
+require 'http_router'
+
+require_relative 'http_callback'
+
+module Pepito
+  module HTTPApi
+    # The http route object.
+    class HTTPRoute
+      # Class to extends the HttpRouter route
+      ExtendedRoute = Class.new(HttpRouter::Route) do
+        include HttpRouter::RouteHelper
+        include HttpRouter::GenerationHelper
+      end
+
+      # The route object.
+      # @return [ExtendedRoute]
+      attr_reader :route
+
+      # @param robot [Pepito::Robot] The currently running robot.
+      # @param klass [Pepito::Handler] The class to call the function from.
+      # @param method [String] The http method (Example: "GET").
+      # @param path [String] The path for the route.
+      # @param func [Symbol] The function to call.
+      # @return [void]
+      def initialize(robot, klass, method, path, func)
+        @route = setup_route(robot, klass, method, path, func)
+      end
+
+      private
+
+      # Setup the extendend route
+      # @param robot [Pepito::Robot] The currently running robot.
+      # @param klass [Pepito::Handler] The class to call the function from.
+      # @param method [String] The http method (Example: "GET").
+      # @param path [String] The path for the route.
+      # @param func [Symbol] The function to call.
+      # @return [ExtendedRoute]
+      def setup_route(robot, klass, method, path, func)
+        route = ExtendedRoute.new
+        route.path = path
+        route.add_request_method(method)
+        route.add_request_method('HEAD') if method == 'GET'
+        route.to(HTTPCallback.new(robot, klass, func))
+        route
+      end
+    end
+  end
+end