ActiveRecord::AssociatedObject

# app/models/post.rb
class Post < ActiveRecord::Base
  # `has_object` defines a `publisher` method that calls Post::Publisher.new(post).
  has_object :publisher
end

# app/models/post/publisher.rb
class Post::Publisher
  def initialize(post)
    @post = post
  end
end

# app/models/post/publisher.rb
class Post::Publisher < ActiveRecord::AssociatedObject
  # ActiveRecord::AssociatedObject defines initialize(post) automatically. It's derived from the `Post::` namespace.

  kredis_datetime :publish_at # Kredis integration generates a "post:publishers:<post_id>:publish_at" key.

  # `performs` builds a `Post::Publisher::PublishJob` and routes configs over to it.
  performs :publish, queue_as: :important, discard_on: SomeError do
    retry_on TimeoutError, wait: :exponentially_longer
  end

  def publish
    # `transaction` is syntactic sugar for `post.transaction` here.
    transaction do
      # A `post` method is generated to access the associated post. There's also a `record` alias available.
      post.update! published: true
      post.subscribers.post_published post
    end
  end
end

# app/models/post/comment.rb
class Post::Comment < ApplicationRecord
  belongs_to :post

  has_object :rating
end

# app/models/post/comment/rating.rb
class Post::Comment::Rating < ActiveRecord::AssociatedObject
  def great?
    # A `comment` method is generated to access the associated comment. There's also a `record` alias available.
    comment.author.subscriber_of? comment.post.author
  end
end

gem "active_job-performs"
gem "active_record-associated_object"

class Post::Publisher < ActiveRecord::AssociatedObject
  performs queue_as: :important
  performs :publish
  performs :retract

  def publish
  end

  def retract(reason:)
  end
end

class Post::Publisher < ActiveRecord::AssociatedObject
  # `performs` without a method defines a general job to share between method jobs.
  class Job < ApplicationJob
    queue_as :important
  end

  # Individual method jobs inherit from the `Post::Publisher::Job` defined above.
  class PublishJob < Job
    def perform(publisher, *arguments, **options)
      # GlobalID integration means associated objects can be passed into jobs like Active Records, i.e. we don't have to do `post.publisher`.
      publisher.publish(*arguments, **options)
    end
  end

  class RetractJob < Job
    def perform(publisher, *arguments, **options)
      publisher.retract(*arguments, **options)
    end
  end

  def publish_later(*arguments, **options)
    PublishJob.perform_later(self, *arguments, **options)
  end

  def retract_later(*arguments, **options)
    RetractJob.perform_later(self, *arguments, **options)
  end
end

class Post < ActiveRecord::Base
  # Callbacks can be passed too to a specific method.
  has_object :publisher, after_touch: true, before_destroy: :prevent_errant_post_destroy

  # The above is the same as writing:
  after_touch { publisher.after_touch }
  before_destroy { publisher.prevent_errant_post_destroy }
end

class Post::Publisher < ActiveRecord::AssociatedObject
  def after_touch
    # Respond to the after_touch on the Post.
  end

  def prevent_errant_post_destroy
    # Passed callbacks can throw :abort too, and in this example prevent post.destroy.
    throw :abort if haha_business?
  end
end