factory_trace 0.3.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1a24e77768b29dad3fe548612611e571e6d482ef20452710030c2630b458b3c
-  data.tar.gz: 9d1dc6c12a05a3a0ea3828525a5d7e6b77e7f7be993eb06fe19e3ac3b8f9640d
+  metadata.gz: fc2882cfec07c5a45a8cf464027b593f4e97891b4a959b49a061acec3728bd41
+  data.tar.gz: dbcfce3c2e80b177a108f7761477b09f404818cf3794f15ae30b4c1c286ac2a8
 SHA512:
-  metadata.gz: 81d359402ed19825baba0e7e7433272a83ecd7cd17b6b8d9968eeb600129b2afba676bd8257e10b6ad4c22f8cf1397f89116493eea9841ede8c802d6622986b6
-  data.tar.gz: 4f8c7509c59504a83f54de7a036368b5d233f4a9a1a1075cf344fff158edd441ca816445605c1b1e5b22fefd507e377d3f05c42c01eef37dbac6acf47d1475c0
+  metadata.gz: 06a0383bfda293f51aac40e74c5a45512652832c7911be4ca751da4940d889c99cd442008433addee8040f60e271276579bb5db34c6d668813e53e6e00a8793e
+  data.tar.gz: cf7d58dd17a8be295da9aa51acba56c4cfa4ba353055ff5d75bb5d6bead9ce125c99e588c19fc9f5ec25bba9c945557fec15ce86cb1901232fd52e5f43046888

data/exe/factory_trace

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH.unshift("#{__dir__}/../lib")
-require 'factory_trace'
+require "factory_trace"
 
 fail "You should pass at least one file with traced information.\nYou can generate it using only_trace mode." if ARGV.empty?
 

data/lib/factory_trace/configuration.rb

@@ -1,18 +1,25 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   class Configuration
-    attr_accessor :path, :enabled, :color, :mode
+    attr_accessor :path, :enabled, :color, :mode, :trace_definition
 
     def initialize
-      @enabled = ENV.key?('FB_TRACE') || ENV.key?('FB_TRACE_FILE')
-      @path = ENV['FB_TRACE_FILE']
+      @enabled = ENV.key?("FB_TRACE") || ENV.key?("FB_TRACE_FILE")
+      @path = ENV["FB_TRACE_FILE"]
       @color = path.nil?
-      @mode = extract_mode(ENV['FB_TRACE']) || :full
+      @mode = extract_mode(ENV["FB_TRACE"]) || :full
+      @trace_definition = true
+    end
+
+    def trace_definition?
+      @trace_definition
     end
 
     def out
-      return STDOUT unless path
+      return $stdout unless path
 
-      File.open(path, 'w')
+      File.open(path, "w")
     end
 
     def mode?(*args)
@@ -22,7 +29,7 @@ module FactoryTrace
     private
 
     def extract_mode(value)
-      matcher = value && value.match(/full|trace_only/)
+      matcher = value&.match(/full|trace_only/)
       matcher && matcher[0].to_sym
     end
   end

data/lib/factory_trace/helpers/caller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module Helpers
+    module Caller
+      module_function
+
+      # @return [String] file and line where the original method was called
+      def location
+        location = caller_locations(2..2).first
+
+        base = Pathname.new(Dir.pwd)
+        method = Pathname.new(location.path)
+
+        "#{method.relative_path_from(base)}:#{location.lineno}"
+      end
+    end
+  end
+end

data/lib/factory_trace/helpers/converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Helpers
     module Converter
@@ -9,7 +11,8 @@ module FactoryTrace
       def trait(trait)
         FactoryTrace::Structures::Trait.new(
           trait.name.to_s,
-          declaration_names: trait.definition.declarations.grep(FactoryBot::Declaration::Implicit).map(&:name).map(&:to_s)
+          declaration_names: extract_declarations(trait),
+          definition_path: (trait.definition_path if trait.respond_to?(:definition_path))
         )
       end
 
