is_this_used 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b45e5ae45262a6793a2d31dbc938dc1ca7dce14c41badab9f098281010c0fd7
-  data.tar.gz: 83027360fc9f6ea7eb6f5209bf76e26f812acc1a6f017d25ae8c102e8dc384d5
+  metadata.gz: cce63d34e732bc62aaae3b0c3b6ec1dd2624a778db4f634a1a2cc111345c62dd
+  data.tar.gz: 80dfa1ff9f4689b3468b237674061a7a5dfc452c6e89d52c031b3e0d9c101c9e
 SHA512:
-  metadata.gz: 7a563b281bf91261a8796ee3cf96ca7b93856f40e97db803aff7139bf554cfbf9fb9965bee06afa7e8b27f1571d14067aa6f9fbce087cb070dabeaad7c143e37
-  data.tar.gz: 0116de239d46752d0240b6b76aadc56c7962f3e64b7e19f39080e7fa1a11eee73d9f7bd8a61287eb53b71d24604706f303529e0b6bd1d3a0941cc2719221ab78
+  metadata.gz: ec65d766721e3b41c649f557418ea9d9e1b1ca03b99610c2c1394508d1798f002560943ef7a5aadb55dcd05519346d79977cd764f6d70be53e463886ce883288
+  data.tar.gz: 4feb1afae406fc3dbec90584d8ee54dee4a1a4893e32d1a79b29c569c6d5c26b1f4d9be78f9635b195ec31aa2a517919da88499dece5099fe1798734299ca5e8

data/README.md

@@ -40,6 +40,8 @@ actually occur.
 
 ## Usage
 
+### `is_this_used?`
+
 is_this_used is pretty simple. Let's say you have a class (or module) like this...
 
 ```ruby
@@ -75,7 +77,7 @@ in the `potential_crufts` table that looks like this:
 
 | id  | owner_name   | method_name     | method_type     | invocations | deleted_at | created_at          | updated_at          |
 | --- | ------------ | --------------- | --------------- | ----------- | ---------- | ------------------- | ------------------- |
-| 1   | SomeOldClass | some_old_method | instance_method | 0           | null       | 2022-01-21 14:07:48 | 2022-01-21 14:07:48 | 
+| 1   | SomeOldClass | some_old_method | instance_method | 0           | null       | 2022-01-21 14:07:48 | 2022-01-21 14:07:48 |
 
 This is easily accessed using the `IsThisUsed::PotentialCruft` model class.
 
@@ -102,7 +104,7 @@ So, having annotated the method, you can check this table after a while. If you
 you have a reasonably good hint that the method may not actually be used. Of course, you should consider that there are
 some processes that are not run frequently at all, so this gem isn't a panacea. Think before you delete!
 
-### Tracking Stacks
+#### Tracking Stacks
 
 In the case that a method _is_ actually invoked, the `invocations` value is incremented and a record is created in
 the `potential_cruft_stacks` table for each unique invocation stacktrace. This can be used to determine which methods
@@ -148,7 +150,7 @@ The `label` and `base_label` fields come from Ruby's `Thread::Backtrace::Locatio
 difference is, as the docs simply say this about `base_label`: "Usually same as label, without decoration". 🤷 Anyhow,
 it's there if you need it.
 
-### Tracking Arguments
+#### Tracking Arguments
 
 In addition to tracking stacks, you can track details about arguments provided to tracked methods. For example, let's say you have the following method:
 
