kybus-bot 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcb4039ffd0fa38cadb57ba4a6a0813d5c105590677f1e6f6a7ef85fa6ee2365
-  data.tar.gz: abf1c8941afd74565c25e012b3eec8e94e17d1e0a42a83b2bc20be1eceac0192
+  metadata.gz: f5c13b85c7bdfcde5cf2aabfa9c07e78a59da781c06d86ca91842605e3467b61
+  data.tar.gz: ef7f22cea28720b25bbbee6930b397b28eb5890e1e470bb66155c691050ed101
 SHA512:
-  metadata.gz: f1e09cd5437c55dbfc6a38df6c3f8ff1383f6f2974538e3ec2ebd380ea38db0e12cd9ce8ba82b87de15bd1200fef0d610ab1e81ee34c644e5fd064f564a31bd7
-  data.tar.gz: 159c13cb384b3168647e572544cdb96098a4d11b8ae4ed7c1143ba562fd0c52eccdf9295729f97e1614ef44d020681bd9615dc064522664114a3c211d9319566
+  metadata.gz: c01b8aadc1b567f9181ad731baa7861882ec535482c79c51eb45fee0257ab443ee9fc8857e133eab1b4dd814b725b4170fff2513484a1759f08ed1add74741ad
+  data.tar.gz: e80319c534274c58df1cf58e8794a56c44100ac46c0483e0d7b9a193e612944efbf610dc3b6da24f91648ad764fa45fb8e7503f4a0774c5b1c541e8c41be3b6b

data/lib/kybus/bot/adapters/debug.rb

@@ -13,7 +13,30 @@ module Kybus
         # It receives a string with the raw text and the id of the channel
         attr_reader :attachment
 
+        class DebugFile
+          def initialize(path)
+            @path = path
+          end
+
+          def to_json(obj)
+            to_h.to_json(obj)
+          end
+
+          def file_name
+            @path
+          end
+
+          def download
+            File.read(@path)
+          end
+
+          def to_h
+            { path: @path }
+          end
+        end
+
         def initialize(text, channel, attachment = nil)
+          super()
           @text = text
           @channel = channel
           @attachment = attachment
@@ -36,6 +59,14 @@ module Kybus
         def has_attachment?
           !!attachment
         end
+
+        def reply?
+          @reply
+        end
+
+        def is_private?
+          true
+        end
       end
 
       # This class simulates a message chat with a user.
@@ -66,7 +97,7 @@ module Kybus
           DebugMessage.new(@pending_messages.shift, @name)
         end
 
-        def send_data(message, attachment)
+        def send_data(message, _attachment)
           return unless @echo
 
           puts "Sending message to channel: #{@name}"
@@ -92,6 +123,8 @@ module Kybus
           end
         end
 
+        attr_accessor :last_message
+
         # It receives a hash with the configurations:
         # - name: the name of the channel
         # - channels a key value, where the key is a name and the value the
@@ -112,11 +145,7 @@ module Kybus
             raise NoMoreMessageException if @channels.values.all?(&:empty?)
 
             msg = @channels.values.find(&:open?)
-            return msg.read_message if msg
-
-            # :nocov: #
-            sleep(1)
-            # :nocov: #
+            return @last_message = msg.read_message if msg
           end
         end
 
@@ -131,7 +160,7 @@ module Kybus
         end
 
         # interface for sending video
-        def send_video(channel_name, video_url)
+        def send_video(channel_name, video_url, caption = nil)
           channel(channel_name).answer("VIDEO: #{video_url}")
         end
 
@@ -141,10 +170,28 @@ module Kybus
         end
 
         # interface for sending image
-        def send_image(channel_name, image_url)
+        def send_image(channel_name, image_url, caption = nil)
           channel(channel_name).answer("IMG: #{image_url}")
         end
 
+        # interface for sending image
+        def send_document(channel_name, doc_url)
+          channel(channel_name).answer("DOC: #{doc_url}")
+        end
+
+        def file_builder(data)
+          case data
+          when DebugMessage::DebugFile
+            data
+          when Hash
+            DebugMessage::DebugFile.new(data[:path])
+          end
+        end
+
+        def mention(user)
+          "@#{user}"
+        end
+
         # changes echo config
         def echo=(toogle)
           @channels.each { |_, channel| channel.echo = toogle }

data/lib/kybus/bot/adapters/discord.rb