@@ -21,9 +24,18 @@ module FactoryTrace
           factory.names.map(&:to_s),
           factory.defined_traits.map(&method(:trait)),
           parent_name: factory.send(:parent).respond_to?(:name) ? factory.send(:parent).name.to_s : nil,
-          declaration_names: factory.definition.declarations.grep(FactoryBot::Declaration::Implicit).map(&:name).map(&:to_s)
+          declaration_names: extract_declarations(factory),
+          definition_path: (factory.definition_path if factory.respond_to?(:definition_path))
         )
       end
+
+      # @param [FactoryBot::Factory|FactoryBot::Trait]
+      #
+      # @return [Array<String>]
+      def extract_declarations(structure)
+        (structure.definition.declarations.grep(FactoryBot::Declaration::Implicit).map(&:name).map(&:to_s) +
+          structure.definition.instance_variable_get(:@base_traits).map(&:to_s)).uniq
+      end
     end
   end
 end

data/lib/factory_trace/helpers/statusable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Helpers
     module Statusable

data/lib/factory_trace/monkey_patches/definition_proxy.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module MonkeyPatches
+    module DefinitionProxy
+      def factory(name, options = {}, &block)
+        @child_factories << [name, Helpers::Caller.location, options, block]
+      end
+
+      def trait(name, &block)
+        @definition.define_trait(FactoryBot::Trait.new(name, Helpers::Caller.location, &block))
+      end
+    end
+  end
+end

data/lib/factory_trace/monkey_patches/dsl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module MonkeyPatches
+    module Default
+      module DSL
+        def factory(name, options = {}, &block)
+          caller_location = options.delete(:caller_location) || Helpers::Caller.location
+          factory = FactoryBot::Factory.new(name, caller_location, options)
+          proxy = FactoryBot::DefinitionProxy.new(factory.definition)
+          proxy.instance_eval(&block) if block
+
+          REGISTER.register_factory(factory)
+
+          proxy.child_factories.each do |(child_name, child_caller_location, child_options, child_block)|
+            parent_factory = child_options.delete(:parent) || name
+            factory(child_name, child_options.merge(parent: parent_factory, caller_location: child_caller_location), &child_block)
+          end
+        end
+
+        def trait(name, &block)
+          REGISTER.register_trait(FactoryBot::Trait.new(name, Helpers::Caller.location, &block))
+        end
+      end
+    end
+  end
+end

data/lib/factory_trace/monkey_patches/factory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module MonkeyPatches
+    module Factory
+      attr_reader :definition_path
+
+      def initialize(name, definition_path, options = {})
+        @definition_path = definition_path
+        super(name, options)
+      end
+    end
+  end
+end

data/lib/factory_trace/monkey_patches/monkey_patches.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module MonkeyPatches
+    REGISTER = FactoryBot::VERSION >= "5.1.0" ? FactoryBot::Internal : FactoryBot
+  end
+end

data/lib/factory_trace/monkey_patches/trait.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FactoryTrace
+  module MonkeyPatches
+    module Trait
+      attr_reader :definition_path
+
+      def initialize(name, definition_path, &block)
+        @definition_path = definition_path
+        super(name, &block)
+      end
+    end
+  end
+end

data/lib/factory_trace/preprocessors/extract_defined.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Preprocessors
     class ExtractDefined
@@ -5,7 +7,7 @@ module FactoryTrace
       def self.call
         collection = FactoryTrace::Structures::Collection.new
 
-        FactoryBot.traits.each do |trait|
+        MonkeyPatches::REGISTER.traits.each do |trait|
           collection.add(FactoryTrace::Helpers::Converter.trait(trait))
         end
 

data/lib/factory_trace/preprocessors/extract_used.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Preprocessors
     class ExtractUsed

data/lib/factory_trace/processors/find_unused.rb

@@ -1,107 +1,119 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Processors
     class FindUnused
