kybus-bot 0.10.0 → 0.11.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class ParameterSaver
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def save_token!(message)
+        @executor.execution_context.last_message = message.serialize
+        if @executor.execution_context.expecting_command?
+          command = @executor.channel_factory.command(message.command)
+          set_command(command, message)
+        else
+          save_param!(message)
+        end
+      end
+
+      private
+
+      def save_param!(message)
+        @executor.execution_context.add_param(message.raw_message)
+        save_attachment!(message) if message.has_attachment?
+      end
+
+      def save_attachment!(message)
+        file = @executor.bot.provider.file_builder(message.attachment)
+        @executor.execution_context.add_file(file)
+      end
+
+      def set_command(command, message)
+        if @executor.inline_args && !command
+          search_command_with_inline_arg(message)
+        elsif !@executor.inline_args && !command
+          set_default_command
+        else
+          @executor.execution_context.command = command
+        end
+      end
+
+      def search_command_with_inline_arg(message)
+        command, values = @executor.channel_factory.command_with_inline_arg(message.raw_message || '')
+        if command
+          set_command_with_values(command, values)
+        else
+          set_default_command
+        end
+      end
+
+      def set_command_with_values(command, values)
+        @executor.execution_context.command = command
+        values.each do |value|
+          @executor.execution_context.next_param = @executor.execution_context.next_missing_param
+          @executor.execution_context.add_param(value)
+        end
+      end
+
+      def set_default_command
+        @executor.execution_context.command = @executor.channel_factory.default_command
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class RegularCommandMatcher
+      def initialize(definitions)
+        @definitions = definitions
+        @matchers = build_matchers
+      end
+
+      def find_command(search)
+        @definitions.each do |name, command|
+          matcher = @matchers[name.class]
+          result = matcher&.call(name, command, search)
+          return result if result
+        end
+        nil
+      end
+
+      private
+
+      def build_matchers
+        {
+          String => method(:match_string),
+          Class => method(:match_class),
+          Regexp => method(:match_regexp)
+        }
+      end
+
+      def match_string(name, command, search)
+        command if name == search
+      end
+
+      def match_class(name, command, search)
+        command if search.is_a?(name)
+      end
+
+      def match_regexp(name, command, search)
+        return unless search.is_a?(String) && name.match?(search)
+
+        storable_command = command.clone
+        storable_command.name = search
+        storable_command
+      end
+    end
+  end
+end

data/lib/kybus/bot/command_executor.rb

@@ -4,6 +4,9 @@ require 'forwardable'
 require_relative 'command/command'
 require_relative 'command/command_definition'
 require_relative 'command/execution_context'
+require_relative 'dsl_methods'
+require_relative 'command/command_handler'
+require_relative 'command/parameter_saver'
 
 module Kybus
   module Bot
@@ -11,7 +14,7 @@ module Kybus
       extend Forwardable
 
       include Kybus::Logger
-      attr_reader :dsl, :bot, :execution_context
+      attr_reader :dsl, :bot, :execution_context, :channel_factory, :inline_args, :error
 
       def_delegator :execution_context, :save!, :save_execution_context!
 
@@ -29,79 +32,32 @@ module Kybus
         @dsl = DSLMethods.new(bot.provider, state, bot)
         @inline_args = inline_args
         @precommand_hook = proc {}
+        @parameter_saver = ParameterSaver.new(self)
+        @command_handler = CommandHandler.new(self)
       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)
-        msg = run_command_or_prepare!
-        save_execution_context!
-        msg
-      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, values = @channel_factory.command_with_inline_arg(message.raw_message || '')
-        if command
-          execution_context.command = command
-          values.each do |value|
-            execution_context.next_param = execution_context.next_missing_param
-            execution_context.add_param(value)
-          end
-        else
-          execution_context.command = @channel_factory.default_command
-        end
-      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
-            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)
-          msg = run_command!
-          execution_context.clear_command
-          msg
+      def precommand_hook(&)
+        if block_given?
+          @precommand_hook = proc(&)
         else
-          param = execution_context.next_missing_param
-          ask_param(param, execution_context.state.command.params_ask_label(param))
+          @precommand_hook
         end
       end
 
-      def precommand_hook(&)
-        @precommand_hook = proc(&)
+      def process_message(message)
+        setup_execution_context(message)
+        @parameter_saver.save_token!(message)
+        msg = @command_handler.run_command_or_prepare!
+        save_execution_context!
+        msg
       end
 
       def fallback(error)
