kybus-bot 0.8.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7c076fdf29d45a346d07aa5639349a66cff1a83ed15f0cfbafc4e6d4698cbd9
-  data.tar.gz: 0fa6891cd37efd3a37b87b59e3dc90fd1628384c43863237e70ea6f757f2086a
+  metadata.gz: 5133b5a89dc9947680ecdbd8ec25befed895f57e017d19121278617b6bc0ff4d
+  data.tar.gz: '08e309bdf344e7066a5354c516487b12764b85cca7ea38165054471e5280cba7'
 SHA512:
-  metadata.gz: f620f4d3674eb392f61f7a50abf378c1fa2fef5b718a93cf4ec1c340f906b1d924948f374fc0214d817664c26a97e4d5cdfa301c6588ba0c2e30bf5af8d7fb75
-  data.tar.gz: f2b708234bb392bfaf98d75f29720ea081ead5e3ea4cba36a7703abd9dcc7516e8328eb8f2583604c0de819e15c391ba1a7066cb3b74bf4ef39c0713186f6e96
+  metadata.gz: da4828437e972ecd01dab962800ae67f011a7ed8ceb88b9f1484d7c4caef740811dfd816f578620a5679a86768b21a00a976750d206c25cdcd7df66e4e3f4a6c
+  data.tar.gz: c7bc12f54fb1352f774cbf607c12bbcae4802edc0d0058e99a38a7bb1554a8083b721a4e715e2185fd92fab668ece278e83ce4a2a15d43f28ddd23f5175cccfa

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

@@ -70,6 +70,10 @@ module Kybus
         def is_private?
           true
         end
+
+        def to_s
+          @text
+        end
       end
 
       # This class simulates a message chat with a user.
@@ -205,7 +209,7 @@ module Kybus
 
         # changes echo config
         def echo=(toogle)
-          @channels.each { |_, channel| channel.echo = toogle }
+          @channels.each_value { |channel| channel.echo = toogle }
         end
       end
 

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

@@ -11,7 +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
+          super()
           @message = msg
         end
 
@@ -20,6 +20,18 @@ module Kybus
           @message.channel.id
         end
 
+        def message_id
+          nil
+        end
+
+        def has_attachment?
+          !!attachment
+        end
+
+        def attachment
+          @message.file
+        end
+
         # Returns the message contents
         def raw_message
           @message.content
@@ -80,7 +92,7 @@ module Kybus
         end
 
         # interface for sending messages
-        def send_message(channel_name, contents, _caption = nil)
+        def send_message(contents, channel_name, _caption = nil)
           puts "#{channel_name} => #{contents}" if @config['debug']
           channel = @client.channel(channel_name)
           if channel
@@ -90,23 +102,27 @@ module Kybus
           end
         end
 
-        # # 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)
-        # end
-        #
-        # # interface for sending uadio
-        # def send_audio(channel_name, audio_url)
-        #   file = Faraday::UploadIO.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)
-        # end
+        def message_builder(raw_message)
+          DiscordMessage.new(raw_message)
+        end
+
+        def send_file(channel_name, file, _caption = nil)
+          @client.send_file(channel_name, File.open(file, 'r'))
+        end
+
+        def send_video(channel_name, file, _caption = nil)
+          @client.send_file(channel_name, File.open(file, 'r'))
+        end
+
+        # interface for sending uadio
+        def send_audio(channel_name, file, _caption = nil)
+          @client.send_file(channel_name, File.open(file, 'r'))
+        end
+
+        # interface for sending image
+        def send_image(channel_name, file, _caption = nil)
+          @client.send_file(channel_name, File.open(file, 'r'))
+        end
       end
 
       register('discord', Discord)

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

@@ -42,17 +42,60 @@ module Kybus
           end
         end
 
