why-classes 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49efb3c918546952656ce560c450af6b1789e75b2292311bc1775092e736a65c
-  data.tar.gz: a5fa304162f3af5851c059ce0e808340abfa9e08b0ea1174d430f7f252a20417
+  metadata.gz: 9de2667919d94d511885316c479efec18017e6b4aef44ff77b188a6e6e7b09f3
+  data.tar.gz: 72a6e64e8c1e0723c8e1dc40bd7edc6790e442dfb6786b752b22cbd9b75cbae0
 SHA512:
-  metadata.gz: efbf0be84df9e152612e5bb3ea4142260471fbdec61b53487224c499b0b4dbfcd9ac10fbd72494843e4726e13c866391d6dcdbc95091e7fab8fee6117bb9b605
-  data.tar.gz: b0bc59250372fb99e49cf12909ed921bc2d86d70d3631b7a3dbb698acf6d8bb2e67249ab93377c6737a6306f67f7c5c63d2f7ebe46e0ba6e8ec3749e518fa83c
+  metadata.gz: 4a140aeb0b4d8cefc2dc29e1fe0a401821a8f67d901a8b2b6d85ea4a16da34512f4d14d64db2f33f3e1795f01cf21e897e1ecbede42b0fc92f82e2ebe87f71fa
+  data.tar.gz: 5cc2be7da1cf8b8637355fec2be91bb0a92e3bd8dbd9eddd211f9b496b07a3266338808e5a6bd91cc7ee5e0067852ef14f881413ee444db184204791edd814d8

data/README.md

@@ -19,12 +19,31 @@ detection and autocorrection share one coordinate system.
 
 | Rule | Smell | Suggests | Autocorrect |
 |------|-------|----------|-------------|
-| `DataBucket` | `attr_*` + a field-assigning `initialize`, no behaviour | `Struct.new` / `Data.define` | ✅ `--fix` |
-| `StatelessSingletonMethods` | only `self.` methods, no state | `module` + `extend self` | advice |
-| `FunctionBucket` | a single `call`/`perform`/`run`, no state | `module_function` | advice |
+| `DataBucket` | `attr_*` + a field-assigning `initialize`, no behaviour | `Struct.new` / `Data.define` | ✅ `--fix` (safe) |
+| `StatelessSingletonMethods` | only `self.` methods, no state | `module` + `extend self` | ⚠️ `--fix-unsafe` |
+| `FunctionBucket` | a single `call`/`perform`/`run`, no state | `module_function` | ⚠️ `--fix-unsafe` |
 | `InvalidInitialState` | `initialize` leaves a field `nil`, needs a setter first | pass it in / drop the object | advice |
 | `InheritanceForMixins` | inheriting a fat base (`< ActiveRecord::Base`) for behaviour | include only the mixins you use | advice |
