factory_trace 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 484192f056c62919a10db1bcabe6d3f769fc7be2973e1278e9eff0874c5a0d96
-  data.tar.gz: 1b339e7c7b1d0a0fa8828631fff9a33926347cdafc22446061aa57b7483c2686
+  metadata.gz: eb1219bf45bfd040c463c2c49694f615bad866afe0042a1036feb02cd2a09d46
+  data.tar.gz: 326e1995408175cd60bbdf36a0e091b9111b3a3566034d920e42d04bf3eb5baf
 SHA512:
-  metadata.gz: 866ba5578d028ca9eb9c623ea38c03ac5df59383831d3d0b11ee765e9f181e69260e49621fea2d353836361f8b6836b6b092fe73f7be948757e0782a6b5f0e05
-  data.tar.gz: dd8cf671469977ab78a6821398a27e39c999b981eb6938bf016ab41be56684d16f259cce7663c154f6f9fd1c1b1d94f62288177e6a3e6e31a841affeb8c3f3b9
+  metadata.gz: 18d6d00e731569b979c8158927a8ee42d1177c8ada0da28173d48253d4185fc00aa957f258d06ad6c2b3a55ec581527aeadc176ea2ded9e3f3a5449c88bbf710
+  data.tar.gz: 1996554340f1aec3c1c997706679dce4ca5d4a43d6bdc3c45e3001d52d5ee26894201960cb5d6b1ae4dc78f93106aff2b43da12aabe91b1195c2b73d09f081e3

data/exe/factory_trace

@@ -6,9 +6,9 @@ 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?
 
 config = FactoryTrace.configuration
-data = FactoryTrace::TraceReader.read_from_files(*ARGV)
-data = FactoryTrace::FindUnused.call(data)
-code = data.size > 2 ? 1 : 0
+hash = FactoryTrace::Readers::TraceReader.read_from_files(*ARGV)
+reports = FactoryTrace::Processors::FindUnused.call(hash[:defined], hash[:used])
+code = reports.any? { |report| report[:code] == :unused } ? 1 : 0
 
-FactoryTrace::ReportWriter.new(config.out, config: config).write(data)
+FactoryTrace::Writers::ReportWriter.new(config.out, config).write(reports)
 exit(code)

data/lib/factory_trace/helpers/converter.rb

@@ -0,0 +1,29 @@
+module FactoryTrace
+  module Helpers
+    module Converter
+      module_function
+
+      # @param [FactoryBot::Trait] trait
+      # @param [FactoryBot::Factory] owner
+      #
+      # @return [FactoryTrace::Structures::Trait]
+      def trait(trait, owner = nil)
+        FactoryTrace::Structures::Trait.new(
+          trait.name.to_s,
+          owner && owner.name.to_s
+        )
+      end
+
+      # @param [FactoryBot::Factory] factory
+      #
+      # @return [FactoryTrace::Structures::Factory]
+      def factory(factory)
+        FactoryTrace::Structures::Factory.new(
+          factory.name.to_s,
+          factory.send(:parent).respond_to?(:name) ? factory.send(:parent).name.to_s : nil,
+          factory.defined_traits.map(&:name).map(&:to_s)
+        )
+      end
+    end
+  end
+end

data/lib/factory_trace/preprocessors/extract_defined.rb

@@ -0,0 +1,20 @@
+module FactoryTrace
+  module Preprocessors
+    class ExtractDefined
+      # @return [FactoryTrace::Structures::Collection]
+      def self.call
+        collection = FactoryTrace::Structures::Collection.new
+
+        FactoryBot.traits.each do |trait|
+          collection.add(FactoryTrace::Helpers::Converter.trait(trait))
+        end
+
+        FactoryBot.factories.each do |factory|
+          collection.add(FactoryTrace::Helpers::Converter.factory(factory))
+        end
+
+        collection
+      end
+    end
+  end
+end

data/lib/factory_trace/preprocessors/extract_used.rb

@@ -0,0 +1,20 @@
+module FactoryTrace
+  module Preprocessors
+    class ExtractUsed
+      # Returns a collection with used factories and traits gathered from trace
+      #
+      # @param [Hash<String, Set<String>>]
+      #
+      # @return [FactoryTrace::Structures::Collection]
+      def self.call(trace)
+        collection = FactoryTrace::Structures::Collection.new
+
+        trace.each do |factory_name, trait_names|
+          collection.add(FactoryTrace::Structures::Factory.new(factory_name, nil, trait_names.to_a))
+        end
+
+        collection
+      end
+    end
+  end
+end

