rubocop-minify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '049d556f390def41fa201dedd271537d50e8cc52089a88390265099294b98d06'
+  data.tar.gz: d5456061700c24de435649ae2a13887c30b8390f50de47667a560e44c56c4873
+SHA512:
+  metadata.gz: 7587a7837c4f11f0edc58d071367b039cd0c51ec9f54e4f1e4dbc84d23dcf7881228bc43714757663f08a7e0e87fec85e77d2c4ac64e6182a683957dd1344da7
+  data.tar.gz: c20b028278b3b49797bbaeaee9b460a5df1105dbfaad073dbda4fc4298bb3746d42da6847fce9ba1b46d0da82aa0b2da0d69e5ac3d827fe906a22ae65b50b0c6

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+First release.
+
+- `Minify/AttributeMethods`: rewrites calls to the attribute methods strict mode removes, from the app's manifest.
+- `minify-erb`: the same rewrite in ERB templates (Herb), with `--fix`.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sampo Kuokkanen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# rubocop-minify
+
+RuboCop cops, and an ERB fixer, that rewrite code relying on what
+[rails-minify](../rails-minify) removes from Rails. Part of rails-minify.
+
+activerecord-minimizer's strict mode stops generating 19 of the 21 attribute
+methods per column (`name?`, `name_changed?`, `saved_change_to_name?`, ...).
+`Minify/AttributeMethods` rewrites the calls into what they stood for:
+
+```ruby
+venue.featured?                         # => venue.featured.present?
+return unless venue.featured?           # => return unless venue.featured
+venue.name?                             # => venue.name.present?
+venue.rank?                             # => venue.query_attribute(:rank)
+venue.name_changed?(to: "x")            # => venue.attribute_changed?(:name, to: "x")
+before_save :geocode, if: :address_changed?
+                                        # => if: -> { attribute_changed?(:address) }
+```
+
+`name?` follows the column's type: a boolean or date column reads as itself
+where only truthiness matters (conditions, `!`, `&&`/`||` inside them) and as
+`.present?` elsewhere; strings use `.present?`; numbers, enums and decorated
+columns use `query_attribute`. Arguments, `&.` and nesting are kept.
+
+## Setup
+
+```ruby
+# Gemfile
+group :development do
+  gem "rubocop-minify", require: false
+end
+```
+
+```yaml
+# .rubocop.yml
+plugins:
+  - rubocop-minify
+```
+
+The cop reads activerecord-minimizer's manifest, `config/ar_minimizer.json`
+(`bin/rails ar_minimizer:manifest`): which names strict mode removes, from
+which models, for which attribute and column type. Without a manifest it does
+nothing.
+
+```sh
+bin/rubocop --only Minify/AttributeMethods -a   # Ruby: app, lib, test, db, ...
+bundle exec minify-erb --fix app                # templates
+```
+
+RuboCop doesn't read ERB, so `minify-erb` does the same rewrite on the Ruby
+inside each tag (parsed with Herb). Without `--fix` it lists the calls; it
+exits non-zero while any are left, for CI.
+
+## What it won't rewrite
+
+Receivers aren't typed, so the cop only rewrites what can't mean something
+else, and reports the rest for you to fix by hand or add to the keep list
+(`config/ar_minimizer_keep.txt`):
+
+* Names the app also defines (`def featured?` in a presenter, `delegate`,
+  `attr_reader`, `alias_method`, ...), scanned from `app/` and `lib/`
+  (`DefinitionPaths`).
+* Names another model defines some other way, such as an enum predicate
+  called like another model's column (the manifest's `shadows`).
+* Names Ruby or Active Record define everywhere (`key?`, `empty?`,
+  `readonly?`), and calls with arguments to methods that take none.
+* Calls without a receiver outside a model, or in a module included by
+  models of which only some have the column. In templates, `self` is a view,
+  so receiver-less calls are never records.
+* Private proxies (`name_will_change!` → `attribute_will_change!(:name)`) on
+  another object; on `self` they're rewritten.
+* Method names passed to `send`, `try` and `delegate`.
+
+## Configuration
+
+```yaml
+Minify/AttributeMethods:
+  Manifest: config/ar_minimizer.json
+  DefinitionPaths:
+    - "app/**/*.rb"
+    - "lib/**/*.rb"
+```
+
+## On golf-buddy
+
+191 models: 130 calls in Ruby (app, lib, test, db) and 21 templates rewritten
+automatically; 11 names left for the keep list, all of them names some other
+class defines too. The test suite gives the same results in strict mode
+afterwards.

