factory_trace 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33c0207895ffee9e1ce968b396f9acf75a298664e9cd9dd7a8766031c8bfbcb9
-  data.tar.gz: 4bb96700eefd658c71639b9423b058a604e8c8ad29cdc96a1569883e62d4c0c3
+  metadata.gz: 4437d507c038bcb203d04574fb49cbfd1f6986a75d8e114f06cd6447d282003a
+  data.tar.gz: 3d4cf49b2dd89104b9ec7d52e56c56f46317724e3d6fdb36001ef005aac13bea
 SHA512:
-  metadata.gz: a590c9294896d635673d8a3f3864fcc09cf3fded38ace341d1d9874f190171809027218ec6331987b26235cd2a855a39a76fe8bfb4b0900453edf74c2a0d35c4
-  data.tar.gz: 98237229d930694a1459a4c052d2221c6cf15bb5c85bf76124d9ea81c0c3d98ff620192e1f94b6b1286aad38f7f1d02301a8e9c15cb4abad2025d4767a4a790f
+  metadata.gz: 2feacb312890c6376e5bc89fa32f844fffd8add32f0730e96f81d51e655956905353d40050d3eda0e32073157be166111fba497a555d98bc821b22e5273a14bb
+  data.tar.gz: 4459f62ba40c6977f2338b67398c598557826a639acf7e5035b499b51d13d7ab5827efc990d1f6cee7151c52162abdf3fab15111c2368a545e80d57c92ab1e66

data/exe/factory_trace

@@ -8,7 +8,7 @@ fail "You should pass at least one file with traced information.\nYou can genera
 config = FactoryTrace.configuration
 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
+code = reports.any? { |report| report[:code] == :unused && !report.key?(:value) } ? 1 : 0
 
 FactoryTrace::Writers::ReportWriter.new(config.out, config).write(reports)
 exit(code)

data/lib/factory_trace/helpers/converter.rb

@@ -4,13 +4,12 @@ module FactoryTrace
       module_function
 
       # @param [FactoryBot::Trait] trait
-      # @param [FactoryBot::Factory] owner
       #
       # @return [FactoryTrace::Structures::Trait]
-      def trait(trait, owner = nil)
+      def trait(trait)
         FactoryTrace::Structures::Trait.new(
           trait.name.to_s,
-          owner && owner.name.to_s
+          declaration_names: trait.definition.declarations.grep(FactoryBot::Declaration::Implicit).map(&:name).map(&:to_s)
         )
       end
 
@@ -19,10 +18,10 @@ module FactoryTrace
       # @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),
-          factory.names.map(&:to_s) - [factory.name.to_s]
+          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)
         )
       end
     end

data/lib/factory_trace/helpers/statusable.rb

@@ -0,0 +1,17 @@
+module FactoryTrace
+  module Helpers
+    module Statusable
+      PRIORITY_ORDER = [:used, :indirectly_used, nil]
+
+      attr_reader :status
+
+      def status=(status)
+        @status = status unless has_prioritized_status?(status)
+      end
+
+      def has_prioritized_status?(status)
+        PRIORITY_ORDER.index(@status) <= PRIORITY_ORDER.index(status)
+      end
+    end
+  end
+end

data/lib/factory_trace/preprocessors/extract_used.rb

@@ -10,7 +10,10 @@ module FactoryTrace
         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, []))
+          traits = trait_names.map { |trait_name| FactoryTrace::Structures::Trait.new(trait_name) }
+          factory = FactoryTrace::Structures::Factory.new([factory_name], traits)
+
+          collection.add(factory)
         end
 
         collection

data/lib/factory_trace/processors/find_unused.rb

@@ -8,111 +8,101 @@ module FactoryTrace
       #
       # @return [Array<Hash>]
       def self.call(defined, used)
-        used_inherited_traits = used_inherited_traits(defined, used)
-        used_child_factories = used_child_factories(defined, used)
+        mark_as_used(defined, used)
 
         output = []
 
         defined.factories.each do |factory|
-          unless used.find(factory)
-            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
+          output << {code: :unused, factory_names: factory.names} unless factory.status
 