@@ -196,8 +198,11 @@ The above would result in the following records in `potential_cruft_arguments` (
 | 1619ec6af47253461e87ebf1923a8a83 | ["color", "locality"]          | 1           |
 | 88c8205498de97d4ef06b249006bb68b | ["status"]                     | 1           |
 
+### `is_any_of_this_stuff_used?`
 
+Let's say you have a class and you're wondering what, if anything, in that class is used. You probably don't want to tag every single method in that class with `is_this_used?`. Instead, you can add `is_any_of_this_stuff_used?` as the last line in that class. When the class is loaded, is_this_used will identify all of the instance and class methods defined directly on the object itself and track each one of those, just as if you'd tagged them individually with `is_this_used?`.
 
+The `is_any_of_this_stuff_used?` method does not accept any arguments and cannot be used to track arguments. However, you can use both `is_this_used?` and `is_any_of_this_stuff_used?` at the same time. If you want to track everything in a class, but track arguments for a specific method, simply tag that method with `is_this_used?` and specify the `track_arguments` argument. Be sure to place `is_any_of_this_stuff_used?` as the last line within the class. Now that one method will have its arguments tracked while the others will simply be tracked normally.
 
 ## Models
 

data/lib/generators/is_this_used/templates/create_potential_cruft_arguments.rb.erb

@@ -7,6 +7,10 @@ class CreatePotentialCruftArguments < ActiveRecord::Migration<%= migration_versi
       t.json :arguments, null: false
       t.integer :occurrences, null: false, index: true, default: 0
       t.timestamps
+
+      t.index %i[potential_cruft_id arguments_hash],
+              unique: true,
+              name: 'index_pca_on_potential_cruft_id_and_arguments_hash'
     end
   end
 end

data/lib/generators/is_this_used/templates/create_potential_cruft_stacks.rb.erb

@@ -7,6 +7,10 @@ class CreatePotentialCruftStacks < ActiveRecord::Migration<%= migration_version
       t.json :stack, null: false
       t.integer :occurrences, null: false, index: true, default: 0
       t.timestamps
+
+      t.index %i[potential_cruft_id stack_hash],
+              unique: true,
+              name: 'index_pcs_on_potential_cruft_id_and_stack_hash'
     end
   end
 end

data/lib/generators/is_this_used/templates/create_potential_crufts.rb.erb

@@ -11,7 +11,10 @@ class CreatePotentialCrufts < ActiveRecord::Migration<%= migration_version %>
 
       t.index :owner_name
       t.index :method_name
-      t.index %i(owner_name method_name)
+      t.index %i[owner_name method_name]
+      t.index %i[owner_name method_name method_type],
+              unique: true,
+              name: 'index_pc_on_owner_name_and_method_name_and_method_type'
     end
   end
 end

data/lib/is_this_used/cruft_tracker.rb

@@ -21,18 +21,26 @@ module IsThisUsed
 
         potential_cruft_stack =
           PotentialCruftStack.find_by(
-            potential_cruft: potential_cruft, stack_hash: stack_hash
+            stack_hash: stack_hash
           )
-        potential_cruft_stack ||=
-          PotentialCruftStack.new(
-            potential_cruft: potential_cruft,
-            stack_hash: stack_hash,
-            stack: stack
-          )
-
-        potential_cruft_stack.occurrences += 1
 
-        potential_cruft_stack.save
+        potential_cruft_stack ||= begin
+                                    PotentialCruftStack.create(
+                                      potential_cruft: potential_cruft,
+                                      stack_hash: stack_hash,
+                                      stack: stack
+                                    )
+                                  rescue ActiveRecord::RecordNotUnique
+                                    PotentialCruftStack.find_by(
+                                      stack_hash: stack_hash
+                                    )
+                                  end
+
+        potential_cruft_stack.with_lock do
+          potential_cruft_stack.reload
+          potential_cruft_stack.occurrences += 1
+          potential_cruft_stack.save!
+        end
       end
 
       def self.filtered_stack
@@ -55,18 +63,24 @@ module IsThisUsed
 
         potential_cruft_argument =
           PotentialCruftArgument.find_by(
-            potential_cruft: potential_cruft, arguments_hash: arguments_hash
-          )
-        potential_cruft_argument ||=
-          PotentialCruftArgument.new(
-            potential_cruft: potential_cruft,
-            arguments_hash: arguments_hash,
-            arguments: arguments
+            arguments_hash: arguments_hash
           )
-
-        potential_cruft_argument.occurrences += 1
-
-        potential_cruft_argument.save
+        potential_cruft_argument ||= begin
+                                       PotentialCruftArgument.create(
+                                         potential_cruft: potential_cruft,
+                                         arguments_hash: arguments_hash,
+                                         arguments: arguments
+                                       )
+                                     rescue ActiveRecord::RecordNotUnique
+                                       PotentialCruftArgument.find_by(
+                                         arguments_hash: arguments_hash
+                                       )
+                                     end
+
+        potential_cruft_argument.with_lock do
+          potential_cruft_argument.occurrences += 1
+          potential_cruft_argument.save!
+        end
       end
     end
 
@@ -75,17 +89,23 @@ module IsThisUsed
     end
 
     module ClassMethods
+      def potentially_crufty_methods_being_tracked
+        @potentially_crufty_methods_being_tracked ||= []
+      end
+
       def is_this_used?(method_name, method_type: nil, track_arguments: false)
         IsThisUsed::Util::LogSuppressor.suppress_logging do
           method_type ||= determine_method_type(method_name)
+
+          tracked_method_identifier = "#{method_name}/#{method_type}"
+          return if potentially_crufty_methods_being_tracked.include?(tracked_method_identifier)
+
           target_method = target_method(method_name, method_type)
 
-          potential_cruft =
-            PotentialCruft.find_or_create_by(
-              owner_name: self.name,
-              method_name: method_name,
-              method_type: method_type
-            )
+          potential_cruft = create_or_find_potential_cruft(
+            method_name: method_name,
+            method_type: method_type
+          )
 
           potential_cruft.update(deleted_at: nil) if potential_cruft.deleted_at.present?
 
@@ -106,6 +126,8 @@ module IsThisUsed
               target_method.call(*args)
             end
           end
+
+          potentially_crufty_methods_being_tracked << tracked_method_identifier
         end
       rescue ActiveRecord::StatementInvalid => e
         raise unless e.cause.present? && e.cause.instance_of?(Mysql2::Error)
@@ -123,6 +145,15 @@ module IsThisUsed
         )
       end
 