data/config/default.yml

@@ -0,0 +1,14 @@
+Minify/AttributeMethods:
+  Description: >-
+    Rewrites calls to the attribute methods activerecord-minimizer's strict
+    mode removes (name?, name_changed?, saved_change_to_name?, ...) into the
+    calls they stood for.
+  Enabled: true
+  VersionAdded: "0.1"
+  # Written by `bin/rails ar_minimizer:manifest`: which names are removed, and for which attribute.
+  Manifest: config/ar_minimizer.json
+  # Where to look for hand-written methods sharing a removed name (a PORO's
+  # featured?): calls of those names are reported but never rewritten.
+  DefinitionPaths:
+    - "app/**/*.rb"
+    - "lib/**/*.rb"

data/exe/minify-erb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Rewrites (with --fix) or lists calls to removed attribute methods in ERB
+# templates, the part of the app RuboCop doesn't read.
+#
+#   minify-erb [--fix] [--manifest config/ar_minimizer.json] [paths...]
+require "optparse"
+require "rubocop_minify"
+
+fix = false
+manifest = "config/ar_minimizer.json"
+OptionParser.new do |o|
+  o.banner = "usage: minify-erb [--fix] [--manifest PATH] [paths...]"
+  o.on("--fix", "rewrite the templates in place") { fix = true }
+  o.on("--manifest PATH") { manifest = it }
+end.parse!
+
+root = Dir.pwd
+rewrite = RubocopMinify.rewrite_for(root, manifest: manifest, definition_paths: ["app/**/*.rb", "lib/**/*.rb"], views: true)
+abort "minify-erb: no #{manifest}; run bin/rails ar_minimizer:manifest" unless rewrite
+
+paths = (ARGV.empty? ? ["app"] : ARGV).flat_map { File.directory?(it) ? Dir.glob("#{it}/**/*.erb") : [it] }.sort
+rewritten = 0
+left = 0
+paths.each do |path|
+  template = File.read(path)
+  line_of = ->(offset) { template.byteslice(0, offset).count("\n") + 1 }
+  if fix
+    fixed, manual = RubocopMinify::ERB.fix(template, rewrite)
+    if fixed != template
+      File.write(path, fixed)
+      rewritten += 1
+      puts "rewrote #{path}"
+    end
+    template = fixed
+    line_of = ->(offset) { template.byteslice(0, offset).count("\n") + 1 }
+    manual.each { puts "#{path}:#{line_of.(it.from)}: #{it.message}" }
+    left += manual.size
+  else
+    RubocopMinify::ERB.edits(template, rewrite).each do |edit|
+      puts "#{path}:#{line_of.(edit.from)}: #{edit.message}"
+      left += 1
+    end
+  end
+end
+puts(fix ? "#{rewritten} templates rewritten, #{left} calls to fix by hand" : "#{left} calls")
+exit(left.zero? ? 0 : 1)

data/lib/rubocop/cop/minify/attribute_methods.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minify
+      # Calls to the attribute methods activerecord-minimizer's strict mode
+      # removes, rewritten into what they stood for. See RubocopMinify::Rewrite.
+      #
+      # @example
+      #   # bad
+      #   venue.featured?
+      #   venue.name_changed?
+      #   before_save :geocode, if: :address_changed?
+      #
+      #   # good
+      #   venue.featured.present?
+      #   venue.attribute_changed?(:name)
+      #   before_save :geocode, if: -> { attribute_changed?(:address) }
+      class AttributeMethods < Base
+        extend AutoCorrector
+
+        def on_new_investigation
+          rewrite = RubocopMinify.rewrite_for(config.base_dir_for_path_parameters,
+            manifest: cop_config.fetch("Manifest", "config/ar_minimizer.json"),
+            definition_paths: Array(cop_config.fetch("DefinitionPaths", ["app/**/*.rb", "lib/**/*.rb"])))
+          return unless rewrite
+
+          source = processed_source.raw_source
+          rewrite.edits(source).each do |edit|
+            range = range_between(source.byteslice(0, edit.from).length, source.byteslice(0, edit.to).length)
+            if edit.replacement
+              add_offense(range, message: edit.message) { it.replace(range, edit.replacement) }
+            else
+              add_offense(range, message: edit.message)
+            end
+          end
+        end
+
+        private
+
+        def range_between(from, to) = Parser::Source::Range.new(processed_source.buffer, from, to)
+      end
+    end
+  end
+end