+        def handle_message(body)
+          chat_id = body.dig('message', 'chat', 'id')
+          message_id = body.dig('message', 'message_id')
+          user = body.dig('message', 'from', 'username') || body.dig('message', 'from', 'first_name')
+          raw_message = body.dig('message', 'text')
+
+          replied_message = body.dig('message', 'reply_to_message')
+          is_private = body.dig('message', 'chat', 'type') == 'private'
+
+          # Check if the message has an attachment
+          has_attachment = body.dig('message',
+                                    'photo') || body.dig('message', 'document') || body.dig('message', 'video')
+          attachment = if has_attachment
+                         body.dig('message',
+                                  'photo')&.last || body.dig('message', 'document') || body.dig('message', 'video')
+                       end
+
+          # Serialize replied_message if it exists
+          serialized_replied_message = if replied_message
+                                         SerializedMessage.new(
+                                           provider: 'telegram',
+                                           channel_id: replied_message.dig('chat', 'id'),
+                                           message_id: replied_message['message_id'],
+                                           user: replied_message.dig('from',
+                                                                     'username') || replied_message.dig('from',
+                                                                                                        'first_name'),
+                                           raw_message: replied_message['text'],
+                                           is_private?: replied_message.dig('chat', 'type') == 'private'
+                                         ).serialize
+                                       end
+
+          SerializedMessage.new(
+            provider: 'telegram',
+            channel_id: chat_id,
+            message_id:,
+            user:,
+            replied_message: serialized_replied_message,
+            raw_message:,
+            is_private?: is_private,
+            attachment:
+          )
+        end
+
         def mention(id)
           "[user](tg://user?id=#{id})"
         end
 
         # interface for sending messages
         def send_message(contents, channel_name)
-          puts "#{channel_name} => #{contents}" if @config['debug']
+          log_debug('Sending message', channel_name:, message: contents)
           @client.api.send_message(chat_id: channel_name.to_i, text: contents, parse_mode: @config['parse_mode'])
           # :nocov:
         rescue ::Telegram::Bot::Exceptions::ResponseError => e
-          return if e.error_code == '403'
+          nil if e.error_code == '403'
         end
         # :nocov:
 

data/lib/kybus/bot/base.rb

@@ -17,6 +17,7 @@ module Kybus
     # provider and the state storage inside an object.
     class Base
       class BotError < StandardError; end
+      class AbortError < BotError; end
 
       class EmptyMessageError < BotError
         def initialize
@@ -29,6 +30,17 @@ module Kybus
 
       attr_reader :provider, :executor, :pool_size, :pool, :definitions
 
+      DYNAMOID_FIELDS = {
+        'channel_id' => :string,
+        'user' => :string,
+        'params' => :string,
+        'metadata' => :string,
+        'files' => :string,
+        'cmd' => :string,
+        'requested_param' => :string,
+        'last_message' => :string
+      }.freeze
+
       def_delegators :executor, :state, :precommand_hook
       def_delegators :definitions, :registered_commands
 
@@ -38,19 +50,40 @@ module Kybus
       #   See supported adapters
       # - name: The bot name
       # - repository: Configurations about the state storage
+
       def initialize(configs)
         build_pool(configs['pool_size'])
         @provider = Kybus::Bot::Adapter.from_config(configs['provider'])
         # TODO: move this to config
-        repository = Kybus::Storage::Repository.from_config(
-          nil,
-          configs['state_repository'].merge('primary_key' => 'channel_id', 'table' => 'bot_sessions'),
-          {}
-        )
+        repository = make_repository(configs)
         @definitions = Kybus::Bot::CommandDefinition.new
         command_factory = CommandStateFactory.new(repository, @definitions)
-        @executor = Kybus::Bot::CommandExecutor.new(self, command_factory, configs['inline_args'])
+        @executor = if configs['sidekiq']
+                      require_relative 'sidekiq_command_executor'
+                      Kybus::Bot::SidekiqCommandExecutor.new(self, command_factory, configs)
+                    else
+                      Kybus::Bot::CommandExecutor.new(self, command_factory, configs['inline_args'])
+                    end
         register_command('default') { nil }
+        rescue_from(::Kybus::Bot::Base::AbortError) do
+          msg = params[:_last_exception]&.message
+          send_message(msg) if msg && msg != 'Kybus::Bot::Base::AbortError'
+        end
+      end
+
+      def make_repository(configs)
+        repository_config = configs['state_repository'].merge('primary_key' => 'channel_id', 'table' => 'bot_sessions')
+        repository_config.merge!('fields' => DYNAMOID_FIELDS) if repository_config['name'] == 'dynamoid'
+        Kybus::Storage::Repository.from_config(nil, repository_config, {})
+      end
+
+      def extend(*args)
+        DSLMethods.include(*args)
+      end
+
+      def self.helpers(mod = nil, &)
+        DSLMethods.include(mod) if mod
+        DSLMethods.class_eval(&) if block_given?
       end
 
       def build_pool(pool_size)