-      # Finds unused factories and traits
-      #
-      # @param [FactoryTrace::Structures::Collection] defined
-      # @param [FactoryTrace::Structures::Collection] used
-      #
-      # @return [Array<Hash>]
-      def self.call(defined, used)
-        mark_as_used(defined, used)
-
-        output = []
-
-        defined.factories.each do |factory|
-          output << {code: :unused, factory_names: factory.names} unless factory.status
-
-          factory.traits.each do |trait|
-            output << {code: :unused, factory_names: factory.names, trait_name: trait.name} unless trait.status
+      class << self
+        # Finds unused factories and traits
+        #
+        # @param [FactoryTrace::Structures::Collection] defined
+        # @param [FactoryTrace::Structures::Collection] used
+        #
+        # @return [Array<Hash>]
+        def call(defined, used)
+          mark_as_used(defined, used)
+
+          output = []
+
+          defined.factories.each do |factory|
+            output << append_definition_path({code: :unused, factory_names: factory.names}, factory) unless factory.status
+
+            factory.traits.each do |trait|
+              output << append_definition_path({code: :unused, factory_names: factory.names, trait_name: trait.name}, trait) unless trait.status
+            end
           end
-        end
 
-        defined.traits.each do |trait|
-          output << {code: :unused, trait_name: trait.name} unless trait.status
-        end
+          defined.traits.each do |trait|
+            output << append_definition_path({code: :unused, trait_name: trait.name}, trait) unless trait.status
+          end
 
-        output.unshift(code: :unused, value: output.size)
-        output.unshift(code: :used, value: defined.total - (output.size - 1))
+          output.unshift(code: :unused, value: output.size)
+          output.unshift(code: :used, value: defined.total - (output.size - 1))
 
-        output
-      end
+          output
+        end
 
-      private
+        private
 
-      # @param [FactoryTrace::Structures::Collection] defined
-      # @param [FactoryTrace::Structures::Collection] used
-      def self.mark_as_used(defined, used)
-        used.factories.each do |used_factory|
-          defined_factory = defined.find_factory_by_names(used_factory.names)
-          mark_factory(defined_factory, defined, status: :used)
+        # @param [FactoryTrace::Structures::Collection] defined
+        # @param [FactoryTrace::Structures::Collection] used
+        def mark_as_used(defined, used)
+          used.factories.each do |used_factory|
+            defined_factory = defined.find_factory_by_names(used_factory.names)
+            mark_factory(defined_factory, defined, status: :used)
 
-          used_factory.traits.each do |used_trait|
-            trait_owner, defined_trait = defined_trait_by_name(defined, used_factory, used_trait.name)
-            mark_trait(defined_trait, trait_owner, defined, status: :used)
+            used_factory.traits.each do |used_trait|
+              trait_owner, defined_trait = defined_trait_by_name(defined, used_factory, used_trait.name)
+              mark_trait(defined_trait, trait_owner, defined, status: :used)
+            end
           end
         end
-      end
 
-      # @param [FactoryTrace::Structures::Collection] defined
-      # @param [FactoryTrace::Structures::Factory|nil] factory
-      # @param [String] trait_name
-      #
-      # @return [Array<Object>]
-      def self.defined_trait_by_name(defined, factory, trait_name)
-        if factory
-          possible_owner = defined.find_factory_by_names(factory.names)
-
-          while possible_owner
-            if (trait = possible_owner.traits.find { |t| t.name == trait_name })
-              return [possible_owner, trait]
+        # @param [FactoryTrace::Structures::Collection] defined
+        # @param [FactoryTrace::Structures::Factory|nil] factory
+        # @param [String] trait_name
+        #
+        # @return [Array<Object>]
+        def defined_trait_by_name(defined, factory, trait_name)
+          if factory
+            possible_owner = defined.find_factory_by_names(factory.names)
+
+            while possible_owner
+              if (trait = possible_owner.traits.find { |t| t.name == trait_name })
+                return [possible_owner, trait]
+              end
+              possible_owner = defined.find_factory_by_names([possible_owner.parent_name])
             end
-            possible_owner = defined.find_factory_by_names([possible_owner.parent_name])
           end
+
+          [nil, defined.find_trait_by_name(trait_name)]
         end
 
+        # @param [FactoryTrace::Structures::Factory] factory
+        # @param [FactoryTrace::Structures::Collection] collection
+        # @param [Symbol] status
+        def mark_factory(factory, collection, status:)
+          return if factory.has_prioritized_status?(status)
 
