acidic_job 0.8.5 → 1.0.0.beta.1

data/lib/acidic_job/configured_job.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/configured_job"
-
-module AcidicJob
-  class ConfiguredJob < ::ActiveJob::ConfiguredJob
-    def perform_acidicly(...)
-      @job_class.new(...).set(@options).perform_acidicly
-    end
-  end
-end

data/lib/acidic_job/extensions/action_mailer.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-module AcidicJob
-  module Extensions
-    module ActionMailer
-      extend ActiveSupport::Concern
-
-      def deliver_acidicly(_options = {})
-        job_class = ::ActionMailer::MailDeliveryJob
-        job_args = [@mailer_class.name, @action.to_s, "deliver_now", @params, *@args]
-        job = job_class.new(job_args)
-
-        AcidicJob::Run.stage!(job)
-      end
-    end
-  end
-end

data/lib/acidic_job/extensions/noticed.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module AcidicJob
-  module Extensions
-    module Noticed
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def deliver_acidicly(recipients)
-          new.deliver_acidicly(recipients)
-        end
-      end
-
-      # THIS IS A HACK THAT COPIES AND PASTES KEY PARTS OF THE `Noticed::Base` CODE
-      # IN ORDER TO ALLOW US TO TRANSACTIONALLY DELIVER NOTIFICATIONS
-      # THIS IS THUS LIABLE TO BREAK WHENEVER THAT GEM IS UPDATED
-      def deliver_acidicly(recipients)
-        delivery_methods = self.class.delivery_methods.dup
-
-        Array.wrap(recipients).uniq.each do |recipient|
-          if (index = delivery_methods.find_index { |m| m[:name] == :database })
-            database_delivery_method = delivery_methods.delete_at(index)
-            self.record = run_delivery_method(database_delivery_method,
-                                              recipient: recipient,
-                                              enqueue: false,
-                                              record: nil)
-          end
-
-          delivery_methods.map do |delivery_method|
-            job_class = delivery_method_for(delivery_method[:name], delivery_method[:options])
-            args = {
-              notification_class: self.class.name,
-              options: delivery_method[:options],
-              params: params,
-              recipient: recipient,
-              record: record
-            }
-            job = job_class.new(args)
-
-            AcidicJob::Run.stage!(job)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/acidic_job/perform_acidicly.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-module AcidicJob
-  module PerformAcidicly
-    extend ActiveSupport::Concern
-
-    # `perform_now` runs a job synchronously and immediately
-    # `perform_later` runs a job asynchronously and queues it immediately
-    # `perform_acidicly` run a job asynchronously and queues it after a successful database commit
-
-    class_methods do
-      def perform_acidicly(...)
-        job_or_instantiate(...).perform_acidicly
-      end
-    end
-
-    def perform_acidicly
-      Run.stage!(self)
-    end
-  end
-end

data/lib/acidic_job/rails.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/railtie"
-
-module AcidicJob
-  class Rails < ::Rails::Railtie
-    initializer "acidic_job.action_mailer_extension" do
-      ::ActiveSupport.on_load(:action_mailer) do
-        # Add `deliver_acidicly` to ActionMailer
-        ::ActionMailer::Parameterized::MessageDelivery.include(Extensions::ActionMailer)
-        ::ActionMailer::MessageDelivery.include(Extensions::ActionMailer)
-      end
-    end
-
-    initializer "acidic_job.active_job_serializers" do
-      ::ActiveSupport.on_load(:active_job) do
-        ::ActiveJob::Serializers.add_serializers(
-          Serializers::ExceptionSerializer,
-          Serializers::FinishedPointSerializer,
-          Serializers::JobSerializer,
-          Serializers::RangeSerializer,
-          Serializers::RecoveryPointSerializer,
-          Serializers::WorkerSerializer,
-          Serializers::ActiveKiqSerializer
-        )
-      end
-    end
-
-    # :nocov:
-    generators do
-      require "generators/acidic_job/install_generator"
-    end
-    # :nocov:
-
-    # This hook happens after all initializers are run, just before returning
-    config.after_initialize do
-      if defined?(::Noticed)
-        # Add `deliver_acidicly` to Noticed
-        ::Noticed::Base.include(Extensions::Noticed)
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/active_kiq_serializer.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-module AcidicJob
-  module Serializers
-    class ActiveKiqSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(worker)
-        super(
-          "job_class" => worker.class.name,
-          "arguments" => Arguments.serialize(worker.arguments),
-        )
-      end
-
-      def deserialize(hash)
-        worker_class = hash["job_class"].constantize
-        worker_class.new(*hash["arguments"])
-      end
-
-      def serialize?(argument)
-        defined?(::AcidicJob::ActiveKiq) && argument.class < ::AcidicJob::ActiveKiq
-      end
-    end
-  end
-end

