callback_hell 0.2.0

data/lib/callback_hell/reports/callbacks/line.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    module Callbacks
+      class Line < LineBase
+        private
+
+        def report_title
+          "Callback Hell callbacks report:"
+        end
+
+        def format_callback_name(callback)
+          "#{callback.kind}_#{callback.callback_group}"
+        end
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/callbacks/table.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    module Callbacks
+      class Table < TableBase
+        private
+
+        def report_title
+          "Callback Hell callbacks report"
+        end
+
+        def format_group_name(callback)
+          "#{timing_symbol(callback.kind)}/#{callback.callback_group}"
+        end
+
+        def timing_symbol(timing)
+          case timing
+          when :before, "before" then "⇥"
+          when :after, "after" then "↦"
+          when :around, "around" then "↔"
+          else
+            " "
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/github_base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    class GithubBase < Base
+      def generate
+        output = ["::group::#{report_title}"]
+
+        @stats.by_model.each_with_index do |(model_name, _), index|
+          output << "" if index > 0
+          output << "::group::#{model_name}"
+
+          # Add total row first
+          total_stats = @stats.stats_for(model_name)
+          output << format_group(
+            "all",
+            total_stats[:total],
+            total_stats[:own],
+            total_stats[:inherited],
+            total_stats[:rails],
+            total_stats[:association_generated],
+            total_stats[:attribute_generated],
+            total_stats[:gems],
+            total_stats[:conditional]
+          )
+
+          # Group and sort callbacks
+          grouped_callbacks = @stats.by_model[model_name].group_by { |cb| format_group_name(cb) }
+
+          grouped_callbacks.keys.sort.each do |group_name|
+            group_callbacks = grouped_callbacks[group_name]
+            output << format_group(
+              group_name,
+              group_callbacks.size,
+              group_callbacks.count { |cb| cb.origin == :own },
+              group_callbacks.count(&:inherited),
+              group_callbacks.count { |cb| cb.origin == :rails },
+              group_callbacks.count(&:association_generated),
+              group_callbacks.count(&:attribute_generated),
+              group_callbacks.count { |cb| cb.origin == :gems },
+              group_callbacks.count(&:conditional)
+            )
+          end
+
+          output << "::endgroup::"
+        end
+
+        output << "::endgroup::"
+        output.join("\n")
+      end
+
+      private
+
+      def report_title
+        raise NotImplementedError
+      end
+
+      def format_group(name, total, own, inherited, rails, association_generated, attribute_generated, gems, conditional)
+        "::debug::kind=#{name} total=#{total} own=#{own} inherited=#{inherited} rails=#{rails} association_generated=#{association_generated} attribute_generated=#{attribute_generated} gems=#{gems} conditional=#{conditional}"
+      end
+
+      def format_group_name(callback)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/line_base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    class LineBase < Base
+      def generate
+        output = [report_title]
+
+        @stats.by_model.each do |model_name, model_callbacks|
+          output << "\n#{model_name}:"
+          model_callbacks.sort_by(&:kind).each do |callback|
+            output << format_callback(callback)
+          end
+        end
+
+        output.join("\n")
+      end
+
+      private
+
+      def report_title
+        raise NotImplementedError
+      end
+
+      def format_callback(callback)
+        [
+          "  #{format_callback_name(callback)}",
+          "method_name: #{callback.human_method_name}",
+          "origin: #{callback.origin}",
+          "association_generated: #{callback.association_generated ? "yes" : "no"}",
+          "attribute_generated: #{callback.attribute_generated ? "yes" : "no"}",
+          "inherited: #{callback.inherited ? "inherited" : "own"}",
+          "conditional: #{callback.conditional ? "yes" : "no"}"
+        ].compact.join(", ")
+      end
+
+      def format_callback_name(callback)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/table_base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "table_tennis"
+
+module CallbackHell
+  module Reports
+    class TableBase < Base
+      def generate
+        headers = ["Model", "Kind", "Total", "Own", "Inherited"]
+        headers << "Rails" if stats.rails?
+        headers << "Associations" if stats.associations?
+        headers << "Attributes" if stats.attributes?
+        headers.concat(["Gems", "Conditional"])
+
+        headers_mapping = headers.index_by { |h| h.parameterize.to_sym }
+
+        table = TableTennis.new(generate_rows(headers_mapping.keys)) do |t|
+          t.title = report_title
+          t.headers = headers_mapping
+          t.placeholder = ""
+          t.color_scales = {total: :gr}
+
+          # Don't shrink table if we run in a test environment,
+          # we need full labels and values to test
+          t.layout = false if defined?(Rails) && Rails.env.test?
+        end
+
+        table.to_s
+      end
+
+      private
+
+      def report_title
+        raise NotImplementedError
+      end
+
+      def generate_rows(headers)
+        rows = []
+        @stats.by_model.each_with_index do |(model_name, _), index|
+          # TODO: not supported by table_tennis
+          # rows << :separator if index > 0
+          rows.concat(model_rows(model_name))
+        end
+        rows.map { headers.zip(_1).to_h }
+      end
+
+      def model_rows(model_name)
+        rows = []
+        total_stats = @stats.stats_for(model_name)
+
+        # Add total row
+        rows << [
+          model_name,
+          "all",
+          total_stats[:total],
+          total_stats[:own],
+          total_stats[:inherited],
+          stats.rails? ? total_stats[:rails] : nil,
+          stats.associations? ? total_stats[:association_generated] : nil,
+          stats.attributes? ? total_stats[:attribute_generated] : nil,
+          total_stats[:gems],
+          total_stats[:conditional]
+        ].compact
+
+        # Group and sort callbacks
+        grouped_callbacks = @stats.by_model[model_name].group_by { |cb| format_group_name(cb) }
+
+        grouped_callbacks.keys.sort.each do |group_name|
+          group_callbacks = grouped_callbacks[group_name]
+          rows << [
+            "",
+            group_name,
+            group_callbacks.size,
+            group_callbacks.count { |cb| cb.origin == :own },
+            group_callbacks.count(&:inherited),
+            stats.rails? ? group_callbacks.count { |cb| cb.origin == :rails } : nil,
+            stats.associations? ? group_callbacks.count(&:association_generated) : nil,
+            stats.attributes? ? group_callbacks.count(&:attribute_generated) : nil,
+            group_callbacks.count { |cb| cb.origin == :gems },
+            group_callbacks.count(&:conditional)
+          ].compact
+        end
+
+        rows
+      end
+
+      def format_group_name(callback)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/validations/github.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    module Validations
+      class Github < GithubBase
+        private
+
+        def report_title
+          "Callback Hell validations report"
+        end
+
+        def format_group_name(callback)
+          callback.validation_type
+        end
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/validations/line.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    module Validations
+      class Line < LineBase
+        private
+
+        def report_title
+          "Callback Hell validations report:"
+        end
+
+        def format_callback_name(callback)
+          if callback.method_name.is_a?(Symbol) || callback.method_name.is_a?(String)
+            type = callback.validation_type
+            (type == "custom") ? "custom (#{callback.method_name})" : type
+          else
+            callback.validation_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callback_hell/reports/validations/table.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  module Reports
+    module Validations
+      class Table < TableBase
+        private
+
+        def report_title
+          "Callback Hell validations report"
+        end
+
+        def format_group_name(callback)
+          callback.validation_type
+        end
+      end
+    end
+  end
+end

