activerecord-minimizer 0.1.0

data/lib/ar_minimizer/manifest.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+module ArMinimizer
+  # The Index as a file, so source can be compiled where no model is loaded
+  # yet (Loader, while Ruby requires each file) or no database is around.
+  # It stores what the index is computed from (each model's columns, patterns
+  # and hand-written methods), one model per line. Generate it like
+  # db/schema.rb and commit it:
+  #
+  #   bin/rails ar_minimizer:manifest        # writes config/ar_minimizer.json
+  #   bin/rails ar_minimizer:manifest:check  # in CI: fails when out of date
+  #
+  # It goes stale when the schema changes, or when a model gets a hand-written
+  # method with a generated method's name, or overrides a reader.
+  module Manifest
+    FORMAT = 1
+
+    class << self
+      def dump(index) = dump_models(index.models, keep: index.keep)
+
+      # From Index.describe_all, without building the index (the boot-time check).
+      def dump_models(models, keep:)
+        pattern_sets = models.map(&:patterns).uniq.sort
+        lines = models.map do |m|
+          JSON.generate({ "name" => m.name, "patterns" => pattern_sets.index(m.patterns), "primary_key" => m.primary_key,
+                          # sorted: column order differs between a migrated database and one loaded from schema.rb
+                          "attributes" => m.attributes.sort.to_h, "hand_written" => m.hand_written,
+                          "superclass" => m.superclass, "modules" => m.modules,
+                          "associations" => m.associations, "scopes" => m.scopes, **({ "shadows" => m.shadows } if m.shadows.any?) })
+        end.sort
+        <<~JSON
+          {"format": #{FORMAT}, "ar_minimizer": #{VERSION.to_json}, "keep": #{keep.map(&:to_s).sort.to_json},
+          "patterns": #{JSON.generate(pattern_sets)},
+          "models": [
+          #{lines.join(",\n")}
+          ]}
+        JSON
+      end
+
+      def parse(json)
+        data = JSON.parse(json)
+        raise ArgumentError, "ar_minimizer manifest format #{data["format"]}, expected #{FORMAT}" unless data["format"] == FORMAT
+
+        models = data["models"].map do |m|
+          Index::Model.new(name: m["name"], attributes: m["attributes"].transform_values { it&.to_sym }, primary_key: m["primary_key"],
+            patterns: data["patterns"].fetch(m["patterns"]), hand_written: m["hand_written"],
+            superclass: m["superclass"], modules: m["modules"] || [],
+            associations: m["associations"] || {}, scopes: m["scopes"] || [], shadows: m["shadows"] || [])
+        end
+        Index.new(models, keep: data["keep"])
+      end
+
+      def load(path) = parse(File.read(path))
+
+      # Changes whenever the compiled output could: the models and this gem's
+      # version (both in the dump). Of a dump or a manifest file's contents.
+      def digest(index_or_json)
+        Digest::SHA256.hexdigest(index_or_json.is_a?(String) ? index_or_json : dump(index_or_json))[0, 16]
+      end
+    end
+  end
+end

data/lib/ar_minimizer/profile.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  # Counts calls that take Slim's slow path (method_missing), per
+  # Model#method, and writes them out at exit, one file per process. With
+  # lazy generation (the default) that is one call per method and model: the
+  # list of methods generated at runtime. Put it in Slim.keep_methods to
+  # generate them at boot instead, before a forking server forks, so the
+  # workers share them.
+  #
+  #   AR_MINIMIZER_PROFILE=tmp/ar_minimizer bin/rails test
+  #   bin/rails ar_minimizer:profile MIN=100 > config/ar_minimizer_keep.txt
+  module Profile
+    class << self
+      attr_reader :tally
+
+      def start!(dir)
+        @dir = dir.to_s
+        @tally = Hash.new(0)
+        @mutex = Mutex.new
+        # Counter must sit in front of Slim::Record (inert while Slim is off),
+        # which resolves aliases without calling super.
+        ActiveRecord::Base.prepend(Slim::Record) unless ActiveRecord::Base < Slim::Record
+        ActiveRecord::Base.prepend(Counter) unless ActiveRecord::Base < Counter
+        at_exit { write }
+      end
+
+      def stop!
+        write
+        @tally = nil
+      end
+
+      def count(model, name)
+        @mutex.synchronize { @tally["#{model.name}##{name}"] += 1 } if @tally
+      end
+
+      def write
+        return if @tally.nil? || @tally.empty?
+
+        FileUtils.mkdir_p(@dir)
+        File.write(File.join(@dir, "#{Process.pid}.tsv"), @tally.map { |name, n| "#{n}\t#{name}\n" }.join)
+      end
+
+      # Merged counts from every file in +dir+, most called first.
+      def report(dir)
+        Dir.glob(File.join(dir.to_s, "*.tsv")).each_with_object(Hash.new(0)) do |file, sum|
+          File.foreach(file) do |line|
+            n, name = line.chomp.split("\t", 2)
+            sum[name] += Integer(n)
+          end
+        end.sort_by { |name, n| [-n, name] }
+      end
+    end
+
+    module Counter
+      def attribute_missing(match, ...)
+        Profile.count(self.class, match.proxy_target.sub("attribute", match.attr_name))
+        super
+      end
+    end
+  end
+end