-        catch = @channel_factory.command(error)
+        catch_command = @channel_factory.command(error)
         log_error('Unexpected error', error)
-        execution_context.command = catch if catch
+        execution_context.command = catch_command if catch_command
       end
 
-      # Method for triggering command
       def run_command!
         execution_context.call!(@dsl)
       rescue StandardError => e
@@ -112,28 +68,40 @@ module Kybus
       end
 
       def invoke(command, args)
-        state.command = command
-        command.params.zip(args).each do |param, value|
-          state.store_param(param, value)
-        end
-        run_command_or_prepare!
+        set_state_command(command, args)
+        @command_handler.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
-
+        validate_redirect(command, command_name, args)
         invoke(command, args)
       end
 
-      # Sends a message to get the next parameter from the user
       def ask_param(param, label = nil)
         msg = label || "I need you to tell me #{param}"
-        bot.send_message(msg, last_message.channel_id)
+        bot.dsl.send_message(msg, last_message.channel_id)
         execution_context.next_param = param
       end
+
+      private
+
+      def setup_execution_context(message)
+        @execution_context = ExecutionContest.new(message.channel_id, @channel_factory)
+      end
+
+      def set_state_command(command, args)
+        state.command = command
+        command.params.zip(args).each do |param, value|
+          state.store_param(param, value)
+        end
+      end
+
+      def validate_redirect(command, command_name, args)
+        return unless command.nil? || command.params_size != args.size
+
+        raise ::Kybus::Bot::Base::BotError, "Wrong redirect #{command_name}, #{bot.registered_commands}"
+      end
     end
   end
 end

data/lib/kybus/bot/dsl_methods.rb

@@ -6,7 +6,7 @@ module Kybus
       include Kybus::Logger
 
       attr_accessor :state
-      attr_reader :provider
+      attr_reader :provider, :args
 
       def initialize(provider, state, bot)
         @provider = provider
@@ -77,13 +77,17 @@ module Kybus
         state&.command&.name
       end
 
-      def redirect(*args)
-        @bot.redirect(*args)
+      def redirect(*)
+        @bot.redirect(*)
       end
 
       def abort(msg = nil)
         raise ::Kybus::Bot::Base::AbortError, msg
       end
+
+      def fork(command, arguments = {})
+        @bot.invoke_job(command, arguments)
+      end
     end
   end
 end

data/lib/kybus/bot/exceptions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    class Base
+      class BotError < StandardError; end
+      class AbortError < BotError; end
+
+      class EmptyMessageError < BotError
+        def initialize
+          super('Message is empty')
+        end
+      end
+    end
+  end
+end

data/lib/kybus/bot/forkers/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    module Forkers
+      class JobNotFound < ::Kybus::Bot::Base::BotError; end
+      class JobNotReady < ::Kybus::Bot::Base::BotError; end
+
+      extend Kybus::DRY::ResourceInjector
+      register(:forkers, {})
+
+      def self.register_forker(name, provider)
+        forkers = resource(:forkers)
+        forkers[name] = provider
+      end
+
+      def self.forker(name)
+        forkers = resource(:forkers)
+        forkers[name]
+      end
+
+      def self.from_config(bot, configs)
+        provider_name = configs&.dig('provider') || 'thread'
+        provider = forker(provider_name)
+        provider.new(bot, configs)
+      end
+
+      class Base
+        include Kybus::Logger
+
+        def initialize(bot, configs)
+          @configs = configs
+          @bot = bot
+          @command_definition = CommandDefinition.new
+        end
+
+        def register_command(command, arguments, &)
+          @command_definition.register_command(command, arguments, &)
+        end
+
+        def fork(command, arguments, dsl)
+          job_definition = @command_definition[command]
+          raise JobNotFound if job_definition.nil?
+
+          raise JobNotReady unless job_definition.ready?(arguments)
+
+          invoke(command, arguments, job_definition, dsl)
+        end
+
+        def handle_job(command, args)
+          job_definition = @command_definition[command]
+          @bot.dsl.instance_eval do
+            @args = args
+            instance_eval(&job_definition.block)
+          end
+          log_info('Job Executed', command:, args:)
+        end
+      end
+    end
+  end
+end