-          factory.trait_names.each do |trait_name|
-            unless trait_used?(used, factory, trait_name) || trait_used?(used_inherited_traits, factory, trait_name)
-              output << {code: :unused, factory_name: factory.name, trait_name: trait_name}
-            end
+          factory.traits.each do |trait|
+            output << {code: :unused, factory_names: factory.names, trait_name: trait.name} unless trait.status
           end
         end
 
         defined.traits.each do |trait|
-          unless used_inherited_traits.find(trait)
-            output << {code: :unused, trait_name: trait.name}
-            next
-          end
+          output << {code: :unused, trait_name: trait.name} unless trait.status
         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.unshift(code: :unused, value: output.size)
+        output.unshift(code: :used, value: defined.total - (output.size - 1))
 
         output
       end
 
       private
 
-      # Checks if factory of the collection contains a trait
-      #
-      # @param [FactoryTrace::Structures::Collection] collection
-      # @param [FactoryTrace::Structures::Factory] factory
-      # @param [String] trait_name
-      #
-      # @return [Boolean]
-      def self.trait_used?(collection, factory, trait_name)
-        factory = collection.find(factory)
-        factory && factory.trait_names.include?(trait_name)
+      # @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)
+
+          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
 
-      # Returns a new collection where traits which were used moved to their owner factory
-      #
       # @param [FactoryTrace::Structures::Collection] defined
-      # @param [FactoryTrace::Structures::Collection] used
+      # @param [FactoryTrace::Structures::Factory|nil] factory
+      # @param [String] trait_name
       #
-      # @return [FactoryTrace::Structures::Collection]
-      def self.used_inherited_traits(defined, used)
-        collection = FactoryTrace::Structures::Collection.new
+      # @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]
+            end
+            possible_owner = defined.find_factory_by_names([possible_owner.parent_name])
+          end
+        end
 
-        used.factories.each do |factory|
-          factory.trait_names.each do |trait_name|
-            possible_owner_name = factory.name
 
-            while possible_owner_name
-              break if defined.find_factory_by_names(possible_owner_name).trait_names.include?(trait_name)
-              possible_owner_name = defined.find_factory_by_names(possible_owner_name).parent_name
-            end
+        [nil, defined.find_trait_by_name(trait_name)]
+      end
 
-            if possible_owner_name
-              factory = collection.find_factory_by_names(possible_owner_name)
-              factory ||= collection.add(FactoryTrace::Structures::Factory.new(possible_owner_name, nil, [], []))
+      # @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)
 
-              factory.trait_names << trait_name unless factory.trait_names.include?(trait_name)
-            else
-              collection.add(FactoryTrace::Structures::Trait.new(trait_name, nil))
-            end
-          end
+        factory.status = status
+        if (parent = collection.find_factory_by_names([factory.parent_name]))
+          mark_factory(parent, collection, status: :indirectly_used)
         end
-
-        collection
+        mark_declarations(factory.declaration_names, factory, collection, status: :indirectly_used)
       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 = {}
+      # @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)
 
-        used.factories.each do |factory|
-          parent_name = defined.find(factory).parent_name
+        trait.status = status
+        mark_declarations(trait.declaration_names, factory, collection, status: :indirectly_used)
+      end
 
-          if parent_name
-            hash[parent_name] ||= []
-            hash[parent_name] << factory.name
+      # @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|
+          if (declaration_factory = collection.find_factory_by_names([declaration_name]))
+            mark_factory(declaration_factory, collection, status: status)
+          elsif (declaration_factory, declaration_trait = defined_trait_by_name(collection, factory, declaration_name))
+            mark_trait(declaration_trait, declaration_factory, collection, status: status)
           end
         end
-
-        hash
       end
     end
   end

data/lib/factory_trace/readers/trace_reader.rb

@@ -13,8 +13,8 @@ module FactoryTrace
           File.open(file_name, 'r') do |file|
             data = new(file, configuration: configuration).read
 
-            result.each do |key, collection|
-              collection.merge!(data[key])
+            [:defined, :used].each do |key|
+              result[key].merge!(data[key])
             end
           end
         end