@@ -11,6 +11,7 @@ module Kybus
       class DiscordMessage < Kybus::Bot::Message
         # It receives a string with the raw text and the id of the channel
         def initialize(msg)
+          super
           @message = msg
         end
 
@@ -45,6 +46,9 @@ module Kybus
       # This adapter is intended to be used on unit tests and development.
       class Discord
         include ::Kybus::Logger
+
+        attr_reader :last_message, :client
+
         # It receives a hash with the configurations:
         # - name: the name of the channel
         # - channels a key value, where the key is a name and the value the
@@ -60,8 +64,6 @@ module Kybus
           @client.run(:async)
         end
 
-        attr_reader :client
-
         def mention(id)
           "<@!#{id}>"
         end
@@ -70,17 +72,15 @@ module Kybus
         def read_message
           # take the first message from the first open message,
           loop do
-            if @pool.empty?
-              sleep(0.1)
-            else
-              break
-            end
+            break unless @pool.empty?
+
+            sleep(0.1)
           end
-          DiscordMessage.new(@pool.shift)
+          @last_message = DiscordMessage.new(@pool.shift)
         end
 
         # interface for sending messages
-        def send_message(channel_name, contents)
+        def send_message(channel_name, contents, caption = nil)
           puts "#{channel_name} => #{contents}" if @config['debug']
           channel = @client.channel(channel_name)
           if channel

data/lib/kybus/bot/adapters/telegram.rb

@@ -1,100 +1,20 @@
 # frozen_string_literal: true
 
 require 'telegram/bot'
+require 'faraday'
+require_relative 'telegram_file'
+require_relative 'telegram_message'
 
 module Kybus
   module Bot
-    # :nodoc: #
     module Adapter
-      # :nodoc: #
-      # Wraps a debugging message inside a class.
-      class TelegramMessage < Kybus::Bot::Message
-        # It receives a string with the raw text and the id of the channel
-        def initialize(message)
-          @message = message
-        end
-
-        def reply?
-          !!@message.reply_to_message
-        end
-
-        def replied_message
-          TelegramMessage.new(@message.reply_to_message)
-        end
-
-        # Returns the channel id
-        def channel_id
-          @message.chat.id
-        end
-
-        # Returns the message contents
-        def raw_message
-          @message.to_s
-        end
-
-        def is_private?
-          @message.chat.type == 'private'
-        end
-
-        def has_attachment?
-          !!@message.document
-        end
-
-        def attachment
-          @message.document
-        end
-
-        def user
-          @message.from.id
-        end
-      end
-
-      class TelegramFile
-        extend Kybus::DRY::ResourceInjector
-        attr_reader :id
-        def initialize(message)
-          if message.is_a?(String)
-            @id = message
-          elsif message.is_a?(Hash)
-            @id = message['id'] || message[:id]
-          elsif message.is_a?(TelegramFile)
-            @id = message.id
-          else
-            @id = message.file_id
-          end
-        end
-
-        def to_h
-          {
-            provide: 'telegram',
-            id: @id
-          }
-        end
-
-        def cli
-          @cli ||= TelegramFile.resource(:cli)
-        end
-
-        def meta
-          @meta ||= cli.api.get_file(file_id: @id)
-        end
-
-        def original_name
-          meta.dig('result', 'file_name')
-        end
-
-        def download
-          token = cli.api.token
-          file_path = meta.dig('result', 'file_path')
-          path = "https://api.telegram.org/file/bot#{token}/#{file_path}"
-          Faraday.get(path).body
-        end
-      end
-
       ##
       # This adapter is intended to be used on unit tests and development.
       class Telegram
         include ::Kybus::Logger
+
+        attr_reader :last_message
+
         # It receives a hash with the configurations:
         # - name: the name of the channel
         # - channels a key value, where the key is a name and the value the
@@ -113,10 +33,12 @@ module Kybus
             @client.listen do |message|
               log_info('Received message', message: message.to_h,
                                            from: message.from.to_h)
-              return TelegramMessage.new(message)
+              return @last_message = TelegramMessage.new(message)
             end
           rescue ::Telegram::Bot::Exceptions::ResponseError => e
+            # :nocov:
             log_error('An error ocurred while calling to Telegram API', e)
+            # :nocov:
           end
         end
 
@@ -124,36 +46,37 @@ module Kybus
           "[user](tg://user?id=#{id})"
         end
 