data/lib/ar_minimizer/railtie.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ArMinimizer
+  class Railtie < Rails::Railtie
+    config.ar_minimizer = ActiveSupport::OrderedOptions.new
+
+    # In config/environments/production.rb:
+    #
+    #   config.ar_minimizer.slim = true       # generate only readers and writers
+    #   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
+    #
+    # config/ar_minimizer.json is the manifest (ar_minimizer:manifest). With it,
+    # load_time and views need no database or loaded models; without it, views
+    # index the models loaded when each template compiles.
+    #
+    # config/ar_minimizer_keep.txt, if present, lists methods to generate at
+    # boot (one "name" or "Model#name" per line; see ar_minimizer:profile).
+    initializer "ar_minimizer", before: :load_config_initializers do |app|
+      options = app.config.ar_minimizer
+      keep_file = app.root.join("config/ar_minimizer_keep.txt")
+      keep_methods = keep_file.exist? ? ArMinimizer::Slim.parse_keep_file(keep_file.read) : []
+      manifest_file = app.root.join("config/ar_minimizer.json")
+      # Read now (a few KB), indexed only when something has to be compiled.
+      manifest_json = manifest_file.read if manifest_file.exist? && (options.load_time || options.views)
+      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"]
+      end
+      ActiveSupport.on_load(:action_view) { ArMinimizer::Views.install!(index: manifest, guards: !!options.guards) } if options.views
+
+      if options.load_time
+        raise "config.ar_minimizer.load_time needs #{manifest_file}: run bin/rails ar_minimizer:manifest" unless manifest
+
+        roots = [app.root.join("app"), app.root.join("lib")].map { File.realpath(it) if it.exist? }.compact
+        # 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))
+      end
+
+      # Every model is loaded after eager loading: say so if the manifest no
+      # longer describes them (the compiled code may skip a new hand-written method).
+      if manifest && options.verify_manifest != false
+        app.config.after_initialize do
+          next unless app.config.eager_load
+
+          live = ArMinimizer::Manifest.dump_models(ArMinimizer::Index.describe_all, keep: ArMinimizer::Slim.keep || ArMinimizer::Slim::DEFAULT_KEEP)
+          if live != manifest_json
+            Rails.logger.error("ar_minimizer: #{manifest_file} is out of date; run bin/rails ar_minimizer:manifest")
+          end
+        end
+      end
+    end
+
+    rake_tasks do
+      namespace :ar_minimizer do
+        desc "Compile attribute pattern calls (name?, name_changed?, ...) in place " \
+          "(production only unless FORCE=1; DRY_RUN=1 to preview; AR_MINIMIZER_PATHS=app,lib)"
+        task build: :environment do
+          Rails.application.eager_load!
+          ArMinimizer::Build.new(
+            root: Rails.root,
+            paths: ENV.fetch("AR_MINIMIZER_PATHS", "app,lib").split(","),
+            env: Rails.env,
+            dry_run: ENV["DRY_RUN"] == "1",
+            force: ENV["FORCE"] == "1",
+            out: $stdout,
+            guards: ENV["GUARDS"] == "1" || !!Rails.application.config.ar_minimizer.guards,
+          ).run
+        end
+
+        desc "Write config/ar_minimizer.json from the loaded models (commit it, like db/schema.rb)"
+        task manifest: :environment do
+          Rails.application.eager_load!
+          path = Rails.root.join("config/ar_minimizer.json")
+          index = ArMinimizer::Index.from_models
+          File.write(path, ArMinimizer::Manifest.dump(index))
+          puts "ar_minimizer: #{path.relative_path_from(Rails.root)} (#{index.size} methods, #{ArMinimizer::Manifest.digest(index)})"
+        end
+
+        namespace :manifest do
+          desc "Fail if config/ar_minimizer.json doesn't match the models (for CI)"
+          task check: :environment do
+            Rails.application.eager_load!
+            path = Rails.root.join("config/ar_minimizer.json")
+            live = ArMinimizer::Manifest.dump(ArMinimizer::Index.from_models)
+            abort "ar_minimizer: #{path} is missing or out of date; run bin/rails ar_minimizer:manifest" unless path.exist? && path.read == live
+            puts "ar_minimizer: manifest up to date"
+          end
+        end
+
+        desc "Print slow-path calls recorded with AR_MINIMIZER_PROFILE=dir, as a keep list " \
+          "(DIR=tmp/ar_minimizer, MIN=1)"
+        task :profile do
+          min = Integer(ENV.fetch("MIN", "1"))
+          ArMinimizer::Profile.report(ENV.fetch("DIR", "tmp/ar_minimizer")).each do |name, n|
+            puts "#{name} # #{n} calls" if n >= min
+          end
+        end
+      end
+    end
+  end
+end