cruft_tracker 0.1.0

data/app/services/cruft_tracker/record_arguments.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CruftTracker
+  class RecordArguments < CruftTracker::ApplicationService
+    record :method, class: CruftTracker::Method
+    array :arguments
+    object :transformer, class: Proc
+
+    private
+
+    def execute
+      arguments_record.with_lock do
+        arguments_record.reload
+        arguments_record.update(occurrences: arguments_record.occurrences + 1)
+      end
+
+      arguments_record
+    end
+
+    def arguments_record
+      @arguments_record ||=
+        begin
+          CruftTracker::Argument.create(
+            method: method,
+            arguments_hash: arguments_hash,
+            arguments: transformed_arguments
+          )
+        rescue ActiveRecord::RecordNotUnique
+          CruftTracker::Argument.find_by(arguments_hash: arguments_hash)
+        end
+    end
+
+    def arguments_hash
+      Digest::MD5.hexdigest(transformed_arguments.to_json)
+    end
+
+    def transformed_arguments
+      @transformed_arguments ||= transformer.call(arguments)
+    end
+  end
+end

data/app/services/cruft_tracker/record_backtrace.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module CruftTracker
+  class RecordBacktrace < CruftTracker::ApplicationService
+    record :method, class: CruftTracker::Method
+
+    private
+
+    def execute
+      backtrace_record.with_lock do
+        backtrace_record.reload
+        backtrace_record.update(occurrences: backtrace_record.occurrences + 1)
+      end
+
+      backtrace_record
+    end
+
+    def backtrace_record
+      @backtrace_record ||=
+        begin
+          CruftTracker::Backtrace.create(
+            traceable: method,
+            trace_hash: backtrace_hash,
+            trace: filtered_backtrace
+          )
+        rescue ActiveRecord::RecordNotUnique
+          CruftTracker::Backtrace.find_by(trace_hash: backtrace_hash)
+        end
+    end
+
+    def backtrace_hash
+      Digest::MD5.hexdigest(filtered_backtrace.to_json)
+    end
+
+    def filtered_backtrace
+      last_locations_before_tracking_starts =
+        caller_locations.reverse.find_index do |location|
+          location.path.match(/.*track_method.*/)
+        end
+
+      caller_locations
+        .last(last_locations_before_tracking_starts || 0)
+        .map do |location|
+          {
+            path: location.path,
+            label: location.label,
+            base_label: location.base_label,
+            lineno: location.lineno
+          }
+        end
+    end
+  end
+end

data/app/services/cruft_tracker/record_invocation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CruftTracker
+  class RecordInvocation < CruftTracker::ApplicationService
+    record :method, class: CruftTracker::Method
+
+    def execute
+      increment_invocations
+    end
+
+    def increment_invocations
+      method.update(invocations: method.reload.invocations + 1)
+    end
+  end
+end

data/app/services/cruft_tracker/track_all_methods.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CruftTracker
+  class TrackAllMethods < CruftTracker::ApplicationService
+    object :owner, class: Object
+    object :comment, class: Object, default: nil
+
+    private
+
+    def execute
+      method_records = []
+      method_records +=
+        own_instance_methods.map do |instance_method|
+          CruftTracker::TrackMethod.run!(
+            owner: owner,
+            name: instance_method,
+            method_type: CruftTracker::Method::INSTANCE_METHOD,
+            comment: comment
+          )
+        end
+      method_records +=
+        own_class_methods.map do |class_method|
+          CruftTracker::TrackMethod.run!(
+            owner: owner,
+            name: class_method,
+            method_type: CruftTracker::Method::CLASS_METHOD,
+            comment: comment
+          )
+        end
+
+      method_records.flatten
+    end
+
+    def own_instance_methods
+      owner.instance_methods(false) + owner.private_instance_methods(false)
+    end
+
+    def own_class_methods
+      owner.methods(false) +
+        owner
+          .private_methods(false)
+          .select do |method|
+            owner.method(method).owner.inspect === owner.singleton_class.inspect
+          end
+    end
+  end
+end