data/lib/factory_trace/processors/find_unused.rb

@@ -0,0 +1,118 @@
+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)
+        used_inherited_traits = used_inherited_traits(defined, used)
+        used_child_factories = used_child_factories(defined, used)
+
+        output = []
+
+        defined.factories.each_value do |factory|
+          unless used.factories[factory.name]
+            if used_child_factories[factory.name]
+              output << {code: :used_indirectly, factory_name: factory.name, child_factories_names: used_child_factories[factory.name]}
+            else
+              output << {code: :unused, factory_name: factory.name}
+            end
+          end
+
+          factory.trait_names.each do |trait_name|
+            unless trait_used?(used, factory.name, trait_name) || trait_used?(used_inherited_traits, factory.name, trait_name)
+              output << {code: :unused, factory_name: factory.name, trait_name: trait_name}
+            end
+          end
+        end
+
+        defined.traits.each_value do |trait|
+          unless used_inherited_traits.traits[trait.name]
+            output << {code: :unused, trait_name: trait.name}
+            next
+          end
+        end
+
+        unused_count = output.count { |result| result[:code] == :unused }
+        used_indirectly_count = output.count { |result| result[:code] == :used_indirectly }
+
+        output.unshift(code: :unused, value: unused_count)
+        output.unshift(code: :used_indirectly, value: used_indirectly_count)
+        output.unshift(code: :used, value: defined.total - unused_count - used_indirectly_count)
+
+        output
+      end
+
+      private
+
+      # Checks if factory of the collection contains a trait
+      #
+      # @param [FactoryTrace::Structures::Collection] collection
+      # @param [String] factory_name
+      # @param [String] trait_name
+      #
+      # @return [Boolean]
+      def self.trait_used?(collection, factory_name, trait_name)
+        collection.factories[factory_name] && collection.factories[factory_name].trait_names.include?(trait_name)
+      end
+
+      # Returns a new collection where traits which were used moved to their owner factory
+      #
+      # @param [FactoryTrace::Structures::Collection] defined
+      # @param [FactoryTrace::Structures::Collection] used
+      #
+      # @return [FactoryTrace::Structures::Collection]
+      def self.used_inherited_traits(defined, used)
+        collection = FactoryTrace::Structures::Collection.new
+
+        used.factories.each_value do |factory|
+          factory.trait_names.each do |trait_name|
+            possible_owner_name = factory.name
+
+            while possible_owner_name
+              break if defined.factories[possible_owner_name].trait_names.include?(trait_name)
+              possible_owner_name = defined.factories[possible_owner_name].parent_name
+            end
+
+            if possible_owner_name
+              factory = collection.factories[possible_owner_name]
+              factory ||= collection.add(FactoryTrace::Structures::Factory.new(possible_owner_name, nil, []))
+
+              factory.trait_names << trait_name unless factory.trait_names.include?(trait_name)
+            else
+              collection.add(FactoryTrace::Structures::Trait.new(trait_name, nil))
+            end
+          end
+        end
+
+        collection
+      end
+
+      # Returns a hash:
+      # - key is factory name
+      # - value is factory names which where used and are children of the factory
+      #
+      # @param [FactoryTrace::Structures::Collection] defined
+      # @param [FactoryTrace::Structures::Collection] used
+      #
+      # @return [Hash<String, Array<String>]
+      def self.used_child_factories(defined, used)
+        hash = {}
+
+        used.factories.each_value do |factory|
+          parent_name = defined.factories[factory.name].parent_name
+
+          if parent_name
+            hash[parent_name] ||= []
+            hash[parent_name] << factory.name
+          end
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/factory_trace/readers/trace_reader.rb

@@ -1,52 +1,59 @@
-require 'set'
-
 module FactoryTrace