-| `SingleAttributeReader` | a method that only reads one field | a freestanding function | advice (off by default) |
+| `SingleAttributeReader` | a method that only reads one field | a freestanding function | ⚠️ `--fix-unsafe` (off by default) |
+
+**Autocorrect tiers.** `--fix` applies only the *safe* tier (`DataBucket`): a
+self-contained, within-file transform. The *unsafe* tier (`StatelessSingletonMethods`,
+`FunctionBucket`, `SingleAttributeReader`) is mechanically correct in the file but can
+break call sites in files this tool never saw — `Foo.new`, subclassing, `Foo.new.call`,
+or `person.age` becoming `age(person)` — so it is opt-in via `--fix-unsafe` (which
+implies `--fix`). Always review the diff. Run `--list-rules` to see each rule's tier.
+
+`SingleAttributeReader` extracts an instance method that only reads one field into a
+freestanding function (Thomas's "decoupled polymorphism"). Two `ParameterStyle`s:
+
+```ruby
+# before                              # entity (default)          # attribute
+class Person                          def age_in_seconds(entity)  def age_in_seconds(date_of_birth)
+  def age_in_seconds            =>      Time.now -                  Time.now - date_of_birth
+    Time.now - @date_of_birth             entity.date_of_birth    end
+  end                                 end
+end
+```
 
 `attr_reader`-only buckets become immutable `Data.define`; `attr_accessor`/`attr_writer`
 buckets (mutation expected) become `Struct.new`.
@@ -44,7 +63,9 @@ why-classes                       # scan the current directory, report + suggest
 why-classes app/models/point.rb   # scan one file
 why-classes --diff app/           # preview the rewrites as a unified diff
 why-classes --fix app/            # apply the safe (DataBucket) rewrites
+why-classes --fix-unsafe app/     # also rewrite stateless classes -> modules
 why-classes --only DataBucket app # run a single rule
+why-classes --cache app/          # cache results for faster re-scans
 why-classes --format json app     # machine-readable output
 why-classes --list-rules          # list every rule
 ```
@@ -63,13 +84,17 @@ app/models/point.rb:1:1: [DataBucket] [correctable] Point is a data bucket: it o
 | Flag | Meaning |
 |------|---------|
 | `--diff`, `--dry-run` | show a diff of proposed rewrites; write nothing |
-| `-a`, `--fix` | apply suggested (safe-tier) corrections and write files |
-| `--fix-unsafe` | also apply unsafe-tier corrections (reserved for future rules) |
+| `-a`, `--fix` | apply safe-tier corrections (`DataBucket`) and write files |
+| `--fix-unsafe` | also apply unsafe-tier corrections (module / `module_function`); implies `--fix` |
 | `--only A,B` / `--except A,B` | select rules |
 | `--format progress\|clang\|json\|diff` | output format (default `progress`) |
 | `--config PATH` | use a specific `.why-classes.yml` |
 | `--[no-]rails` | toggle Rails awareness |
 | `--fail-level none\|convention\|warning` | CI exit-code threshold (default `convention`) |
+| `--cache` / `--cache-dir PATH` | cache results on disk for faster re-scans (report modes only) |
+| `--list-rules` | list every rule with its tier (`[--fix]` / `[--fix-unsafe]` / `[advice]`) |
+| `-v`, `--version` | print the version and exit |
+| `-h`, `--help` | print usage and exit |
 
 Exit codes: `0` clean (or below the fail level), `1` offenses found, `2` usage error.
 

data/config/default.yml

@@ -44,6 +44,10 @@ Rules:
 
   SingleAttributeReader:
     Enabled: false             # noisy; opt-in
+    # Freestanding function shape used by --fix-unsafe:
+    #   entity    -> def age_in_seconds(entity);  entity.date_of_birth ...
+    #   attribute -> def age_in_seconds(date_of_birth); date_of_birth ...
+    ParameterStyle: entity
 
 Rails:
   # Subclasses of these legitimately must be classes -> suppress the

data/lib/why_classes/cli.rb

@@ -50,13 +50,18 @@ module WhyClasses
 
         o.on("--diff", "--dry-run", "Show a diff of proposed rewrites; write nothing") { @collected[:mode] = :diff }
         o.on("-a", "--fix", "Apply suggested (safe-tier) corrections and write files") { @collected[:mode] = :fix }
-        o.on("--fix-unsafe", "Also apply unsafe-tier corrections") { @collected[:fix_unsafe] = true }
+        o.on("--fix-unsafe", "Also apply unsafe-tier corrections (implies --fix)") do
+          @collected[:fix_unsafe] = true
+          @collected[:mode] ||= :fix
+        end
         o.on("--only RULES", Array, "Run only these rules") { |v| @collected[:only] = v }
         o.on("--except RULES", Array, "Skip these rules") { |v| @collected[:except] = v }
         o.on("--format FORMAT", "Output format: #{VALID_FORMATS.join(', ')}") { |v| @collected[:format] = v }
         o.on("--config PATH", "Path to a .why-classes.yml") { |v| @collected[:config_path] = v }
         o.on("--[no-]rails", "Toggle Rails awareness") { |v| @collected[:rails] = v }
         o.on("--fail-level LEVEL", "CI exit threshold: #{VALID_FAIL_LEVELS.join(', ')}") { |v| @collected[:fail_level] = v }
+        o.on("--cache", "Cache analysis results on disk (report modes only)") { @collected[:cache] = true }
+        o.on("--cache-dir PATH", "Directory for the cache (default .why-classes-cache)") { |v| @collected[:cache_dir] = v }
         o.on("--list-rules", "List all rules and exit") { list_rules_and_exit }
         o.on("-v", "--version", "Print version and exit") { print_version_and_exit }
         o.on("-h", "--help", "Print this help and exit") { print_help_and_exit(o) }
@@ -73,9 +78,15 @@ module WhyClasses
       end
     end
 
+    TIER_LABELS = {
+      suggested: "[--fix]       ",
+      unsafe: "[--fix-unsafe]",
+      none: "[advice]      "
+    }.freeze
+
     def list_rules_and_exit
       Registry.all.sort_by(&:rule_name).each do |rule|
-        mark = rule.autocorrectable? ? "[correctable]" : "[advice]    "
+        mark = TIER_LABELS.fetch(rule.tier, "[advice]      ")
         @io.puts "#{mark} #{rule.rule_name.ljust(28)} #{rule.description}"
       end
       @early_exit = 0

data/lib/why_classes/correction_plan.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+
+module WhyClasses
+  # Decides which correctable offenses should actually be applied, given the
+  # configuration and whether --fix-unsafe was requested. Detection ("is there a
+  # corrector?") is separate from application ("should we run it?"): a rule can
+  # report a rewrite as available while the plan declines to apply it.
+  module CorrectionPlan
+    module_function
+
+    def applicable(offenses, configuration:, fix_unsafe: false)
+      offenses.select { |offense| apply?(offense, configuration, fix_unsafe) }
+    end
+
+    def apply?(offense, configuration, fix_unsafe)
+      return false if offense.corrector.nil?
+
+      # No Enabled re-check here: offenses only exist for rules that were active
+      # (see Registry.active), so a --only-forced rule can still autocorrect.
+      tier = Registry.fetch(offense.rule_name).tier
+      case tier
+      when :suggested
+        configuration.autocorrect?(offense.rule_name)
+      when :unsafe
+        fix_unsafe
+      else
+        false
+      end
+    end
+  end
+end

data/lib/why_classes/correctors/function_bucket_corrector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../ast/node_helpers"
+
+module WhyClasses
+  module Correctors
+    # Rewrites a single-function "service object" class into a module function:
+    #
+    #   class CreateUser        =>   module CreateUser
+    #     def call                     module_function
+    #       ...
+    #     end                          def call
+    #   end                              ...
+    #                                    end
+    #                                  end
+    #
+    # Unsafe-tier: `CreateUser.new.call` call sites elsewhere would break.
+    module FunctionBucketCorrector
+      module_function
+
+      def correctable?(shape)
+        return false if shape.module?
+        return false if shape.superclass?
+        return false if shape.uses_metaprogramming?
+        return false unless shape.initialize_method.nil?
+        return false unless shape.singleton_methods.empty?
+
+        shape.behavior_methods.size == 1
+      end
+
+      def corrector(class_node, method_node)
+        lambda do |rewriter|
+          rewriter.replace(class_node.location.keyword, "module")
+          inner = " " * (class_node.location.keyword.column + 2)
+          rewriter.insert_before(method_node.location.expression, "module_function\n\n#{inner}")
+        end
+      end
+    end
+  end
+end

data/lib/why_classes/correctors/polymorphic_function_corrector.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "../ast/node_helpers"
+
+module WhyClasses
+  module Correctors
+    # Decoupled polymorphism (Dave Thomas): an instance method that only reads a
+    # single field is more flexible as a freestanding function. This corrector
+    # *extracts* such a method out of the class:
+    #
+    #   class Person                        def age_in_seconds(entity)
+    #     def initialize(dob)         =>       Time.now - entity.date_of_birth
+    #       @date_of_birth = dob            end
+    #     end
+    #                                       # class keeps only what remains
+    #     def age_in_seconds
+    #       Time.now - @date_of_birth
+    #     end
+    #   end
+    #
+    # Two parameter styles:
+    #   :entity    -> `def age_in_seconds(entity)`  using `entity.date_of_birth`
+    #                 (works for anything responding to the reader)
+    #   :attribute -> `def age_in_seconds(date_of_birth)` using `date_of_birth`
+    #                 (the "even more generic" form -- just the value)
+    #
+    # Unsafe-tier: every `person.age_in_seconds` call site elsewhere must become
+    # `age_in_seconds(person)`, which this single-file tool cannot rewrite.
+    module PolymorphicFunctionCorrector
+      H = AST::NodeHelpers
+
+      module_function
+
+      def correctable?(shape, method_node)
+        return false if shape.uses_metaprogramming?
+        return false unless no_parameters?(method_node)
+
+        read = H.ivars_read(method_node)
+        return false unless read.size == 1
+        return false unless H.ivars_assigned(method_node).empty?
+        return false if leans_on_self?(method_node, shape)
+
+        true
+      end
+
+      def corrector(class_node, method_node, style:)
+        field = H.ivars_read(method_node).first.to_s.delete_prefix("@")
+        lambda do |rewriter|
+          buffer = class_node.location.expression.source_buffer
+          rewriter.remove(removal_range(buffer, method_node))
+          rewriter.insert_after(class_node.location.end, "\n\n#{freestanding(class_node, method_node, field, style)}")
+        end
+      end
+
+      # --- preconditions -------------------------------------------------------
+
+      def no_parameters?(method_node)
+        args = method_node.children[1]
+        args.nil? || args.children.empty?
+      end
+
+      # Bail when the body depends on the receiver in ways extraction would break:
+      # `self`, `super`, blocks (`yield`), or a bare call to a sibling method.
+      def leans_on_self?(method_node, shape)
+        siblings = shape.instance_method_names - [method_node.children[0]]
+        H.collect(method_node) do |n|
+          %i[self zsuper super yield].include?(n.type) ||
+            (n.type == :send && n.children[0].nil? && siblings.include?(n.children[1]))
+        end.any?
+      end
+
+      # --- rewriting -----------------------------------------------------------
+
+      def freestanding(class_node, method_node, field, style)
+        param = style == :attribute ? field : "entity"
+        replacement = style == :attribute ? field : "#{param}.#{field}"
+        body = rewritten_source(method_node, field, param: param, replacement: replacement)
+        reindent(body, class_node.location.keyword.column, method_node.location.keyword.column)
+      end
+
+      # Splice the method's own source: add the parameter and rewrite each ivar
+      # read. Offsets are relative to the method's start.
+      def rewritten_source(method_node, field, param:, replacement:)
+        base = method_node.location.expression.begin_pos
+        src = method_node.location.expression.source
+        edits = []
+        name_end = method_node.location.name.end_pos - base
+        edits << [name_end, name_end, "(#{param})"]
+        H.collect(method_node) { |n| n.type == :ivar && n.children[0] == :"@#{field}" }.each do |ivar|
+          edits << [ivar.location.expression.begin_pos - base, ivar.location.expression.end_pos - base, replacement]
+        end
+        splice(src, edits)
+      end
+
+      def splice(str, edits)
+        edits.sort_by { |start, _stop, _text| -start }.each do |start, stop, text|
+          str = str[0...start] + text + str[stop..]
+        end
+        str
+      end
+
+      # The method source has no leading indent on line 1 and absolute indent on
+      # the rest. Shift it to sit at the class's indentation level: line 1 gets
+      # the target indent; the remaining lines are dedented by the difference
+      # between the method's indent and the target.
+      def reindent(source, target_col, method_col)
+        delta = [method_col - target_col, 0].max
+        pad = " " * target_col
+        source.lines.each_with_index.map do |line, i|
+          i.zero? ? pad + line : line.sub(/\A {0,#{delta}}/, "")
+        end.join
+      end
+
+      # Range covering the method's whole line(s) plus its trailing newline, and
+      # one preceding blank line if present, for a tidy removal.
+      def removal_range(buffer, method_node)
+        expr = method_node.location.expression
+        source = buffer.source
+        line_start = expr.begin_pos - method_node.location.keyword.column
+        stop = expr.end_pos
+        stop += 1 if source[stop] == "\n"
+        line_start -= 1 if source[line_start - 1] == "\n" && source[line_start - 2] == "\n"
+        ::Parser::Source::Range.new(buffer, line_start, stop)
+      end
+    end
+  end
+end

data/lib/why_classes/correctors/stateless_module_corrector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../ast/node_helpers"
+
+module WhyClasses
+  module Correctors
+    # Rewrites a stateless "class of class-methods" into a module that exposes the
+    # same methods via `extend self`:
+    #
+    #   class Checksum          =>   module Checksum
+    #     def self.calculate(id)         def calculate(id)
+    #       ...                            ...
+    #     end                            end
+    #   end
+    #                                    extend self
+    #                                  end
+    #
+    # Unsafe-tier: mechanical within the file, but `Checksum.new`, subclassing,
+    # or `Checksum.superclass` elsewhere would break.
+    module StatelessModuleCorrector
+      H = AST::NodeHelpers
+
+      module_function
+
+      # Convertible only when every class method uses the `def self.x` form.
+      # A `class << self` block is bailed on (kept as advice).
+      def correctable?(shape)
+        return false if shape.module?
+        return false if shape.superclass?
+        return false if shape.uses_metaprogramming?
+        return false unless shape.instance_methods.empty?
+        return false if shape.singleton_methods.empty?
+
+        body = H.body_statements(H.class_body(shape.node))
+        body.none? { |n| H.node?(n) && n.type == :sclass }
+      end
+
+      def corrector(class_node)
+        lambda do |rewriter|
+          rewriter.replace(class_node.location.keyword, "module")
+          H.singleton_methods(class_node).each do |defs|
+            receiver = defs.children[0]
+            self_dot = receiver.location.expression.join(defs.location.operator)
+            rewriter.remove(self_dot)
+          end
+          inner = " " * (class_node.location.keyword.column + 2)
+          rewriter.insert_before(class_node.location.end, "\n#{inner}extend self\n")
+        end
+      end
+    end
+  end
+end

data/lib/why_classes/offense.rb

@@ -17,8 +17,11 @@ module WhyClasses
     :correctable,
     :corrector
   ) do
+    # Whether a corrector is available (display marker). Stays true across cache
+    # round-trips even though the non-serializable corrector proc is dropped;
+    # actually applying an edit checks #corrector directly (see CorrectionPlan).
     def correctable?
-      correctable && !corrector.nil?
+      correctable
     end
 
     # Sort key: by position within a file.

data/lib/why_classes/options.rb

@@ -13,7 +13,9 @@ module WhyClasses
     :format,
     :config_path,
     :rails,
-    :fail_level
+    :fail_level,
+    :cache,
+    :cache_dir
   ) do
     def self.defaults(**overrides)
       new(**{
@@ -25,7 +27,9 @@ module WhyClasses
         format: "progress",
         config_path: nil,
         rails: nil,
-        fail_level: "convention"
+        fail_level: "convention",
+        cache: false,
+        cache_dir: ".why-classes-cache"
       }.merge(overrides))
     end
   end

data/lib/why_classes/registry.rb

@@ -29,10 +29,17 @@ module WhyClasses
     end
 
     # Resolve the rule classes to run given config + CLI selection.
+    #
+    # An explicit --only forces the listed rules on even if they are disabled by
+    # default/config (mirrors RuboCop's --only); otherwise the config's Enabled
+    # flag decides.
     def active(configuration:, only: nil, except: nil)
-      selected = all
-      selected = selected.select { |r| Array(only).include?(r.rule_name) } if only && !only.empty?
-      selected = selected.reject { |r| Array(except).include?(r.rule_name) } if except && !except.empty?
+      only = Array(only)
+      except = Array(except)
+      selected = all.reject { |r| except.include?(r.rule_name) }
+
+      return selected.select { |r| only.include?(r.rule_name) } unless only.empty?
+
       selected.select { |r| configuration.enabled?(r.rule_name) }
     end
   end

data/lib/why_classes/rule.rb

@@ -25,7 +25,16 @@ module WhyClasses
 
       # Whether this rule can ever autocorrect. Advice-only rules return false.
       def autocorrectable?
-        false
+        tier != :none
+      end
+
+      # Autocorrection tier:
+      #   :suggested -- mechanical and low-risk; applied by --fix
+      #   :unsafe    -- correct in-file but may break cross-file call sites;
+      #                 applied only by --fix-unsafe
+      #   :none      -- advice only, no corrector
+      def tier
+        :none
       end
 
       def inherited(subclass)

data/lib/why_classes/rules/data_bucket.rb

@@ -13,8 +13,8 @@ module WhyClasses
         "Class that only holds data (attr_* + field-assigning initialize) -> use Struct or Data."
       end
 
-      def self.autocorrectable?
-        true
+      def self.tier
+        :suggested
       end
 
       def on_class(node)
@@ -52,7 +52,6 @@ module WhyClasses
 
       def build_corrector(node, _shape, analysis)
         return nil if analysis.nil?
-        return nil unless configuration.autocorrect?(self.class.rule_name)
 
         name = H.class_name(node)
         replacement = analysis.replacement(name)

data/lib/why_classes/rules/function_bucket.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rule"
+require_relative "../correctors/function_bucket_corrector"
 
 module WhyClasses
   module Rules
@@ -13,6 +14,10 @@ module WhyClasses
         "Class with a single call/perform/run method and no state -> use a module function."
       end
 
+      def self.tier
+        :unsafe
+      end
+
       def on_class(node)
         s = shape(node)
         return if s.name.nil?
@@ -20,14 +25,21 @@ module WhyClasses
         return if s.superclass? # framework/base subclasses handled above; other inheritance is separate
         return unless function_bucket?(s)
 
-        method = s.behavior_methods.first.children[0]
+        method_node = s.behavior_methods.first
+        method = method_node.children[0]
+        corrector =
+          if Correctors::FunctionBucketCorrector.correctable?(s)
+            Correctors::FunctionBucketCorrector.corrector(node, method_node)
+          end
+
         add_offense(
           node,
           message: "#{s.name} is a bucket for a single function (`##{method}`) with no state.",
           suggestion: "Prefer a module function or a plain method:\n" \
                       "    module #{s.name}\n      module_function\n\n" \
                       "      def #{method}(...)\n        ...\n      end\n    end\n" \
-                      "  Callers become `#{s.name}.#{method}(...)` with no throwaway instance."
+                      "  Callers become `#{s.name}.#{method}(...)` with no throwaway instance.",
+          corrector: corrector
         )
       end
 

