Removed tainbox from gem dependencies (#33)

Author: dmi3-bu

.rubocop.yml

@@ -29,3 +29,6 @@ Style/HashConversion:
 
 RSpec/ExampleLength:
   Max: 50
+
+Metrics/ParameterLists:
+  Max: 40

Gemfile.lock

@@ -8,10 +8,9 @@ GIT
 PATH
   remote: .
   specs:
-    rabbit_messaging (1.5.0)
+    rabbit_messaging (1.6.0)
       bunny (~> 2.0)
       kicks
-      tainbox
 
 GEM
   remote: https://rubygems.org/
@@ -152,8 +151,6 @@ GEM
     sorted_set (1.0.3)
       rbtree
       set (~> 1.0)
-    tainbox (2.1.2)
-      activesupport
     thor (1.3.2)
     timeout (0.4.3)
     tzinfo (2.0.6)

README.md

@@ -208,8 +208,6 @@ to teardown and setup external connections between daemon restarts, for example
     Rabbit.config.handler_resolver_callable = -> (group_id, event) { "recivers/#{group_id}/#{event}".camelize.constantize }
     ```
 
-  They use powerful `Tainbox` api to handle message data. Project_id also passed to them.
-
   If you wish so, you can override `initialize(message)`, where message is an object
   with simple api (@see lib/rabbit/receiving/message.rb)
 

bin/console

@@ -1,8 +1,6 @@
 #!/usr/bin/env ruby
 
-# Required for tainbox :(
-require "active_support/deprecation"
-require "active_support/deprecator"
+require "active_support/core_ext/module/delegation"
 
 require "bundler/setup"
 require "rabbit_messaging"

lib/rabbit.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "tainbox"
-
 require "rabbit/version"
 require "rabbit/daemon"
 require "rabbit/publishing"
@@ -14,38 +12,74 @@ module Rabbit
   MessageNotDelivered = Class.new(StandardError)
 
   class Config
-    include Tainbox
-
-    attribute :group_id, :Symbol
-    attribute :project_id, :Symbol
-    attribute :queue_suffix, :String
-    attribute :hooks, default: {}
-    attribute :environment, :Symbol, default: :production
-    attribute :queue_name_conversion
-    attribute :receiving_job_class_callable
-    attribute :handler_resolver_callable
-    attribute :exception_notifier
-    attribute :before_receiving_hooks, default: []
-    attribute :after_receiving_hooks, default: []
-    attribute :skip_publishing_in, default: %i[test development]
-    attribute :use_backoff_handler, :Boolean, default: false
-    attribute :backoff_handler_max_retries, Integer, default: 6
-    attribute :connection_reset_max_retries, Integer, default: 10
-    attribute :connection_reset_timeout, Float, default: 0.2
-    attribute :connection_reset_exceptions, Array, default: [Bunny::ConnectionClosedError]
-    attribute :logger_message_size_limit, Integer, default: 9_500
-
-    attribute :receive_logger, default: lambda {
-      Logger.new(Rabbit.root.join("log", "incoming_rabbit_messages.log"))
-    }
-
-    attribute :publish_logger, default: lambda {
-      Logger.new(Rabbit.root.join("log", "rabbit.log"))
-    }
-
-    attribute :malformed_logger, default: lambda {
-      Logger.new(Rabbit.root.join("log", "malformed_messages.log"))
-    }
+    attr_accessor :group_id,
+                  :project_id,
+                  :queue_suffix,
+                  :hooks,
+                  :environment,
+                  :queue_name_conversion,
+                  :receiving_job_class_callable,
+                  :handler_resolver_callable,
+                  :exception_notifier,
+                  :before_receiving_hooks,
+                  :after_receiving_hooks,
+                  :skip_publishing_in,
+                  :use_backoff_handler,
+                  :backoff_handler_max_retries,
+                  :connection_reset_max_retries,
+                  :connection_reset_timeout,
+                  :connection_reset_exceptions,
+                  :logger_message_size_limit,
+                  :receive_logger,
+                  :publish_logger,
+                  :malformed_logger
+
+    def initialize( # rubocop:disable Metrics/MethodLength
+      group_id: nil,
+      project_id: nil,
+      queue_suffix: nil,
+      hooks: {},
+      environment: :production,
+      queue_name_conversion: nil,
+      receiving_job_class_callable: nil,
+      handler_resolver_callable: nil,
+      exception_notifier: nil,
+      before_receiving_hooks: [],
+      after_receiving_hooks: [],
+      skip_publishing_in: %i[test development],
+      use_backoff_handler: false,
+      backoff_handler_max_retries: 6,
+      connection_reset_max_retries: 10,
+      connection_reset_timeout: 0.2,
+      connection_reset_exceptions: [Bunny::ConnectionClosedError],
+      logger_message_size_limit: 9_500,
+      receive_logger: nil,
+      publish_logger: nil,
+      malformed_logger: nil
+    )
+      self.group_id = group_id
+      self.project_id = project_id
+      self.queue_suffix = queue_suffix
+      self.hooks = hooks
+      self.environment = environment
+      self.queue_name_conversion = queue_name_conversion
+      self.receiving_job_class_callable = receiving_job_class_callable
+      self.handler_resolver_callable = handler_resolver_callable
+      self.exception_notifier = exception_notifier
+      self.before_receiving_hooks = before_receiving_hooks
+      self.after_receiving_hooks = after_receiving_hooks
+      self.skip_publishing_in = skip_publishing_in
+      self.use_backoff_handler = use_backoff_handler
+      self.backoff_handler_max_retries = backoff_handler_max_retries
+      self.connection_reset_max_retries = connection_reset_max_retries
+      self.connection_reset_timeout = connection_reset_timeout
+      self.connection_reset_exceptions = connection_reset_exceptions
+      self.logger_message_size_limit = logger_message_size_limit
+
+      self.receive_logger = receive_logger || default_receive_logger
+      self.publish_logger = publish_logger || default_publish_logger
+      self.malformed_logger = malformed_logger || default_malformed_logger
+    end
 
     def validate!
       raise InvalidConfig, "missing project_id" unless project_id
@@ -68,6 +102,20 @@ def app_name
     def read_queue
       [app_name, queue_suffix].reject { |x| x.nil? || x.empty? }.join(".")
     end
+
+    private
+
+    def default_receive_logger
+      Logger.new(Rabbit.root.join("log", "incoming_rabbit_messages.log"))
+    end
+
+    def default_publish_logger
+      Logger.new(Rabbit.root.join("log", "rabbit.log"))
+    end
+
+    def default_malformed_logger
+      Logger.new(Rabbit.root.join("log", "malformed_messages.log"))
+    end
   end
 
   extend self

lib/rabbit/event_handler.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-require "tainbox"
 require "active_support/core_ext/class/attribute"
 
 class Rabbit::EventHandler
-  include Tainbox
+  attr_accessor :project_id, :data, :message_info
 
-  attribute :project_id
-  attribute :data
-  attribute :message_info
+  class << self
+    attr_accessor :queue, :ignore_queue_conversion, :additional_job_configs
 
-  class_attribute :queue
-  class_attribute :ignore_queue_conversion, default: false
-  class_attribute :additional_job_configs, default: {}
+    def inherited(subclass)
+      super
+      subclass.ignore_queue_conversion = false
+      subclass.additional_job_configs = {}
+    end
 
-  class << self
     private
 
     def queue_as(queue = nil, &block)
@@ -31,9 +30,17 @@ def job_configs(**config_opts)
   end
 
   def initialize(message)
-    self.attributes   = message.data
-    self.data         = message.data
-    self.project_id   = message.project_id
+    assign_attributes(message.data)
+
+    self.data = message.data
+    self.project_id = message.project_id
     self.message_info = message.arguments
   end
+
+  def assign_attributes(attrs = {})
+    attrs.each do |key, value|
+      setter = "#{key}="
+      public_send(setter, value) if respond_to?(setter)
+    end
+  end
 end

lib/rabbit/publishing/message.rb

@@ -1,28 +1,31 @@
 # frozen_string_literal: true
 
-require "tainbox"
-
 module Rabbit::Publishing
   class Message
-    include Tainbox
-
-    attribute :routing_key,    String
-    attribute :event,          String
-    attribute :data,           default: {}
-    attribute :exchange_name,  default: []
-    attribute :confirm_select, default: true
-    attribute :realtime,       default: false
-    attribute :headers
-    attribute :message_id
+    attr_accessor :routing_key, :event, :data,
+                  :confirm_select, :realtime, :headers, :message_id
+    attr_reader :exchange_name
 
     alias_method :confirm_select?, :confirm_select
     alias_method :realtime?, :realtime
 
+    def initialize(attributes = {})
+      self.routing_key     = attributes[:routing_key]
+      self.event           = attributes[:event]&.to_s
+      self.data            = attributes.fetch(:data, {})
+      self.exchange_name   = Array(attributes.fetch(:exchange_name, []))
+      self.confirm_select  = attributes.fetch(:confirm_select, true)
+      self.realtime        = attributes.fetch(:realtime, false)
+      self.headers         = attributes.fetch(:headers, {})
+      self.message_id      = attributes[:message_id]
+    end
+
     def to_hash
-      {
-        **attributes,
-        data: JSON.parse(data.to_json),
-      }
+      instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete("@").to_sym
+        value = instance_variable_get(var)
+        hash[key] = value
+      end.merge(data: JSON.parse(data.to_json))
     end
 
     def to_s
@@ -49,15 +52,11 @@ def basic_publish_args
     end
 
     def exchange_name=(names)
-      super(Array(names).map(&:to_s))
+      @exchange_name = Array(names).map(&:to_s)
     end
 
     def real_exchange_name
       [Rabbit.config.group_id, Rabbit.config.project_id, *exchange_name].join(".")
     end
-
-    def headers
-      super || {}
-    end
   end
 end

lib/rabbit/receiving/message.rb

@@ -1,20 +1,12 @@
 # frozen_string_literal: true
 
-require "tainbox"
-
 require "rabbit/receiving/malformed_message"
 
 module Rabbit::Receiving
   class Message
-    include Tainbox
-
-    attribute :group_id
-    attribute :project_id
-    attribute :message_id
-    attribute :event
-    attribute :data
-    attribute :arguments
-    attribute :original_message
+    attr_accessor :group_id, :project_id, :message_id,
+                  :event, :arguments, :original_message
+    attr_reader :data
 
     def self.build(message, arguments)
       group_id, project_id = arguments.fetch(:app_id).split(".")
@@ -29,15 +21,46 @@ def self.build(message, arguments)
       )
     end
 
+    def initialize(
+      group_id: nil,
+      project_id: nil,
+      message_id: nil,
+      event: nil,
+      data: nil,
+      arguments: nil,
+      original_message: nil
+    )
+      self.group_id = group_id
+      self.project_id = project_id
+      self.message_id = message_id
+      self.event = event
+      self.data = data unless data.nil?
+      self.arguments = arguments
+      self.original_message = original_message
+    end
+
     def data=(value)
       self.original_message = value
-      super(JSON.parse(value).deep_symbolize_keys)
+      parsed = JSON.parse(value).deep_symbolize_keys
+      @data = parsed
     rescue JSON::ParserError => error
       mark_as_malformed!("JSON::ParserError: #{error.message}")
     end
 
     def mark_as_malformed!(errors = "Error not specified")
       MalformedMessage.raise!(self, errors, caller(1))
     end
+
+    def attributes
+      {
+        group_id: group_id,
+        project_id: project_id,
+        message_id: message_id,
+        event: event,
+        data: data,
+        arguments: arguments,
+        original_message: original_message,
+      }
+    end
   end
 end

lib/rabbit/receiving/receive.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require "tainbox"
-
 require "rabbit"
 require "rabbit/receiving/queue"
 require "rabbit/receiving/job"
 require "rabbit/helper"
 
 class Rabbit::Receiving::Receive
-  include Tainbox
+  attr_accessor :message, :delivery_info, :arguments
 
-  attribute :message
-  attribute :delivery_info
-  attribute :arguments
+  def initialize(message: nil, delivery_info: nil, arguments: nil)
+    self.message = message
+    self.delivery_info = delivery_info
+    self.arguments = arguments
+  end
 
   def call
     log!