@@ -67,6 +100,11 @@ module Kybus
         @executor.dsl
       end
 
+      def handle_message(msg)
+        parsed = @provider.handle_message(msg)
+        @executor.process_message(parsed)
+      end
+
       # Starts the bot execution, this is a blocking call.
       def run
         # TODO: Implement an interface for killing the process
@@ -77,7 +115,7 @@ module Kybus
       end
 
       def redirect(command, *params)
-        @executor.invoke(command, params)
+        @executor.redirect(command, params)
       end
 
       def send_message(contents, channel)
@@ -85,12 +123,18 @@ module Kybus
         provider.message_builder(@provider.send_message(contents, channel))
       end
 
-      def register_command(klass, params = [], &block)
-        definitions.register_command(klass, params, &block)
+      def register_command(klass, params = [], &)
+        definitions.register_command(klass, params, &)
       end
 
-      def rescue_from(klass, &block)
-        definitions.register_command(klass, [], &block)
+      def rescue_from(klass, &)
+        definitions.register_command(klass, [], &)
+      end
+
+      def method_missing(method, ...)
+        raise unless dsl.respond_to?(method)
+
+        dsl.send(method, ...)
       end
     end
   end

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

@@ -8,16 +8,16 @@ module Kybus
       end
 
       # Stores an operation definition
-      def register_command(name, params, &block)
-        @commands[name] = Command.new(name, params, &block)
+      def register_command(name, params, &)
+        @commands[name] = Command.new(name, params, &)
       end
 
       def registered_commands
         @commands.keys
       end
 
-      def each(&block)
-        @commands.each(&block)
+      def each(&)
+        @commands.each(&)
       end
 
       # Returns a command with the name

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

@@ -7,11 +7,27 @@ module Kybus
 
       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 = JSON.parse(data, symbolize_names: true) if data.is_a?(String)
+        (data[:params] = JSON.parse(data[:params] || '{}', symbolize_names: true)) if data[:params].is_a?(String)
+        (data[:metadata] = JSON.parse(data[:metadata] || '{}', symbolize_names: true)) if data[:metadata].is_a?(String)
+        (data[:files] = JSON.parse(data[:files] || '{}', symbolize_names: true)) if data[:files].is_a?(String)
+        (data[:last_message] = data[:last_message] && SerializedMessage.from_json(data[:last_message]))
         @data = data
       end
 
+      def self.from_json(str, commands_provider)
+        data = JSON.parse(str, symbolize_names: true)
+        new(data[:data], commands_provider.command(data[:command]))
+      end
+
+      def to_json(*_args)
+        to_h.to_json
+      end
+
+      def to_h
+        { command: command.name, data: @data.to_h.merge(last_message: @data[:last_message]&.to_h) }
+      end
+
       def clear_command
         @data[:cmd] = nil
       end
@@ -25,6 +41,14 @@ module Kybus
         command.next_missing_param(params)
       end
 
+      def set_last_message(msg)
+        @data[:last_message] = msg
+      end
+
+      def last_message
+        @data[:last_message]
+      end
+
       def command=(cmd)
         @command = cmd
         @data[:cmd] = cmd.name
@@ -46,7 +70,7 @@ module Kybus
 
       def save_file(identifier, file)
         files[identifier] = file
-        store_param("_#{@data[:requested_param]}_filename".to_sym, file.file_name)
+        store_param(:"_#{@data[:requested_param]}_filename", file.file_name)
       end
 
       def requested_param=(param)
@@ -61,13 +85,17 @@ module Kybus
         @data[:params][param] = value
       end
 
+      def metadata
+        @data[:metadata] || {}
+      end
+
       def save!
         backup = @data.clone
-        %i[params files].each do |param|
+        %i[params files last_message metadata].each do |param|
           @data[param] = @data[param].to_json
         end
         @data.store