data/lib/acidic_job/test_case.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./testing"
-
-module AcidicJob
-  class TestCase < ::ActiveJob::TestCase
-    include ::AcidicJob::Testing
-  end
-end

data/lib/acidic_job/testing.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "database_cleaner"
-
-module AcidicJob
-  module Testing
-    def self.included(mod)
-      mod.class_eval "self.use_transactional_tests = false if respond_to?(:use_transactional_tests)", __FILE__, __LINE__
-    end
-
-    def before_setup
-      @connection = ::ActiveRecord::Base.connection
-      @original_cleaners = ::DatabaseCleaner.cleaners
-      ::DatabaseCleaner.cleaners = transaction_free_cleaners_for(@original_cleaners)
-      super
-      ::DatabaseCleaner.start
-    end
-
-    def after_teardown
-      ::DatabaseCleaner.clean
-      super
-      ::DatabaseCleaner.cleaners = @original_cleaners
-    end
-
-    private
-
-    # Ensure that the system's original DatabaseCleaner configuration is maintained, options included,
-    # except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy.
-    def transaction_free_cleaners_for(original_cleaners)
-      non_transaction_cleaners = original_cleaners.dup.to_h do |(orm, opts), cleaner|
-        [[orm, opts], ensure_no_transaction_strategies_for(cleaner)]
-      end
-      ::DatabaseCleaner::Cleaners.new(non_transaction_cleaners)
-    end
-
-    def ensure_no_transaction_strategies_for(cleaner)
-      return cleaner unless strategy_name_for(cleaner) == "transaction"
-
-      cleaner.strategy = deletion_strategy_for(cleaner)
-      cleaner
-    end
-
-    def strategy_name_for(cleaner)
-      cleaner               # <DatabaseCleaner::Cleaner>
-        .strategy           # <DatabaseCleaner::ActiveRecord::Truncation>
-        .class              # DatabaseCleaner::ActiveRecord::Truncation
-        .name               # "DatabaseCleaner::ActiveRecord::Truncation"
-        .rpartition("::")   # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-        .last               # "Truncation"
-        .downcase           # "truncation"
-    end
-
-    def deletion_strategy_for(cleaner)
-      strategy = cleaner.strategy
-      strategy_namespace = strategy                    # <DatabaseCleaner::ActiveRecord::Truncation>
-                           .class                      # DatabaseCleaner::ActiveRecord::Truncation
-                           .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
-                           .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-                           .first                      # "DatabaseCleaner::ActiveRecord"
-      deletion_strategy_class_name = [strategy_namespace, "::", "Deletion"].join
-      deletion_strategy_class = deletion_strategy_class_name.constantize
-      instance_variable_hash = strategy.instance_variables.to_h do |var|
-        [
-          var.to_s.remove("@"),
-          strategy.instance_variable_get(var)
-        ]
-      end
-      options = instance_variable_hash.except("db", "connection_class")
-
-      deletion_strategy_class.new(**options)
-    end
-  end
-end