-  class TraceReader
-    # Read the data from files and merge it
-    # First hash - all factories
-    # Second hash - used factories
-    #
-    # @return [Array<Hash>]
-    def self.read_from_files(*file_names, config: Configuration.new)
-      file_names.reduce([{}, {}]) do |array, file_name|
-        reader = new(File.open(file_name, 'r'), config: config)
-        new = reader.read
-        array.each_with_index.map do |hash, index|
-          hash.merge(new[index]) { |_key, v1, v2| v1 | v2 }
+  module Readers
+    class TraceReader
+      attr_reader :io, :configuration
+
+      # Read the data from files and merge it
+      #
+      # @return [Hash<Symbol, FactoryTrace::Structures::Collection>]
+      def self.read_from_files(*file_names, configuration: Configuration.new)
+        result = {defined: FactoryTrace::Structures::Collection.new, used: FactoryTrace::Structures::Collection.new}
+
+        file_names.each do |file_name|
+          File.open(file_name, 'r') do |file|
+            data = new(file, configuration: configuration).read
+
+            result.each do |key, collection|
+              collection.merge!(data[key])
+            end
+          end
         end
+
+        result
       end
-    end
 
-    def initialize(io, config: Configuration.new)
-      @io = io
-      @config = config
-    end
+      def initialize(io, configuration: Configuration.new)
+        @io = io
+        @configuration = configuration
+      end
 
-    # Read the data from file
-    # First hash - all factories
-    # Second hash - used factories
-    #
-    # @return [Array<Hash>]
-    def read
-      data = [{}, {}]
-      point = -1
+      # Read the data from file
+      #
+      # @return [Hash<Symbol, FactoryTrace::Structures::Collection>]
+      def read
+        hash = JSON.parse(io.read)
 
-      io.each_line do |line|
-        next point += 1 if line.match?(/-all-|-used-/)
+        {
+          defined: parse_collection(hash['defined']),
+          used: parse_collection(hash['used'])
+        }
+      end
 
-        factory, *traits = line.strip.split(',')
+      private
 
-        if factory
-          data[point][factory] ||= Set.new
-          data[point][factory] |= traits
-        end
-      end
+      def parse_collection(hash)
+        collection = FactoryTrace::Structures::Collection.new
 
-      data
-    end
+        hash['factories'].each do |h|
+          collection.add(FactoryTrace::Structures::Factory.new(h['name'], h['parent_name'], h['trait_names']))
+        end
 
-    private
+        hash['traits'].each do |h|
+          collection.add(FactoryTrace::Structures::Trait.new(h['name'], h['owner_name']))
+        end
 
-    attr_reader :io, :config
+        collection
+      end
+    end
   end
 end

data/lib/factory_trace/structures/collection.rb

@@ -0,0 +1,82 @@
+module FactoryTrace
+  module Structures
+    class Collection
+      attr_reader :factories, :traits
+
+      # @param [Hash<String, FactoryTrace::Structures::Factory>]
+      # @param [Hash<String, FactoryTrace::Structures::Trait>]
+      def initialize(factories = {}, traits = {})
+        @factories = factories
+        @traits = traits
+      end
+
+      # @param [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait] element
+      #
+      # @return [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait]
+      def add(element)
+        case element
+        when FactoryTrace::Structures::Factory then store(factories, element)
+        when FactoryTrace::Structures::Trait then store(traits, element)
+        else
+          fail "Unknown element: #{element.inspect}"
+        end
+      end
+
+      # Merge passed collection into self
+      #
+      # @param [FactoryTrace::Structures::Collection]
+      #
+      # @return [FactoryTrace::Structures::Collection]
+      def merge!(collection)
+        collection.factories.each_value do |factory|
+          if factories[factory.name]
+            factories[factory.name].merge!(factory)
+          else
+            add(FactoryTrace::Structures::Factory.new(factory.name, factory.parent_name, factory.trait_names))
+          end
+        end
+
+        collection.traits.each_value do |trait|
+          add(FactoryTrace::Structures::Trait.new(trait.name, trait.owner_name)) unless traits[trait.name]
+        end
+      end
+
+      # @return [Hash]
+      def to_h
+        {
+          factories: convert(factories),
+          traits: convert(traits)
+        }
+      end
+
+      # Total number of factories and traits
+      #
+      # @return [Integer]
+      def total
+        traits.size + factories.size + factories.values.sum { |factory| factory.trait_names.size }
+      end
+
+      # @return [Boolean]
+      def ==(collection)
+        return false unless collection.is_a?(FactoryTrace::Structures::Collection)
+
+        factories == collection.factories && traits == collection.traits
+      end
+
+      private
+
+      # @param [Hash] hash
+      # @param [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait] element
+      #
+      # @return [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait] element
+      def store(hash, element)
+        hash[element.name] = element
+      end
+
+      # @return [Hash]
+      def convert(hash)
+        hash.each_value.map(&:to_h)
+      end
+    end
+  end
+end

