activesupport-minimizer 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b015df981e76956005ec4dbec6f10808c1fe61a2be2d17395be4bc622ae0541d
-  data.tar.gz: c569ebbecfa90d6b135966578016eb725e9b705e8bb3896443a87fa096c9c340
+  metadata.gz: 8bb3bd538359f52f42e0b8e2f591c3ea3b4b3cabf2740ce4ce5d51fbd810817c
+  data.tar.gz: 598f2c2e3897cef1e12d3bcdcd02d95a760ac695c202084c08a83dae1346a4b1
 SHA512:
-  metadata.gz: a65151b39365a9eaeefb4bf743edfd103e20f0c9e3cdb9efb38384ed61a4b6f771263df98a8c15e766d00072686fd25fea6abf7187f62b70bce6ec42db751112
-  data.tar.gz: c9f8740139908120958cec43192c1b241cdb7df945aa2bf01851dc0c05060bd67e1ff8f8b32170c56fcabbe8f5e3b872f01bcbe1c07fe402f00df6acb9de35a3
+  metadata.gz: f183c2881281f4687a85312464e95e954383507e4d7bc1d3fe2cd4263b99c977a827b3e16b9b7059621ffede37536f357e84858d2c7a5aeb1467b2710c5b41d4
+  data.tar.gz: a0b386f48da881a5df8a74afdcaa7491afb12f0e16cffbb5ee143d10193ab0e64a033f6d9fe6f12cc4d864a5da71a054c77bd4607384382792c0f6d262885991

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.2 (2026-10-18)
+
+- Rails main: the controller terminator (now `AbstractController::Callbacks::TERMINATOR`, a lambda in 8.1) is recognized again, so a before_action is a plain call followed by `performed?` instead of a lambda passed to the terminator: one block less per callback to compile, one allocation less per call.
+- The part of a chain an around callback wraps is a method of its own, which the around gets as a one-line block, instead of a proc holding the rest of the chain: no callbacks in blocks nested in blocks, and no proc allocated per around per run.
+
 ## 0.1.1 (2026-10-18)
 
 - Unrolled callbacks: one method per class and chain instead of one per controller action (`only:`/`except:` become a Set lookup), and classes whose chains are the same share one method body. Fewer methods for the JIT to compile.

data/lib/as_minimizer/unroller.rb

@@ -38,6 +38,11 @@ module AsMinimizer
   # skipped after a halt when the chain says so. For controllers, `only:` and
   # `except:` are a lookup of action_name in the filter's action set.
   #
+  # The part of the chain an around callback wraps is a method of its own
+  # (__as_save_1, ...), which the around gets as a one-line block: the
+  # callbacks run in plain methods rather than blocks nested in blocks, and
+  # nothing is allocated for an around callback that only yields.
+  #
   # One method per class and chain (not per controller action), and one body
   # per distinct chain: classes whose chains come out the same (subclasses of
   # a controller that add no callbacks of their own, ...) get the same method
@@ -48,6 +53,8 @@ module AsMinimizer
   module Unroller
     # Filters and conditions that aren't symbols are referenced from here.
     OBJECTS = []
+    # What a nested level returns when the chain halted in it.
+    HALTED = Object.new.freeze
     # [kind, body] => a module holding the generated method; classes with the
     # same chain define theirs from its UnboundMethod, sharing the body.
     SHARED = {}
@@ -99,16 +106,16 @@ module AsMinimizer
         generator = Generator.new(klass, kind, chain)
         body = generator.source
         warn_missing(klass, kind, generator.targets)
-        name = :"__as_#{kind}"
         shared = SHARED[[kind, body]] ||= begin
           label = "#{klass.name || "anonymous"}##{kind}"
-          code = "# #{label} callbacks (and every class whose chain is the same), unrolled by activesupport-minimizer\n" \
-                 "def #{name}\n#{body}\nend\n"
+          code = "# #{label} callbacks (and every class whose chain is the same), unrolled by activesupport-minimizer\n#{body}"
           Module.new.tap { it.module_eval(code, file_for(klass, kind, label, code), 1) }
         end
-        klass.send(:define_method, name, shared.instance_method(name))
-        klass.send(:private, name)
-        name
+        shared.instance_methods(false).each do |name|
+          klass.send(:define_method, name, shared.instance_method(name))
+          klass.send(:private, name)
+        end
+        :"__as_#{kind}"
       rescue Unsupported
         nil
       end
@@ -159,13 +166,15 @@ module AsMinimizer
         @kind = kind
         @chain = chain
         @config = chain.config
-        @lambdas = 0
         @targets = []
       end
 
+      # The method definitions: __as_<kind>, and one more per around callback.
       def source
         terminator!
-        "halted = false\nvalue = nil\n#{level(levels)}value"
+        @methods = []
+        @methods << "def __as_#{@kind}(&)\nhalted = false\nvalue = nil\n#{level(levels)}value\nend\n"
+        @methods.join
       end
 
       private
@@ -175,7 +184,7 @@ module AsMinimizer
         @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")
+          elsif performed_terminator?(terminator)
             :performed
           else
             object(terminator)
@@ -186,6 +195,15 @@ module AsMinimizer
         @inline_actions = !(@klass.respond_to?(:raise_on_missing_callback_actions) && @klass.raise_on_missing_callback_actions)
       end
 
+      # Rails 8.1's controller terminator is a lambda; main's is TERMINATOR.
+      def performed_terminator?(terminator)
+        if terminator.is_a?(Proc)
+          terminator.source_location&.first&.end_with?("abstract_controller/callbacks.rb")
+        else
+          defined?(AbstractController::Callbacks::TERMINATOR) && terminator.equal?(AbstractController::Callbacks::TERMINATOR)
+        end
+      end
+
       # What CallbackChain#compile builds: each around opens a nested level;
       # befores keep definition order, afters run last-defined first.
       def levels
@@ -234,16 +252,22 @@ module AsMinimizer
         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.
+      # The rest of the chain is a method of its own: the around callback gets
+      # a block calling it, and it's called directly when the around is
+      # skipped. It returns the chain's value, or HALTED.
       def around(callback, inner)
+        name = "__as_#{@kind}_#{@methods.size}"
+        @methods << "def #{name}(halted, &)\nvalue = nil\n#{inner}halted ? ::AsMinimizer::Unroller::HALTED : value\nend\n"
         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"
+        direct = "inner = #{name}(halted, &)\n"
+        code =
+          if cond
+            skip = cond == "true" ? "halted" : "halted || !(#{cond})"
+            "inner = nil\nif #{skip}\n  #{direct.chomp}\nelse\n  #{call(callback, callback.filter, "{ inner = #{name}(halted, &) }")}\nend\n"
+          else
+            direct
+          end
+        code << "if ::AsMinimizer::Unroller::HALTED.equal?(inner)\n  halted = true\n  value = false\nelse\n  value = inner\nend\n"
       end
 
       # Ruby for the callback's :if/:unless, "true" when there are none, nil
@@ -288,18 +312,19 @@ module AsMinimizer
         end
       end
 
+      # block: a block literal ("{ ... }") an around callback runs the rest of the chain with.
       def call(callback, filter, block = nil)
         case filter
-        when Symbol then (@targets << [filter, :filter, callback.kind]; "self.#{method_call(filter)}#{"(&#{block})" if block}")
+        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)})"
+            "instance_exec(self, proc #{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(", ")})"
+        else "#{object(filter)}.#{scope_method(callback)}(self)#{" #{block}" if block}"
         end
       end
 

data/lib/as_minimizer/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-minimizer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Sampo Kuokkanen