-
         # interface for sending messages
         def send_message(channel_name, contents)
           puts "#{channel_name} => #{contents}" if @config['debug']
           @client.api.send_message(chat_id: channel_name, text: contents)
-        rescue ::Telegram::Bot::Exceptions::ResponseError => err
-          return if err[:error_code] == '403'
+          # :nocov:
+        rescue ::Telegram::Bot::Exceptions::ResponseError => e
+          return if e[:error_code] == '403'
         end
+        # :nocov:
 
         # interface for sending video
-        def send_video(channel_name, video_url)
-          file = Faraday::UploadIO.new(video_url, 'video/mp4')
-          @client.api.send_video(chat_id: channel_name, audio: file)
+        def send_video(channel_name, video_url, comment = nil)
+          file = Faraday::FilePart.new(video_url, 'video/mp4')
+          @client.api.send_video(chat_id: channel_name, video: file, caption: comment)
         end
 
         # interface for sending uadio
         def send_audio(channel_name, audio_url)
-          file = Faraday::UploadIO.new(audio_url, 'audio/mp3')
+          file = Faraday::FilePart.new(audio_url, 'audio/mp3')
           @client.api.send_audio(chat_id: channel_name, audio: file)
         end
 
         # interface for sending image
-        def send_image(channel_name, image_url)
-          file = Faraday::UploadIO.new(image_url, 'image/jpeg')
-          @client.api.send_photo(chat_id: channel_name, photo: file)
+        def send_image(channel_name, image_url, comment = nil)
+          file = Faraday::FilePart.new(image_url, 'image/jpeg')
+          @client.api.send_photo(chat_id: channel_name, photo: file, caption: comment)
         end
 
         # interface for sending document
         def send_document(channel_name, image_url)
-          file = Faraday::UploadIO.new(image_url, 'application/octect-stream')
+          file = Faraday::FilePart.new(image_url, 'application/octect-stream')
           @client.api.send_document(chat_id: channel_name, document: file)
         end
 

data/lib/kybus/bot/adapters/telegram_file.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'telegram/bot'
+require 'faraday'
+
+module Kybus
+  module Bot
+    # :nodoc: #
+    module Adapter
+      class TelegramFile
+        extend Kybus::DRY::ResourceInjector
+        attr_reader :id
+
+        def initialize(message)
+          @id = case message
+                when String
+                  message
+                when Hash
+                  message['id'] || message[:id]
+                when TelegramFile
+                  message.id
+                else
+                  message.file_id
+                end
+        end
+
+        def to_h
+          {
+            provide: 'telegram',
+            id: @id
+          }
+        end
+
+        def cli
+          @cli ||= TelegramFile.resource(:cli)
+        end
+
+        def meta
+          @meta ||= cli.api.get_file(file_id: @id)
+        end
+
+        def original_name
+          meta.dig('result', 'file_name')
+        end
+
+        def download
+          token = cli.api.token
+          file_path = meta.dig('result', 'file_path')
+          path = "https://api.telegram.org/file/bot#{token}/#{file_path}"
+          Faraday.get(path).body
+        end
+      end
+    end
+  end
+end

data/lib/kybus/bot/adapters/telegram_message.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'telegram/bot'
+require 'faraday'
+
+module Kybus
+  module Bot
+    # :nodoc: #
+    module Adapter
+      # :nodoc: #
+      # Wraps a debugging message inside a class.
+      class TelegramMessage < Kybus::Bot::Message
+        # It receives a string with the raw text and the id of the channel
+        def initialize(message)
+          super()
+          @message = message
+        end
+
+        def reply?
+          !!@message.reply_to_message
+        end
+
+        def replied_message
+          TelegramMessage.new(@message.reply_to_message)
+        end
+
+        # Returns the channel id
+        def channel_id
+          @message.chat.id
+        end
+
+        # Returns the message contents
+        def raw_message
+          @message.to_s
+        end
+
+        def is_private?
+          @message.chat.type == 'private'
+        end
+
+        def has_attachment?
+          !!attachment
+        end
+
+        def attachment
+          @message.document || @message.photo&.last || @message.audio
+        end
+
+        def user
+          @message.from.id
+        end
+      end
+    end
+  end
+end

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
-
-      def send_image(content, channel = nil)
-        provider.send_image(channel || current_channel, content)
-      end
+      extend Forwardable
+      include Kybus::Logger
 
