modelscope 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bce912a368e26f345cb884efa8e2a812c8ca58dae75d856cf6aba131bc3c6d9b
-  data.tar.gz: 0fc51f66a85f939a811e851b061d95b9bc64bee134b9eb5c39dde04dca4a14a1
+  metadata.gz: 4e40c1dcb806b8b59a48b18a239a7160b6c816e61a173896bc1f5b233395d884
+  data.tar.gz: 3cb1b59b808eaa01eba216b5e53c4b7286a8aa145fdca08697835a8716c20621
 SHA512:
-  metadata.gz: d1fbf5acaa0f20d6e47f44712f3d72a0f22b6ab297156fa7fce87bfe16b157166cacf3befaaa3e098c0e5005bd9e5f475ee45d15003b742523839dfa16e5985d
-  data.tar.gz: fcbda96d45601414867abfe42d86e12b4e7441f3fd07d6a401ca4004dd7fa30b460fcf7a64af46a6be3529ba9a90fbdbb676391dd563acdf341c7a582053f9f1
+  metadata.gz: 37802c37e0d1cb44f696eaea22c8531f1433e543a15ae23a5a3e283c0bb31f5bb26b948f3558d25a37aa64a81ca9ebcb1129b18aec9a4147b04500e62812b12f
+  data.tar.gz: a1c81b68ae3d3b3dfe8ff9108216ce5ec554de75724d061b8d99d1f6b1af87956f04328bf020eb3a0a71723c82ee32e89853667b60865673a9b6311d4feca8f5

data/README.md