data/lib/kybus/bot/forkers/lambda_sqs_forker.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    module Forkers
+      class LambdaSQSForker < Base
+        extend Kybus::DRY::ResourceInjector
+
+        def self.register_queue_client(client)
+          register(:sqs, client)
+        end
+
+        def initialize(bot, configs)
+          super
+          @client = LambdaSQSForker.resource(:sqs)
+          @queue = configs['queue']
+          @queue_url = @client.get_queue_url(queue_name: @queue).queue_url
+        end
+
+        def invoke(command, args, _job_definition, dsl)
+          @client.send_message(queue_url: @queue_url, message_body: make_message(command, args, dsl).to_json)
+        end
+
+        def make_message(command, args, dsl)
+          {
+            job: command,
+            args: args.to_h,
+            state: dsl.state.to_h
+          }
+        end
+
+        def handle_job(command, args)
+          log_info('Got job from SQS', command:)
+          super
+        end
+      end
+
+      register_forker('sqs', LambdaSQSForker)
+    end
+  end
+end

data/lib/kybus/bot/forkers/thread_forker.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Bot
+    module Forkers
+      class ThreadForker < Base
+        def invoke(command, args, _job_definition, _dsl)
+          Thread.new do
+            log_info('Forking job', command:)
+            handle_job(command, args)
+          end
+        end
+      end
+
+      register_forker('thread', ThreadForker)
+    end
+  end
+end

data/lib/kybus/bot/migrator.rb

@@ -5,55 +5,73 @@ module Kybus
     module Migrator
       class << self
         def run_migrations!(config)
-          case config['name']
+          migrator = migrator_for(config['name'])
+          migrator.run_migrations!(config)
+        end
+
+        private
+
+        def migrator_for(name)
+          case name
           when 'sequel'
-            run_sequel_migrations(config)
+            SequelMigrator
           when 'dynamoid'
-            run_dynamoid_migrations(config)
+            DynamoidMigrator
           else
-            raise "Provider not supported #{config['name']}"
+            raise "Provider not supported #{name}"
           end
         end
+      end
 
-        private
+      class SequelMigrator
+        class << self
+          def run_migrations!(config)
+            require 'sequel'
+            require 'sequel/extensions/migration'
 
-        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
+            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
         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)
+      class DynamoidMigrator
+        class << self
+          def run_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
+            )
+
+            create_table_if_not_exists(repository)
+          end
+
+          private
+
+          def create_table_if_not_exists(repository)
+            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

@@ -2,21 +2,15 @@
 
 module Kybus
   module Bot
-    # Base iplementation for messages from distinct providers
+    # Base implementation 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]
+        super()
+        @data = parse_data(data)
+        validate_data!
+        parse_replied_message
       end
 
       def self.from_json(json)
@@ -32,7 +26,7 @@ module Kybus
         !@data[attachment].nil?
       end
 
-      def method_missing(method, *_args)
+      def method_missing(method, *_args) # rubocop:disable Style/MissingRespondToMissing
         @data[method]
       end
 
@@ -40,8 +34,32 @@ module Kybus
         @data.dup
       end
 
-      def to_json(*args)
-        @data.to_json(*args)
+      def to_json(*)
+        @data.to_json(*)
+      end
+
+      private
+
+      def parse_data(data)
+        data = data.to_h if data.is_a?(SerializedMessage)
+        raise Base::BotError, 'BadSerializedMessage: nil message' if data.nil?
+
+        data = data[:data] if data.is_a?(Hash) && data.key?(:data)
+        data.is_a?(String) ? JSON.parse(data, symbolize_names: true) : data
+      end
+
+      def validate_data!
+        missing_keys = MANDATORY_FIELDS.reject { |k| @data.key?(k) }
+        return if missing_keys.empty?
+
+        raise Base::BotError,
+              "BadSerializedMessage: Missing keys `#{missing_keys}', got: #{@data}"
+      end
+
+      def parse_replied_message
+        return unless @data[:replied_message]
+
+        @data[:replied_message] = SerializedMessage.new(@data[:replied_message])
       end
     end
   end

data/lib/kybus/bot/sidekiq_command_executor.rb

@@ -32,7 +32,9 @@ module Kybus
         dsl, state = build_context(details_json)
         dsl.instance_eval(&state.command.block)
       rescue StandardError => e
+        # :nocov:
         log_error('Error in worker', error: e.class, msg: e.message, trace: e.backtrace)
+        # :nocov:
       end
     end
 

data/lib/kybus/bot/version.rb

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