-      def send_audio(content, channel = nil)
-        provider.send_audio(channel || current_channel, content)
-      end
+      attr_reader :provider, :executor, :pool_size, :pool, :definitions
 
-      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,45 @@ 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
+      end
+
+      # Starts the bot execution, this is a blocking call.
+      def run
         # TODO: Implement an interface for killing the process
-        @pool.each(&:run)
+        pool.each(&:run)
         # :nocov: #
-        @pool.each(&:await)
+        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)
-      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']
+      def register_command(klass, params = [], &block)
+        definitions.register_command(klass, params, &block)
       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)
-      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)
-      end
-
-      def parse_state!
-      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
-      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,23 @@ 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_reader :block, :params, :name
 
       # Receives a list of params as symbols and the lambda with the block.
-      def initialize(params, block)
+      def initialize(name, params, &block)
+        @name = name
         @params = params
         @block = block
       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)
-      end
-
-      def registered_commands
-        @commands.keys
-      end
-
-      # Returns a command with the name
-      def [](name)
-        @commands[name]
+        params.find { |key| !current_params.key?(key) }.to_s
       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,77 @@
+# 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,45 @@
+# 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(name)
+        @definitions[name]
+      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|
+          next unless name.is_a?(String)
+          return [command, name_with_arg.gsub(name, '')] if name_with_arg.start_with?(name)
+        end
+        nil
+      end
+
+      def load_state(channel)
+        data = factory.get(channel)
+        CommandState.new(data, command_or_default(data[:cmd]))
+      rescue Kybus::Storage::Exceptions::ObjectNotFound
+        CommandState.new(factory.create(channel_id: channel, params: '{}'), nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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
+        context.instance_eval(&block)
+        clear_command
+      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 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

data/lib/kybus/bot/command_executor.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'command/command'
+require_relative 'command/command_definition'
+require_relative 'command/execution_context'
+
+module Kybus
+  module Bot
+    class CommandExecutor
+      extend Forwardable
+
+      include Kybus::Logger
+      attr_reader :dsl, :bot, :execution_context
+
+      def_delegator :execution_context, :save!, :save_execution_context!
+
+      def state
+        execution_context&.state
+      end
+
+      def initialize(bot, channel_factory, inline_args)
+        @bot = bot
+        @channel_factory = channel_factory
+        @dsl = DSLMethods.new(bot.provider, state)
+        @inline_args = inline_args
+        @precommand_hook = proc {}
+      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)
+        @execution_context = ExecutionContest.new(message.channel_id, @channel_factory)
+        save_token!(message)
+        run_command_or_prepare!
+        save_execution_context!
+      end
+
+      def save_param!(message)
+        execution_context.add_param(message.raw_message)
+        return unless message.has_attachment?
+
+        file = bot.provider.file_builder(message.attachment)
+        execution_context.add_file(file)
+      end
+
+      def search_command_with_inline_arg(message)
+        command, value = @channel_factory.command_with_inline_arg(message.raw_message)
+        if command
+          execution_context.command = command
+          execution_context.next_param = execution_context.next_missing_param
+          execution_context.add_param(value)
+        else
+          execution_context.command = @channel_factory.default_command
+        end
+      end
+
+      def save_token!(message)
+        if message.command?
+          command = @channel_factory.command(message.command)
+          if @inline_args && !command
+            search_command_with_inline_arg(message)
+          elsif !@inline_args && !command
+            execution_context.command = @channel_factory.default_command
+          else
+            execution_context.command = command
+          end
+        else
+          save_param!(message)
+        end
+      end
+
+      def run_command_or_prepare!
+        if execution_context.ready?
+          @dsl.state = execution_context.state
+          @dsl.instance_eval(&@precommand_hook)
+          run_command!
+        else
+          ask_param(execution_context.next_missing_param)
+        end
+      end
+
+      def precommand_hook(&block)
+        @precommand_hook = proc(&block)
+      end
+
+      def fallback(error)
+        catch = @channel_factory.command(error.class)
+        log_error('Unexpected error', error)
+        execution_context.command = catch if catch
+      end
+
+      # Method for triggering command
+      def run_command!
+        execution_context.call!(@dsl)
+      rescue StandardError => e
+        raise unless fallback(e)
+
+        retry
+      end
+
+      # Sends a message to get the next parameter from the user
+      def ask_param(param)
+        provider = bot.provider
+        msg = "I need you to tell me #{param}"
+        log_debug(msg)
+        provider.send_message(provider.last_message.channel_id, msg)
+        execution_context.next_param = param
+      end
+    end
+  end
+end

