activesupport-minimizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 057c323c4f9d34ec9172be627d4a8362422d43fcc0ff40a2e6df1bdc46ea85dc
+  data.tar.gz: ce5c57db54cde067e88a7396afe0c38934fb8cc1b322a3835db4a79837a94221
+SHA512:
+  metadata.gz: d89cf16715590c6689131ec5d6f7ffa15226f7a171fcfc736b3d82331abc58d48eb62d1fbb0a5d5a5a7bcd2c6155a4337e868e246786adc5b1f51de2218e099c
+  data.tar.gz: bcc03a8edb2d24e2e996ef3312046a8aa45516b83d1a767a33fbff1d772a866584083fc1df57f2bd43522d4e46215014ab614fb215f275aaedd8953b7e8208f3

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+First release.
+
+- ActiveSupport::Callbacks chains run as one generated method per class and chain (per action for controllers).
+- `source_dir` writes the generated methods out, so backtraces point at real files.
+- Census and check of callbacks naming methods that don't exist.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sampo Kuokkanen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# activesupport-minimizer
+
+Runs `ActiveSupport::Callbacks` chains as generated methods: controller
+`before_action`/`around_action`/`after_action`, model `before_save`,
+`after_commit`, validations, `after_initialize`, Active Job callbacks — any
+class using `define_callbacks`. Part of [rails-minify](../rails-minify).
+
+```ruby
+# config/environments/production.rb
+config.as_minimizer.unroll_callbacks = true
+config.as_minimizer.source_dir = "tmp/rails_minify/callbacks" # optional: write the generated methods out
+```
+
+The first time a chain runs for a class (for controllers: per action), it
+becomes one method:
+
+```ruby
+before_save :normalize
+before_save :check, if: :published?
+
+# Post#save
+halted = false
+value = nil
+if !halted
+  halted = true
+  catch(:abort) do
+    self.normalize
+    halted = false
+  end
+  halted_callback_hook(:normalize, :save) if halted
+end
+if !halted && self.published?
+  ...
+end
+value = !halted && (block_given? ? yield : true)
+...
+```
+
+It follows `run_callbacks`: before callbacks in order with the chain's
+terminator after each (`throw :abort`, `performed?` for controllers, or any
+custom one), around callbacks nesting the rest of the chain (passed as a
+Proc, like ActiveSupport does), after callbacks last-defined first, skipped
+after a halt when the chain says so. Symbols, procs of any arity, objects
+(`before_save(record)`, `validate(record)`, `around(controller)`) and
+`Conditionals::Value` work as filters and conditions. For controllers,
+`only:`/`except:` are decided per action, so other actions' filters are gone;
+with `raise_on_missing_callback_actions` on they are checked at runtime
+instead, as Rails does. A chain that changes gets a new method.
+
+## Debugging
+
+Backtraces name the chain and the line in it:
+
+```
+app/models/user.rb:140:in 'User#generate_username'
+unrolled: User#validation:32:in 'block in User#__as_validation'
+unrolled: User#validation:31:in 'Kernel#catch'
+```
+
+where stock Rails shows `CallTemplate::MethodCall#make_lambda`,
+`Filters::Before#call`, `DefaultTerminator#call`... With `source_dir`, those
+frames point at a real file (`tmp/rails_minify/callbacks/User/validation.rb`),
+so you can open the exact code that ran. `AsMinimizer::Unroller.source_for(User, :save)`
+prints it too.
+
+## Numbers
+
+Ruby 4.0, Rails 8.1, µs per call (`bench/models.rb`, a model with 2
+validations, 2 before_save, 2 after_save, after_initialize):
+
+|                          | stock | unrolled | stock (YJIT) | unrolled (YJIT) |
+|--------------------------|------:|---------:|-------------:|----------------:|
+| `valid?`                 |  13.9 |      9.2 |          5.8 |             3.2 |
+| `Post.new`               |   7.0 |      6.4 |          2.8 |             2.4 |
+| `create!` (SQLite memory)|   182 |      174 |           70 |              65 |
+
+A controller action behind 9 callbacks: 12.6 µs of callback overhead → 4.0 µs
+(6.4 → 2.3 µs with YJIT).
+
+golf-buddy's test suite (4317 runs) gives the same results with it on.

data/lib/activesupport-minimizer.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "as_minimizer"