-        [nil, defined.find_trait_by_name(trait_name)]
-      end
+          factory.status = status
+          if (parent = collection.find_factory_by_names([factory.parent_name]))
+            mark_factory(parent, collection, status: :indirectly_used)
+          end
+          mark_declarations(factory.declaration_names, factory, collection, status: :indirectly_used)
+        end
 
-      # @param [FactoryTrace::Structures::Factory] factory
-      # @param [FactoryTrace::Structures::Collection] collection
-      # @param [Symbol] status
-      def self.mark_factory(factory, collection, status:)
-        return if factory.has_prioritized_status?(status)
+        # @param [FactoryTrace::Structures::Trait] trait
+        # @param [FactoryTrace::Structures::Factory|nil] factory which trait belongs to
+        # @param [FactoryTrace::Structures::Collection] collection
+        # @param [Symbol] status
+        def mark_trait(trait, factory, collection, status:)
+          return if trait.has_prioritized_status?(status)
 
-        factory.status = status
-        if (parent = collection.find_factory_by_names([factory.parent_name]))
-          mark_factory(parent, collection, status: :indirectly_used)
+          trait.status = status
+          mark_declarations(trait.declaration_names, factory, collection, status: :indirectly_used)
         end
-        mark_declarations(factory.declaration_names, factory, collection, status: :indirectly_used)
-      end
 
-      # @param [FactoryTrace::Structures::Trait] trait
-      # @param [FactoryTrace::Structures::Factory|nil] factory which trait belongs to
-      # @param [FactoryTrace::Structures::Collection] collection
-      # @param [Symbol] status
-      def self.mark_trait(trait, factory, collection, status:)
-        return if trait.has_prioritized_status?(status)
-
-        trait.status = status
-        mark_declarations(trait.declaration_names, factory, collection, status: :indirectly_used)
-      end
+        # @param [Array<String>] declaration_names
+        # @param [FactoryTrace::Structures::Factory|nil] factory
+        # @param [FactoryTrace::Structures::Collection] collection
+        # @param [Symbol] status
+        def mark_declarations(declaration_names, factory, collection, status:)
+          declaration_names.each do |declaration_name|
+            declaration_factory = collection.find_factory_by_names([declaration_name])
+            next mark_factory(declaration_factory, collection, status: status) if declaration_factory
+
+            declaration_factory, declaration_trait = defined_trait_by_name(collection, factory, declaration_name)
+            mark_trait(declaration_trait, declaration_factory, collection, status: status) if declaration_trait
+          end
+        end
 
-      # @param [Array<String>] declaration_names
-      # @param [FactoryTrace::Structures::Factory|nil] factory
-      # @param [FactoryTrace::Structures::Collection] collection
-      # @param [Symbol] status
-      def self.mark_declarations(declaration_names, factory, collection, status:)
-        declaration_names.each do |declaration_name|
-          declaration_factory = collection.find_factory_by_names([declaration_name])
-          next mark_factory(declaration_factory, collection, status: status) if declaration_factory
-
-          declaration_factory, declaration_trait = defined_trait_by_name(collection, factory, declaration_name)
-          mark_trait(declaration_trait, declaration_factory, collection, status: status) if declaration_trait
+        # @param [Hash]
+        # @param [FactoryTrace::Structures::Factory|FactoryTrace::Structures::Trait]
+        #
+        # @return [Hash]
+        def append_definition_path(hash, object)
+          hash[:definition_path] = object.definition_path if object.definition_path
+          hash
         end
       end
     end

data/lib/factory_trace/readers/trace_reader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Readers
     class TraceReader
@@ -10,7 +12,7 @@ module FactoryTrace
         result = {defined: FactoryTrace::Structures::Collection.new, used: FactoryTrace::Structures::Collection.new}
 
         file_names.each do |file_name|
-          File.open(file_name, 'r') do |file|
+          File.open(file_name, "r") do |file|
             data = new(file, configuration: configuration).read
 
             [:defined, :used].each do |key|