@@ -41,15 +41,28 @@ module FactoryTrace
 
       private
 
+      def parse_trait(hash)
+        FactoryTrace::Structures::Trait.new(hash['name'], declaration_names: hash['declaration_names'])
+      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']
+        )
+      end
+
       def parse_collection(hash)
         collection = FactoryTrace::Structures::Collection.new
 
         hash['factories'].each do |h|
-          collection.add(FactoryTrace::Structures::Factory.new(h['name'], h['parent_name'], h['trait_names'], h['alias_names']))
+          collection.add(parse_factory(h))
         end
 
         hash['traits'].each do |h|
-          collection.add(FactoryTrace::Structures::Trait.new(h['name'], h['owner_name']))
+          collection.add(parse_trait(h))
         end
 
         collection

data/lib/factory_trace/structures/collection.rb

@@ -10,15 +10,13 @@ module FactoryTrace
         @traits = traits
       end
 
-      # @param [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait] element
+      # @param [FactoryTrace::Structures::Factory|FactoryTrace::Structures::Trait] element
       #
-      # @return [FactoryTrace::Structures::Factory, FactoryTrace::Structures::Trait]
+      # @return [FactoryTrace::Structures::Factory|FactoryTrace::Structures::Trait]
       def add(element)
         case element
         when FactoryTrace::Structures::Factory then factories << element
         when FactoryTrace::Structures::Trait then traits << element
-        else
-          fail "Unknown element: #{element.inspect}"
         end
 
         element
@@ -27,61 +25,47 @@ module FactoryTrace
       # @param [Array<String>] names
       #
       # @return [FactoryTrace::Structures::Factory|nil]
-      def find_factory_by_names(*names)
-        factories.find { |factory| names.include?(factory.name) || (names & factory.alias_names).size > 0 }
+      def find_factory_by_names(names)
+        factories.find { |factory| (names & factory.names).size > 0 }
       end
 
-      # @param [Array<String>] names
+      # @param [String] name
       #
       # @return [FactoryTrace::Structures::Trait|nil]
-      def find_trait_by_names(*names)
-        traits.find { |trait| names.include?(trait.name) }
+      def find_trait_by_name(name)
+        traits.find { |trait| name == trait.name }
       end
 
-      # @param [FactoryTrace::Structures::Factory|FactoryTrace::Structures::Trait]
-      #
-      # @return [FactoryTrace::Structures::Factory|FactoryTrace::Structures::Trait]
-      def find(element)
-        case element
-        when FactoryTrace::Structures::Factory then find_factory_by_names(element.name, *element.alias_names)
-        when FactoryTrace::Structures::Trait then find_trait_by_names(element.name)
-        else
-          fail "Unknown element: #{element.inspect}"
-        end
+      # @return [Hash]
+      def to_h
+        {
+          factories: factories.map(&:to_h),
+          traits: traits.map(&:to_h)
+        }
       end
 
       # Merge passed collection into self
       #
       # @param [FactoryTrace::Structures::Collection]
-      #
-      # @return [FactoryTrace::Structures::Collection]
       def merge!(collection)
         collection.factories.each do |factory|
-          if (persisted = find(factory))
+          if (persisted = find_factory_by_names(factory.names))
             persisted.merge!(factory)
           else
-            add(FactoryTrace::Structures::Factory.new(factory.name, factory.parent_name, factory.trait_names, factory.alias_names))
+            add(factory)
           end
         end
 
         collection.traits.each do |trait|
-          add(FactoryTrace::Structures::Trait.new(trait.name, trait.owner_name)) unless find(trait)
+          add(trait) unless find_trait_by_name(trait.name)
         end
       end
 
-      # @return [Hash]
-      def to_h
-        {
-          factories: factories.map(&:to_h),
-          traits: traits.map(&:to_h)
-        }
-      end
-
       # Total number of factories and traits
       #
       # @return [Integer]
       def total
-        traits.size + factories.size + factories.sum { |factory| factory.trait_names.size }
+        traits.size + factories.size + factories.sum { |factory| factory.traits.size }
       end
 
       # @return [Boolean]

data/lib/factory_trace/structures/factory.rb

@@ -1,46 +1,48 @@
 module FactoryTrace
   module Structures
     class Factory
-      attr_reader :name, :parent_name, :trait_names, :alias_names
+      include Helpers::Statusable
 
-      # @param [String] name
-      # @param [String, nil] parent_name
-      # @param [Array<String>] trait_names
-      # @param [Array<String>] alias_names
-      def initialize(name, parent_name, trait_names, alias_names)
-        @name = name
+      attr_reader :names, :parent_name, :traits, :declaration_names
+
+      # @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: [])
+        @names = names
+        @traits = traits
         @parent_name = parent_name
-        @trait_names = trait_names
-        @alias_names = alias_names
+        @declaration_names = declaration_names
       end
 
-      # @return [Hash<Symbol, String>]
+      # @return [Hash<Symbol, Object>]
       def to_h
         {
-          name: name,
+          names: names,
+          traits: traits.map(&:to_h),
           parent_name: parent_name,
-          trait_names: trait_names,
-          alias_names: alias_names
+          declaration_names: declaration_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
+        factory.traits.each do |trait|
+          traits << trait unless traits.any? { |t| t.name == trait.name }
+        end
       end
 
       # @return [Boolean]
       def ==(factory)
         return false unless factory.is_a?(FactoryTrace::Structures::Factory)
 
-        name == factory.name &&
+        names == factory.names &&
+          traits == factory.traits &&
           parent_name == factory.parent_name &&
-          trait_names == factory.trait_names &&
-          alias_names == factory.alias_names
+          declaration_names == factory.declaration_names
       end
     end
   end

data/lib/factory_trace/structures/trait.rb

@@ -1,20 +1,22 @@
 module FactoryTrace
   module Structures
     class Trait
-      attr_reader :name, :owner_name
+      include Helpers::Statusable
+
+      attr_reader :name, :declaration_names
 
       # @param [String] name
-      # @param [String, nil] owner_name
-      def initialize(name, owner_name)
+      # @param [Array<String>] declaration_names
+      def initialize(name, declaration_names: [])
         @name = name
-        @owner_name = owner_name
+        @declaration_names = declaration_names
       end
 
-      # @return [Hash<Symbol, String>]
+      # @return [Hash<Symbol, Object>]
       def to_h
         {
           name: name,
-          owner_name: owner_name
+          declaration_names: declaration_names
         }
       end
 
@@ -22,7 +24,7 @@ module FactoryTrace
       def ==(trait)
         return false unless trait.is_a?(FactoryTrace::Structures::Trait)
 
-        name == trait.name && owner_name == trait.owner_name
+        name == trait.name && declaration_names == trait.declaration_names
       end
     end
   end

data/lib/factory_trace/version.rb

@@ -1,3 +1,3 @@
 module FactoryTrace
-  VERSION = '0.2.4'
+  VERSION = '0.3.0'
 end

data/lib/factory_trace/writers/report_writer.rb

@@ -40,8 +40,8 @@ module FactoryTrace
           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] && result[:factories_names]
+          "#{humanize_code(result[:code])} factory #{colorize(:blue, result[:factory_name])} as parent for #{list(result[:factories_names])}"
         when result[:factory_name]
           "#{humanize_code(result[:code])} factory #{colorize(:blue, result[:factory_name])}"
         else

data/lib/factory_trace.rb

@@ -6,6 +6,7 @@ require 'set'
 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/structures/factory'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factory_trace
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - djezzzl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-02 00:00:00.000000000 Z
+date: 2019-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -78,6 +78,7 @@ files:
 - lib/factory_trace.rb
 - lib/factory_trace/configuration.rb
 - lib/factory_trace/helpers/converter.rb
+- lib/factory_trace/helpers/statusable.rb
 - lib/factory_trace/preprocessors/extract_defined.rb
 - lib/factory_trace/preprocessors/extract_used.rb
 - lib/factory_trace/processors/find_unused.rb