@@ -1,3 +1,85 @@
+## Description
+
+Build an initial implementation of Model Scope.
+
+### Example usage
+
+As an end user, I'd like to install a gem and run a Rake task to get the report:
+
+```sh
+$ bundle add modelscope --group development
+
+$ bin/rails modelscope:callbacks
+
+Model Scope callbacks report:
+
+Model | Kind         | Total | Own | Inherited | Rails | Gems | Conditional |
+------|--------------|-------|-----|-----------|-------|------|-------------|
+User  |  all         |  23   |  5  |     2     |   8   |   8  |    21       |
+      | b/validation |  3    |  1  |     0     |   1   |   1  |     2       |
+      | a/save       |  13   |  5  |     4     |   3   |   2  |     4       |
+
+# ...
+```
+
+The `rails modelscope:validations` task works in a similar fashion.
+
+The **key features** in the example:
+
+- The library should work without requiring adding any custom code; just adding the gem to the bundle should be enough to use it.
+- For each model we show the total number of callbacks in two dimensions: callback kind (`before_create`, `after_save`, etc.) and **origin distributions** (where the callback is defined). We also count conditional callbacks separately.
+
+### References
+
+There is an outdated project called [arca](https://github.com/jonmagic/arca), which has some code (for older Rails versions) to get the callbacks information from models.
+
+Feel free to re-use its parts if you find them useful.
+
+## Tasks
+
+- [x] Research the possibility of extending the set of parameters to analyze callbacks (right now we have "kind", "origin", "conditional" — what else could be useful?)
+- [x] Implement core functionality for callbacks (an API which accepts a model class and returns all the data)
+- [x] Come up with the set of paramters for validations — what information can we get from Active Record, which could be useful?
+- [x] Implement core functionality for validations
+- [x] Implement a Rake task with table-like output for console (it's okay to use gems to format the output — we aim for a good UX)
+- [x] Don't forget about tests/CI at all stages.
+
+## Future considerations
+
+Please, keep in mind the potential future extensions when designing a library:
+
+- Different output formats/modes support (JSON, Web UI, etc.)
+- Ability to filter models by name.
+- Modular architecture support (multiple `app/models` directories).
+
+---
+
+# Development log
+
+Structure: Runner runs the task, Collector collects Callback's, Callback represends a single "find", Stats does the stats for reports if needed, Report formats the existing data (several kinds of reports).
+
+Table report done via `terminal-table`.
+
+Added the `line` report format for debugging. Also added `github` report format for GitHub Actions (reference: Rubocop).
+
+`model` parameter for the rake tasks supports both class names and relative file names.
+
+Now supporting `paths` parameter for extra paths, and auto loading models from Rails Engines.
+
+Integration specs are done using checking the output of `line` formatter.
+
+Unit tests are simple, the actual logic is in the integration tests.
+
+Re: "Research the possibility of extending the set of parameters to analyze callbacks" added two categories of callbacks: caused by attributes, and caused by associations.
+
+Added `rake modelscope:validations` that heavily reuses existing code.
+
+Using custom matchers to check for callbacks. And custom matchers for validations. Lots of integration tests.
+
+TODO: rename. callback_hell is a nice name. modelscope is taken.
+
+---
+
 [![Gem Version](https://badge.fury.io/rb/modelscope.svg)](https://rubygems.org/gems/modelscope) [![Build](https://github.com/evilmartians/modelscope/workflows/Build/badge.svg)](https://github.com/evilmartians/modelscope/actions)
 [![JRuby Build](https://github.com/evilmartians/modelscope/workflows/JRuby%20Build/badge.svg)](https://github.com/evilmartians/modelscope/actions)
 

data/lib/modelscope/analyzers/callback_analyzer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Analyzers
+    class CallbackAnalyzer
+      RAILS_GEMS = %w[
+        actioncable actionmailbox actionmailer actionpack actiontext
+        actionview activejob activemodel activerecord activestorage
+        activesupport railties
+      ].freeze
+
+      RAILS_ATTRIBUTE_OWNERS = [
+        defined?(ActiveRecord::Normalization) ? ActiveRecord::Normalization : ActiveModel::Attributes::Normalization,
+        ActiveRecord::Encryption::EncryptableRecord
+      ].freeze
+
+      def initialize(callback, model, defining_class)
+        @callback = callback
+        @model = model
+        @defining_class = defining_class
+        @filter = callback.filter
+      end
+
+      def origin
+        if rails_callback?
+          :rails
+        elsif external_class?
+          :gems
+        elsif !@filter.is_a?(Symbol)
+          :own
+        else
+          external_method?(callback_method) ? :gems : :own
+        end
+      end
+
+      def inherited?
+        @model != @defining_class
+      end
+
+      def conditional?
+        [@callback.instance_variable_get(:@if),
+          @callback.instance_variable_get(:@unless)].any? do |condition|
+          next false if condition.nil?
+          [*condition].any? { |c| c.is_a?(Symbol) || c.is_a?(Proc) }
+        end
+      end
+
+      def association_generated?
+        generated_by_module?("GeneratedAssociationMethods") ||
+          from_rails_path?(%r{/active_record/(autosave_association\.rb|associations/builder)}) ||
+          ValidationAnalyzer.belongs_to_validator?(@filter, @model)
+      end
+
+      def attribute_generated?
+        generated_by_module?("GeneratedAttributeMethods") ||
+          generated_by_rails_attributes? ||
+          from_rails_path?("active_record/attribute_methods/")
+      end
+
+      private
+
+      def rails_callback?
+        ValidationAnalyzer.belongs_to_validator?(@filter, @model) || standard_rails_callback?
+      end
+
+      def standard_rails_callback?
+        case @filter
+        when Symbol, Proc then from_rails_path?
+        else @defining_class == ApplicationRecord
+        end
+      end
+
+      def callback_owner
+        @callback_owner ||= determine_owner
+      end
+
+      def determine_owner
+        case @filter
+        when Symbol then callback_method&.owner
+        when Proc then nil
+        when ActiveModel::Validator, ActiveModel::EachValidator then @defining_class
+        else @filter.class
+        end
+      end
+
+      def callback_method
+        return nil unless @filter.is_a?(Symbol) || @filter.is_a?(String)
+
+        @callback_method ||= begin
+          @model.instance_method(@filter)
+        rescue
+          nil
+        end
+      end
+
+      def source_location
+        @source_location ||= case @filter
+        when Symbol, String then callback_method&.source_location&.first
+        when Proc then @filter.source_location&.first
+        end.to_s
+      end
+
+      def external_class?
+        @defining_class != @model && !@model.ancestors.include?(@defining_class)
+      end
+
+      def external_method?(method)
+        return false unless method
+
+        source = method.source_location&.first.to_s
+        !from_app_path?(source)
+      end
+
+      def from_app_path?(path)
+        path.start_with?(Rails.root.to_s) &&
+          !path.start_with?(Rails.root.join("vendor").to_s)
+      end
+
+      def generated_by_module?(suffix)
+        callback_method&.owner&.name&.end_with?("::" + suffix) || false
+      end
+
+      def generated_by_rails_attributes?
+        method = callback_method
+        return false unless method
+
+        RAILS_ATTRIBUTE_OWNERS.include?(method.owner)
+      end
+
+      def from_rails_path?(subpath = nil)
+        return false if source_location.empty?
+
+        rails_paths.any? do |rails_path|
+          case subpath
+          when String
+            source_location.include?("/#{subpath}")
+          when Regexp
+            source_location.match?(subpath)
+          else
+            source_location.include?(rails_path)
+          end
+        end
+      end
+
+      def rails_paths
+        @rails_paths ||= RAILS_GEMS.map { |name| Gem::Specification.find_by_name(name).full_gem_path }
+      end
+
+      def rails_module?(mod)
+        mod.name&.start_with?("ActiveRecord::", "ActiveModel::")
+      end
+
+      def validator?(obj)
+        obj.is_a?(ActiveModel::Validator)
+      end
+    end
+  end
+end

data/lib/modelscope/analyzers/validation_analyzer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Analyzers
+    class ValidationAnalyzer
+      STANDARD_VALIDATIONS = %w[
+        presence uniqueness format length inclusion exclusion
+        numericality acceptance confirmation
+      ].freeze
+
+      STANDARD_VALIDATION_PATTERN = /^validates?_(#{STANDARD_VALIDATIONS.join("|")})(?:_of)?$/
+
+      class << self
+        def belongs_to_validator?(filter, model)
+          presence_validator?(filter) &&
+            association_attribute?(filter.attributes.first, model, :belongs_to)
+        end
+
+        def detect_type(filter, model)
+          return nil unless filter
+
+          if belongs_to_validator?(filter, model)
+            "associated"
+          elsif validator?(filter)
+            validator_type(filter)
+          else
+            normalize_validation_name(filter.to_s)
+          end
+        end
+
+        def human_method_name(filter)
+          case filter
+          when Proc then format_proc_location(filter)
+          when Class, ActiveModel::Validator then format_validator(filter)
+          else filter.to_s
+          end
+        end
+
+        private
+
+        def presence_validator?(filter)
+          filter.is_a?(ActiveRecord::Validations::PresenceValidator)
+        end
+
+        def association_attribute?(attribute, model, macro)
+          model.reflect_on_association(attribute)&.macro == macro
+        end
+
+        def validator?(obj)
+          obj.class <= ActiveModel::EachValidator
+        end
+
+        def validator_type(validator)
+          validator.class.name.demodulize.sub("Validator", "").underscore
+        end
+
+        def normalize_validation_name(name)
+          case name
+          when STANDARD_VALIDATION_PATTERN, /^validate_(#{STANDARD_VALIDATIONS.join("|")})$/
+            $1
+          when /associated_records_for_/
+            "associated"
+          else
+            "custom"
+          end
+        end
+
+        def format_proc_location(proc)
+          location = proc.source_location
+          return "Proc (unknown location)" unless location
+
+          file = location.first.split("/").last(2).join("/")
+          "Proc (#{file}:#{location.last})"
+        end
+
+        def format_validator(validator)
+          "#{validator.class.name.split("::").last} (#{validator.attributes.join(", ")})"
+        end
+      end
+    end
+  end
+end

data/lib/modelscope/callback.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ModelScope
+  class Callback
+    attr_reader :model, :method_name, :conditional, :origin, :inherited, :kind,
+      :association_generated, :attribute_generated, :callback, :defining_class,
+      :fingerprint
+
+    def initialize(model:, rails_callback:, name:, defining_class:)
+      @model = model
+      @callback = rails_callback
+      @name = name
+      @defining_class = defining_class
+
+      analyzer = Analyzers::CallbackAnalyzer.new(@callback, model, defining_class)
+
+      @kind = @callback.kind
+      @method_name = @callback.filter
+      @conditional = analyzer.conditional?
+      @origin = analyzer.origin
+      @inherited = analyzer.inherited?
+      @association_generated = analyzer.association_generated?
+      @attribute_generated = analyzer.attribute_generated?
+      # fingerprint allows us to de-duplicate callbacks/validations;
+      # in most cases, it's just an object_id, but for named validations/callbacks,
+      # it's a combination of the name, kind and the method_name.
+      # The "0" and "1" prefixes define how to handle duplicates (1 means last write wins, 0 means first write wins)
+      @fingerprint = (@method_name.is_a?(Symbol) && @origin != :rails) ? ["1", @name, @kind, @method_name].join("-") : "0-#{@callback.object_id}"
+    end
+
+    def callback_group
+      @name.to_s
+    end
+
+    def validation_type
+      return nil unless callback_group == "validate"
+      Analyzers::ValidationAnalyzer.detect_type(@callback.filter, model)
+    end
+
+    def human_method_name
+      Analyzers::ValidationAnalyzer.human_method_name(@callback.filter)
+    end
+
+    def to_s
+      [
+        "#{model.name}: #{human_method_name}",
+        "kind=#{kind}_#{callback_group}",
+        "origin=#{origin}",
+        inherited ? "inherited=true" : nil,
+        conditional ? "conditional=true" : nil,
+        association_generated ? "association=true" : nil,
+        attribute_generated ? "attribute=true" : nil
+      ].compact.join(" ")
+    end
+  end
+end

data/lib/modelscope/collector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ModelScope
+  class Collector
+    attr_reader :models
+
+    def initialize(models = nil, paths: nil, kind: :callbacks)
+      @paths = paths
+      @kind = kind
+
+      eager_load!
+      @models = Set.new(models ? [*models] : ApplicationRecord.descendants)
+    end
+
+    def collect(select_models = models)
+      select_models.flat_map { |model| collect_for_model(model) }
+    end
+
+    private
+
+    def eager_load!
+      Rails.application.eager_load!
+      load_additional_paths
+    end
+
+    def collect_for_model(model)
+      model.ancestors.select { |ancestor| ancestor < ActiveRecord::Base }
+        # collect from parent to child to correctly handle inheritance
+        .reverse
+        .flat_map { |ancestor| collect_callbacks_for_class(model, ancestor) }
+        .group_by(&:fingerprint)
+        # merge groups
+        .transform_values do |callbacks|
+          probe = callbacks.first
+          if probe.fingerprint.start_with?("1")
+            # we must keep the last non-matching callback (i.e., if all callbacks are the same,
+            # we must keep the first one)
+            callbacks.each do |clbk|
+              if clbk.callback != probe.callback
+                probe = clbk
+              end
+            end
+          end
+          probe
+        end
+        .values
+    end
+
+    def collect_callbacks_for_class(model, klass)
+      callbacks = klass.__callbacks
+      callbacks = callbacks.slice(:validate) if @kind == :validations
+
+      callbacks.flat_map do |kind, chain|
+        chain.map { |callback| build_callback(model, callback, kind, klass) }
+      end
+    end
+
+    def build_callback(model, callback, kind, klass)
+      Callback.new(
+        model: model,
+        rails_callback: callback,
+        name: kind,
+        defining_class: klass
+      )
+    end
+
+    def load_additional_paths
+      model_paths.each do |path|
+        Dir[File.join(path, "**", "*.rb")].sort.each { |file| require_dependency file }
+      end
+    end
+
+    def model_paths
+      @model_paths ||= begin
+        paths = engine_paths
+        paths += [@paths] if @paths
+        paths.select(&:exist?)
+      end
+    end
+
+    def engine_paths
+      @engine_paths ||= Rails::Engine.subclasses.map { |engine| engine.root.join("app/models") }
+    end
+  end
+end

data/lib/modelscope/railtie.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-module Modelscope # :nodoc:
-  class Railtie < ::Rails::Railtie # :nodoc:
+module ModelScope
+  class Railtie < ::Rails::Railtie
+    load "tasks/modelscope.rake"
   end
 end

data/lib/modelscope/reports/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Reports
+    class Base
+      attr_reader :callbacks
+
+      def initialize(callbacks, **opts)
+        @callbacks = callbacks
+        @stats = Stats.new(callbacks, **opts)
+      end
+
+      def generate
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/modelscope/reports/callbacks/github.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Reports
+    module Callbacks
+      class Github < GithubBase
+        private
+
+        def report_title
+          "Model Scope 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/modelscope/reports/callbacks/line.rb

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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Reports
+    module Callbacks
+      class Table < TableBase
+        private
+
+        def report_title
+          "Model Scope 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/modelscope/reports/github_base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ModelScope
+  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/modelscope/reports/line_base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ModelScope
+  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/modelscope/reports/table_base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module ModelScope
+  module Reports
+    class TableBase < Base
+      def generate
+        table = Terminal::Table.new do |t|
+          t.title = report_title
+          t.headings = ["Model", "Kind", "Total", "Own", "Inherited", "Rails", "Associations", "Attributes", "Gems", "Conditional"]
+          t.rows = generate_rows
+        end
+
+        table.to_s
+      end
+
+      private
+
+      def report_title
+        raise NotImplementedError
+      end
+
+      def generate_rows
+        rows = []
+        @stats.by_model.each_with_index do |(model_name, _), index|
+          rows << :separator if index > 0
+          rows.concat(model_rows(model_name))
+        end
+        rows
+      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],
+          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]
+          rows << [
+            "",
+            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
+
+        rows
+      end
+
+      def format_group_name(callback)
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ModelScope
+  module Reports
+    module Validations
+      class Line < LineBase
+        private
+
+        def report_title
+          "Model Scope 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/modelscope/reports/validations/table.rb

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

data/lib/modelscope/runner.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ModelScope
+  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)
+      @format = (format || DEFAULT_FORMAT).to_sym
+      @model_name = model
+      @paths = paths
+      @kind = kind
+      @sort_by = sort_by
+      @sort_order = sort_order
+    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).collect
+    end
+
+    def generate_report(callbacks, ckind)
+      find_reporter_class(ckind).new(callbacks, sort_by: @sort_by, sort_order: @sort_order).generate
+    end
+
+    def find_reporter_class(ckind)
+      namespace = ckind.to_s.capitalize
+      format = @format.to_s.capitalize
+      class_name = "ModelScope::Reports::#{namespace}::#{format}"
+      class_name.constantize
+    rescue NameError
+      raise ModelScope::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 ModelScope::Error, "Cannot find model: #{@model_name}"
+    end
+  end
+end

data/lib/modelscope/stats.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ModelScope
+  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
+
+    attr_reader :callbacks
+    private attr_reader :sort_by, :sort_order
+
+    def initialize(callbacks, sort_by: :size, sort_order: :desc)
+      @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)
+    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
+
+    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/modelscope/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Modelscope # :nodoc:
-  VERSION = "0.0.1"
+module ModelScope
+  VERSION = "0.1.1"
 end

data/lib/modelscope.rb

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

data/lib/tasks/modelscope.rake

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rails"
+
+namespace :modelscope 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)
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+
+    Examples:
+      # Show all models callbacks in table format (default)
+      rake modelscope:callbacks
+  DESC
+  task callbacks: :environment do
+    opts = {
+      kind: :callbacks,
+      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
+
+    puts ModelScope::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)
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+
+    Examples:
+      # Show all models validations in table format (default)
+      rake modelscope: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
+
+    puts ModelScope::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)
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+  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
+
+    puts ModelScope::Runner.run(**opts)
+  end
+end

metadata

@@ -1,43 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: modelscope
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-17 00:00:00.000000000 Z
+date: 2025-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :development
+        version: '7.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: combustion
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +79,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -78,18 +133,29 @@ files:
 - LICENSE.txt
 - README.md
 - lib/modelscope.rb
+- lib/modelscope/analyzers/callback_analyzer.rb
+- lib/modelscope/analyzers/validation_analyzer.rb
+- lib/modelscope/callback.rb
+- lib/modelscope/collector.rb
 - lib/modelscope/railtie.rb
+- lib/modelscope/reports/base.rb
+- lib/modelscope/reports/callbacks/github.rb
+- lib/modelscope/reports/callbacks/line.rb
+- lib/modelscope/reports/callbacks/table.rb
+- lib/modelscope/reports/github_base.rb
+- lib/modelscope/reports/line_base.rb
+- lib/modelscope/reports/table_base.rb
+- lib/modelscope/reports/validations/github.rb
+- lib/modelscope/reports/validations/line.rb
+- lib/modelscope/reports/validations/table.rb
+- lib/modelscope/runner.rb
+- lib/modelscope/stats.rb
 - lib/modelscope/version.rb
+- lib/tasks/modelscope.rake
 homepage: http://github.com/evilmartians/modelscope
 licenses:
 - MIT
-metadata:
-  bug_tracker_uri: http://github.com/evilmartians/modelscope/issues
-  changelog_uri: https://github.com/palkan/modelscope/blob/master/CHANGELOG.md
-  documentation_uri: http://github.com/evilmartians/modelscope
-  homepage_uri: http://github.com/evilmartians/modelscope
-  source_code_uri: http://github.com/evilmartians/modelscope
-post_install_message:
+metadata: {}
 rdoc_options: []
 require_paths:
 - lib
@@ -97,15 +163,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key:
+rubygems_version: 3.6.5
 specification_version: 4
 summary: Rails models analyzers
 test_files: []