data/lib/factory_trace/structures/factory.rb

@@ -0,0 +1,41 @@
+module FactoryTrace
+  module Structures
+    class Factory
+      attr_reader :name, :parent_name, :trait_names
+
+      # @param [String] name
+      # @param [String, nil] parent_name
+      # @param [Array<String>] trait_names
+      def initialize(name, parent_name, trait_names)
+        @name = name
+        @parent_name = parent_name
+        @trait_names = trait_names
+      end
+
+      # @return [Hash<Symbol, String>]
+      def to_h
+        {
+          name: name,
+          parent_name: parent_name,
+          trait_names: trait_names
+        }
+      end
+
+      # Merge passed factory into self
+      #
+      # @param [FactoryTrace::Structures::Factory]
+      #
+      # @return [FactoryTrace::Structures::Factory]
+      def merge!(factory)
+        @trait_names = (trait_names + factory.trait_names).uniq
+      end
+
+      # @return [Boolean]
+      def ==(factory)
+        return false unless factory.is_a?(FactoryTrace::Structures::Factory)
+
+        name == factory.name && parent_name == factory.parent_name && trait_names == factory.trait_names
+      end
+    end
+  end
+end

data/lib/factory_trace/structures/trait.rb

@@ -0,0 +1,29 @@
+module FactoryTrace
+  module Structures
+    class Trait
+      attr_reader :name, :owner_name
+
+      # @param [String] name
+      # @param [String, nil] owner_name
+      def initialize(name, owner_name)
+        @name = name
+        @owner_name = owner_name
+      end
+
+      # @return [Hash<Symbol, String>]
+      def to_h
+        {
+          name: name,
+          owner_name: owner_name
+        }
+      end
+
+      # @return [Boolean]
+      def ==(trait)
+        return false unless trait.is_a?(FactoryTrace::Structures::Trait)
+
+        name == trait.name && owner_name == trait.owner_name
+      end
+    end
+  end
+end

data/lib/factory_trace/tracker.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module FactoryTrace
   class Tracker
     attr_reader :storage
@@ -10,8 +8,8 @@ module FactoryTrace
 
     def track!
       ActiveSupport::Notifications.subscribe('factory_bot.run_factory') do |_name, _start, _finish, _id, payload|
-        name = payload[:name]
-        traits = payload[:traits]
+        name = payload[:name].to_s
+        traits = payload[:traits].map(&:to_s)
 
         storage[name] ||= Set.new
         storage[name] |= traits

data/lib/factory_trace/version.rb

@@ -1,3 +1,3 @@
 module FactoryTrace
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/lib/factory_trace/writers/report_writer.rb

@@ -1,41 +1,67 @@
 module FactoryTrace
-  class ReportWriter < Writer
-    COLORS = {
-      blue: "\e[34m",
-      green: "\e[32m",
-      red: "\e[31m"
-    }.freeze
-
-    # @param [Array<Hash>] results
-    def write(results)
-      total_color = results.size == 2 ? :green : :red
-
-      results.each do |result|
-        io.puts(convert(result, total_color: total_color))
+  module Writers
+    class ReportWriter < Writer
+      COLORS = {
+        blue: "\e[34m",
+        yellow: "\e[33m",
+        green: "\e[32m",
+        red: "\e[31m"
+      }.freeze
+
+      CODES = {
+        used: 'used',
+        unused: 'unused',
+        used_indirectly: 'used only indirectly'
+      }.freeze
+
+      # @param [Array<Hash>] results
+      def write(results)
+        total_color =
+          if results.any? { |result| result[:code] == :unused }
+            :red
+          elsif results.any? { |result| result[:code] == :used_indirectly }
+            :yellow
+          else
+            :green
+          end
+
+        results.each do |result|
+          io.puts(convert(result, total_color: total_color))
+        end
       end
-    end
 