-        %i[params files].each do |param|
+        %i[params files last_message metadata].each do |param|
           @data[param] = backup[param]
         end
       end

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

@@ -62,7 +62,7 @@ module Kybus
         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)
+        CommandState.new(factory.create(channel_id: channel.to_s, params: '{}', metadata: '{}', last_message: nil), nil)
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Kybus
       attr_reader :state
 
       def_delegator :state, :requested_param=, :next_param=
-      def_delegators :state, :clear_command, :save!, :ready?, :next_missing_param
+      def_delegators :state, :clear_command, :save!, :ready?, :next_missing_param, :set_last_message
 
       def block
         state.command.block
@@ -55,7 +55,7 @@ module Kybus
 
       # stores the command into state
       def command=(cmd)
-        log_debug('Message set as command', command: cmd)
+        log_debug('Message set as command', command: cmd.name)
         state.command = cmd
       end
     end

data/lib/kybus/bot/command_executor.rb

@@ -19,6 +19,10 @@ module Kybus
         execution_context&.state
       end
 
+      def last_message
+        state&.last_message
+      end
+
       def initialize(bot, channel_factory, inline_args)
         @bot = bot
         @channel_factory = channel_factory
@@ -46,7 +50,7 @@ module Kybus
       end
 
       def search_command_with_inline_arg(message)
-        command, values = @channel_factory.command_with_inline_arg(message.raw_message)
+        command, values = @channel_factory.command_with_inline_arg(message.raw_message || '')
         if command
           execution_context.command = command
           values.each do |value|
@@ -59,6 +63,7 @@ module Kybus
       end
 
       def save_token!(message)
+        execution_context.set_last_message(message.serialize)
         if execution_context.expecting_command?
           command = @channel_factory.command(message.command)
           if @inline_args && !command
@@ -86,8 +91,8 @@ module Kybus
         end
       end
 
-      def precommand_hook(&block)
-        @precommand_hook = proc(&block)
+      def precommand_hook(&)
+        @precommand_hook = proc(&)
       end
 
       def fallback(error)
@@ -106,12 +111,7 @@ module Kybus
         retry
       end
 
-      def invoke(command_name, args)
-        command = @channel_factory.command(command_name)
-        if command.nil? || command.params_size != args.size
-          raise "Wrong redirect #{command_name}, #{bot.registered_commands}"
-        end
-
+      def invoke(command, args)
         state.command = command
         command.params.zip(args).each do |param, value|
           state.store_param(param, value)
@@ -119,11 +119,19 @@ module Kybus
         run_command_or_prepare!
       end
 
+      def redirect(command_name, args)
+        command = @channel_factory.command(command_name)
+        if command.nil? || command.params_size != args.size
+          raise "Wrong redirect #{command_name}, #{bot.registered_commands}"
+        end
+
+        invoke(command, args)
+      end
+
       # Sends a message to get the next parameter from the user
       def ask_param(param, label = nil)
-        provider = bot.provider
         msg = label || "I need you to tell me #{param}"
-        bot.send_message(msg, provider.last_message.channel_id)
+        bot.send_message(msg, last_message.channel_id)
         execution_context.next_param = param
       end
     end

data/lib/kybus/bot/dsl_methods.rb

@@ -3,6 +3,8 @@
 module Kybus
   module Bot
     class DSLMethods
+      include Kybus::Logger
+
       attr_accessor :state
       attr_reader :provider
 
@@ -42,6 +44,10 @@ module Kybus
         state.files
       end
 
+      def metadata
+        state.metadata
+      end
+
       def file(name)
         (file = files[name]) && provider.file_builder(file)
       end
@@ -51,28 +57,32 @@ module Kybus
       end
 
       def current_user
-        provider.last_message.user
+        last_message.user
       end
 
       def is_private?
-        provider.last_message.is_private?
+        last_message.is_private?
       end
 
       def last_message
-        provider.last_message
+        state.last_message
       end
 
       # returns the current_channel from where the message was sent
       def current_channel
-        state.channel_id
+        last_message.channel_id
       end
 
       def command_name
         state&.command&.name
       end
 
