Trying to figure out how to properly `include` an `inherited` hook

inherited.rb

module Hook

  def self.included(base)
    # base.extend ClassMethods
    base.class_eval do

      # def self.inherited(baseclass)
      #   # super
      #   puts "1 #{baseclass.to_s}"
      # end
    end

    class << base
      prepend ClassMethods
    end
  end

  module ClassMethods
    def inherited(baseclass)
      super
      puts "2 #{baseclass.to_s}"
      super
    end
  end
end

class Foo
  include Hook
  def self.inherited(baseclass)
    puts "FOO #{baseclass.to_s}"
  end
end

class Bar
  def self.inherited(baseclass)
    puts "BAR #{baseclass.to_s}"
  end
  include Hook
end

class Guy1 < Foo
end

puts "---"

class Guy2 < Bar
end

use-case.md

I want to make it so that all of our activerecord models treat a database-calculated column/attribute as read-only.

I could use attr_readonly, but the issue with that is that it is only enforced on updates. You can still write the attribute when you create a row.

However, let's say I wanted to go that route. I would do something like this:

module DbTriggers
  module Railties
    module ActiveRecord

      def self.included(base)
        base.class_eval do
          attr_readonly :__auto_created_at
        end
      end
    end
  end
end

::ActiveRecord::Base.send :include, ::DbTriggers::Railties::ActiveRecord

Boom, done. (You can also use extend and self.extended).

Ok, let's say we want to handle the case of creates. Well, one of the ways we can do this is overwrite the writer/setter method for that column __auto_created_at=.

Easy enough, right?

module DbTriggers
  module Railties
    module ActiveRecord
      def __auto_created_at=(val)
        raise ::ActiveRecord::ActiveRecordError, '__auto_modified_at is read-only'
      end
    end
  end
end

::ActiveRecord::Base.send :include, ::DbTriggers::Railties::ActiveRecord

class MyModel < ::ActiveRecord::Base
end

# ActiveRecord::DangerousAttributeError:
# __auto_created_at= is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.

Wha wha whaaaaa?? Well, thank you, ActiveRecord... not really.

So, what happens here is this defines ActiveRecord::Base#__auto_created_at=. Then, when you get around to defining MyModel, Rails goes and inspects the database and creates attribute readers/writers for all the columns on the fly. As it's doing that, it tries to recreate __auto_created_at=. Turns out that ActiveRecord has a hook after method definition on its subclasses to check if you're overwriting a method that's already been defined by ActiveRecord. It does not like that.

So what are we to do? Maybe there are other options here, but one solution is to automatically define __auto_created_at= on our own subclasses.

module DbTriggers
  module Railties
    module ActiveRecord

      def self.included(base)
        class << base
          prepend ClassMethods
        end
      end

      module ClassMethods
        def inherited(base)
          super

          base.class_eval do
            def __auto_created_at=(value)
              raise ::ActiveRecord::ActiveRecordError, '__auto_created_at is read-only'
            end
          end
        end
      end
    end
  end
end

In other words: when this module is included in a base class, make it so that any sub class that inherits from that base class has this method, __auto_created_at= defined as an instance method on that sub class.

So much thanks man.
I use it to inspect the callback chain of my controller.
Not finished yet but it's something that look like :

module DebugControllerCallbackChain
  def self.included(base)
    class << base
      prepend ClassMethods
    end
  end

  module ClassMethods
    def inherited(base)
      super
      base.class_eval do
        _process_action_callbacks.each_with_index do |callback, index|
          define_method(callback.filter) do |*args|
            if index == 0
              Rails.logger.debug("#{request.uuid} : #{request.path} called the action #{controller_name}##{action_name} | ssl?(#{request.ssl?})")
              callback_list = Lms::Admin::ReportingController._process_action_callbacks.map(&:filter).map(&:to_s)
              Rails.logger.debug("#{request.uuid} : The followings callback will be called : #{callback_list.join(', ')}")
              Rails.logger.debug("#{request.uuid} : params => #{params}")
              Rails.logger.debug("#{request.uuid} : session => #{session}")
            end

            Rails.logger.debug("#{request.uuid} : Callback CALLED => #{callback.filter} with options #{callback.options}")
            Rails.logger.debug("#{request.uuid} : Callback FROM => #{method(callback.filter).to_s}")

            super(*args)
          end if callback.kind == :before
        end
      end
    end
  end
end

class ApplicationController < ActionController::Base
  include DebugControllerCallbackChain
end