data/lib/rubocop/minify/plugin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module Minify
+    # `plugins: [rubocop-minify]` in .rubocop.yml.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(name: "rubocop-minify", version: RubocopMinify::VERSION,
+          homepage: "https://github.com/sampokuokkanen/rails-minify",
+          description: "Rewrites code relying on what rails-minify removes from Rails")
+      end
+
+      def supported?(context) = context.engine == :rubocop
+
+      def rules(_context)
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: Pathname.new(__dir__).join("../../../config/default.yml"))
+      end
+    end
+  end
+end

data/lib/rubocop-minify.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "rubocop_minify"
+require "rubocop/minify/plugin"
+require "rubocop/cop/minify/attribute_methods"

data/lib/rubocop_minify/definitions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RubocopMinify
+  # Hand-written methods in the app, by name: { "featured?" => "app/models/poro.rb:12" }.
+  # def, define_method, alias, alias_method, attr_*, delegate and def_delegator(s).
+  module Definitions
+    DEFINERS = %i[define_method alias_method attr_reader attr_writer attr_accessor delegate def_delegator def_delegators].freeze
+
+    def self.scan(root, patterns)
+      found = {}
+      patterns.flat_map { Dir.glob(it, base: root) }.sort.each do |path|
+        walk(Prism.parse_file(File.join(root, path)).value, path, found)
+      end
+      found
+    end
+
+    def self.walk(node, path, found)
+      case node
+      when Prism::DefNode
+        found[node.name.to_s] ||= "#{path}:#{node.location.start_line}"
+      when Prism::AliasMethodNode
+        found[node.new_name.slice.delete_prefix(":")] ||= "#{path}:#{node.location.start_line}" if node.new_name.is_a?(Prism::SymbolNode)
+      when Prism::CallNode
+        if DEFINERS.include?(node.name)
+          symbols = node.arguments&.arguments&.grep(Prism::SymbolNode) || []
+          symbols = symbols.first(1) if %i[define_method alias_method].include?(node.name)
+          symbols = symbols.drop(1) if node.name == :def_delegators # the accessor comes first
+          symbols.each { found[it.unescaped] ||= "#{path}:#{node.location.start_line}" }
+        end
+      end
+      node&.compact_child_nodes&.each { walk(it, path, found) }
+    end
+  end
+end

data/lib/rubocop_minify/erb.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "herb"
+
+module RubocopMinify
+  # The same rewrite in ERB templates (RuboCop doesn't read them): Herb finds
+  # the Ruby in each tag, Rewrite works on it as code that runs in a view.
+  module ERB
+    # Rewrite::Edits with offsets into the template.
+    def self.edits(template, rewrite)
+      found = []
+      collect = lambda do |node|
+        if node.class.name.start_with?("Herb::AST::ERB") && node.respond_to?(:content) && node.content &&
+            !node.class.name.end_with?("CommentNode") && !node.tag_opening&.value.to_s.start_with?("<%#")
+          base = node.content.range.from
+          rewrite.edits(node.content.value).each do |e|
+            found << Rewrite::Edit.new(e.from + base, e.to + base, e.replacement, e.message)
+          end
+        end
+        node.compact_child_nodes.each(&collect)
+      end
+      collect.(Herb.parse(template).value)
+      found
+    end
+
+    # The template with every rewritable call rewritten, and what's left to
+    # do by hand.
+    def self.fix(template, rewrite)
+      5.times do
+        edits = edits(template, rewrite)
+        fixed = Rewrite.apply(template, edits)
+        return [fixed, edits.reject(&:replacement)] if fixed == template
+
+        template = fixed
+      end
+      [template, edits(template, rewrite).reject(&:replacement)]
+    end
+  end
+end

