activerecord-minimizer 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd5b6b67995d6c1cbf665637d1c06d7bba3a481906a2dfab3478c1f7e9e303b0
-  data.tar.gz: f9a99422b743b0942a7e07d8de0fb43273f4ec2fdc9e9f1e34c0021e196a6aee
+  metadata.gz: b96e595f334bcacd836276d8ff508f885079a41d045ef4ffdcc743689ae6469b
+  data.tar.gz: 7ecfa22211db6dc240d50dbc20cdcf99f6e133e8e4ba416e54a477c2b3a6a817
 SHA512:
-  metadata.gz: 1bc117e578665279e838e5ce2ea05d915c271a435224b21824e4ce51af8ac01a53248c2c7c3532f9fca3c46c2927927ff81d5b65a1db5dc93aa4dd267836fbb2
-  data.tar.gz: 8895e58f378594e9b92df76e98c72d6d377f6b6c2e1f9a77441677efc1ecdef23a15d2640cac6584940c0d7c5128ac8f563d225bbd471d5d1e5f8d58aa6652c2
+  metadata.gz: 3cd2f5496af0696ee69d1eea8e49573c5cd3df9668d34fae090746f8b9f86311c7f3c83caca487eecf639dc6d2e33e49d107f41f7b9c73aa216cc5886cf07f0b
+  data.tar.gz: 55114753dad4d0ffad49945183424379059bca3637f0d24517e7bcc6d86cf475646bec3d4e2cc499c76b79b3d3ec900555d41d1a2e267237f3b05695d9472428

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.0 (2026-11-05)
+
+- Removed `config.ar_minimizer.enums` (`ArMinimizer::Enums`). It made enum predicates faster in a benchmark but changed nothing measurable in production, and it no longer worked on Rails main. Setting it does nothing now. `ar_minimizer:census` no longer counts enum methods.
+
+## 0.2.0 (2026-10-20)
+
+- With `load_time`, the manifest's index (10-20 MB on a large app) is let go once an eager-loading boot is done, before a preloading server forks; a file loaded later indexes the manifest again.
+- README: strict mode and enums are the core; compiling call sites (`load_time`, `views`, `ar_minimizer:build`, `guards`) and small records are experimental, with the production results. The manifest is only needed by the experimental parts.
+
 ## 0.1.3 (2026-10-18)
 
 - `ar_minimizer:manifest` stops, saying why, when no model's table exists (a database not set up yet), instead of writing a manifest that describes no models.

data/README.md

@@ -4,8 +4,7 @@ Active Record generates a reader, a writer and one method per attribute
 method pattern for every column of every model: `name?`, `name_changed?`,
 `name_was`, `saved_change_to_name?`, `name_before_type_cast`,
 `restore_name!`, ... 21 patterns in Rails 8.1, so 21 methods per column.