@@ -34,34 +36,35 @@ module FactoryTrace
         hash = JSON.parse(io.read)
 
         {
-          defined: parse_collection(hash['defined']),
-          used: parse_collection(hash['used'])
+          defined: parse_collection(hash["defined"]),
+          used: parse_collection(hash["used"])
         }
       end
 
       private
 
       def parse_trait(hash)
-        FactoryTrace::Structures::Trait.new(hash['name'], declaration_names: hash['declaration_names'])
+        FactoryTrace::Structures::Trait.new(hash["name"], declaration_names: hash["declaration_names"], definition_path: hash["definition_path"])
       end
 
       def parse_factory(hash)
         FactoryTrace::Structures::Factory.new(
-          hash['names'],
-          hash['traits'].map(&method(:parse_trait)),
-          parent_name: hash['parent_name'],
-          declaration_names: hash['declaration_names']
+          hash["names"],
+          hash["traits"].map(&method(:parse_trait)),
+          parent_name: hash["parent_name"],
+          declaration_names: hash["declaration_names"],
+          definition_path: hash["definition_path"]
         )
       end
 
       def parse_collection(hash)
         collection = FactoryTrace::Structures::Collection.new
 
-        hash['factories'].each do |h|
+        hash["factories"].each do |h|
           collection.add(parse_factory(h))
         end
 
-        hash['traits'].each do |h|
+        hash["traits"].each do |h|
           collection.add(parse_trait(h))
         end
 

data/lib/factory_trace/structures/collection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Structures
     class Collection
@@ -69,10 +71,10 @@ module FactoryTrace
       end
 
       # @return [Boolean]
-      def ==(collection)
-        return false unless collection.is_a?(FactoryTrace::Structures::Collection)
+      def ==(other)
+        return false unless other.is_a?(FactoryTrace::Structures::Collection)
 
-        factories == collection.factories && traits == collection.traits
+        factories == other.factories && traits == other.traits
       end
     end
   end

data/lib/factory_trace/structures/factory.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Structures
     class Factory
       include Helpers::Statusable
 
-      attr_reader :names, :parent_name, :traits, :declaration_names
+      attr_reader :names, :parent_name, :traits, :declaration_names, :definition_path
 
       # @param [Array<String>] names
       # @param [Array<FactoryTrace::Structure::Trait>] traits
       # @param [String|nil] parent_name
       # @param [Array<String>] declaration_names
-      def initialize(names, traits, parent_name: nil, declaration_names: [])
+      # @param [String] definition_path
+      def initialize(names, traits, parent_name: nil, declaration_names: [], definition_path: nil)
         @names = names
         @traits = traits
         @parent_name = parent_name
         @declaration_names = declaration_names
+        @definition_path = definition_path
       end
 
       # @return [Hash<Symbol, Object>]
@@ -22,7 +26,8 @@ module FactoryTrace
           names: names,
           traits: traits.map(&:to_h),
           parent_name: parent_name,
-          declaration_names: declaration_names
+          declaration_names: declaration_names,
+          definition_path: definition_path
         }
       end
 
@@ -36,13 +41,14 @@ module FactoryTrace
       end
 
       # @return [Boolean]
-      def ==(factory)
-        return false unless factory.is_a?(FactoryTrace::Structures::Factory)
+      def ==(other)
+        return false unless other.is_a?(FactoryTrace::Structures::Factory)
 
-        names == factory.names &&
-          traits == factory.traits &&
-          parent_name == factory.parent_name &&
-          declaration_names == factory.declaration_names
+        names == other.names &&
+          traits == other.traits &&
+          parent_name == other.parent_name &&
+          declaration_names == other.declaration_names &&
+          definition_path == other.definition_path
       end
     end
   end

data/lib/factory_trace/structures/trait.rb

@@ -1,30 +1,35 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Structures
     class Trait
       include Helpers::Statusable
 
-      attr_reader :name, :declaration_names
+      attr_reader :name, :declaration_names, :definition_path
 
       # @param [String] name
       # @param [Array<String>] declaration_names