+      def is_any_of_this_stuff_used?
+        own_instance_methods.each do |instance_method|
+          is_this_used?(instance_method, method_type: INSTANCE_METHOD)
+        end
+        own_class_methods.each do |class_method|
+          is_this_used?(class_method, method_type: CLASS_METHOD)
+        end
+      end
+
       def target_method(method_name, method_type)
         case method_type
         when INSTANCE_METHOD
@@ -133,12 +164,8 @@ module IsThisUsed
       end
 
       def determine_method_type(method_name)
-        is_instance_method =
-          (self.instance_methods + self.private_instance_methods).include?(
-            method_name
-          )
-        is_class_method =
-          (self.methods + self.private_methods).include?(method_name)
+        is_instance_method = all_instance_methods(self).include?(method_name)
+        is_class_method = all_class_methods(self).include?(method_name)
 
         if is_instance_method && is_class_method
           raise AmbiguousMethodType.new(self.name, method_name)
@@ -150,6 +177,47 @@ module IsThisUsed
           raise NoSuchMethod.new(self.name, method_name)
         end
       end
+
+      def all_instance_methods(object)
+        object.instance_methods + object.private_instance_methods
+      end
+
+      def all_class_methods(object)
+        object.methods + object.private_methods
+      end
+
+      def own_instance_methods
+        ancestors_instance_methods =
+          (self.ancestors - [self])
+            .map {|ancestor| all_instance_methods(ancestor)}
+            .flatten
+            .uniq
+
+        all_instance_methods(self) - ancestors_instance_methods
+      end
+
+      def own_class_methods
+        ancestors_class_methods =
+          (self.ancestors - [self])
+            .map {|ancestor| all_class_methods(ancestor)}
+            .flatten
+            .uniq
+
+        all_class_methods(self) -
+          all_instance_methods(IsThisUsed::CruftTracker::ClassMethods) -
+          ancestors_class_methods
+      end
+
+      def create_or_find_potential_cruft(method_name:, method_type:)
+        PotentialCruft.find_or_create_by(owner_name: self.name,
+                                         method_name: method_name,
+                                         method_type: method_type)
+
+      rescue ActiveRecord::RecordNotUnique
+        PotentialCruft.find_by(owner_name: self.name,
+                               method_name: method_name,
+                               method_type: method_type)
+      end
     end
   end
 

data/lib/is_this_used/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IsThisUsed
-  VERSION = '0.1.12'
+  VERSION = '0.1.13'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: is_this_used
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Doug Hughes
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-10 00:00:00.000000000 Z
+date: 2022-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord