kybus-bot 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5133b5a89dc9947680ecdbd8ec25befed895f57e017d19121278617b6bc0ff4d
-  data.tar.gz: '08e309bdf344e7066a5354c516487b12764b85cca7ea38165054471e5280cba7'
+  metadata.gz: 07b049513ef4f14a6c9d7896822a8d62a1f7eccee3df45325d7e5f6eff105abc
+  data.tar.gz: 259700235d2b8a923fa6dfd706b8e0e30b0546f16575ffb960b9e4f45d0a218c
 SHA512:
-  metadata.gz: da4828437e972ecd01dab962800ae67f011a7ed8ceb88b9f1484d7c4caef740811dfd816f578620a5679a86768b21a00a976750d206c25cdcd7df66e4e3f4a6c
-  data.tar.gz: c7bc12f54fb1352f774cbf607c12bbcae4802edc0d0058e99a38a7bb1554a8083b721a4e715e2185fd92fab668ece278e83ce4a2a15d43f28ddd23f5175cccfa
+  metadata.gz: a66ec612123afc67d7296e405f902beac5bae5849b3de7d1cc538ceadc6cbd62c993a3fd373c7a672592196706d2bd71c5e57feb15256299e1c2d55de2bae38d
+  data.tar.gz: 887ea27d9d9974ba1621fe9430c483ed072e041019b1d66de17f137f32ddc362033382b914dc0ba7ddb8b18df124efec02634d779c5da2a223ac0f5a21a8391c

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

@@ -35,14 +35,17 @@ module Kybus
           end
         end
 
+        def self.make_message_id
+          @message_id ||= 0
+          @message_id += 1
+        end
+
         def initialize(text, channel, attachment = nil)
           super()
           @text = text
           @channel = channel
           @attachment = attachment
-          @@message_id ||= 0
-          @@message_id += 1
-          @message_id = @@message_id + 1
+          @message_id = DebugMessage.make_message_id
         end
 
         # Returns the channel id
@@ -125,7 +128,7 @@ module Kybus
       # This adapter is intended to be used on unit tests and development.
       class Debug
         # Exception for stoping the loop of messages
-        class NoMoreMessageException < Kybus::Exceptions::AntError
+        class NoMoreMessageException < Kybus::Exceptions::KybusError
           def initialize
             super('There are no messages left')
           end

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

@@ -8,118 +8,70 @@ require_relative 'telegram_message'
 module Kybus
   module Bot
     module Adapter
-      ##
-      # 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
-        #   list of the messages in the channel.
-        # - echo: a flag to enable debug messages.
         def initialize(configs)
           @config = configs
           @client = ::Telegram::Bot::Client.new(@config['token'])
           TelegramFile.register(:cli, @client)
         end
 
-        # Interface for receiving message
         def read_message
-          # take the first message from the first open message,
           loop do
             @client.listen do |message|
-              log_info('Received message', message: message.to_h,
-                                           from: message.from.to_h)
+              log_info('Received message', message: message.to_h, from: message.from.to_h)
               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:
+            log_error('An error occurred while calling to Telegram API', e)
           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')
+          user = extract_user(body.dig('message', 'from'))
           raw_message = body.dig('message', 'text')
-
-          replied_message = body.dig('message', 'reply_to_message')
           is_private = body.dig('message', 'chat', 'type') == 'private'
+          attachment = extract_attachment(body['message'])
+          serialized_replied_message = serialize_replied_message(body.dig('message', 'reply_to_message'))
 
-          # 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:
-          )
+          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)
           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
           nil if e.error_code == '403'
         end
-        # :nocov:
 
-        # interface for sending video
         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::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, 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::FilePart.new(image_url, 'application/octect-stream')
+          file = Faraday::FilePart.new(image_url, 'application/octet-stream')
           @client.api.send_document(chat_id: channel_name, document: file)
         end
 
@@ -130,6 +82,35 @@ module Kybus
         def file_builder(file)
           TelegramFile.new(file)
         end
+
+        private
+
+        def extract_user(from)
+          from['username'] || from['first_name']
+        end
+
+        def extract_attachment(message)
+          return unless message
+
+          %w[photo document video].each do |type|
+            attachment = message[type]
+            return type == 'photo' ? attachment.last : attachment if attachment
+          end
+          nil
+        end
+
+        def serialize_replied_message(replied_message)
+          return unless replied_message
+
+          SerializedMessage.new(
+            provider: 'telegram',
+            channel_id: replied_message.dig('chat', 'id'),
+            message_id: replied_message['message_id'],
+            user: extract_user(replied_message['from']),
+            raw_message: replied_message['text'],
+            is_private?: replied_message.dig('chat', 'type') == 'private'
+          ).serialize
+        end
       end
 
       register('telegram', Telegram)

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