data/app/services/cruft_tracker/track_method.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# require 'cruft_tracker/record_invocation'
+# require 'cruft_tracker/record_backtrace'
+module CruftTracker
+  class TrackMethod < CruftTracker::ApplicationService
+    private
+
+    object :owner, class: Module
+    symbol :name
+    symbol :method_type, default: -> { determine_method_type }
+    object :comment, class: Object, default: nil
+    object :arguments_transformer, class: Proc, default: nil
+
+    def execute
+      method_record = create_or_find_method_record
+      method_record.deleted_at = nil
+      method_record.comment = comment if comment != method_record.comment
+      method_record.save
+
+      wrap_target_method(
+        method_type,
+        target_method,
+        method_record,
+        arguments_transformer
+      )
+
+      CruftTracker::Registry << method_record
+
+      method_record
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless e.cause.present? && e.cause.instance_of?(Mysql2::Error)
+
+      Rails.logger.warn(
+        'CruftTracker was unable to record a method. Does the cruft_tracker_methods table exist? Have migrations been run?'
+      )
+    rescue NoMethodError
+      Rails.logger.warn(
+        'CruftTracker was unable to record a method. Have migrations been run?'
+      )
+    rescue Mysql2::Error::ConnectionError,
+           ActiveRecord::ConnectionNotEstablished
+      Rails.logger.warn(
+        'CruftTracker was unable to record a method due to being unable to connect to the database. This may be a non-issue in cases where the database is intentionally not available.'
+      )
+    end
+
+    def wrap_target_method(
+      method_type,
+      target_method,
+      method_record,
+      arguments_transformer
+    )
+      target_method.owner.define_method target_method.name do |*args|
+        CruftTracker::RecordInvocation.run!(method: method_record)
+        CruftTracker::RecordBacktrace.run!(method: method_record)
+        if arguments_transformer.present?
+          CruftTracker::RecordArguments.run!(
+            method: method_record,
+            arguments: args,
+            transformer: arguments_transformer
+          )
+        end
+        if method_type == CruftTracker::Method::INSTANCE_METHOD
+          target_method.bind(self).call(*args)
+        else
+          target_method.call(*args)
+        end
+      end
+    end
+
+    def create_or_find_method_record
+      CruftTracker::Method.create(
+        owner: owner.name,
+        name: name,
+        method_type: method_type,
+        comment: comment
+      )
+    rescue ActiveRecord::RecordNotUnique
+      CruftTracker::Method.find_by(
+        owner: owner.name,
+        name: name,
+        method_type: method_type
+      )
+    end
+
+    def target_method
+      case method_type
+      when CruftTracker::Method::INSTANCE_METHOD
+        owner.instance_method(name)
+      when CruftTracker::Method::CLASS_METHOD
+        owner.method(name)
+      end
+    end
+
+    def determine_method_type
+      is_instance_method = all_instance_methods.include?(name)
+      is_class_method = all_class_methods.include?(name)
+
+      if is_instance_method && is_class_method
+        raise AmbiguousMethodType.new(owner.name, name)
+      elsif is_instance_method
+        CruftTracker::Method::INSTANCE_METHOD
+      elsif is_class_method
+        CruftTracker::Method::CLASS_METHOD
+      else
+        raise NoSuchMethod.new(owner.name, name)
+      end
+    end
+
+    def all_instance_methods
+      owner.instance_methods + owner.private_instance_methods
+    end
+
+    def all_class_methods
+      owner.methods + owner.private_methods
+    end
+
+    class AmbiguousMethodType < StandardError
+      def initialize(owner_name, ambiguous_name)
+        super(
+          "#{owner_name} has instance and class methods named '#{
+            ambiguous_name
+          }'. Please specify the correct type."
+        )
+      end
+    end
+
+    class NoSuchMethod < StandardError
+      def initialize(owner_name, missing_name)
+        super(
+          "#{owner_name} does not have an instance or class method named '#{
+            missing_name
+          }'."
+        )
+      end
+    end
+  end
+end

data/app/views/cruft_tracker/methods/index.html.erb

@@ -0,0 +1 @@
+hi!!

data/app/views/layouts/cruft_tracker/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Cruft tracker</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "cruft_tracker/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,3 @@
+CruftTracker::Engine.routes.draw do
+  resources :methods, only: %i[index]
+end

data/db/migrate/20220414134857_create_cruft_tracker_methods.rb

@@ -0,0 +1,17 @@
+class CreateCruftTrackerMethods < ActiveRecord::Migration[5.2]
+  def change
+    create_table :cruft_tracker_methods do |t|
+      t.string :owner, null: false
+      t.string :name, null: false
+      t.string :method_type, null: false
+      t.integer :invocations, null: false, default: 0
+      t.datetime :deleted_at
+      t.timestamps
+
+      t.index :owner
+      t.index :name
+      t.index %i[owner name]
+      t.index %i[owner name method_type], unique: true
+    end
+  end
+end

