kybus-bot 0.5.1 → 0.8.1

data/lib/kybus/bot/base.rb

@@ -3,19 +3,19 @@
 require 'kybus/dry/daemon'
 require 'kybus/bot/adapters/base'
 require 'kybus/storage'
-require_relative 'command_definition'
+require_relative 'command/command_state'
+require_relative 'dsl_methods'
+require_relative 'command_executor'
+require_relative 'command/command_state_factory'
 
 require 'kybus/logger'
+require 'forwardable'
 
 module Kybus
   module Bot
     # Base class for bot implementation. It wraps the threads execution, the
     # provider and the state storage inside an object.
     class Base
-      include Kybus::Storage::Datasource
-      include Kybus::Logger
-      attr_reader :provider
-
       class BotError < StandardError; end
 
       class EmptyMessageError < BotError
@@ -24,26 +24,13 @@ module Kybus
         end
       end
 
-      def send_message(content, channel = nil)
-        raise(EmptyMessageError) unless content
-        provider.send_message(channel || current_channel, content)
-      end
-
-      def rescue_from(klass, &block)
-        @commands.register_command(klass, [], block)
-      end
+      extend Forwardable
+      include Kybus::Logger
 
-      def send_image(content, channel = nil)
-        provider.send_image(channel || current_channel, content)
-      end
+      attr_reader :provider, :executor, :pool_size, :pool, :definitions
 
-      def send_audio(content, channel = nil)
-        provider.send_audio(channel || current_channel, content)
-      end
-
-      def send_document(content, channel = nil)
-        provider.send_document(channel || current_channel, content)
-      end
+      def_delegators :executor, :state, :precommand_hook
+      def_delegators :definitions, :registered_commands
 
       # Configurations needed:
       # - pool_size: number of threads created in execution
@@ -52,216 +39,58 @@ module Kybus
       # - name: The bot name
       # - repository: Configurations about the state storage
       def initialize(configs)
-        @pool_size = configs['pool_size']
+        build_pool(configs['pool_size'])
         @provider = Kybus::Bot::Adapter.from_config(configs['provider'])
-        @commands = Kybus::Bot::CommandDefinition.new
-        register_command('default') do; end
-
         # TODO: move this to config