-    private
-
-    # @param [Hash<Symbol, Object>] result
-    # @param [Symbol] total_color
-    def convert(result, total_color:)
-      case
-      when result[:value]
-        colorize(total_color, "total number of unique #{result[:code]} factories & traits: #{result[:value]}")
-      when result[:factory_name] && result[:trait_name]
-        "#{result[:code]} trait #{colorize(:blue, result[:trait_name])} of factory #{colorize(:blue, result[:factory_name])}"
-      when result[:factory_name]
-        "#{result[:code]} factory #{colorize(:blue, result[:factory_name])}"
-      else
-        "#{result[:code]} global trait #{colorize(:blue, result[:trait_name])}"
+      private
+
+      # @param [Hash<Symbol, Object>] result
+      # @param [Symbol] total_color
+      def convert(result, total_color:)
+        case
+        when result[:value]
+          colorize(total_color, "total number of unique #{humanize_code(result[:code])} factories & traits: #{result[:value]}")
+        when result[:factory_name] && result[:trait_name]
+          "#{humanize_code(result[:code])} trait #{colorize(:blue, result[:trait_name])} of factory #{colorize(:blue, result[:factory_name])}"
+        when result[:factory_name] && result[:child_factories_names]
+          "#{humanize_code(result[:code])} factory #{colorize(:blue, result[:factory_name])} as parent for #{list(result[:child_factories_names])}"
+        when result[:factory_name]
+          "#{humanize_code(result[:code])} factory #{colorize(:blue, result[:factory_name])}"
+        else
+          "#{humanize_code(result[:code])} global trait #{colorize(:blue, result[:trait_name])}"
+        end
       end
-    end
 
-    def colorize(color, msg)
-      return msg unless config.color
+      def colorize(color, msg)
+        return msg unless configuration.color
 
-      "#{COLORS[color]}#{msg}\e[0m"
+        "#{COLORS[color]}#{msg}\e[0m"
+      end
+
+      def humanize_code(code)
+        CODES[code]
+      end
+
+      def list(elements)
+        elements.map { |element| colorize(:blue, element) }.join(', ')
+      end
     end
   end
 end

data/lib/factory_trace/writers/trace_writer.rb

@@ -1,20 +1,10 @@
 module FactoryTrace
-  class TraceWriter < Writer
-    # @param [Array<Hash>] results
-    def write(results)
-      io.puts('-all-')
-      output(results[0])
-      io.puts('-used-')
-      output(results[1])
-    end
-
-    private
-
-    # @param [Hash<Symbol, Set<Hash>>] data
-    def output(data)
-      data.each do |key, set|
-        line = [key, set.to_a.join(',')].join(',')
-        io.puts(line)
+  module Writers
+    class TraceWriter < Writer
+      # @param [FactoryTrace::Structures::Collection] defined
+      # @param [FactoryTrace::Structures::Collection] used
+      def write(defined, used)
+        io.puts(JSON.pretty_generate(defined: defined.to_h, used: used.to_h))
       end
     end
   end

data/lib/factory_trace/writers/writer.rb

@@ -1,23 +1,12 @@
 module FactoryTrace
-  class Writer
-    def self.factory(io, config: Configuration.new)
-      writer =
-        if config.mode?(:full)
-          ReportWriter
-        elsif config.mode?(:trace_only)
-          TraceWriter
-        end
-
-      writer.new(io, config: config)
-    end
-
-    def initialize(io, config: Configuration.new)
-      @io = io
-      @config = config
+  module Writers
+    class Writer
+      attr_reader :io, :configuration
+
+      def initialize(io, configuration = Configuration.new)
+        @io = io
+        @configuration = configuration
+      end
     end
-
-    private
-
-    attr_reader :io, :config
   end
 end

data/lib/factory_trace.rb

@@ -1,12 +1,21 @@
 # External dependencies
 require 'factory_bot'
+require 'json'
+require 'set'
 # Library
 require 'factory_trace/configuration'
 require 'factory_trace/version'
+require 'factory_trace/helpers/converter'
 require 'factory_trace/tracker'
 
-require 'factory_trace/find_unused'
-require 'factory_trace/storage_handler'
+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/processors/find_unused'
 
 require 'factory_trace/readers/trace_reader'
 require 'factory_trace/writers/writer'
@@ -29,7 +38,11 @@ module FactoryTrace
       # This is required to exclude parent traits from +defined_traits+
       FactoryBot.reload
 
-      writer.write(results)
+      if configuration.mode?(:full)
+        Writers::ReportWriter.new(configuration.out, configuration).write(Processors::FindUnused.call(defined, used))
+      elsif configuration.mode?(:trace_only)
+        Writers::TraceWriter.new(configuration.out, configuration).write(defined, used)
+      end
     end
 
     def configure
@@ -42,24 +55,16 @@ module FactoryTrace
 
     private
 