data/db/migrate/20220418133030_create_cruft_tracker_backtraces.rb

@@ -0,0 +1,20 @@
+class CreateCruftTrackerBacktraces < ActiveRecord::Migration[5.2]
+  def change
+    create_table :cruft_tracker_backtraces do |t|
+      t.references :traceable,
+                   polymorphic: true,
+                   null: false,
+                   index: {
+                     name: 'index_pcbt_on_traceable_id_and_type'
+                   }
+      t.string :trace_hash, null: false, index: true
+      t.json :trace, null: false
+      t.integer :occurrences, null: false, index: true, default: 0
+      t.timestamps
+
+      t.index %i[traceable_id trace_hash],
+              unique: true,
+              name: 'index_pcbt_on_traceable_id_and_trace_hash'
+    end
+  end
+end

data/db/migrate/20220419171326_add_comment_to_cruft_tracker_methods.rb

@@ -0,0 +1,9 @@
+class AddCommentToCruftTrackerMethods < ActiveRecord::Migration[5.2]
+  def change
+    add_column :cruft_tracker_methods,
+               :comment,
+               :json,
+               null: true,
+               after: :invocations
+  end
+end

data/db/migrate/20220419174055_create_cruft_tracker_arguments.rb

@@ -0,0 +1,15 @@
+class CreateCruftTrackerArguments < ActiveRecord::Migration[5.2]
+  def change
+    create_table :cruft_tracker_arguments do |t|
+      t.references :method, null: false
+      t.string :arguments_hash, null: false, index: true
+      t.json :arguments, null: false
+      t.integer :occurrences, null: false, index: true, default: 0
+      t.timestamps
+
+      t.index %i[method_id arguments_hash],
+              unique: true,
+              name: 'index_pca_on_method_id_and_arguments_hash'
+    end
+  end
+end

data/lib/cruft_tracker/engine.rb

@@ -0,0 +1,17 @@
+module CruftTracker
+  class Engine < ::Rails::Engine
+    isolate_namespace CruftTracker
+
+    config.after_initialize do
+      CruftTracker::CleanupUntrackedMethods.run!
+    rescue StandardError
+      # Swallow all errors to prevent initialization failures.
+    end
+
+    # initializer 'cruft_tracker.action_controller' do |app|
+    #   ActiveSupport.on_load(:action_controller) do
+    #     ::ActionController::Base.helper(CruftTracker::ApplicationHelper)
+    #   end
+    # end
+  end
+end

data/lib/cruft_tracker/registry.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CruftTracker
+  class Registry
+    include Singleton
+
+    attr_accessor :tracked_methods
+
+    def self.<<(tracked_method)
+      instance.tracked_methods << tracked_method
+    end
+
+    def self.include?(tracked_method)
+      instance.tracked_methods.include?(tracked_method)
+    end
+
+    def self.reset
+      instance.tracked_methods = []
+    end
+
+    def initialize
+      @tracked_methods = []
+    end
+  end
+end

data/lib/cruft_tracker/version.rb

@@ -0,0 +1,3 @@
+module CruftTracker
+  VERSION = '0.1.0'
+end

data/lib/cruft_tracker.rb

@@ -0,0 +1,31 @@
+require 'cruft_tracker/version'
+require 'cruft_tracker/engine'
+require 'cruft_tracker/registry'
+
+module CruftTracker
+  # Your code goes here...
+
+  def self.is_this_view_used?
+    puts '>>>> is this view used?'
+  end
+
+  def self.is_this_method_used?(
+    owner,
+    name,
+    method_type: nil,
+    comment: nil,
+    track_arguments: nil
+  )
+    CruftTracker::TrackMethod.run!(
+      owner: owner,
+      name: name,
+      method_type: method_type,
+      comment: comment,
+      arguments_transformer: track_arguments
+    )
+  end
+
+  def self.are_any_of_these_methods_being_used?(owner, comment: nil)
+    CruftTracker::TrackAllMethods.run!(owner: owner, comment: comment)
+  end
+end

data/lib/tasks/cruft_tracker_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cruft_tracker do
+#   # Task goes here
+# end