-      def method_missing(method, *args, &block)
-        @bot.send(method, *args, &block)
+      def redirect(*args)
+        @bot.redirect(*args)
+      end
+
+      def abort(msg = nil)
+        raise ::Kybus::Bot::Base::AbortError, msg
       end
     end
   end

data/lib/kybus/bot/message.rb

@@ -7,6 +7,7 @@ module Kybus
   module Bot
     # Base implementation for messages from distinct providers
     class Message
+      require_relative 'serialized_message'
       # Converts the messages into a hash
       # Returns true when the received message is a command. Convention states
       # that messages should start with '/' to be considered commands
@@ -15,7 +16,20 @@ module Kybus
       end
 
       def command
-        raw_message&.split(' ')&.first
+        raw_message&.split&.first
+      end
+
+      def serialize
+        SerializedMessage.new({
+                                provider: self.class.name,
+                                channel_id:,
+                                message_id:,
+                                user:,
+                                replied_message: reply? ? replied_message.serialize : nil,
+                                raw_message:,
+                                is_private?: is_private?,
+                                attachment: has_attachment? ? attachment : nil
+                              })
       end
     end
   end

data/lib/kybus/bot/migrator.rb

@@ -1,21 +1,60 @@
 # frozen_string_literal: true
 
-require 'sequel'
-require 'sequel/extensions/migration'
 module Kybus
   module Bot
     module Migrator
       class << self
-        def run_migrations!(conn)
+        def run_migrations!(config)
+          case config['name']
+          when 'sequel'
+            run_sequel_migrations(config)
+          when 'dynamoid'
+            run_dynamoid_migrations(config)
+          else
+            raise "Provider not supported #{config['name']}"
+          end
+        end
+
+        private
+
+        def run_sequel_migrations(config)
+          require 'sequel'
+          require 'sequel/extensions/migration'
+
+          conn = Sequel.connect(config['endpoint'])
           conn.create_table?(:bot_sessions) do
             String :channel_id
             String :user
             String :params, text: true
+            String :metadata, text: true
             String :files, text: true
             String :cmd
             String :requested_param
+            String :last_message, text: true
           end
         end
+
+        def run_dynamoid_migrations(config)
+          repository = Kybus::Storage::Datasource::DynamoidRepository.from_config(
+            'name' => 'dynamoid',
+            'dynamoid_config' => true,
+            'access_key' => config['access_key'],
+            'secret_key' => config['secret_key'],
+            'region' => config['region'],
+            'endpoint' => config['endpoint'],
+            'namespace' => config['namespace'],
+            'table' => 'bot_sessions',
+            'primary_key' => 'channel_id',
+            'fields' => Base::DYNAMOID_FIELDS,
+            'read_capacity' => config['read_capacity'] || 1,
+            'write_capacity' => config['write_capacity'] || 1
+          )
+
+          # Ensure the table is created
+          return if Dynamoid.adapter.list_tables.include?('bot_sessions')
+
+          repository.model_class.create_table(sync: true)
+        end
       end
     end
   end

data/lib/kybus/bot/serialized_message.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    # Base iplementation for messages from distinct providers
+    class SerializedMessage < Message
+      MANDATORY_FIELDS = %i[channel_id provider message_id user raw_message].freeze
+
+      def initialize(data)
+        data = data.to_h if data.is_a?(SerializedMessage)
+        raise 'BadSerializedMessage: nil message' if data.nil?
+
+        data = data[:data] if data.is_a?(Hash) && data.key?(:data)
+
+        missing_keys = MANDATORY_FIELDS.reject { |k| data.keys.include?(k) }
+        raise "BadSerializedMessage: Missing keys `#{missing_keys}', got: #{data}" unless missing_keys.empty?
+
+        @data = data.is_a?(String) ? JSON.parse(data, symbolize_names: true) : data
+        @data[:replied_message] = SerializedMessage.new(@data[:replied_message]) if @data[:replied_message]
+      end
+
+      def self.from_json(json)
+        data = json.is_a?(String) ? JSON.parse(json, symbolize_names: true) : json
+        new(data)
+      end
+
+      def reply?
+        @data[:replied_message].is_a?(SerializedMessage)
+      end
+
+      def has_attachment?
+        !@data[attachment].nil?
+      end
+
+      def method_missing(method, *_args)
+        @data[method]
+      end
+
+      def to_h
+        @data.dup
+      end
+
+      def to_json(*args)
+        @data.to_json(*args)
+      end
+    end
+  end
+end

data/lib/kybus/bot/sidekiq_command_executor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require_relative 'sidekiq_dsl_methods'
+
+module Kybus
+  module Bot
+    class SidekiqWorker
+      include Sidekiq::Worker
+      extend Kybus::DRY::ResourceInjector
+      include Kybus::Logger
+
+      def provider
+        SidekiqWorker.resource(:provider)
+      end
+
+      def factory
+        SidekiqWorker.resource(:factory)
+      end
+
+      def bot
+        SidekiqWorker.resource(:bot)
+      end
+
+      def build_context(details_json)
+        state = CommandState.from_json(details_json, factory)
+        log_debug('Loaded message into worker', state: state.to_h)
+        [SidekiqDSLMethods.new(provider, state, bot, factory), state]
+      end
+
+      def perform(details_json)
+        dsl, state = build_context(details_json)
+        dsl.instance_eval(&state.command.block)
+      rescue StandardError => e
+        log_error('Error in worker', error: e.class, msg: e.message, trace: e.backtrace)
+      end
+    end
+
+    class SidekiqCommandExecutor < CommandExecutor
+      def initialize(bot, channel_factory, configs)
+        super(bot, channel_factory, configs['inline_args'])
+        SidekiqWorker.register(:factory, @channel_factory)
+        SidekiqWorker.register(:provider, bot.provider)
+        SidekiqWorker.register(:bot, bot)
+      end
+
+      def run_command!
+        log_debug(msg: 'Enqueued process to sidekiq', state: state.to_h)
+        SidekiqWorker.perform_async(state.to_json)
+        nil
+      end
+    end
+  end
+end

data/lib/kybus/bot/sidekiq_dsl_methods.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class SidekiqDSLMethods < DSLMethods
+      def initialize(provider, state, bot, factory)
+        super(provider, state, bot)
+        @factory = factory
+      end
+
+      def redirect(command_name, args = {})
+        command = @factory.command(command_name)
+        raise "Wrong redirect #{command_name}" if command.nil? || command.params_size != args.size
+
+        state.command = command
+        command.params.zip(args).each do |param, value|
+          state.store_param(param, value)
+        end
+
+        instance_eval(&state.command.block)
+      end
+    end
+  end
+end

data/lib/kybus/bot/test.rb

@@ -31,7 +31,7 @@ module Kybus
       def receives(msg, attachments = nil)
         attachments = Adapter::DebugMessage::DebugFile.new(attachments) if attachments
         msg = Adapter::DebugMessage.new(msg, @default_channel_id, attachments)
-        log_info('Received message', channel: @default_channel_id, msg:)
+        log_info('Received message', channel: @default_channel_id, msg: msg.raw_message)
         provider.last_message = msg
         executor.process_message(msg)
       end

data/lib/kybus/bot/version.rb

@@ -2,6 +2,6 @@
 
 module Kybus
   module Bot
-    VERSION = '0.8.2'
+    VERSION = '0.10.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kybus-bot
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Gilberto Vargas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-18 00:00:00.000000000 Z
+date: 2024-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kybus-core
@@ -24,188 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: kybus-logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: kybus-storage
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: rack-minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.3'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.1'
-- !ruby/object:Gem::Dependency
-  name: sequel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: telegram-bot-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
 description: Provides a framework for building bots with ruby
 email:
 - tachoguitar@gmail.com
@@ -230,6 +48,9 @@ files:
 - lib/kybus/bot/dsl_methods.rb
 - lib/kybus/bot/message.rb
 - lib/kybus/bot/migrator.rb
+- lib/kybus/bot/serialized_message.rb
+- lib/kybus/bot/sidekiq_command_executor.rb
+- lib/kybus/bot/sidekiq_dsl_methods.rb
 - lib/kybus/bot/test.rb
 - lib/kybus/bot/testing.rb
 - lib/kybus/bot/version.rb
@@ -253,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.14
 signing_key: 
 specification_version: 4
 summary: Provides a framework for building bots with ruby