-    def results
-      if configuration.mode?(:full)
-        FindUnused.call(preprocessed)
-      elsif configuration.mode?(:trace_only)
-        preprocessed
-      end
+    def used
+      @used ||= Preprocessors::ExtractUsed.call(tracker.storage)
     end
 
-    def preprocessed
-      @preprocessed ||= StorageHandler.prepare(tracker.storage)
+    def defined
+      @defined ||= Preprocessors::ExtractDefined.call
     end
 
     def tracker
       @tracker ||= Tracker.new
     end
-
-    def writer
-      @writer ||= Writer.factory(configuration.out, config: configuration)
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factory_trace
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - djezzzl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-05 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -77,9 +77,14 @@ files:
 - exe/factory_trace
 - lib/factory_trace.rb
 - lib/factory_trace/configuration.rb
-- lib/factory_trace/find_unused.rb
+- lib/factory_trace/helpers/converter.rb
+- lib/factory_trace/preprocessors/extract_defined.rb
+- lib/factory_trace/preprocessors/extract_used.rb
+- lib/factory_trace/processors/find_unused.rb
 - lib/factory_trace/readers/trace_reader.rb
-- lib/factory_trace/storage_handler.rb
+- lib/factory_trace/structures/collection.rb
+- lib/factory_trace/structures/factory.rb
+- lib/factory_trace/structures/trait.rb
 - lib/factory_trace/tracker.rb
 - lib/factory_trace/version.rb
 - lib/factory_trace/writers/report_writer.rb

data/lib/factory_trace/find_unused.rb

@@ -1,36 +0,0 @@
-module FactoryTrace
-  class FindUnused
-    # @param [Array<Hash>] initial_data
-    # @return [Array<Hash>]
-    def self.call(initial_data)
-      all, used = initial_data
-
-      output = []
-
-      all.each do |factory_name, trait_names|
-        unless used.key?(factory_name)
-          output << {code: :unused, factory_name: factory_name}
-          next
-        end
-
-        trait_names.each do |trait_name|
-          unless used[factory_name].include?(trait_name)
-            output << {code: :unused, trait_name: trait_name}.tap { |h| h[:factory_name] = factory_name unless factory_name == '_traits' }
-          end
-        end
-      end
-
-      output.unshift(code: :unused, value: output.size)
-      output.unshift(code: :used, value: count_total(used))
-
-      output
-    end
-
-    private
-
-    # @param [Hash<Symbol, Set<Symbol>>]
-    def self.count_total(data)
-      data.reduce(0) { |result, (factory_name, trait_names)| result + (factory_name != '_traits' ? 1 : 0) + trait_names.size }
-    end
-  end
-end

data/lib/factory_trace/storage_handler.rb

@@ -1,61 +0,0 @@
-require 'set'
-
-module FactoryTrace
-  class StorageHandler
-    # @param [Hash<Symbol, Set<Symbol>>] initial_data
-    #
-    # First hash - all factories
-    # Second hash - used factories
-    #
-    # @return [Array<Hash>]
-    def self.prepare(initial_data)
-      [collect_all, convert(initial_data)]
-    end
-
-    private
-
-    def self.collect_all
-      FactoryBot.factories.reduce({'_traits' => Set.new(FactoryBot.traits.map(&:name).map(&:to_s))}) do |hash, factory|
-        hash[factory.name.to_s] = Set.new(factory.defined_traits.map(&:name).map(&:to_s))
-        hash
-      end
-    end
-
-    # Return new structure where each trait is moved to its own factory
-    #
-    # @param [Hash<Symbol, Set<Symbol>>]
-    # @return [Hash<String, Set<String>>]
-    def self.convert(data)
-      # +_traits+ is for global traits
-      output = {'_traits' => Set.new}
-
-      data.each do |factory_name, trait_names|
-        factory_name = factory_name.to_s
-
-        output[factory_name] ||= Set.new
-
-        trait_names.each do |trait_name|
-          trait_name = trait_name.to_s
-
-          factory = FactoryBot.factories[factory_name]
-          trait_found = false
-
-          until factory.is_a?(FactoryBot::NullFactory)
-            if factory.defined_traits.any? { |trait| trait.name.to_s == trait_name }
-              trait_found = true
-              output[factory.name.to_s] ||= Set.new
-              output[factory.name.to_s] << trait_name
-              break
-            end
-            factory = factory.send(:parent)
-          end
-
-          # Belongs to global traits
-          output['_traits'] << trait_name unless trait_found
-        end
-      end
-
-      output
-    end
-  end
-end