-        @repository = Kybus::Storage::Repository.from_config(
+        repository = Kybus::Storage::Repository.from_config(
           nil,
-          configs['state_repository']
-            .merge('primary_key' => 'channel_id',
-                   'table' => 'bot_sessions'),
+          configs['state_repository'].merge('primary_key' => 'channel_id', 'table' => 'bot_sessions'),
           {}
         )
-        @factory = Kybus::Storage::Factory.new(EmptyModel)
-        @factory.register(:default, :json)
-        @factory.register(:json, @repository)
+        @definitions = Kybus::Bot::CommandDefinition.new
+        command_factory = CommandStateFactory.new(repository, @definitions)
+        @executor = Kybus::Bot::CommandExecutor.new(self, command_factory, configs['inline_args'])
+        register_command('default') { nil }
       end
 
-      # Starts the bot execution, this is a blocking call.
-      def run
-        @pool = Array.new(@pool_size) do
+      def build_pool(pool_size)
+        @pool = Array.new(pool_size) do
           # TODO: Create a subclass with the context execution
-          Kybus::DRY::Daemon.new(@pool_size, true) do
+          Kybus::DRY::Daemon.new(pool_size, true) do
             message = provider.read_message
-            @last_message = message
-            process_message(message)
+            executor.process_message(message)
           end
         end
-        # TODO: Implement an interface for killing the process
-        @pool.each(&:run)
-        # :nocov: #
-        @pool.each(&:await)
-        # :nocov: #
-      end
-
-      # Process a single message, this method can be overwriten to enable
-      # more complex implementations of commands. It receives a message object.
-      def process_message(message)
-        run_simple_command!(message)
-      end
-
-      # Executes a command with the easiest definition. It runs a state machine:
-      # - If the message is a command, set the status to asking params
-      # - If the message is a param, stores it
-      # - If the command is ready to be executed, trigger it.
-      def run_simple_command!(message)
-        load_state!(message.channel_id)
-        log_debug('loaded state', message: message.to_h, state: @state.to_h)
-        if message.command?
-          self.command = message.raw_message
-        else
-          add_param(message.raw_message)
-          add_file(message.attachment) if message.has_attachment?
-        end
-        if command_ready?
-          run_command!
-        else
-          ask_param(next_missing_param)
-        end
-        save_state!
-      rescue StandardError => e
-        catch = @commands[e.class]
-        raise if catch.nil?
-
-        instance_eval(&catch.block)
-        clear_command
-      end
-
-      # DSL method for adding simple commands
-      def register_command(name, params = [], &block)
-        @commands.register_command(name, params, block)
-      end
-
-      # Method for triggering command
-      def run_command!
-        instance_eval(&current_command_object.block)
-        clear_command
-      end
-
-      def clear_command
-        @state[:cmd] = nil
-      end
-
-      # Checks if the command is ready to be executed
-      def command_ready?
-        cmd = current_command_object
-        cmd.ready?(current_params)
-      end
-
-      # loads parameters from state
-      def current_params
-        @state[:params] || {}
-      end
-
-      def params
-        current_params
-      end
-
-      def add_file(file)
-        return if @state[:requested_param].nil?
-
-        log_debug('Received new file',
-                  param: @state[:requested_param].to_sym,
-                  file: file.to_h)
-
-        files[@state[:requested_param].to_sym] = provider.file_builder(file)
-        @state[:params][("_#{@state[:requested_param]}_filename").to_sym] = file.file_name
-      end
-
-      def files
-        @state[:files] ||= {}
       end
 
-      def file(name)
-        (file = files[name]) && provider.file_builder(file)
+      def dsl
+        @executor.dsl
       end
 
-      def mention(name)
-        provider.mention(name)
-      end
-
-      def registered_commands
-        @commands.registered_commands
-      end
-
-      # Loads command from state
-      def current_command_object
-        command = @state[:cmd]
-        @commands[command] || @commands['default']
-      end
-
-      # returns the current_channel from where the message was sent
-      def current_channel
-        @state[:channel_id]
-      end
-
-      def current_user
-        @last_message.user
-      end
-
-      def is_private?
-        @last_message.is_private?
-      end
-
-      # stores the command into state
-      def command=(cmd)
-        log_debug('Message set as command', command: cmd)
-
-        @state[:cmd] = cmd.split(' ').first
-        @state[:params] = { }
-        @state[:files] = { }
-      end
-
-      # validates which is the following parameter required
-      def next_missing_param
-        current_command_object.next_missing_param(current_params)
-      end
-
-      # Sends a message to get the next parameter from the user
-      def ask_param(param)
-        log_debug('I\'m going to ask the next param', param: param)
-        provider.send_message(current_channel,
-                               "I need you to tell me #{param}")
-        @state[:requested_param] = param.to_s
-      end
-
-      # Stores a parameter into the status
-      def add_param(value)
-        return if @state[:requested_param].nil?
-
-        log_debug('Received new param',
-                  param: @state[:requested_param].to_sym,
-                  value: value)
-
-        @state[:params][@state[:requested_param].to_sym] = value
-      end
-
-      # Loads the state from storage
-      def load_state!(channel)
-        @state = load_state(channel)
+      # Starts the bot execution, this is a blocking call.
+      def run
+        # TODO: Implement an interface for killing the process
+        pool.each(&:run)
+        # :nocov: #
+        pool.each(&:await)
+        # :nocov: #
       end
 
-      # Private implementation for load message
-      def load_state(channel)
-        data = @factory.get(channel)
-        data[:params] = JSON.parse(data[:params] || '{}', symbolize_names: true)
-        data[:files] = JSON.parse(data[:files] || '{}', symbolize_names: true)
-        data
-      rescue Kybus::Storage::Exceptions::ObjectNotFound
-        @factory.create(channel_id: channel, params: {}.to_json)
+      def redirect(command, *params)
+        @executor.invoke(command, params)
       end
 
-      def parse_state!
+      def send_message(contents, channel)
+        log_debug('Sending message', contents:, channel:)
+        provider.message_builder(@provider.send_message(contents, channel))
       end
 
-      # Saves the state into storage
-      def save_state!
-        backup = @state.clone
-        %i[params files].each do |param|
-          @state[param] = @state[param].to_json
-        end
-
-        @state.store
-        %i[params files].each do |param|
-          @state[param] = backup[param]
-        end
+      def register_command(klass, params = [], &block)
+        definitions.register_command(klass, params, &block)
       end
 
-      def session
-        @repository
+      def rescue_from(klass, &block)
+        definitions.register_command(klass, [], &block)
       end
     end
   end

data/lib/kybus/bot/{command_definition.rb → command/command.rb}

@@ -6,43 +6,39 @@ module Kybus
     # it currently only gets a param list, but it will be extended to a more
     # complex DSL.
     class Command
-      attr_reader :block
+      attr_accessor :name
+      attr_reader :block, :params
 
       # Receives a list of params as symbols and the lambda with the block.
-      def initialize(params, block)
-        @params = params
+      def initialize(name, params_config, &block)
+        @name = name
         @block = block
+        case params_config
+        when Array
+          @params = params_config
+          @params_config = {}
+        when Hash
+          @params = params_config.keys
+          @params_config = params_config
+        end
       end
 
       # Checks if the params object given contains all the needed values
       def ready?(current_params)
-        @params.all? { |key| current_params.key?(key) }
+        params.all? { |key| current_params.key?(key) }
       end
 
       # Finds the first empty param from the given parameter
       def next_missing_param(current_params)
-        @params.find { |key| !current_params.key?(key) }
-      end
-    end
-
-    # Wraps a collection of commands.
-    class CommandDefinition
-      def initialize
-        @commands = {}
-      end
-
-      # Stores an operation definition
-      def register_command(name, params, block)
-        @commands[name] = Command.new(params, block)
+        params.find { |key| !current_params.key?(key) }.to_s
       end
 
-      def registered_commands
-        @commands.keys
+      def params_ask_label(param)
+        @params_config[param.to_sym]
       end
 
-      # Returns a command with the name
-      def [](name)
-        @commands[name]
+      def params_size
+        @params.size
       end
     end
   end

data/lib/kybus/bot/command/command_definition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class CommandDefinition
+      def initialize
+        @commands = {}
+      end
+
+      # Stores an operation definition
+      def register_command(name, params, &block)
+        @commands[name] = Command.new(name, params, &block)
+      end
+
+      def registered_commands
+        @commands.keys
+      end
+
+      def each(&block)
+        @commands.each(&block)
+      end
+
+      # Returns a command with the name
+      def [](name)
+        @commands[name]
+      end
+    end
+  end
+end

data/lib/kybus/bot/command/command_state.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class CommandState
+      attr_reader :command
+
+      def initialize(data, command)
+        @command = command
+        data[:params] = JSON.parse(data[:params] || '{}', symbolize_names: true)
+        data[:files] = JSON.parse(data[:files] || '{}', symbolize_names: true)
+        @data = data
+      end
+
+      def clear_command
+        @data[:cmd] = nil
+      end
+
+      def ready?
+        command&.ready?(params)
+      end
+
+      # validates which is the following parameter required
+      def next_missing_param
+        command.next_missing_param(params)
+      end
+
+      def command=(cmd)
+        @command = cmd
+        @data[:cmd] = cmd.name
+        @data[:params] = {}
+        @data[:files] = {}
+      end
+
+      def params
+        @data[:params] || {}
+      end
+
+      def channel_id
+        @data[:channel_id]
+      end
+
+      def files
+        @data[:files] || {}
+      end
+
+      def save_file(identifier, file)
+        files[identifier] = file
+        store_param("_#{@data[:requested_param]}_filename".to_sym, file.file_name)
+      end
+
+      def requested_param=(param)
+        @data[:requested_param] = param
+      end
+
+      def requested_param
+        @data[:requested_param]
+      end
+
+      def store_param(param, value)
+        @data[:params][param] = value
+      end
+
+      def save!
+        backup = @data.clone
+        %i[params files].each do |param|
+          @data[param] = @data[param].to_json
+        end
+        @data.store
+        %i[params files].each do |param|
+          @data[param] = backup[param]
+        end
+      end
+    end
+  end
+end

data/lib/kybus/bot/command/command_state_factory.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class CommandStateFactory
+      include Kybus::Storage::Datasource
+      attr_reader :factory
+
+      def initialize(repository, definitions)
+        factory = Kybus::Storage::Factory.new(EmptyModel)
+        factory.register(:default, :json)
+        factory.register(:json, repository)
+        @factory = factory
+        @definitions = definitions
+      end
+
+      def command(search)
+        @definitions.each do |name, command|
+          case name
+          when String
+            return command if name == search
+          when Class
+            return command if search.is_a?(name)
+          when Regexp
+            if search.is_a?(String) && name.match?(search)
+              storable_command = command.clone
+              storable_command.name = search
+              return storable_command
+            end
+          end
+        end
+        nil
+      end
+
+      def default_command
+        @definitions['default']
+      end
+
+      def command_or_default(name)
+        command(name) || default_command
+      end
+
+      def command_with_inline_arg(name_with_arg)
+        @definitions.each do |name, command|
+          case name
+          when Class
+            return [command, []] if name_with_arg.is_a?(name)
+          when String
+            return [command, name_with_arg.gsub(name, '').split('__')] if name_with_arg.start_with?(name)
+          when Regexp
+            next unless name_with_arg.match?(name)
+
+            storable_command = command.dup
+            storable_command.name = name_with_arg
+            return [storable_command, [name_with_arg]]
+          end
+        end
+        nil
+      end
+
+      def load_state(channel)
+        data = factory.get(channel.to_s)
+        CommandState.new(data, command(data[:cmd]))
+      rescue Kybus::Storage::Exceptions::ObjectNotFound
+        CommandState.new(factory.create(channel_id: channel.to_s, params: '{}'), nil)
+      end
+    end
+  end
+end

data/lib/kybus/bot/command/execution_context.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class ExecutionContest
+      include Kybus::Logger
+      extend Forwardable
+
+      attr_reader :state
+
+      def_delegator :state, :requested_param=, :next_param=
+      def_delegators :state, :clear_command, :save!, :ready?, :next_missing_param
+
+      def block
+        state.command.block
+      end
+
+      def call!(context)
+        context.state = state
+        statement = context.instance_eval(&block)
+        clear_command
+        statement
+      end
+
+      def initialize(channel_id, channel_factory)
+        @channel_factory = channel_factory
+        load_state!(channel_id)
+      end
+
+      # Stores a parameter into the status
+      def add_param(value)
+        param = state.requested_param
+        return unless param
+
+        log_debug('Received new param', param:, value:)
+        state.store_param(param.to_sym, value)
+      end
+
+      def expecting_command?
+        state.command.nil?
+      end
+
+      def add_file(file)
+        param = state.requested_param
+        return unless param
+
+        log_debug('Received new file', param:, file: file.to_h)
+        state.save_file(param.to_sym, file)
+      end
+
+      # Loads the state from storage
+      def load_state!(channel)
+        @state = @channel_factory.load_state(channel)
+      end
+
+      # stores the command into state
+      def command=(cmd)
+        log_debug('Message set as command', command: cmd)
+        state.command = cmd
+      end
+    end
+  end
+end