activesupport-minimizer 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 057c323c4f9d34ec9172be627d4a8362422d43fcc0ff40a2e6df1bdc46ea85dc
-  data.tar.gz: ce5c57db54cde067e88a7396afe0c38934fb8cc1b322a3835db4a79837a94221
+  metadata.gz: 8bb3bd538359f52f42e0b8e2f591c3ea3b4b3cabf2740ce4ce5d51fbd810817c
+  data.tar.gz: 598f2c2e3897cef1e12d3bcdcd02d95a760ac695c202084c08a83dae1346a4b1
 SHA512:
-  metadata.gz: d89cf16715590c6689131ec5d6f7ffa15226f7a171fcfc736b3d82331abc58d48eb62d1fbb0a5d5a5a7bcd2c6155a4337e868e246786adc5b1f51de2218e099c
-  data.tar.gz: bcc03a8edb2d24e2e996ef3312046a8aa45516b83d1a767a33fbff1d772a866584083fc1df57f2bd43522d4e46215014ab614fb215f275aaedd8953b7e8208f3
+  metadata.gz: f183c2881281f4687a85312464e95e954383507e4d7bc1d3fe2cd4263b99c977a827b3e16b9b7059621ffede37536f357e84858d2c7a5aeb1467b2710c5b41d4
+  data.tar.gz: a0b386f48da881a5df8a74afdcaa7491afb12f0e16cffbb5ee143d10193ab0e64a033f6d9fe6f12cc4d864a5da71a054c77bd4607384382792c0f6d262885991

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.
+- `Check.long_chains`: chains with more than a limit (default 5) of the app's own callbacks. Callbacks inherited from excluded classes (default `ApplicationController`) don't count; a base class over the limit is reported once, with the classes that inherit it.
+- `Check.callback_loops`: model callbacks that call `save`, `update`, `touch`, ... on their own record, which runs the callbacks again (found with Prism), with the guard if there is one.
+- Census counts per class, not per action.
+
 ## 0.1.0 (2026-10-18)
 
 First release.

data/README.md

@@ -77,4 +77,4 @@ validations, 2 before_save, 2 after_save, after_initialize):
 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.