data/lib/rubocop_minify/rewrite.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RubocopMinify
+  # Finds calls to the attribute methods activerecord-minimizer's strict mode
+  # removes and what each stood for:
+  #
+  #   venue.featured?            -> venue.featured.present?   (venue.featured in a condition)
+  #   venue.name?                -> venue.name.present?
+  #   venue.rank?                -> venue.query_attribute(:rank)
+  #   venue.name_changed?(to: x) -> venue.attribute_changed?(:name, to: x)
+  #   before_save :x, if: :name_changed?  -> if: -> { attribute_changed?(:name) }
+  #
+  # Which names are removed, for which attribute and with which column type
+  # comes from the ar_minimizer manifest (an ArMinimizer::Index). Receivers
+  # aren't typed: a name is rewritten wherever it's called on an explicit
+  # receiver, unless the app also defines a method of that name somewhere
+  # (+defined+), and then it's only reported. Calls without a receiver are
+  # only rewritten inside models and the app modules they include.
+  class Rewrite
+    # Byte offsets into the source. replacement nil: reported, not rewritten.
+    Edit = Data.define(:from, :to, :replacement, :message)
+
+    SEND = %i[send public_send __send__ try try!].freeze
+    # A removed name that core classes also define (key?, empty?, ...) is
+    # far more often one of those.
+    CORE = [Object, Kernel, Comparable, Enumerable, Hash, Array, String, Symbol, Integer, Float, NilClass, Range, Set].freeze
+    CALLBACK_OPTIONS = %i[if unless].freeze
+
+    # defined: { method name => "path:line" } of hand-written methods.
+    # views: the source is template code (self is a view, never a record).
+    def initialize(index, defined: {}, views: false)
+      @index = index
+      @defined = defined
+      @views = views
+    end
+
+    def edits(source)
+      root = Prism.parse(source).value
+      @edits = []
+      @nesting = []
+      @class_level = 0
+      @locals = locals(root)
+      visit(root, false)
+      @edits.sort_by(&:from)
+    end
+
+    # Applies the rewritable edits that don't overlap (nested ones are left
+    # for the next pass), from the end so offsets stay valid.
+    def self.apply(source, edits)
+      out = source.b
+      last = nil
+      edits.select(&:replacement).sort_by { -it.from }.each do |edit|
+        next if last && edit.to > last
+
+        out.bytesplice(edit.from, edit.to - edit.from, edit.replacement.b)
+        last = edit.from
+      end
+      out.force_encoding(source.encoding)
+    end
+
+    private
+
+    # cond: only the value's truthiness matters here (if/unless/while
+    # conditions, the operand of !, and/or inside those).
+    def visit(node, cond)
+      case node
+      when Prism::IfNode, Prism::UnlessNode, Prism::WhileNode, Prism::UntilNode
+        visit(node.predicate, true)
+        node.compact_child_nodes.each { visit(it, false) unless it.equal?(node.predicate) }
+      when Prism::AndNode, Prism::OrNode
+        visit(node.left, cond)
+        visit(node.right, cond)
+      when Prism::ParenthesesNode
+        body = node.body
+        if body.is_a?(Prism::StatementsNode) && body.body.size == 1
+          visit(body.body[0], cond)
+        else
+          visit_children(node)
+        end
+      when Prism::ClassNode, Prism::ModuleNode
+        @nesting.push(node.constant_path.slice.delete_prefix("::"))
+        outer, @class_level = @class_level, 0
+        visit_children(node)
+        @class_level = outer
+        @nesting.pop
+      when Prism::SingletonClassNode, Prism::DefNode
+        # class << self and def self.x: self is the class, not a record
+        class_level = node.is_a?(Prism::SingletonClassNode) || node.receiver
+        @class_level += 1 if class_level
+        visit_children(node)
+        @class_level -= 1 if class_level
+      when Prism::CallNode
+        if node.name == :! && node.receiver && !node.arguments
+          visit(node.receiver, true)
+        elsif (edit = call_edit(node, cond))
+          @edits << edit
+          visit_children(node) unless edit.replacement # its parts are copied into the replacement
+        else
+          symbol_edits(node)
+          visit_children(node)
+        end
+      when nil
+      else
+        visit_children(node)
+      end
+    end
+
+    def visit_children(node) = node.compact_child_nodes.each { visit(it, false) }
+
+    def call_edit(node, cond)
+      name = node.name.to_s
+      entry = @index[name] or return
+      return if node.block || core?(name)
+      return if node.arguments && !entry.args # the generated method takes none: something else
+
+      receiver = node.receiver
+      implicit = receiver.nil? || receiver.is_a?(Prism::SelfNode)
+      if implicit
+        return if @views
+
+        case self_coverage(entry)
+        when :all then nil # self is always a record with the attribute
+        when :some then return edit(node, nil, "#{name} is removed by strict mode from #{models(entry)}, but not every class this code runs in has it: rewrite by hand")
+        else return # not a record with the attribute: an enum predicate, a helper, ...
+        end
+      else
+        if (where = @defined[name])
+          return edit(node, nil, "#{name} is removed by strict mode from #{models(entry)}, but #{where} defines a method of that name: rewrite calls on those records by hand")
+        end
+        if (others = @index.shadowed(name)).any?
+          return edit(node, nil, "#{name} is removed by strict mode from #{models(entry)}, but #{others.first(4).join(", ")} define#{"s" if others.size == 1} it otherwise (an enum, a delegate, ...): rewrite calls on those records by hand")
+        end
+      end
+
+      replacement = call_replacement(node, entry, cond)
+      message = replacement ? "#{name} is removed by strict mode; use #{replacement}" : "#{name} is removed by strict mode; call #{entry.proxy}(#{symbol(entry.attr)}, ...) on the record itself (it's private)"
+      edit(node, replacement, message)
+    end
+
+    def call_replacement(node, entry, cond)
+      receiver = node.receiver
+      prefix = receiver ? "#{receiver.slice}#{node.call_operator}" : ""
+
+      if entry.proxy == "attribute?"
+        reader = receiver || !@locals.include?(entry.attr) ? "#{prefix}#{entry.attr}" : "self.#{entry.attr}"
+        case entry.query
+        when :truthy then return cond ? reader : "#{reader}.present?" # true, false, nil, or a date/time
+        when :string then return "#{reader}.present?"
+        end
+      end
+
+      args = [symbol(entry.attr), node.arguments&.slice].compact.join(", ")
+      if (proxy = entry.public_proxy)
+        "#{prefix}#{proxy}(#{args})"
+      elsif receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        "#{prefix}#{entry.proxy}(#{args})" # private, callable on self
+      end
+    end
+
+    # Method names passed as symbols: callback conditions become lambdas;
+    # send/try/delegate are reported.
+    def symbol_edits(node)
+      if SEND.include?(node.name) && (first = node.arguments&.arguments&.first).is_a?(Prism::SymbolNode)
+        report_symbol(first, "#{first.unescaped} is removed by strict mode; call what it stood for instead of #{node.name}")
+      elsif node.name == :delegate && node.receiver.nil?
+        node.arguments&.arguments&.grep(Prism::SymbolNode)&.each do
+          report_symbol(it, "#{it.unescaped} is removed by strict mode, so delegating it raises; delegate the reader and define the method")
+        end
+      end
+
+      keywords = node.arguments&.arguments&.grep(Prism::KeywordHashNode)&.flat_map(&:elements) || []
+      keywords.each do |pair|
+        next unless pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode) && CALLBACK_OPTIONS.include?(pair.key.unescaped.to_sym)
+
+        values = pair.value.is_a?(Prism::ArrayNode) ? pair.value.elements : [pair.value]
+        values.grep(Prism::SymbolNode).each { callback_edit(it) }
+      end
+    end
+
+    def callback_edit(sym)
+      name = sym.unescaped
+      entry = @index[name] or return
+      case self_coverage(entry)
+      when :all then nil
+      when :some then return report_symbol(sym, "#{name} is removed by strict mode from #{models(entry)}, but not every class this code runs in has it")
+      else return
+      end
+
+      body =
+        if entry.proxy == "attribute?" && entry.query == :truthy
+          entry.attr # callback conditions only test truthiness
+        elsif entry.proxy == "attribute?" && entry.query == :string
+          "#{entry.attr}.present?"
+        else
+          "#{entry.public_proxy || entry.proxy}(#{symbol(entry.attr)})"
+        end
+      @edits << edit(sym, "-> { #{body} }", "#{name} is removed by strict mode; use -> { #{body} }")
+    end
+
+    def report_symbol(sym, message)
+      @edits << edit(sym, nil, message) if @index[sym.unescaped] && !core?(sym.unescaped)
+    end
+
+    # On every record too (readonly?, frozen?, ...) when ActiveRecord is loaded.
+    def core?(name)
+      CORE.any? { it.method_defined?(name) || it.private_method_defined?(name) } ||
+        (defined?(::ActiveRecord::Base) && ::ActiveRecord::Base.method_defined?(name))
+    end
+
+    def models(entry)
+      names = entry.classes
+      names.size > 4 ? "#{names.first(4).join(", ")} and #{names.size - 4} more" : names.join(", ")
+    end
+
+    def edit(node, replacement, message)
+      loc = node.location
+      Edit.new(loc.start_offset, loc.end_offset, replacement, message)
+    end
+
+    # :all when self is a record of a model with the entry's attribute
+    # wherever this code runs (in the model, its subclasses, or every model
+    # including this module), :some when only in some of them, nil otherwise.
+    def self_coverage(entry)
+      return if @nesting.empty? || @class_level.positive?
+
+      name = @nesting.join("::")
+      classes =
+        if @index.model?(name) then @index.with_descendants(name)
+        elsif @index.app_module?(name) then @index.includers_of(name)
+        else return
+        end
+      covered = classes.count { entry.classes.include?(it) }
+      if covered == classes.size then :all
+      elsif covered.positive? then :some
+      end
+    end
+
+    def symbol(attr) = attr.to_sym.inspect
+
+    # Names of local variables and parameters anywhere in the file: a bare
+    # reader call with one of these names would read the local instead.
+    def locals(root)
+      names = Set.new
+      walk = lambda do |node|
+        type = node.class.name
+        names << node.name.to_s if (type.include?("LocalVariable") || type.end_with?("ParameterNode")) && node.respond_to?(:name) && node.name
+        node.compact_child_nodes.each(&walk)
+      end
+      walk.(root)
+      names
+    end
+  end
+end