-      def initialize(name, declaration_names: [])
+      # @param [String] definition_path
+      def initialize(name, declaration_names: [], definition_path: nil)
         @name = name
         @declaration_names = declaration_names
+        @definition_path = definition_path
       end
 
       # @return [Hash<Symbol, Object>]
       def to_h
         {
           name: name,
-          declaration_names: declaration_names
+          declaration_names: declaration_names,
+          definition_path: definition_path
         }
       end
 
       # @return [Boolean]
-      def ==(trait)
-        return false unless trait.is_a?(FactoryTrace::Structures::Trait)
+      def ==(other)
+        return false unless other.is_a?(FactoryTrace::Structures::Trait)
 
-        name == trait.name && declaration_names == trait.declaration_names
+        name == other.name && declaration_names == other.declaration_names && definition_path == other.definition_path
       end
     end
   end

data/lib/factory_trace/tracker.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support"
+
 module FactoryTrace
   class Tracker
     attr_reader :storage
@@ -7,7 +11,7 @@ module FactoryTrace
     end
 
     def track!
-      ActiveSupport::Notifications.subscribe('factory_bot.run_factory') do |_name, _start, _finish, _id, payload|
+      ActiveSupport::Notifications.subscribe("factory_bot.run_factory") do |_name, _start, _finish, _id, payload|
         name = payload[:name].to_s
         traits = payload[:traits].map(&:to_s)
 

data/lib/factory_trace/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
-  VERSION = '0.3.2'
+  VERSION = "1.0.0"
 end

data/lib/factory_trace/writers/report_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Writers
     class ReportWriter < Writer
@@ -9,8 +11,8 @@ module FactoryTrace
       }.freeze
 
       CODES = {
-        used: 'used',
-        unused: 'unused',
+        used: "used",
+        unused: "unused"
       }.freeze
 
       # @param [Array<Hash>] results
@@ -27,15 +29,14 @@ module FactoryTrace
       # @param [Hash<Symbol, Object>] result
       # @param [Symbol] total_color
       def convert(result, total_color:)
-        case
-        when result[:value]
+        if result[:value]
           colorize(total_color, "total number of unique #{humanize_code(result[:code])} factories & traits: #{result[:value]}")
-        when result[:factory_names] && result[:trait_name]
-          "#{humanize_code(result[:code])} trait #{colorize(:blue, result[:trait_name])} of factory #{list(result[:factory_names])}"
-        when result[:factory_names]
-          "#{humanize_code(result[:code])} factory #{list(result[:factory_names])}"
+        elsif result[:factory_names] && result[:trait_name]
+          append_definition_path(result) { "#{humanize_code(result[:code])} trait #{colorize(:blue, result[:trait_name])} of factory #{list(result[:factory_names])}" }
+        elsif result[:factory_names]
+          append_definition_path(result) { "#{humanize_code(result[:code])} factory #{list(result[:factory_names])}" }
         else
-          "#{humanize_code(result[:code])} global trait #{colorize(:blue, result[:trait_name])}"
+          append_definition_path(result) { "#{humanize_code(result[:code])} global trait #{colorize(:blue, result[:trait_name])}" }
         end
       end
 
@@ -45,12 +46,19 @@ module FactoryTrace
         "#{COLORS[color]}#{msg}\e[0m"
       end
 
+      def append_definition_path(result)
+        msg = yield
+        return msg unless configuration.trace_definition? && result[:definition_path]
+
+        "#{msg} => #{result[:definition_path]}"
+      end
+
       def humanize_code(code)
         CODES[code]
       end
 
       def list(elements, color: :blue)
-        elements.map { |element| colorize(color, element) }.join(', ')
+        elements.map { |element| colorize(color, element) }.join(", ")
       end
     end
   end

data/lib/factory_trace/writers/trace_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Writers
     class TraceWriter < Writer

data/lib/factory_trace/writers/writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FactoryTrace
   module Writers
     class Writer

data/lib/factory_trace.rb

@@ -1,34 +1,46 @@
+# frozen_string_literal: true
+
 # External dependencies