data/lib/why_classes/rules/single_attribute_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rule"
+require_relative "../correctors/polymorphic_function_corrector"
 
 module WhyClasses
   module Rules
@@ -12,6 +13,10 @@ module WhyClasses
         "Instance method that only reads one field -> consider a freestanding polymorphic function."
       end
 
+      def self.tier
+        :unsafe
+      end
+
       def on_class(node)
         s = shape(node)
         return if s.name.nil?
@@ -27,12 +32,34 @@ module WhyClasses
           add_offense(
             method,
             message: "#{s.name}##{method.children[0]} only reads @#{field}; it isn't tied to #{s.name}.",
-            suggestion: "A freestanding function is more flexible and works on any object " \
-                        "exposing `#{field}`:\n" \
-                        "    def #{method.children[0]}(#{field})\n      # use #{field} directly\n    end"
+            suggestion: suggestion(method, field),
+            corrector: build_corrector(node, s, method)
           )
         end
       end
+
+      private
+
+      def build_corrector(class_node, shape, method)
+        return nil unless Correctors::PolymorphicFunctionCorrector.correctable?(shape, method)
+
+        Correctors::PolymorphicFunctionCorrector.corrector(class_node, method, style: parameter_style)
+      end
+
+      def parameter_style
+        rule_option("ParameterStyle", "entity").to_sym
+      end
+
+      def suggestion(method, field)
+        name = method.children[0]
+        if parameter_style == :attribute
+          "A freestanding function is more flexible; pass the value directly:\n" \
+            "    def #{name}(#{field})\n      # use #{field} instead of @#{field}\n    end"
+        else
+          "A freestanding function works on any object exposing `#{field}`:\n" \
+            "    def #{name}(entity)\n      # use entity.#{field} instead of @#{field}\n    end"
+        end
+      end
     end
   end
 end

