modelscope 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bce912a368e26f345cb884efa8e2a812c8ca58dae75d856cf6aba131bc3c6d9b
-  data.tar.gz: 0fc51f66a85f939a811e851b061d95b9bc64bee134b9eb5c39dde04dca4a14a1
+  metadata.gz: 797e5f9be7613c91445fe7079db6889653f1807efb0c65fd571bdd4371e3dba9
+  data.tar.gz: 12c425ccff813c02fcf3570cbb7da963da2b933397af1931460e27b51373771c
 SHA512:
-  metadata.gz: d1fbf5acaa0f20d6e47f44712f3d72a0f22b6ab297156fa7fce87bfe16b157166cacf3befaaa3e098c0e5005bd9e5f475ee45d15003b742523839dfa16e5985d
-  data.tar.gz: fcbda96d45601414867abfe42d86e12b4e7441f3fd07d6a401ca4004dd7fa30b460fcf7a64af46a6be3529ba9a90fbdbb676391dd563acdf341c7a582053f9f1
+  metadata.gz: 78a6d989e9fe646b473b2e4518152ff77dd32b4d0b3adf2d29fe8bf6d86a395d068f8f4193d484ae748d86ecc7453fc0cb8d2376e52e3972c27791a0660a9030
+  data.tar.gz: 307b3ee5b3fee4df6fcd06b7a52d4606cddf409f75faafabc1a5409bd64f892441f9742f4d22fc2009585acd5c5fd4645a2b3d45921d0c2dd19fcfbfed25bb24

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,167 @@
+# 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?
+        owner = callback_owner
+        return false unless owner
+
+        if validator?(@filter)
+          @model != @defining_class
+        else
+          owner != @model &&
+            !rails_module?(owner) &&
+            owner != @defining_class
+        end
+      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,38 @@
+# frozen_string_literal: true
+
+module ModelScope
+  class Callback
+    attr_reader :model, :method_name, :conditional, :origin, :inherited, :kind,
+      :association_generated, :attribute_generated
+
+    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?
+    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
+  end
+end

data/lib/modelscope/collector.rb

@@ -0,0 +1,69 @@
+# 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
+      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 }
+        .flat_map { |ancestor| collect_callbacks_for_class(model, ancestor) }
+    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)
+        @callbacks = callbacks
+        @stats = Stats.new(callbacks)
+      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,59 @@
+# frozen_string_literal: true
+
+module ModelScope
+  class Runner
+    DEFAULT_FORMAT = :table
+
+    def self.run(format: DEFAULT_FORMAT, model: nil, paths: nil, kind: :callbacks)
+      new(format: format, model: model, paths: paths, kind: kind).run
+    end
+
+    def initialize(format:, model:, paths:, kind: :callbacks)
+      @format = (format || DEFAULT_FORMAT).to_sym
+      @model_name = model
+      @paths = paths
+      @kind = kind
+    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).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,59 @@
+# frozen_string_literal: true
+
+module ModelScope
+  class Stats
+    COUNTERS = %i[
+      total own inherited rails gems conditional
+      association_generated attribute_generated
+    ].freeze
+
+    attr_reader :callbacks
+
+    def initialize(callbacks)
+      @callbacks = callbacks
+      @stats_cache = {}
+    end
+
+    def by_model
+      @by_model ||= callbacks.group_by { |cb| cb.model.name }
+    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.0"
 end

data/lib/modelscope.rb

@@ -1,4 +1,19 @@
 # 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
+end
+
+ModelScope.loader
+
 require "modelscope/railtie" if defined?(Rails::Railtie)

data/lib/tasks/modelscope.rake

@@ -0,0 +1,80 @@
+# 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)
+      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
+    paths = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+
+    puts ModelScope::Runner.run(
+      format: ENV["format"],
+      model: ENV["model"],
+      paths: paths,
+      kind: :callbacks
+    )
+  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)
+      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
+    paths = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+
+    puts ModelScope::Runner.run(
+      format: ENV["format"],
+      model: ENV["model"],
+      paths: paths,
+      kind: :validations
+    )
+  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)
+      path=DIR1,DIR2             Additional model directories (comma-separated)
+  DESC
+  task report: :environment do
+    paths = ENV["path"]&.split(",")&.map { |p| Rails.root.join(p) }
+
+    puts ModelScope::Runner.run(
+      format: ENV["format"],
+      model: ENV["model"],
+      paths: paths,
+      kind: :report
+    )
+  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.0
 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: []