-activerecord-minimizer generates the readers and writers only, and compiles
-the call sites that used the rest into the calls they stood for. Part of
+activerecord-minimizer generates the readers and writers only. Part of
 [rails-minify](../rails-minify).
 
 ```ruby
@@ -57,7 +56,13 @@ first call to one generates it on that model.
 Turn `slim` on in development and tests as well as production: the
 errors then show up while you work and in CI. Slim follows code reloads.
 
-## Compiling call sites
+## Experimental
+
+Each is off unless set. They are faster per call in benchmarks, but made no
+measurable difference on a production app (see [Numbers](#numbers)), and the
+compiling parts cost memory in every worker.
+
+### Compiling call sites
 
 Calls whose receiver is known to be a record of a model with that column are
 compiled to what the generated method would have done:
@@ -92,7 +97,7 @@ Where it compiles:
   `app/` and `lib/` in place instead, like explode_sqlite. Production only (or
   `FORCE=1`); `DRY_RUN=1` previews.
 
-All three read the **manifest**, `config/ar_minimizer.json`, written by
+All three read the **manifest** (strict mode doesn't need one), `config/ar_minimizer.json`, written by
 `bin/rails ar_minimizer:manifest`: per model its columns and their query kind,
 the attribute method patterns, hand-written methods, superclass, app modules,
 associations, scopes, and names it defines another way (an enum predicate
@@ -103,19 +108,14 @@ stale, and an eager-loading boot logs an error if it is.
 Never compiled: methods any model defines by hand, names used as columns,
 primary key methods, `defined?(...)`, calls with blocks, heredoc arguments.
 
-## More
+### More
 
-* **Enums** (`config.ar_minimizer.enums = true`) replaces the closures Rails
-  defines for enum predicates and bang methods, which build and intern the
-  `<name>_for_database` symbol on every call, with ordinary methods carrying
-  the enum's values: `def published? = public_send(:status_for_database) == 1`.
-  1.3–1.6× faster predicates; non-finite float values keep Rails' closures.
 * **Small records** (`config.ar_minimizer.small_records = true`). A loaded
   record owns two Hashes most records never put anything in, 160 bytes each:
   the association cache and the attribute set's Attribute objects. Both start
   as one shared frozen empty Hash and get their own on the first insert. A
   read-only record goes from 1,480 to 1,160 bytes (23 columns), at the same
-  speed. Destroyed and frozen records still raise on writes.
+  speed. Only worth it on pages that load thousands of records. Destroyed and frozen records still raise on writes.
 * **Census** (`ArMinimizer::Census`, run by rails-minify's
   `bin/rails minify:census`): how many call sites compile, and why the others
   don't.
@@ -140,6 +140,16 @@ On [Japan Voyage](https://japanvoyage.jp) (191 models, 2009 columns):
 * Test suite (4317 runs) in strict mode, after rubocop-minify's rewrites and
   with a 41-line keep list: the same results as the untouched app.
 
+In production there (Falcon, 6 workers, half the workers with a part and half
+without, the same traffic for an hour, October 2026):
+
+| part | result |
+|---|---|
+| strict mode | no call to a removed method; the same latency and memory |
+| small records | no difference: tens of records per request |
+| compiling in views | no faster, ~22 MB more per worker |
+| compiling at load time | ~12% more CPU per request, not reproduced locally; measured before the app was preloaded, so worth measuring again |
+
 ## Requirements and caveats
 
 * Ruby 3.4+, Rails 8.0, 8.1 and main (`rake test:rails`).

data/lib/ar_minimizer/census.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 module ArMinimizer
-  # What the attribute-method and enum compilers cover in an app.
+  # What the attribute-method compilers cover in an app.
   module Census
-    Result = Data.define(:models, :columns, :stock_methods, :generated_methods, :enum_methods, :enum_compiled,
-      :sites, :files, :manifest) do
+    Result = Data.define(:models, :columns, :stock_methods, :generated_methods, :sites, :files, :manifest) do
       def lines(verbose: false)
         [
           "models: #{models}, #{columns} columns",
           "attribute methods: #{stock_methods} in stock Rails, #{generated_methods || "n/a (slim off)"} generated with slim",
-          "enum methods: #{enum_compiled}/#{enum_methods} compiled",
           "attribute call sites: #{sites} compilable in #{files} files under app/ and lib/",
           "manifest: #{manifest}",
         ]
@@ -24,22 +22,14 @@ module ArMinimizer
         models.each(&:define_attribute_methods)
         models.sum { it.send(:generated_attribute_methods).instance_methods(false).size }
       end
-      enum_methods = enum_compiled = 0
-      models.each do |model|
-        mod = model.instance_variable_get(:@_enum_methods_module) or next
-        mod.instance_methods(false).each do |name|
-          enum_methods += 1
-          enum_compiled += 1 if mod.instance_method(name).source_location&.first.to_s.start_with?("enum ")
-        end
-      end
       sites = files = 0
       Dir.glob(File.join(root.to_s, "{app,lib}", "**", "*.rb")).each do |file|
         n = Rewriter.new(index: index, path: file, guards: guards).rewrite(File.read(file)).sites
         sites += n
         files += 1 if n.positive?
       end
-      Result.new(models.size, models.sum { it.attribute_names.size }, stock, generated, enum_methods, enum_compiled,
-        sites, files, manifest_state(root, index))
+      Result.new(models.size, models.sum { it.attribute_names.size }, stock, generated, sites, files,
+        manifest_state(root, index))
     end
 
     def self.manifest_state(root, index)

data/lib/ar_minimizer/loader.rb

@@ -15,7 +15,7 @@ module ArMinimizer
       # version: changes when the index does (Manifest.digest of the file).
       def install!(index:, patterns:, exclude_patterns: nil, version: nil, guards: false)
         require "require-hooks/setup"
-        @index = index
+        @index = @index_source = index
         @guards = guards
         @mutex = Mutex.new
         if defined?(RequireHooks::Bootsnap) && RequireHooks::Bootsnap.respond_to?(:add_version_hash)
@@ -33,6 +33,13 @@ module ArMinimizer
         @index
       end
 
+      # Lets go of the index (10-20 MB on a large app) once app/ and lib/ are
+      # loaded, before a preloading server forks: a file loaded later indexes
+      # the manifest again.
+      def release_index!
+        @mutex.synchronize { @index = @index_source } if @index_source.respond_to?(:call)
+      end
+
       # nil leaves the file as it is.
       def transform(path, source)
         result = Rewriter.new(index: index, path: path, marker: false, guards: @guards).rewrite(source || File.read(path))

data/lib/ar_minimizer/railtie.rb

@@ -10,7 +10,6 @@ module ArMinimizer
     #   config.ar_minimizer.strict = false    # ... and generate the rest when first called, instead of removing them
     #   config.ar_minimizer.load_time = true  # compile app/ and lib/ as they load (needs the manifest)
     #   config.ar_minimizer.views = true      # compile templates as ActionView loads them
-    #   config.ar_minimizer.enums = true      # enum predicates/bang methods as plain methods
     #   config.ar_minimizer.small_records = true  # no Hashes for records that never fill them
     #   config.ar_minimizer.guards = true     # also compile calls on receivers of unknown class, behind a class check
     #
@@ -30,7 +29,6 @@ module ArMinimizer
       manifest = -> { ArMinimizer::Manifest.parse(manifest_json) } if manifest_json
 
       ActiveSupport.on_load(:active_record) do
-        ArMinimizer::Enums.install! if options.enums
         ArMinimizer::SmallRecords.install! if options.small_records
         ArMinimizer::Slim.enable!(keep_methods: keep_methods, strict: options.strict != false) if options.slim
         ArMinimizer::Profile.start!(ENV["AR_MINIMIZER_PROFILE"]) if ENV["AR_MINIMIZER_PROFILE"]
@@ -44,6 +42,7 @@ module ArMinimizer
         # File.fnmatch? without FNM_PATHNAME: `*` crosses directories.
         ArMinimizer::Loader.install!(index: manifest, patterns: roots.map { "#{it}/*.rb" }, guards: !!options.guards,
           version: ArMinimizer::Manifest.digest(manifest_json))
+        app.config.after_initialize { ArMinimizer::Loader.release_index! if app.config.eager_load }
       end
 
       # Every model is loaded after eager loading: say so if the manifest no

data/lib/ar_minimizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArMinimizer
-  VERSION = "0.1.3"
+  VERSION = "0.3.0"
 end

data/lib/ar_minimizer.rb

@@ -25,7 +25,6 @@ module ArMinimizer
   autoload :Views, "ar_minimizer/views"
   autoload :Profile, "ar_minimizer/profile"
   autoload :Manifest, "ar_minimizer/manifest"
-  autoload :Enums, "ar_minimizer/enums"
   autoload :Census, "ar_minimizer/census"
   autoload :SmallRecords, "ar_minimizer/small_records"
   autoload :Loader, "ar_minimizer/loader"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-minimizer
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Sampo Kuokkanen
@@ -59,8 +59,7 @@ dependencies:
         version: '0.4'
 description: Generates only the reader and writer per Active Record column (strict
   mode removes the other 19 attribute methods), compiles call sites to the calls those
-  methods stood for, turns enum closures into plain methods and stops records allocating
-  Hashes they never fill.
+  methods stood for and stops records allocating Hashes they never fill.
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -72,7 +71,6 @@ files:
 - lib/ar_minimizer.rb
 - lib/ar_minimizer/build.rb
 - lib/ar_minimizer/census.rb
-- lib/ar_minimizer/enums.rb
 - lib/ar_minimizer/index.rb
 - lib/ar_minimizer/loader.rb
 - lib/ar_minimizer/manifest.rb

data/lib/ar_minimizer/enums.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module ArMinimizer
-  # Enum predicates and bang methods as ordinary methods.
-  #
-  # Rails defines them with closures, and each predicate call builds and
-  # interns the `<name>_for_database` symbol before calling it:
-  #
-  #   # def active?() status_for_database == 0 end      (Rails' own comment)
-  #   define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
-  #
-  # Here the enum's literal data goes into the method source instead, as
-  # Roundhouse does for macros with literal arguments:
-  #
-  #   def active? = public_send(:status_for_database) == 0
-  #   def active! = update!("status" => 0)
-  #
-  # Rails still runs first (conflict detection, scopes); only the two methods
-  # are replaced. Rails allows booleans, integers, floats, symbols and strings
-  # as values; non-finite floats, and method names that aren't plain
-  # identifiers, keep Rails' closures.
-  module Enums
-    IDENTIFIER = /\A[a-zA-Z_][a-zA-Z0-9_]*\z/
-
-    class << self
-      # Before models load (their class bodies declare the enums).
-      def install!
-        @enabled = true
-        mod = ActiveRecord::Enum.const_get(:EnumMethods)
-        mod.prepend(Definer) unless mod < Definer
-      end
-
-      def disable! = @enabled = false
-
-      def enabled? = @enabled == true
-
-      def literal(value)
-        case value
-        when Integer, String, Symbol, true, false, nil then value.inspect
-        when Float then value.inspect if value.finite?
-        end
-      end
-    end
-
-    module Definer
-      private
-
-      def define_enum_methods(name, value_method_name, value, scopes, instance_methods)
-        super
-        return unless instance_methods && Enums.enabled?
-        return unless value_method_name.match?(IDENTIFIER) && (literal = Enums.literal(value))
-
-        remove_method(:"#{value_method_name}?", :"#{value_method_name}!")
-        module_eval(<<~RUBY, "enum #{klass.name}.#{name}", 1)
-          def #{value_method_name}? = public_send(#{:"#{name}_for_database".inspect}) == #{literal}
-          def #{value_method_name}! = update!(#{name.inspect} => #{literal})
-        RUBY
-      end
-    end
-  end
-end