@@ -40,7 +40,7 @@ module Kybus
         end
 
         def original_name
-          meta.dig('result', 'file_name')
+          meta.file_path
         end
 
         def file_name
@@ -49,7 +49,7 @@ module Kybus
 
         def download
           token = cli.api.token
-          file_path = meta.dig('result', 'file_path')
+          file_path = meta.file_path
           path = "https://api.telegram.org/file/bot#{token}/#{file_path}"
           Faraday.get(path).body
         end

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

@@ -47,9 +47,13 @@ module Kybus
         end
 
         def attachment
-          (@message.respond_to?(:document) && @message&.document) ||
-            (@message.respond_to?(:photo) && @message.photo&.last) ||
-            (@message.respond_to?(:audio) && @message&.audio)
+          %i[document photo audio].each do |method|
+            next unless @message.respond_to?(method)
+
+            attachment = @message.public_send(method)
+            return method == :photo ? attachment.last : attachment if attachment
+          end
+          nil
         end
 
         def user

data/lib/kybus/bot/base.rb

@@ -6,25 +6,19 @@ require 'kybus/storage'
 require_relative 'command/command_state'
 require_relative 'dsl_methods'
 require_relative 'command_executor'
+require_relative 'command/command_definition'
+require_relative 'command/execution_context'
 require_relative 'command/command_state_factory'
-
+require_relative 'exceptions'
+require_relative 'forkers/base'
+require_relative 'forkers/thread_forker'
+require_relative 'forkers/lambda_sqs_forker'
 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
-      class BotError < StandardError; end
-      class AbortError < BotError; end
-
-      class EmptyMessageError < BotError
-        def initialize
-          super('Message is empty')
-        end
-      end
-
+    class Base # rubocop: disable Metrics/ClassLength
       extend Forwardable
       include Kybus::Logger
 
@@ -44,41 +38,17 @@ module Kybus
       def_delegators :executor, :state, :precommand_hook
       def_delegators :definitions, :registered_commands
 
-      # Configurations needed:
-      # - pool_size: number of threads created in execution
-      # - provider: a configuration for a thread provider.
-      #   See supported adapters
-      # - name: The bot name
-      # - repository: Configurations about the state storage
-
       def initialize(configs)
-        build_pool(configs['pool_size'])
+        @pool_size = configs['pool_size']
         @provider = Kybus::Bot::Adapter.from_config(configs['provider'])
-        # TODO: move this to config
-        repository = make_repository(configs)
         @definitions = Kybus::Bot::CommandDefinition.new
+        repository = create_repository(configs)
         command_factory = CommandStateFactory.new(repository, @definitions)
-        @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)
+        @executor = create_executor(configs, command_factory)
+        register_default_command
+        register_abort_handler
+        build_forker(configs)
+        build_pool
       end
 
       def self.helpers(mod = nil, &)
@@ -86,14 +56,8 @@ module Kybus
         DSLMethods.class_eval(&) if block_given?
       end
 
-      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
-            message = provider.read_message
-            executor.process_message(message)
-          end
-        end
+      def extend(*)
+        DSLMethods.include(*)
       end
 
       def dsl
@@ -105,13 +69,9 @@ module Kybus
         @executor.process_message(parsed)
       end
 
-      # 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
 
       def redirect(command, *params)
@@ -127,14 +87,63 @@ module Kybus
         definitions.register_command(klass, params, &)
       end
 
+      def register_job(name, args, &)
+        @forker.register_command(name, args, &)
+      end
+
+      def invoke_job(name, args)
+        @forker.fork(name, args, dsl)
+      end
+
       def rescue_from(klass, &)
         definitions.register_command(klass, [], &)
       end
 
-      def method_missing(method, ...)
-        raise unless dsl.respond_to?(method)
+      def method_missing(method, ...) # rubocop: disable Style/MissingRespondToMissing
+        return dsl.send(method, ...) if dsl.respond_to?(method)
 
-        dsl.send(method, ...)
+        super
+      end
+
+      private
+
+      def create_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 create_executor(configs, command_factory)
+        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
+      end
+
+      def register_default_command
+        register_command('default') { nil }
+      end
+
+      def register_abort_handler
+        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 build_forker(configs)
+        @forker = Forkers.from_config(self, configs['forker'])
+      end
+
+      def build_pool
+        @pool = Array.new(pool_size) do
+          Kybus::DRY::Daemon.new(pool_size, true) do
+            message = provider.read_message
+            executor.process_message(message)
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'command'
+
 module Kybus
   module Bot
     class CommandDefinition

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class CommandHandler
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def run_command_or_prepare!
+        if @executor.execution_context.ready?
+          run_ready_command
+        else
+          ask_for_next_param
+        end
+      end
+
+      private
+
+      def run_ready_command
+        @executor.dsl.state = @executor.execution_context.state
+        @executor.dsl.instance_eval(&@executor.precommand_hook)
+        msg = @executor.run_command!
+        @executor.execution_context.clear_command
+        msg
+      end
+
+      def ask_for_next_param
+        param = @executor.execution_context.next_missing_param
+        @executor.ask_param(param, @executor.execution_context.state.command.params_ask_label(param))
+      end
+    end
+  end
+end

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