data/lib/as_minimizer/census.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AsMinimizer
+  # How many callback chains the unroller can run, and why the rest run
+  # through ActiveSupport. Controllers are checked per routed action.
+  module Census
+    Result = Data.define(:unrolled, :fallbacks, :problems) do
+      # fallbacks: { reason => ["PostsController#process_action[show]", ...] }
+      def lines(verbose: false)
+        total = unrolled + fallbacks.values.sum(&:size)
+        out = ["callback chains: #{unrolled}/#{total} unrolled"]
+        fallbacks.sort_by { -it[1].size }.each do |reason, labels|
+          out << "  #{labels.size} through ActiveSupport: #{reason}"
+          labels.first(verbose ? labels.size : 3).each { out << "    #{it}" }
+        end
+        missing = problems.count { it.status == :missing }
+        out << "callback targets: #{missing} missing, #{problems.size - missing} possibly answered by method_missing"
+        problems.each { out << "  #{it}" } if verbose || missing.positive?
+        out
+      end
+    end
+
+    def self.report(classes = Check.callback_classes, routed: nil)
+      unrolled = 0
+      fallbacks = Hash.new { |h, k| h[k] = [] }
+      classes.each do |klass|
+        name = Check.name_of(klass)
+        klass.__callbacks.each do |kind, chain|
+          next if chain.empty?
+
+          actions = kind == :process_action && klass.respond_to?(:action_methods) ? controller_actions(klass, routed) : [nil]
+          actions.each do |action|
+            Unroller::Generator.new(klass, kind, action, chain).source
+            unrolled += 1
+          rescue Unroller::Unsupported => e
+            fallbacks[e.message] << "#{name}##{kind}#{"[#{action}]" if action}"
+          end
+        end
+      end
+      Result.new(unrolled, fallbacks.to_h, Check.callback_targets(classes, routed: routed))
+    end
+
+    def self.controller_actions(klass, routed)
+      return [] if klass.abstract?
+
+      actions = klass.action_methods.to_a
+      actions &= routed[klass.name].to_a if routed&.key?(klass.name)
+      actions.sort
+    end
+  end
+end

data/lib/as_minimizer/check.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module AsMinimizer
+  # Callbacks naming methods that don't exist. Rails registers callbacks by
+  # name and only finds out when the chain runs: a NoMethodError, for a
+  # controller a 500 on every action the filter covers. (Roundhouse's
+  # filter_targets check, for a running app.)
+  module Check
+    Problem = Data.define(:klass, :chain, :kind, :role, :target, :status, :actions) do
+      def to_s
+        where = actions ? " (#{actions.empty? ? "no action" : actions.join(", ")})" : ""
+        verb = status == :missing ? "names no method" : "may be answered by method_missing"
+        "#{Check.name_of(klass)}: #{kind}_#{chain} #{role} #{target.inspect} #{verb}#{where}"
+      end
+    end
+
+    # method_missing implementations whose answers are known: attribute methods.
+    ATTRIBUTE_METHOD_MISSING = %w[ActiveModel::AttributeMethods ActiveRecord::AttributeMethods ArMinimizer::Slim::Record].freeze
+    PLAIN_METHOD_MISSING = %w[BasicObject Kernel].freeze
+
+    # Some classes redefine .name (and raise); Module#name is nil for anonymous ones.
+    def self.name_of(klass)
+      Module.instance_method(:name).bind_call(klass) || (klass.name rescue nil) || klass.inspect
+    rescue StandardError, ScriptError
+      klass.inspect
+    end
+
+    class << self
+      # :present, :missing, or :unknown (the class has its own method_missing).
+      def status(klass, name)
+        return :present if klass.method_defined?(name) || klass.private_method_defined?(name) || klass.protected_method_defined?(name)
+        return :present if attribute_method?(klass, name)
+
+        owner = klass.instance_method(:method_missing).owner.name.to_s
+        if PLAIN_METHOD_MISSING.include?(owner) || ATTRIBUTE_METHOD_MISSING.include?(owner)
+          :missing
+        else
+          :unknown
+        end
+      end
+
+      # Every named class using callbacks, or the ones given. routed:
+      # { "PostsController" => Set["show", ...] } limits controllers to the
+      # actions a request can reach (public helper methods are actions too).
+      def callback_targets(classes = callback_classes, routed: nil)
+        @routed = routed
+        classes.flat_map { problems_in(it) }
+      end
+
+      # From a RouteSet: controller class name => routed action names.
+      def routed_actions(routes)
+        routes.routes.each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |route, map|
+          controller, action = route.defaults.values_at(:controller, :action)
+          map["#{controller.camelize}Controller"] << action.to_s if controller && action
+        end
+      end
+
+      def callback_classes
+        ObjectSpace.each_object(Class).filter_map do |klass|
+          name = Module.instance_method(:name).bind_call(klass) # some classes redefine .name (and raise)
+          [name, klass] if name && klass < ActiveSupport::Callbacks && klass.respond_to?(:__callbacks)
+        rescue StandardError, ScriptError
+          nil
+        end.sort_by(&:first).map(&:last)
+      end
+
+      private
+
+      def problems_in(klass)
+        klass.__callbacks.flat_map do |chain_name, chain|
+          actions = controller_actions(klass, chain_name)
+          next [] if actions&.empty? # abstract controllers: checked through their subclasses
+
+          chain.flat_map do |callback|
+            targets(callback).filter_map do |name, role|
+              status = status(klass, name)
+              next if status == :present
+
+              applies = actions&.select { applies?(callback, it) }
+              next if applies&.empty?
+
+              Problem.new(klass, chain_name, callback.kind, role, name, status, applies)
+            end
+          end
+        end
+      end
+
+      def targets(callback)
+        list = []
+        list << [callback.filter, :filter] if callback.filter.is_a?(Symbol)
+        (callback.instance_variable_get(:@if) + callback.instance_variable_get(:@unless)).each do |c|
+          list << [c, :condition] if c.is_a?(Symbol)
+        end
+        list
+      end
+
+      def controller_actions(klass, chain_name)
+        return unless chain_name == :process_action && klass.respond_to?(:action_methods)
+
+        return [] if klass.abstract?
+
+        actions = klass.action_methods.to_a
+        actions &= @routed[klass.name].to_a if @routed&.key?(klass.name)
+        actions.sort
+      end
+
+      def applies?(callback, action)
+        callback.instance_variable_get(:@if).all? { !action_filter?(it) || listed?(it, action) } &&
+          callback.instance_variable_get(:@unless).none? { action_filter?(it) && listed?(it, action) }
+      end
+
+      def action_filter?(c) = defined?(AbstractController::Callbacks::ActionFilter) && c.is_a?(AbstractController::Callbacks::ActionFilter)
+
+      def listed?(filter, action) = filter.instance_variable_get(:@actions).include?(action)
+
+      # name_changed?, saved_change_to_title?, ... for a real attribute (Slim may not have generated it).
+      def attribute_method?(klass, name)
+        return false unless klass.respond_to?(:attribute_method_patterns) && klass.respond_to?(:attribute_names)
+
+        attributes = klass.attribute_names
+        klass.attribute_method_patterns.any? do |pattern|
+          attr = pattern.respond_to?(:matched_attribute_name) ? pattern.matched_attribute_name(name.to_s) : pattern.match(name.to_s)&.attr_name
+          attr && (attributes.include?(attr) || klass.attribute_alias?(attr))
+        end
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/as_minimizer/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AsMinimizer
+  class Railtie < Rails::Railtie
+    config.as_minimizer = ActiveSupport::OrderedOptions.new
+
+    # config.as_minimizer.unroll_callbacks = true   (e.g. config/environments/production.rb)
+    # config.as_minimizer.source_dir = "tmp/rails_minify/callbacks"  # write the generated methods out
+    initializer "as_minimizer" do |app|
+      options = app.config.as_minimizer
+      next unless options.unroll_callbacks
+
+      AsMinimizer::Unroller.source_dir = app.root.join(options.source_dir) if options.source_dir
+      AsMinimizer::Unroller.install!
+    end
+
+    rake_tasks do
+      namespace :as_minimizer do
+        desc "List callbacks (before_action, before_save, ...) naming methods that don't exist; fails if any"
+        task check: :environment do
+          Rails.application.eager_load!
+          # Routes define methods too (Devise's authenticate_user!); Rails 8 loads them lazily.
+          app = Rails.application
+          app.respond_to?(:reload_routes_unless_loaded) ? app.reload_routes_unless_loaded : app.reload_routes!
+          problems = AsMinimizer::Check.callback_targets(routed: AsMinimizer::Check.routed_actions(app.routes))
+          problems.each { puts "  #{it}" }
+          missing = problems.count { it.status == :missing }
+          puts "as_minimizer: #{missing} missing, #{problems.size - missing} possibly answered by method_missing"
+          abort if missing.positive?
+        end
+      end
+    end
+  end
+end

data/lib/as_minimizer/unroller.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module AsMinimizer
+  # Runs a class's callback chain (controller actions, model save/create/
+  # update/destroy/commit, validations, jobs: anything on ActiveSupport::Callbacks)
+  # as one generated method, built the first time the chain runs:
+  #
+  #   before_save :normalize
+  #   before_save :check, if: :published?
+  #   after_save :notify
+  #
+  #   # Post#save then runs (abbreviated)
+  #   def __as_save
+  #     halted = false
+  #     value = nil
+  #     if !halted
+  #       halted = true
+  #       catch(:abort) do
+  #         self.normalize
+  #         halted = false
+  #       end
+  #       halted_callback_hook(:normalize, :save) if halted
+  #     end
+  #     ...
+  #     value = !halted && (block_given? ? yield : true)
+  #     if !halted && ::AsMinimizer::Unroller::OBJECTS[3].call(self, value)
+  #       self.notify
+  #     end
+  #     value
+  #   end
+  #
+  # It follows ActiveSupport::Callbacks#run_callbacks: before callbacks in
+  # order, the chain's terminator after each (performed? for controllers,
+  # throw :abort for the rest, or any custom terminator), around callbacks
+  # nesting the rest of the chain, after callbacks last-defined first and
+  # skipped after a halt when the chain says so. For controllers, `only:` and
+  # `except:` are decided per action when the method is generated.
+  #
+  # The generated code is named in backtraces ("unrolled: Post#save"), and with
+  # source_dir set, written to a file there, so backtraces point at code you can open.
+  module Unroller
+    # Filters and conditions that aren't symbols are referenced from here.
+    OBJECTS = []
+    MUTEX = Mutex.new
+    Unsupported = Class.new(StandardError)
+
+    class << self
+      attr_accessor :source_dir
+
+      def install!
+        @enabled = true
+        ActiveSupport::Callbacks.prepend(Hook) unless ActiveSupport::Callbacks < Hook
+      end
+
+      def disable! = @enabled = false
+
+      def enabled? = @enabled == true
+
+      # The generated method's name, or nil to let ActiveSupport run the chain.
+      def method_for(target, kind)
+        klass = target.class
+        chain = target.__callbacks[kind]
+        action = target.action_name if kind == :process_action && target.respond_to?(:action_name)
+        cache = klass.instance_variable_get(:@__as_unrolled) ||
+          MUTEX.synchronize { klass.instance_variable_get(:@__as_unrolled) || klass.instance_variable_set(:@__as_unrolled, {}) }
+        hit = (per_kind = cache[kind]) && per_kind[action]
+        return hit[1] if hit && hit[0].equal?(chain)
+
+        MUTEX.synchronize do
+          per_kind = (cache[kind] ||= {})
+          hit = per_kind[action]
+          return hit[1] if hit && hit[0].equal?(chain)
+
+          name = generate(klass, kind, action, chain)
+          per_kind[action] = [chain, name]
+          name
+        end
+      end
+
+      def source_for(klass, kind, action = nil) = Generator.new(klass, kind, action, klass.__callbacks[kind]).source
+
+      private
+
+      def generate(klass, kind, action, chain)
+        generator = Generator.new(klass, kind, action, chain)
+        body = generator.source
+        warn_missing(klass, kind, action, generator.targets)
+        name = :"__as_#{kind}#{"_#{action.unpack1("H*")}" if action}"
+        label = "#{klass.name || "anonymous"}##{kind}#{"[#{action}]" if action}"
+        code = "# #{label} callbacks, unrolled by activesupport-minimizer\ndef #{name}\n#{body}\nend\n"
+        klass.class_eval(code, file_for(klass, kind, action, label, code), 1)
+        klass.send(:private, name)
+        name
+      rescue Unsupported
+        nil
+      end
+
+      # Rails finds out when the chain runs (NoMethodError, a 500 for a
+      # controller); say so when the method is generated, once per target.
+      def warn_missing(klass, kind, action, targets)
+        targets.each do |name, role, callback_kind|
+          next unless Check.status(klass, name) == :missing
+
+          @warned ||= {}
+          next if @warned[[klass, kind, name]]
+
+          @warned[[klass, kind, name]] = true
+          AsMinimizer.warn("activesupport-minimizer: #{klass.name || klass}'s #{callback_kind}_#{kind} #{role} #{name.inspect} " \
+            "names no method#{" (action #{action})" if action}; running the chain will raise NoMethodError")
+        end
+      end
+
+      def file_for(klass, kind, action, label, code)
+        return "unrolled: #{label}" unless source_dir
+
+        path = File.join(source_dir.to_s, (klass.name || "anonymous_#{klass.object_id}").gsub("::", "/"),
+          "#{kind}#{"_#{action}" if action}.rb")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, code)
+        path
+      end
+    end
+
+    module Hook
+      def run_callbacks(kind, type = nil, &block)
+        if type.nil? && Unroller.enabled? && (name = Unroller.method_for(self, kind))
+          __send__(name, &block)
+        else
+          super
+        end
+      end
+    end
+
+    class Generator
+      Level = Struct.new(:befores, :afters, :around, :nested)
+
+      # Symbols the generated code calls (filters and conditions that apply).
+      attr_reader :targets
+
+      def initialize(klass, kind, action, chain)
+        @klass = klass
+        @kind = kind
+        @action = action
+        @chain = chain
+        @config = chain.config
+        @lambdas = 0
+        @targets = []
+      end
+
+      def source
+        terminator!
+        "halted = false\nvalue = nil\n#{level(levels)}value"
+      end
+
+      private
+
+      def terminator!
+        terminator = @config[:terminator]
+        @terminator =
+          if terminator.equal?(ActiveSupport::Callbacks::CallbackChain.const_get(:DEFAULT_TERMINATOR))
+            :abort
+          elsif terminator.is_a?(Proc) && terminator.source_location&.first&.end_with?("abstract_controller/callbacks.rb")
+            :performed
+          else
+            object(terminator)
+          end
+        @skip_after = @config[:skip_after_callbacks_if_terminated]
+        # With raise_on_missing_callback_actions, only:/except: check the action list at runtime.
+        @static_actions = @action && !(@klass.respond_to?(:raise_on_missing_callback_actions) && @klass.raise_on_missing_callback_actions)
+      end
+
+      # What CallbackChain#compile builds: each around opens a nested level;
+      # befores keep definition order, afters run last-defined first.
+      def levels
+        current = Level.new([], [], nil, nil)
+        @chain.to_a.reverse_each do |callback|
+          case callback.kind
+          when :before then current.befores.unshift(callback)
+          when :after then current.afters.push(callback)
+          when :around then current = Level.new([], [], callback, current)
+          end
+        end
+        current
+      end
+
+      def level(lvl)
+        code = +""
+        lvl.befores.each { code << before(it) }
+        if lvl.around
+          code << around(lvl.around, level(lvl.nested))
+        else
+          code << "value = !halted && (block_given? ? yield : true)\n"
+        end
+        lvl.afters.each { code << after(it) }
+        code
+      end
+
+      def before(callback)
+        cond = conditions(callback) or return ""
+        call = call(callback, callback.filter)
+        check = if cond == "true" then "!halted" else "!halted && #{cond}" end
+        hook = "halted_callback_hook(#{literal(callback.filter)}, #{callback.name.inspect})"
+        case @terminator
+        when :performed
+          "if #{check}\n  #{call}\n  if performed?\n    halted = true\n    #{hook}\n  end\nend\n"
+        when :abort
+          "if #{check}\n  halted = true\n  catch(:abort) do\n    #{call}\n    halted = false\n  end\n  #{hook} if halted\nend\n"
+        else
+          "if #{check}\n  if #{@terminator}.call(self, -> { #{call} })\n    halted = true\n    #{hook}\n  end\nend\n"
+        end
+      end
+
+      def after(callback)
+        cond = conditions(callback) or return ""
+        check = [("!halted" if @skip_after), (cond unless cond == "true")].compact
+        call = call(callback, callback.filter)
+        check.empty? ? "#{call}\n" : "if #{check.join(" && ")}\n  #{call}\nend\n"
+      end
+
+      # The rest of the chain goes in a proc: the around callback gets it as
+      # its block, and it runs directly when the around is skipped.
+      def around(callback, inner)
+        cond = conditions(callback)
+        inner_name = "inner#{@lambdas += 1}"
+        code = "#{inner_name} = proc do\n#{inner}end\n" # a Proc, as ActiveSupport passes: extra arguments are ignored
+        return code << "#{inner_name}.()\n" unless cond
+
+        skip = cond == "true" ? "halted" : "halted || !(#{cond})"
+        code << "if #{skip}\n  #{inner_name}.()\nelse\n  #{call(callback, callback.filter, inner_name)}\nend\n"
+      end
+
+      # Ruby for the callback's :if/:unless, "true" when there are none, nil
+      # when it never runs (an `only:`/`except:` that rules out this action).
+      def conditions(callback)
+        parts = []
+        callback.instance_variable_get(:@if).each do |c|
+          if static_action_filter?(c)
+            return nil unless action_listed?(c)
+          else
+            parts << condition(callback, c)
+          end
+        end
+        callback.instance_variable_get(:@unless).each do |c|
+          if static_action_filter?(c)
+            return nil if action_listed?(c)
+          else
+            parts << "!(#{condition(callback, c)})"
+          end
+        end
+        parts.empty? ? "true" : parts.join(" && ")
+      end
+
+      def static_action_filter?(c)
+        @static_actions && defined?(AbstractController::Callbacks::ActionFilter) && c.is_a?(AbstractController::Callbacks::ActionFilter)
+      end
+
+      def action_listed?(filter) = filter.instance_variable_get(:@actions).include?(@action)
+
+      # As CallTemplate.build + make_lambda.
+      def condition(callback, c)
+        case c
+        when Symbol then (@targets << [c, :condition, callback.kind]; "self.#{method_call(c)}")
+        when ActiveSupport::Callbacks::Conditionals::Value then "#{object(c)}.call(self, value)"
+        when Proc
+          raise Unsupported, "a condition proc with 2 parameters" if c.arity == 2 # needs a block, which conditions never get: ActiveSupport raises
+          [1, -2].include?(c.arity) ? "instance_exec(self, &#{object(c)})" : "instance_exec(&#{object(c)})"
+        else "#{object(c)}.#{scope_method(callback)}(self)"
+        end
+      end
+
+      def call(callback, filter, block = nil)
+        case filter
+        when Symbol then (@targets << [filter, :filter, callback.kind]; "self.#{method_call(filter)}#{"(&#{block})" if block}")
+        when Proc
+          case filter.arity
+          when 2
+            raise Unsupported, "a before/after proc with 2 parameters" unless block # ActiveSupport raises ArgumentError here
+            "instance_exec(self, #{block}, &#{object(filter)})"
+          when 1, -2 then "instance_exec(self, &#{object(filter)})"
+          else "instance_exec(&#{object(filter)})"
+          end
+        else "#{object(filter)}.#{scope_method(callback)}(#{["self", ("&#{block}" if block)].compact.join(", ")})"
+        end
+      end
+
+      # The method an object filter answers to: before_save, validate, around, ...
+      def scope_method(callback)
+        name = Array(@config[:scope]).map { callback.public_send(it) }.join("_")
+        method_call(name)
+      end
+
+      def method_call(name)
+        raise Unsupported, "method name #{name.inspect} isn't an identifier" unless name.to_s.match?(/\A[a-zA-Z_]\w*[?!]?\z/)
+
+        name.to_s
+      end
+
+      def literal(filter) = filter.is_a?(Symbol) ? filter.inspect : object(filter)
+
+      def object(obj)
+        index = OBJECTS.index { it.equal?(obj) } || (OBJECTS << obj).size - 1
+        "::AsMinimizer::Unroller::OBJECTS[#{index}]"
+      end
+    end
+  end
+end

data/lib/as_minimizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AsMinimizer
+  VERSION = "0.1.0"
+end

data/lib/as_minimizer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/callbacks"
+require "as_minimizer/version"
+
+module AsMinimizer
+  autoload :Unroller, "as_minimizer/unroller"
+  autoload :Check, "as_minimizer/check"
+  autoload :Census, "as_minimizer/census"
+
+  def self.warn(message)
+    logger = defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+    logger ? logger.warn(message) : Kernel.warn(message)
+  end
+end
+
+require "as_minimizer/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: activesupport-minimizer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sampo Kuokkanen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.3'
+description: Runs ActiveSupport::Callbacks chains (controller filters, model and validation
+  callbacks, Active Job callbacks) as one generated method per chain instead of the
+  filter and lambda objects Rails walks on every run.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/activesupport-minimizer.rb
+- lib/as_minimizer.rb
+- lib/as_minimizer/census.rb
+- lib/as_minimizer/check.rb
+- lib/as_minimizer/railtie.rb
+- lib/as_minimizer/unroller.rb
+- lib/as_minimizer/version.rb
+homepage: https://github.com/sampokuokkanen/rails-minify/tree/main/activesupport-minimizer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sampokuokkanen/rails-minify/tree/main/activesupport-minimizer
+  changelog_uri: https://github.com/sampokuokkanen/rails-minify/blob/main/activesupport-minimizer/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sampokuokkanen/rails-minify/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Run ActiveSupport callback chains (controllers, models, validations, jobs)
+  as generated methods
+test_files: []