data/lib/callback_hell/runner.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  class Runner
+    DEFAULT_FORMAT = :table
+
+    def self.run(format: DEFAULT_FORMAT, model: nil, paths: nil, kind: :callbacks, **opts)
+      new(format: format, model: model, paths: paths, kind: kind, **opts).run
+    end
+
+    def initialize(format:, model:, paths:, kind: :callbacks, sort_by: :size, sort_order: :desc, mode: :default)
+      @format = (format || DEFAULT_FORMAT).to_sym
+      @model_name = model
+      @paths = paths
+      @kind = kind
+      @sort_by = sort_by
+      @sort_order = sort_order
+      @mode = mode
+    end
+
+    def run
+      if @kind == :report
+        [:callbacks, :validations].map do |ckind|
+          generate_report(collect_callbacks(ckind), ckind)
+        end.join("\n\n")
+      else
+        generate_report(collect_callbacks(@kind), @kind)
+      end
+    end
+
+    private
+
+    def collect_callbacks(ckind)
+      Collector.new(find_model_class, paths: @paths, kind: ckind, mode: @mode).collect
+    end
+
+    def generate_report(callbacks, ckind)
+      find_reporter_class(ckind).new(
+        callbacks, sort_by: @sort_by, sort_order: @sort_order,
+        mode: @mode, kind: ckind
+      ).generate
+    end
+
+    def find_reporter_class(ckind)
+      namespace = ckind.to_s.capitalize
+      format = @format.to_s.capitalize
+      class_name = "CallbackHell::Reports::#{namespace}::#{format}"
+      class_name.constantize
+    rescue NameError
+      raise CallbackHell::Error, "Unknown format: #{@format} for #{ckind}"
+    end
+
+    def find_model_class
+      return unless @model_name
+
+      if @model_name.match?(/^[A-Z]/)
+        @model_name.constantize
+      else
+        @model_name.classify.constantize
+      end
+    rescue NameError
+      raise CallbackHell::Error, "Cannot find model: #{@model_name}"
+    end
+  end
+end