data/lib/why_classes/rules/stateless_singleton_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rule"
+require_relative "../correctors/stateless_module_corrector"
 
 module WhyClasses
   module Rules
@@ -12,6 +13,10 @@ module WhyClasses
         "Class with only class methods and no state -> use a module with `extend self`."
       end
 
+      def self.tier
+        :unsafe
+      end
+
       def on_class(node)
         s = shape(node)
         return if s.name.nil?
@@ -19,6 +24,11 @@ module WhyClasses
         return if configuration.framework_base_class?(s.superclass)
         return unless only_singleton_methods?(s)
 
+        corrector =
+          if Correctors::StatelessModuleCorrector.correctable?(s)
+            Correctors::StatelessModuleCorrector.corrector(node)
+          end
+
         add_offense(
           node,
           message: "#{s.name} has only class methods and no state; it's a bucket of functions, " \
@@ -26,7 +36,8 @@ module WhyClasses
           suggestion: "Make it a module and expose the methods with `extend self`:\n" \
                       "    module #{s.name}\n      def #{example_method(s)}(...)\n        ...\n      end\n\n" \
                       "      private\n      # helper methods here are now genuinely private\n\n" \
-                      "      extend self\n    end"
+                      "      extend self\n    end",
+          corrector: corrector
         )
       end
 