-require 'factory_bot'
-require 'json'
-require 'set'
+require "factory_bot"
+require "json"
+require "set"
+require "pathname"
 # Library
-require 'factory_trace/configuration'
-require 'factory_trace/version'
-require 'factory_trace/helpers/converter'
-require 'factory_trace/helpers/statusable'
-require 'factory_trace/tracker'
+require "factory_trace/configuration"
+require "factory_trace/version"
+require "factory_trace/helpers/converter"
+require "factory_trace/helpers/statusable"
+require "factory_trace/helpers/caller"
+require "factory_trace/tracker"
+
+require "factory_trace/structures/factory"
+require "factory_trace/structures/trait"
+require "factory_trace/structures/collection"
+
+require "factory_trace/preprocessors/extract_defined"
+require "factory_trace/preprocessors/extract_used"
 
-require 'factory_trace/structures/factory'
-require 'factory_trace/structures/trait'
-require 'factory_trace/structures/collection'
+require "factory_trace/processors/find_unused"
 
-require 'factory_trace/preprocessors/extract_defined'
-require 'factory_trace/preprocessors/extract_used'
+require "factory_trace/readers/trace_reader"
+require "factory_trace/writers/writer"
+require "factory_trace/writers/report_writer"
+require "factory_trace/writers/trace_writer"
 
-require 'factory_trace/processors/find_unused'
+require "factory_trace/monkey_patches/monkey_patches"
+require "factory_trace/monkey_patches/factory"
+require "factory_trace/monkey_patches/trait"
+require "factory_trace/monkey_patches/definition_proxy"
+require "factory_trace/monkey_patches/dsl"
 
-require 'factory_trace/readers/trace_reader'
-require 'factory_trace/writers/writer'
-require 'factory_trace/writers/report_writer'
-require 'factory_trace/writers/trace_writer'
 # Integrations
-require 'integrations/rspec' if defined?(RSpec::Core)
+require "integrations/rspec" if defined?(RSpec::Core)
 
 module FactoryTrace
   class << self
     def start
       return unless configuration.enabled
+      trace_definitions! if configuration.trace_definition?
 
       tracker.track!
     end
@@ -67,5 +79,12 @@ module FactoryTrace
     def tracker
       @tracker ||= Tracker.new
     end
+
+    def trace_definitions!
+      FactoryBot::Factory.prepend(FactoryTrace::MonkeyPatches::Factory)
+      FactoryBot::Trait.prepend(FactoryTrace::MonkeyPatches::Trait)
+      FactoryBot::Syntax::Default::DSL.prepend(FactoryTrace::MonkeyPatches::Default::DSL)
+      FactoryBot::DefinitionProxy.prepend(FactoryTrace::MonkeyPatches::DefinitionProxy)
+    end
   end
 end

data/lib/integrations/rspec.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 RSpec.configure do |config|
   config.before(:suite) { FactoryTrace.start }
   config.after(:suite) { FactoryTrace.stop }
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factory_trace
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.0.0
 platform: ruby
 authors:
 - djezzzl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-12 00:00:00.000000000 Z
+date: 2022-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: 
 email:
 - lawliet.djez@gmail.com
@@ -77,8 +91,14 @@ files:
 - exe/factory_trace
 - lib/factory_trace.rb
 - lib/factory_trace/configuration.rb
+- lib/factory_trace/helpers/caller.rb
 - lib/factory_trace/helpers/converter.rb
 - lib/factory_trace/helpers/statusable.rb
+- lib/factory_trace/monkey_patches/definition_proxy.rb
+- lib/factory_trace/monkey_patches/dsl.rb
+- lib/factory_trace/monkey_patches/factory.rb
+- lib/factory_trace/monkey_patches/monkey_patches.rb
+- lib/factory_trace/monkey_patches/trait.rb
 - lib/factory_trace/preprocessors/extract_defined.rb
 - lib/factory_trace/preprocessors/extract_used.rb
 - lib/factory_trace/processors/find_unused.rb
@@ -111,8 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Provide an easy way to maintain factories and traits from FactoryBot