data/lib/callback_hell/stats.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module CallbackHell
+  class Stats
+    COUNTERS = %i[
+      total own inherited rails gems conditional
+      association_generated attribute_generated
+    ].freeze
+
+    SORT = %i[size name].freeze
+    SORT_ORDER = %i[desc asc].freeze
+
+    MODE = %i[default full].freeze
+
+    attr_reader :callbacks
+    private attr_reader :sort_by, :sort_order
+
+    def initialize(callbacks, sort_by: :size, sort_order: :desc, mode: :default, kind: :callbacks)
+      @callbacks = callbacks
+      @stats_cache = {}
+      @sort_by = sort_by
+      raise ArgumentError, "Invalid sort_by: #{@sort_by}. Available: #{SORT.join(", ")}" unless SORT.include?(@sort_by)
+      @sort_order = sort_order
+      raise ArgumentError, "Invalid sort_order: #{@sort_order}. Available: #{SORT_ORDER.join(", ")}" unless SORT_ORDER.include?(@sort_order)
+      @mode = mode
+      raise ArgumentError, "Invalid mode: #{@mode}. Available: #{MODE.join(", ")}" unless MODE.include?(@mode)
+      @kind = kind
+    end
+
+    def by_model
+      @by_model ||= callbacks.group_by { |cb| cb.model.name }.sort_by do |name, callbacks|
+        if sort_by == :size
+          callbacks.size
+        elsif sort_by == :name
+          name
+        end
+      end.tap do |sorted|
+        sorted.reverse! if sort_order == :desc
+      end.to_h
+    end
+
+    def stats_for(model_name)
+      @stats_cache[model_name] ||= begin
+        model_callbacks = by_model[model_name]
+        return {} unless model_callbacks
+
+        collect_stats(model_callbacks)
+      end
+    end
+
+    def stats_for_group(model_name, group)
+      key = "#{model_name}_#{group}"
+      @stats_cache[key] ||= begin
+        model_callbacks = by_model[model_name]&.select { |cb| cb.callback_group == group }
+        return {} unless model_callbacks
+
+        collect_stats(model_callbacks)
+      end
+    end
+
+    def rails?
+      @mode == :full || @kind == :validations
+    end
+
+    def associations?
+      @mode == :full
+    end
+
+    def attributes?
+      @mode == :full
+    end
+
+    private
+
+    def collect_stats(callbacks)
+      callbacks.each_with_object(initial_stats) do |cb, stats|
+        stats[:total] += 1
+        stats[:own] += 1 if cb.origin == :own
+        stats[:inherited] += 1 if cb.inherited
+        stats[:rails] += 1 if cb.origin == :rails
+        stats[:gems] += 1 if cb.origin == :gems
+        stats[:conditional] += 1 if cb.conditional
+        stats[:association_generated] += 1 if cb.association_generated
+        stats[:attribute_generated] += 1 if cb.attribute_generated
+      end
+    end
+
+    def initial_stats
+      COUNTERS.to_h { |counter| [counter, 0] }
+    end
+  end
+end

data/lib/callback_hell/version.rb

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

data/lib/callback_hell.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+module CallbackHell
+  class Error < StandardError; end
+
+  def self.loader # @private
+    @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+      loader.ignore("#{__dir__}/tasks")
+      loader.setup
+    end
+  end
+
+  def self.collect_callbacks(*models, **options)
+    collector = Collector.new(**options)
+    collector.collect(models)
+  end
+
+  def self.collect_validations(*models, **options)
+    collector = Collector.new(**options, kind: :validations)
+    collector.collect(models)
+  end
+end
+
+CallbackHell.loader
+
+require "callback_hell/railtie" if defined?(Rails::Railtie)