@@ -7,12 +7,7 @@ module Kybus
 
       def initialize(data, command)
         @command = command
-        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
+        @data = parse_data(data)
       end
 
       def self.from_json(str, commands_provider)
@@ -36,12 +31,11 @@ module Kybus
         command&.ready?(params)
       end
 
-      # validates which is the following parameter required
       def next_missing_param
         command.next_missing_param(params)
       end
 
-      def set_last_message(msg)
+      def last_message=(msg)
         @data[:last_message] = msg
       end
 
@@ -91,12 +85,29 @@ module Kybus
 
       def save!
         backup = @data.clone
-        %i[params files last_message metadata].each do |param|
-          @data[param] = @data[param].to_json
-        end
+        serialize_data!
         @data.store
+        @data = backup
+      end
+
+      private
+
+      def parse_data(data)
+        data = JSON.parse(data, symbolize_names: true) if data.is_a?(String)
+        %i[params metadata files].each do |key|
+          data[key] = parse_json(data[key]) if data[key].is_a?(String)
+        end
+        data[:last_message] = SerializedMessage.from_json(data[:last_message]) if data[:last_message]
+        data
+      end
+
+      def parse_json(value)
+        JSON.parse(value || '{}', symbolize_names: true)
+      end
+
+      def serialize_data!
         %i[params files last_message metadata].each do |param|
-          @data[param] = backup[param]
+          @data[param] = @data[param].to_json
         end
       end
     end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'regular_command_matcher'
+require_relative 'inline_command_matcher'
+
 module Kybus
   module Bot
     class CommandStateFactory
@@ -7,29 +10,14 @@ module Kybus
       attr_reader :factory
 
       def initialize(repository, definitions)
-        factory = Kybus::Storage::Factory.new(EmptyModel)
-        factory.register(:default, :json)
-        factory.register(:json, repository)
-        @factory = factory
+        @factory = build_factory(repository)
         @definitions = definitions
+        @regular_command_matcher = RegularCommandMatcher.new(definitions)
+        @inline_command_matcher = InlineCommandMatcher.new(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
+        @regular_command_matcher.find_command(search)
       end
 
       def default_command
@@ -41,21 +29,7 @@ module Kybus
       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
+        @inline_command_matcher.find_command_with_inline_arg(name_with_arg)
       end
 
       def load_state(channel)
@@ -64,6 +38,15 @@ module Kybus
       rescue Kybus::Storage::Exceptions::ObjectNotFound
         CommandState.new(factory.create(channel_id: channel.to_s, params: '{}', metadata: '{}', last_message: nil), nil)
       end
+
+      private
+
+      def build_factory(repository)
+        factory = Kybus::Storage::Factory.new(EmptyModel)
+        factory.register(:default, :json)
+        factory.register(:json, repository)
+        factory
+      end
     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, :set_last_message
+      def_delegators :state, :clear_command, :save!, :ready?, :next_missing_param, :last_message=
 
       def block
         state.command.block

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class InlineCommandMatcher
+      def initialize(definitions)
+        @definitions = definitions
+        @matchers = build_matchers
+      end
+
+      def find_command_with_inline_arg(name_with_arg)
+        @definitions.each do |name, command|
+          matcher = @matchers[name.class]
+          result = matcher&.call(name, command, name_with_arg)
+          return result if result
+        end
+        nil
+      end
+
+      private
+
+      def build_matchers
+        {
+          Class => method(:match_inline_class),
+          String => method(:match_inline_string),
+          Regexp => method(:match_inline_regexp)
+        }
+      end
+
+      def match_inline_class(name, command, name_with_arg)
+        [command, []] if name_with_arg.is_a?(name)
+      end
+
+      def match_inline_string(name, command, name_with_arg)
+        [command, name_with_arg.gsub(name, '').split('__')] if name_with_arg.start_with?(name)
+      end
+
+      def match_inline_regexp(name, command, name_with_arg)
+        return unless name_with_arg.match?(name)
+
+        storable_command = command.dup
+        storable_command.name = name_with_arg
+        [storable_command, [name_with_arg]]
+      end
+    end
+  end
+end