@@ -38,8 +49,8 @@ module WhyClasses
         return false unless s.attr_fields.empty?
         return false if s.uses_metaprogramming?
 
-        # Allow only constants / comments as other statements.
-        s.other_statements.all? { |n| %i[casgn].include?(n.type) }
+        # Allow only constants and `class << self` blocks as other statements.
+        s.other_statements.all? { |n| %i[casgn sclass].include?(n.type) }
       end
 
       def example_method(s)

data/lib/why_classes/runner.rb

@@ -6,6 +6,8 @@ require_relative "source_file"
 require_relative "file_finder"
 require_relative "disable_comments"
 require_relative "correction"
+require_relative "correction_plan"
+require_relative "cache"
 require_relative "formatters/progress_formatter"
 require_relative "formatters/clang_formatter"
 require_relative "formatters/json_formatter"
@@ -60,7 +62,7 @@ module WhyClasses
     end
 
     def process(source_file)
-      offenses = offenses_for(source_file)
+      offenses = analyze_with_cache(source_file)
       corrected, applied = maybe_correct(source_file, offenses)
       FileReport.new(
         path: source_file.path,
@@ -74,9 +76,9 @@ module WhyClasses
     def maybe_correct(source_file, offenses)
       return [source_file.source, 0] unless correcting?
 
-      correctable = offenses.select do |offense|
-        offense.correctable? && @configuration.autocorrect?(offense.rule_name)
-      end
+      correctable = CorrectionPlan.applicable(
+        offenses, configuration: @configuration, fix_unsafe: @options.fix_unsafe
+      )
       result = Correction.apply(source_file, correctable)
       write_file(source_file.path, result.source) if @options.mode == :fix && result.source != source_file.source
       [result.source, result.applied]
@@ -86,6 +88,28 @@ module WhyClasses
       %i[fix diff].include?(@options.mode)
     end
 
+    # Cache is only consulted in report modes: correcting needs live corrector
+    # procs, which are never serialized.
+    def analyze_with_cache(source_file)
+      return offenses_for(source_file) unless cache
+
+      cache.fetch(source_file) || cache.store(source_file, offenses_for(source_file))
+    end
+
+    def cache
+      return @cache if defined?(@cache)
+
+      @cache =
+        if @options.cache && !correcting?
+          require "json"
+          Cache.new(
+            dir: @options.cache_dir,
+            config_digest: Digest::SHA256.hexdigest(@configuration.raw.to_json),
+            rule_names: Registry.active(configuration: @configuration, only: @options.only, except: @options.except).map(&:rule_name)
+          )
+        end
+    end
+
     def write_file(path, source)
       File.write(path, source)
     end

data/lib/why_classes/version.rb

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

data/lib/why_classes.rb

@@ -12,6 +12,7 @@ require_relative "why_classes/configuration"
 require_relative "why_classes/config_loader"
 require_relative "why_classes/disable_comments"
 require_relative "why_classes/correction"
+require_relative "why_classes/correction_plan"
 require_relative "why_classes/file_finder"
 
 # Rules self-register with the Registry when required.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: why-classes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Gabriel Quaresma
@@ -46,7 +46,7 @@ description: |
   mechanically-safe refactorings (notably data bucket -> Struct/Data) can be applied
   automatically with --fix.
 email:
-- gabriel.quaresma@codeminer42.com
+- j.quaresmasantos_98@hotmail.com
 executables:
 - why-classes
 extensions: []
@@ -59,11 +59,16 @@ files:
 - lib/why_classes.rb
 - lib/why_classes/ast/class_shape.rb
 - lib/why_classes/ast/node_helpers.rb
+- lib/why_classes/cache.rb
 - lib/why_classes/cli.rb
 - lib/why_classes/config_loader.rb
 - lib/why_classes/configuration.rb
 - lib/why_classes/correction.rb
+- lib/why_classes/correction_plan.rb
 - lib/why_classes/correctors/data_bucket_corrector.rb
+- lib/why_classes/correctors/function_bucket_corrector.rb
+- lib/why_classes/correctors/polymorphic_function_corrector.rb
+- lib/why_classes/correctors/stateless_module_corrector.rb
 - lib/why_classes/disable_comments.rb
 - lib/why_classes/file_finder.rb
 - lib/why_classes/formatters/base_formatter.rb
@@ -85,12 +90,12 @@ files:
 - lib/why_classes/runner.rb
 - lib/why_classes/source_file.rb
 - lib/why_classes/version.rb
-homepage: https://github.com/gabriel-quaresma/why-classes
+homepage: https://github.com/joaoGabriel55/why-classes
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/gabriel-quaresma/why-classes
-  source_code_uri: https://github.com/gabriel-quaresma/why-classes
+  homepage_uri: https://github.com/joaoGabriel55/why-classes
+  source_code_uri: https://github.com/joaoGabriel55/why-classes
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -106,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Detect over-use of classes in Ruby and refactor toward modules, Struct and
   Data.