data/lib/rubocop_minify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubocopMinify
+  VERSION = "0.1.0"
+end

data/lib/rubocop_minify.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rubocop_minify/version"
+require "rubocop_minify/rewrite"
+require "rubocop_minify/definitions"
+
+module RubocopMinify
+  autoload :ERB, "rubocop_minify/erb"
+
+  # One Rewrite per app root and settings: reading the manifest and scanning
+  # the app for definitions happens once per process.
+  def self.rewrite_for(root, manifest:, definition_paths:, views: false)
+    @rewrites ||= {}
+    @rewrites[[root, manifest, definition_paths, views]] ||= begin
+      path = File.expand_path(manifest, root)
+      if File.exist?(path)
+        require "ar_minimizer"
+        Rewrite.new(ArMinimizer::Manifest.load(path), defined: definitions(root, definition_paths), views: views)
+      end
+    end
+  end
+
+  def self.definitions(root, paths)
+    @definitions ||= {}
+    @definitions[[root, paths]] ||= Definitions.scan(root, paths)
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-minify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sampo Kuokkanen
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-minimizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: herb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+description: RuboCop cop and ERB fixer that rewrite calls to the attribute methods
+  activerecord-minimizer's strict mode removes (name?, name_changed?, ...) into the
+  calls they stood for, from the app's manifest.
+executables:
+- minify-erb
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- config/default.yml
+- exe/minify-erb
+- lib/rubocop-minify.rb
+- lib/rubocop/cop/minify/attribute_methods.rb
+- lib/rubocop/minify/plugin.rb
+- lib/rubocop_minify.rb
+- lib/rubocop_minify/definitions.rb
+- lib/rubocop_minify/erb.rb
+- lib/rubocop_minify/rewrite.rb
+- lib/rubocop_minify/version.rb
+homepage: https://github.com/sampokuokkanen/rails-minify/tree/main/rubocop-minify
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sampokuokkanen/rails-minify/tree/main/rubocop-minify
+  changelog_uri: https://github.com/sampokuokkanen/rails-minify/blob/main/rubocop-minify/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sampokuokkanen/rails-minify/issues
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Minify::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: RuboCop cops (and an ERB fixer) that rewrite code relying on what rails-minify
+  removes from Rails
+test_files: []