data/lib/kybus/bot/dsl_methods.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class DSLMethods
+      attr_accessor :state
+      attr_reader :provider
+
+      def initialize(provider, state)
+        @provider = provider
+        @state = state
+      end
+
+      def send_message(content, channel = nil)
+        raise(Base::EmptyMessageError) unless content
+
+        provider.send_message(channel || current_channel, content)
+      end
+
+      def send_image(content, channel = nil, caption: nil)
+        provider.send_image(channel || current_channel, content, caption)
+      end
+
+      def send_video(content, channel = nil, caption: nil)
+        provider.send_video(channel || current_channel, content, caption)
+      end
+
+      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 params
+        state.params
+      end
+
+      def files
+        state.files
+      end
+
+      def file(name)
+        (file = files[name]) && provider.file_builder(file)
+      end
+
+      def mention(name)
+        provider.mention(name)
+      end
+
+      def current_user
+        provider.last_message.user
+      end
+
+      def is_private?
+        provider.last_message.is_private?
+      end
+
+      def last_message
+        provider.last_message
+      end
+
+      # returns the current_channel from where the message was sent
+      def current_channel
+        state.channel_id
+      end
+    end
+  end
+end

data/lib/kybus/bot/message.rb

@@ -8,17 +8,14 @@ module Kybus
     # Base implementation for messages from distinct providers
     class Message
       # Converts the messages into a hash
-      def to_h
-        {
-          text: raw_message,
-          channel: channel_id
-        }
-      end
-
       # Returns true when the received message is a command. Convention states
       # that messages should start with '/' to be considered commands
       def command?
-        raw_message&.split(' ')&.first&.start_with?('/')
+        command&.start_with?('/')
+      end
+
+      def command
+        raw_message&.split(' ')&.first
       end
     end
   end

data/lib/kybus/bot/test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'adapters/debug'
 
@@ -13,19 +15,24 @@ module Kybus
         'pool_size' => 1,
         'provider' => {
           'name' => 'debug',
-          'echo' => true,
+          'echo' => false,
           'channels' => { 'testing' => [] }
         }
       }.freeze
 
-      def self.make_test_bot
-        new(CONFIG)
+      def self.make_test_bot(extra_configs = {})
+        new(CONFIG.merge(extra_configs))
       end
 
       def receives(msg, attachments = nil)
-        msg = ::Kybus::Bot::Adapter::DebugMessage.new(msg, 'testing', attachments)
-        @last_message = msg
-        process_message(msg)
+        attachments = Adapter::DebugMessage::DebugFile.new(attachments) if attachments
+        msg = Adapter::DebugMessage.new(msg, 'testing', attachments)
+        provider.last_message = msg
+        executor.process_message(msg)
+      end
+
+      def expects(method)
+        executor.dsl.expects(method)
       end
     end
   end

data/lib/kybus/bot/version.rb

@@ -2,6 +2,6 @@
 
 module Kybus
   module Bot
-    VERSION = '0.5.1'
+    VERSION = '0.7.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kybus-bot
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Gilberto Vargas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kybus-core
@@ -218,8 +218,16 @@ files:
 - lib/kybus/bot/adapters/debug.rb
 - lib/kybus/bot/adapters/discord.rb
 - lib/kybus/bot/adapters/telegram.rb
+- lib/kybus/bot/adapters/telegram_file.rb
+- lib/kybus/bot/adapters/telegram_message.rb
 - lib/kybus/bot/base.rb
-- lib/kybus/bot/command_definition.rb
+- lib/kybus/bot/command/command.rb
+- lib/kybus/bot/command/command_definition.rb
+- lib/kybus/bot/command/command_state.rb
+- lib/kybus/bot/command/command_state_factory.rb
+- lib/kybus/bot/command/execution_context.rb
+- lib/kybus/bot/command_executor.rb
+- lib/kybus/bot/dsl_methods.rb
 - lib/kybus/bot/message.rb
 - lib/kybus/bot/migrator.rb
 - lib/kybus/bot/test.rb
@@ -228,7 +236,8 @@ files:
 homepage: https://github.com/tachomex/kybus
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -244,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Provides a framework for building bots with ruby