data/lib/tasks/callback_hell.rake

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rails"
+
+namespace :ch do
+  desc <<~DESC
+    Generate callbacks report for Active Record models.
+
+    Options:
+      format=table|line|github   Report format (default: table)
+      model=ModelName            Filter by model name (optional). Can be
+                                 specified as constant
+                                 name (MessageThread) or file path
+                                 (message_thread, admin/message_thread)
+      sort=total|name            Sort by score or name (default: score:desc)
+      mode=default|full          Default mode collects only user-defined callbacks,
+                                 full includes association-, attribute-, or validation-generated
+                                 callbacks
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+
+    Examples:
+      # Show all models callbacks in table format (default)
+      rake ch:callbacks
+  DESC
+  task callbacks: :environment do
+    opts = {
+      kind: :callbacks,
+      format: ENV["format"],
+      model: ENV["model"],
+      mode: :default
+    }.compact
+
+    if ENV["path"]
+      opts[:paths] = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+    end
+
+    if ENV["sort"]
+      sort_by, sort_order = ENV["sort"].split(":")
+      opts[:sort_by] = sort_by.to_sym
+      sort_order ||= ((sort_by == "size") ? :desc : :asc)
+      opts[:sort_order] = sort_order.to_sym
+    end
+
+    if ENV["mode"]
+      raise ArgumentError, "Mode must be either default or full" unless ENV["mode"].in?(%w[default full])
+      opts[:mode] = ENV["mode"].to_sym
+    end
+
+    puts CallbackHell::Runner.run(**opts)
+  end
+
+  desc <<~DESC
+    Generate validations report for Active Record models.
+
+    Options:
+      format=table|line|github   Report format (default: table)
+      model=ModelName            Filter by model name (optional). Can be
+                                 specified as constant
+                                 name (MessageThread) or file path
+                                 (message_thread, admin/message_thread)
+      sort=total|name            Sort by score or name (default: score:desc)
+      mode=default|full          Default mode collects only user-defined validations,
+                                 full includes association- or attribute-generated
+                                 validations
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+
+    Examples:
+      # Show all models validations in table format (default)
+      rake ch:validations
+  DESC
+  task validations: :environment do
+    opts = {
+      kind: :validations,
+      format: ENV["format"],
+      model: ENV["model"]
+    }.compact
+
+    if ENV["path"]
+      opts[:paths] = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+    end
+
+    if ENV["sort"]
+      sort_by, sort_order = ENV["sort"].split(":")
+      opts[:sort_by] = sort_by.to_sym
+      sort_order ||= ((sort_by == "size") ? :desc : :asc)
+      opts[:sort_order] = sort_order.to_sym
+    end
+
+    if ENV["mode"]
+      raise ArgumentError, "Mode must be either default or full" unless ENV["mode"].in?(%w[default full])
+      opts[:mode] = ENV["mode"].to_sym
+    end
+
+    puts CallbackHell::Runner.run(**opts)
+  end
+
+  desc <<~DESC
+    Generate combined report (callbacks and validations) for Active Record models.
+
+    Options:
+      format=table|line|github   Report format (default: table)
+      model=ModelName            Filter by model name (optional). Can be
+                                 specified as constant
+                                 name (MessageThread) or file path
+                                 (message_thread, admin/message_thread)
+      sort=total|name            Sort by score or name (default: score:desc)
+      mode=default|full          Default mode collects only user-defined callbacks,
+                                 full includes association-, attribute-, or validation-generated
+                                 callbacks/validations
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+
+    Examples:
+      rake ch:report
+  DESC
+  task report: :environment do
+    opts = {
+      kind: :report,
+      format: ENV["format"],
+      model: ENV["model"]
+    }.compact
+
+    if ENV["path"]
+      opts[:paths] = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+    end
+
+    if ENV["sort"]
+      sort_by, sort_order = ENV["sort"].split(":")
+      opts[:sort_by] = sort_by.to_sym
+      sort_order ||= ((sort_by == "size") ? :desc : :asc)
+      opts[:sort_order] = sort_order.to_sym
+    end
+
+    if ENV["mode"]
+      raise ArgumentError, "Mode must be either default or full" unless ENV["mode"].in?(%w[default full])
+      opts[:mode] = ENV["mode"].to_sym
+    end
+
+    puts CallbackHell::Runner.run(**opts)
+  end
+end
+
+# Top-level convenience task
+desc "Generate callback and validation analysis report"
+task ch: "ch:report"