+[Japan Voyage](https://japanvoyage.jp)'s test suite (4317 runs) gives the same results with it on.

data/lib/as_minimizer/census.rb

@@ -28,12 +28,14 @@ module AsMinimizer
         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
+          # Controllers no route reaches (abstract ones included) never run their chain.
+          next if kind == :process_action && klass.respond_to?(:action_methods) && controller_actions(klass, routed).empty?
+
+          begin
+            Unroller::Generator.new(klass, kind, chain).source
             unrolled += 1
           rescue Unroller::Unsupported => e
-            fallbacks[e.message] << "#{name}##{kind}#{"[#{action}]" if action}"
+            fallbacks[e.message] << "#{name}##{kind}"
           end
         end
       end

data/lib/as_minimizer/check.rb

@@ -14,6 +14,33 @@ module AsMinimizer
       end
     end
 
+    # A chain with more of the app's own callbacks than the limit.
+    LongChain = Data.define(:klass, :chain, :callbacks, :limit, :action, :also) do
+      def to_s
+        where = action ? " (#{action})" : ""
+        others = also.empty? ? "" : " (inherited by #{also.size}: #{also.first(3).map { Check.name_of(it) }.join(", ")}#{", ..." if also.size > 3})"
+        "#{Check.name_of(klass)}#{others}: #{chain} chain has #{callbacks.size} callbacks#{where}, more than #{limit}\n" +
+          callbacks.map { "    #{it}" }.join("\n")
+      end
+    end
+
+    # A model callback that saves (updates, touches, ...) the record it runs
+    # for: that runs the chain again, so it repeats until something stops it.
+    Loop = Data.define(:klass, :chain, :callback, :call, :location, :guard) do
+      def to_s
+        "#{Check.name_of(klass)}: #{callback} calls #{call} on the record itself (#{location}), " \
+          "which runs the #{chain} callbacks again#{"; guarded by #{guard}, check it can't stay true" if guard}"
+      end
+    end
+
+    # Chains whose callbacks are validations, not callbacks.
+    SKIP_CHAINS = %i[validate].freeze
+    # Model chains a save, update or touch of the same record runs again.
+    REENTERED_CHAINS = %i[validation save create update commit touch].freeze
+    # Calls on the record itself that run its callbacks (update_column(s) and
+    # update_all don't).
+    SELF_SAVES = %i[save save! update update! update_attribute update_attributes update_attributes! touch increment! decrement! toggle!].freeze
+
     # 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
@@ -55,6 +82,67 @@ module AsMinimizer
         end
       end
 
+      # Chains with more than +limit+ of the app's own callbacks (defined under
+      # +root+, not in gems). Controllers: their action with the most.
+      # Callbacks a subclass inherits from an +exclude+d class (the
+      # ApplicationController default: time zone, locale, current user, ...,
+      # the per-request basics) don't count. A class over the limit is reported
+      # once, with how many classes inherit its chain; those aren't repeated.
+      def long_chains(classes = callback_classes, limit: 5, root:, routed: nil, exclude: ["ApplicationController"])
+        @routed = routed
+        excluded = exclude.filter_map { Object.const_get(it) if Object.const_defined?(it) }
+        reported = {} # [class, chain] => LongChain
+        classes.sort_by { it.ancestors.size }.each do |klass|
+          next if excluded.include?(klass)
+
+          klass.__callbacks.each do |chain_name, chain|
+            next if SKIP_CHAINS.include?(chain_name)
+            next if chain.none?
+
+            # Already over the limit in a superclass: covered by that report.
+            parent = klass.ancestors.drop(1).find { reported.key?([it, chain_name]) }
+            if parent
+              reported[[parent, chain_name]].also << klass
+              next
+            end
+
+            inherited = excluded.select { klass < it && it.respond_to?(:__callbacks) }
+                                .flat_map { it.__callbacks[chain_name].to_a }.to_set
+            actions = controller_actions(klass, chain_name)
+            candidates = actions.nil? || actions.empty? ? [nil] : actions # a base class: all of its callbacks
+            action, own = candidates.map do |act|
+              [act, chain.select { |cb| !inherited.include?(cb) && (act.nil? || applies?(cb, act)) && own_location(klass, cb, root) }]
+            end.max_by { it[1].size }
+            next unless own.size > limit
+
+            reported[[klass, chain_name]] = LongChain.new(klass, chain_name, own.map { describe(klass, it, root) }, limit, action, [])
+          end
+        end
+        reported.values
+      end
+
+      # Model callbacks (under +root+) that call save, update, touch, ... on
+      # the record they run for. allow: ["Trip#recalculate", ...] to accept one.
+      def callback_loops(classes = callback_classes, root:, allow: [])
+        classes.flat_map do |klass|
+          next [] unless defined?(ActiveRecord::Base) && klass < ActiveRecord::Base
+
+          klass.__callbacks.flat_map do |chain_name, chain|
+            next [] unless REENTERED_CHAINS.include?(chain_name)
+
+            chain.flat_map do |callback|
+              next [] unless (location = own_location(klass, callback, root))
+              next [] if allow.include?("#{name_of(klass)}##{callback.filter}")
+
+              self_saves(*location).map do |call, line|
+                Loop.new(klass, chain_name, "#{callback.kind}_#{chain_name} #{callback.filter.is_a?(Symbol) ? callback.filter.inspect : "block"}",
+                  call, "#{relative(location[0], root)}:#{line}", guard(callback))
+              end
+            end
+          end
+        end.uniq { [it.klass, it.callback, it.call, it.location] }
+      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)
@@ -113,6 +201,65 @@ module AsMinimizer
 
       def listed?(filter, action) = filter.instance_variable_get(:@actions).include?(action)
 
+      # [file, line] of the callback's code when it's the app's own (under root, not a gem), else nil.
+      def own_location(klass, callback, root)
+        filter = callback.filter
+        location =
+          case filter
+          when Symbol then (klass.instance_method(filter).source_location rescue nil)
+          when Proc then filter.source_location
+          end
+        return unless location && location[0].start_with?(root.to_s) && !location[0].match?(%r{/(vendor|gems)/})
+
+        location
+      end
+
+      def describe(klass, callback, root)
+        file, line = own_location(klass, callback, root)
+        name = callback.filter.is_a?(Symbol) ? callback.filter.inspect : "block"
+        "#{callback.kind}_#{callback.name} #{name} (#{relative(file, root)}:#{line})"
+      end
+
+      def relative(file, root) = file.delete_prefix("#{root}/")
+
+      # The :if/:unless that might stop a loop, as written. Rails' own
+      # condition on model after_* callbacks (skip after a halt) isn't one.
+      def guard(callback)
+        conditions = (callback.instance_variable_get(:@if).map { ["if", it] } + callback.instance_variable_get(:@unless).map { ["unless", it] })
+          .reject { |_, c| c.is_a?(ActiveSupport::Callbacks::Conditionals::Value) }
+        conditions.filter_map { |kind, c| "#{kind}: #{c.inspect}" if c.is_a?(Symbol) }.first ||
+          (conditions.any? ? "a #{conditions.first[0]}: condition" : nil)
+      end
+
+      # [[call, line]] for calls in SELF_SAVES on self in the method or block
+      # starting at file:line.
+      def self_saves(file, line)
+        require "prism"
+        @parsed ||= {}
+        root_node = (@parsed[file] ||= Prism.parse_file(file).value)
+        body = find_starting(root_node, line) or return []
+        found = []
+        walk = lambda do |node|
+          if node.is_a?(Prism::CallNode) && SELF_SAVES.include?(node.name) && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+            found << [node.name.to_s, node.location.start_line]
+          end
+          node.compact_child_nodes.each(&walk)
+        end
+        walk.(body)
+        found
+      end
+
+      def find_starting(node, line)
+        return node if (node.is_a?(Prism::DefNode) || node.is_a?(Prism::LambdaNode) || node.is_a?(Prism::BlockNode)) && node.location.start_line == line
+
+        node.compact_child_nodes.each do |child|
+          next unless child.location.start_line <= line && child.location.end_line >= line
+
+          found = find_starting(child, line) and return found
+        end
+        nil
+      end
+
       # 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)

data/lib/as_minimizer/unroller.rb

@@ -36,13 +36,28 @@ module AsMinimizer
   # 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.
+  # `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
+  # body, so a JIT compiles it once.
   #
   # 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 = []
+    # 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 = {}
     MUTEX = Mutex.new
     Unsupported = Class.new(StandardError)
 
@@ -62,44 +77,52 @@ module AsMinimizer
       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]
