activerecord-minimizer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7993bf021f8de2ed44f37b3dd541d6644b1fd1d38817acaecf424852713acb2a
-  data.tar.gz: 0c520dcb7ca0543b4ac891ea9abced9968d0fec36edd258c9a47dc7ea33f962d
+  metadata.gz: b96e595f334bcacd836276d8ff508f885079a41d045ef4ffdcc743689ae6469b
+  data.tar.gz: 7ecfa22211db6dc240d50dbc20cdcf99f6e133e8e4ba416e54a477c2b3a6a817
 SHA512:
-  metadata.gz: faa673f2b296a034bbca5c927642dcde2f3f38c6e689b825c8f6884fbe0810a7ec0514f3669a685fa6f81487b578d4a41345f38de5ca3f327851c0d195abd1c2
-  data.tar.gz: '09b436a70b52965449931ebc407b9396ca7068233644025de33516f56148f0c31507cd5f265a4a3884cec901482fe9c1dc3ee02e9b42e28accd41f077b332d73'
+  metadata.gz: 3cd2f5496af0696ee69d1eea8e49573c5cd3df9668d34fae090746f8b9f86311c7f3c83caca487eecf639dc6d2e33e49d107f41f7b9c73aa216cc5886cf07f0b
+  data.tar.gz: 55114753dad4d0ffad49945183424379059bca3637f0d24517e7bcc6d86cf475646bec3d4e2cc499c76b79b3d3ec900555d41d1a2e267237f3b05695d9472428

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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.

data/README.md

@@ -56,14 +56,6 @@ 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.
 
-## 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.
-
 ## Experimental
 
 Each is off unless set. They are faster per call in benchmarks, but made no
@@ -105,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** (strict mode and enums don't need one), `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
@@ -154,7 +146,6 @@ without, the same traffic for an hour, October 2026):
 | part | result |
 |---|---|
 | strict mode | no call to a removed method; the same latency and memory |
-| enums | the same median latency; no change in allocations on these pages |
 | 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 |

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/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"]

data/lib/ar_minimizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArMinimizer
-  VERSION = "0.2.0"
+  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.2.0
+  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