+        hit = cache[kind]
         return hit[1] if hit && hit[0].equal?(chain)
 
         MUTEX.synchronize do
-          per_kind = (cache[kind] ||= {})
-          hit = per_kind[action]
+          hit = cache[kind]
           return hit[1] if hit && hit[0].equal?(chain)
 
-          name = generate(klass, kind, action, chain)
-          per_kind[action] = [chain, name]
+          name = generate(klass, kind, chain)
+          cache[kind] = [chain, name]
           name
         end
       end
 
-      def source_for(klass, kind, action = nil) = Generator.new(klass, kind, action, klass.__callbacks[kind]).source
+      def source_for(klass, kind) = Generator.new(klass, kind, klass.__callbacks[kind]).source
+
+      # Generated methods, and the distinct bodies behind them.
+      def stats
+        classes = ObjectSpace.each_object(Class).select { it.instance_variable_defined?(:@__as_unrolled) }
+        { methods: classes.sum { it.instance_variable_get(:@__as_unrolled).count { |_, (_, name)| name } }, bodies: SHARED.size }
+      end
 
       private
 
-      def generate(klass, kind, action, chain)
-        generator = Generator.new(klass, kind, action, chain)
+      def generate(klass, kind, chain)
+        generator = Generator.new(klass, kind, 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
+        warn_missing(klass, kind, generator.targets)
+        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#{body}"
+          Module.new.tap { it.module_eval(code, file_for(klass, kind, label, code), 1) }
+        end
+        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
 
       # 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)
+      def warn_missing(klass, kind, targets)
         targets.each do |name, role, callback_kind|
           next unless Check.status(klass, name) == :missing
 
@@ -108,15 +131,14 @@ module AsMinimizer
 
           @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")
+            "names no method; running the chain will raise NoMethodError")
         end
       end
 
-      def file_for(klass, kind, action, label, code)
+      def file_for(klass, kind, 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")
+        path = File.join(source_dir.to_s, (klass.name || "anonymous_#{klass.object_id}").gsub("::", "/"), "#{kind}.rb")
         FileUtils.mkdir_p(File.dirname(path))
         File.write(path, code)
         path
@@ -139,19 +161,20 @@ module AsMinimizer
       # Symbols the generated code calls (filters and conditions that apply).
       attr_reader :targets
 
-      def initialize(klass, kind, action, chain)
+      def initialize(klass, kind, chain)
         @klass = klass
         @kind = kind
-        @action = action
         @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
@@ -161,14 +184,24 @@ 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)
           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)
+        # With raise_on_missing_callback_actions, only:/except: go through the
+        # filter object, which raises for actions that don't exist.
+        @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;
@@ -219,32 +252,40 @@ 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
-      # when it never runs (an `only:`/`except:` that rules out this action).
+      # when it can never run (an `only:` with no actions).
       def conditions(callback)
         parts = []
         callback.instance_variable_get(:@if).each do |c|
-          if static_action_filter?(c)
-            return nil unless action_listed?(c)
+          if inline_action_filter?(c)
+            return nil if actions_of(c).empty?
+
+            parts << "#{object(actions_of(c))}.include?(action_name)"
           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)
+          if inline_action_filter?(c)
+            parts << "!#{object(actions_of(c))}.include?(action_name)" unless actions_of(c).empty?
           else
             parts << "!(#{condition(callback, c)})"
           end
@@ -252,11 +293,12 @@ module AsMinimizer
         parts.empty? ? "true" : parts.join(" && ")
       end
 
-      def static_action_filter?(c)
-        @static_actions && defined?(AbstractController::Callbacks::ActionFilter) && c.is_a?(AbstractController::Callbacks::ActionFilter)
+      def inline_action_filter?(c)
+        @inline_actions && defined?(AbstractController::Callbacks::ActionFilter) && c.is_a?(AbstractController::Callbacks::ActionFilter)
       end
 
-      def action_listed?(filter) = filter.instance_variable_get(:@actions).include?(@action)
+      # only:/except: actions, as the frozen Set of Strings Rails keeps.
+      def actions_of(filter) = filter.instance_variable_get(:@actions)
 
       # As CallTemplate.build + make_lambda.
       def condition(callback, c)
@@ -270,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.0"
+  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.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Sampo Kuokkanen