real_data_tests 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1db1628bca035d2b5e5f402b39ceaabd5c78b5bf957cd7bcd7856e5819889334
-  data.tar.gz: 477319961d6795bd6005c8d5819cc7d26ded26ba46704cc3bc6ab2c5e701227e
+  metadata.gz: 21f2ee14eda8fe0a048506c0ac7948c0f1c3cacb603ddb9c6490f1abef0e7fda
+  data.tar.gz: '0698d429e6feb3f2dfd358014ff71b7cca4415d2393cbab950f99776191ec43c'
 SHA512:
-  metadata.gz: 30b473701dfd16d6337803a481caf8e358cf87c04877c076a66b2079da57bd68d0896d321c16c2cf1ecab1ce08b5179aba7f9845b0b28d58ecf9e67fb8d9f2b7
-  data.tar.gz: f0ea756e2384a7d43f5d40a36d018b569fc5abdba092f5635ade2d11ec1bf24a33c1ba219d1d983fbc7a918fbf842bd2a85436a644cc65fa40d2ea0fb07a923d
+  metadata.gz: 7839506386159938f4d5764bc0871876d7bb02ebac18ed522f23fc822e137757ea5a8a8dda7c36c4c43a91e48fa44cc0b8d69dfdca6fde402a12fe743c606fc9
+  data.tar.gz: bc74ab0ab3c19d1766714ebe35b25c310360a7b2d0154b675b223b46e0ee8610dd37ada15de1620867895fb922cba7edaf63a3d252e2d86dcaeb070bb9716b5b

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.3.2] - 2025-01-14
+### Fixed
+- Enhanced association statistics tracking in RecordCollector
+  - Added separate statistics tracking method to ensure accurate counts
+  - Stats are now tracked before circular dependency checks
+  - Fixed parent-child relationship counting in recursive associations
+  - Improved initialization of statistics structures for better reliability
+
+## [0.3.1] - 2025-01-14
+### Fixed
+- Fixed circular dependency handling in RecordCollector to correctly limit record collection
+  - Moved prevention logic earlier in the collection process to stop circular dependencies before record collection
+  - Improved tracking of visited associations for more accurate prevention
+  - Added better logging for dependency prevention decisions
+  - Fixed test case for circular dependency prevention in nested associations
+
 ## [0.3.0] - 2025-01-13
 ### Added
 - **Polymorphic Association Support**:

data/lib/real_data_tests/configuration.rb

@@ -61,7 +61,10 @@ module RealDataTests
   class PresetConfig
     attr_reader :association_filter_mode, :association_filter_list,
                 :model_specific_associations, :association_limits,
-                :prevent_reciprocal_loading, :anonymization_rules
+                :prevent_reciprocal_loading, :anonymization_rules,
+                :prevented_reciprocals
+
+    attr_accessor :max_depth, :max_self_ref_depth
 
     def initialize
       @association_filter_mode = nil
@@ -70,6 +73,27 @@ module RealDataTests
       @association_limits = {}
       @prevent_reciprocal_loading = {}
       @anonymization_rules = {}
+      @prevented_reciprocals = Set.new
+      @max_depth = 10
+      @max_self_ref_depth = 2
+    end
+
+    def prevent_circular_dependency(klass, association_name)
+      key = if klass.is_a?(String)
+        "#{klass}:#{association_name}"
+      else
+        "#{klass.name}:#{association_name}"
+      end
+      @prevented_reciprocals << key
+    end
+
+    def has_circular_dependency?(klass, association_name)
+      key = if klass.is_a?(String)
+        "#{klass}:#{association_name}"
+      else
+        "#{klass.name}:#{association_name}"
+      end
+      @prevented_reciprocals.include?(key)
     end
 
     def include_associations(*associations)
@@ -109,7 +133,7 @@ module RealDataTests
 
     def prevent_reciprocal?(record_class, association_name)
       path = "#{record_class.name}.#{association_name}"
-      @prevent_reciprocal_loading[path]
+      @prevent_reciprocal_loading[path] || has_circular_dependency?(record_class, association_name)
     end
 
     def prevent_reciprocal(path)

data/lib/real_data_tests/record_collector.rb

@@ -6,74 +6,55 @@ module RealDataTests
       @record = record
       @collected_records = Set.new
       @collection_stats = {}
-
-      # Initialize stats for the record's class
-      @collection_stats[record.class.name] = {
-        count: 0,
-        associations: Hash.new(0),
-        polymorphic_types: {}
-      }
-
-      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
-        if assoc.polymorphic?
-          @collection_stats[record.class.name][:polymorphic_types][assoc.name.to_s] ||= Set.new
-        end
-      end
-
       @processed_associations = Set.new
       @association_path = []
+      @current_depth = 0
+      @visited_associations = {}
+      @processed_self_refs = Hash.new { |h, k| h[k] = Set.new }
 
-      puts "\nInitializing RecordCollector for #{record.class.name}##{record.id}"
-      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
-        if assoc.polymorphic?
-          type = record.public_send("#{assoc.name}_type")
-          id = record.public_send("#{assoc.name}_id")
-          puts "Found polymorphic belongs_to '#{assoc.name}' with type: #{type}, id: #{id}"
-        end
-      end
+      init_collection_stats(record)
     end
 
     def collect
       puts "\nStarting record collection from: #{@record.class.name}##{@record.id}"
-      filter_mode = RealDataTests.configuration.association_filter_mode
-      filter_list = RealDataTests.configuration.association_filter_list
+      filter_mode = RealDataTests.configuration.current_preset.association_filter_mode
+      filter_list = RealDataTests.configuration.current_preset.association_filter_list
       puts "Using #{filter_mode || 'no'} filter with #{filter_list.any? ? filter_list.join(', ') : 'no associations'}"
-      collect_record(@record)
+      collect_record(@record, 0)
       print_collection_stats
       @collected_records.to_a
     end
 
     private
 
-    def should_process_association?(record, association)
-      association_key = "#{record.class.name}##{record.id}:#{association.name}"
-      return false if @processed_associations.include?(association_key)
-
-      puts "  Checking if should process: #{association_key}"
-      should_process = RealDataTests.configuration.should_process_association?(record, association.name)
-      puts "  Configuration says: #{should_process}"
+    def init_collection_stats(record)
+      @collection_stats[record.class.name] = {
+        count: 0,
+        associations: Hash.new(0),
+        polymorphic_types: {}
+      }
 
-      if should_process
-        @processed_associations.add(association_key)
-        if RealDataTests.configuration.prevent_reciprocal?(record.class, association.name)
-          puts "  Skipping prevented reciprocal association: #{association.name} on #{record.class.name}"
-          return false
+      record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        if assoc.polymorphic?
+          @collection_stats[record.class.name][:polymorphic_types][assoc.name.to_s] ||= Set.new
         end
-        true
-      else
-        false
       end
     end
 
-    def collect_record(record)
+    def collect_record(record, depth)
       return if @collected_records.include?(record)
       return unless record # Guard against nil records
+      return if depth > RealDataTests.configuration.current_preset.max_depth
 
       puts "\nCollecting record: #{record.class.name}##{record.id}"
       @collected_records.add(record)
 
-      # Ensure stats structure is initialized
-      @collection_stats[record.class.name] ||= { count: 0, associations: {}, polymorphic_types: {} }
+      # Initialize stats structure
+      @collection_stats[record.class.name] ||= {
+        count: 0,
+        associations: {},
+        polymorphic_types: {}
+      }
       @collection_stats[record.class.name][:count] += 1
 
       # Track types for polymorphic belongs_to associations
@@ -91,43 +72,146 @@ module RealDataTests
           else
             puts "  Skipping polymorphic type for #{assoc.name} due to missing associated record"
           end
-        rescue ActiveRecord::RecordNotFound => e
+        rescue StandardError => e
           puts "  Error loading polymorphic association #{assoc.name}: #{e.message}"
         end
       end
 
-      collect_associations(record)
+      collect_associations(record, depth)
     end
 
-    def collect_associations(record)
+    def collect_associations(record, depth)
       return unless record.class.respond_to?(:reflect_on_all_associations)
+      return if depth >= RealDataTests.configuration.current_preset.max_depth
 
       associations = record.class.reflect_on_all_associations
       puts "\nProcessing associations for: #{record.class.name}##{record.id}"
       puts "Found #{associations.length} associations"
 
       associations.each do |association|
-        next unless should_process_association?(record, association)
+        association_key = "#{record.class.name}##{record.id}:#{association.name}"
+        puts "  Checking if should process: #{association_key}"
+
+        if RealDataTests.configuration.current_preset.prevent_reciprocal?(record.class, association.name)
+          track_key = "#{record.class.name}:#{association.name}"
+          @visited_associations[track_key] ||= Set.new
+
+          # Skip if we've already processed this association type for this class
+          if @visited_associations[track_key].any?
+            puts "    Skipping prevented reciprocal association: #{track_key}"
+            next
+          end
+          @visited_associations[track_key].add(record.id)
+        end
+
+        next unless should_process_association?(record, association, depth)
 
         puts "  Processing #{association.macro} #{association.polymorphic? ? 'polymorphic ' : ''}association: #{association.name}"
-        process_association(record, association)
+        process_association(record, association, depth)
       end
     end
 
-    def process_association(record, association)
+    def should_process_association?(record, association, depth = 0)
+      return false if depth >= RealDataTests.configuration.current_preset.max_depth
+
+      # Handle self-referential associations
+      if self_referential_association?(record.class, association)
+        track_key = "#{record.class.name}:#{association.name}"
+        return false if @processed_self_refs[track_key].include?(record.id)
+        @processed_self_refs[track_key].add(record.id)
+      end
+
+      association_key = "#{record.class.name}##{record.id}:#{association.name}"
+      return false if @processed_associations.include?(association_key)
+
+      # Check if the association is allowed by configuration
+      should_process = RealDataTests.configuration.current_preset.should_process_association?(record, association.name)
+
+      if should_process
+        @processed_associations.add(association_key)
+        true
+      else
+        false
+      end
+    end
+
+    def process_association(record, association, depth)
+      @association_path.push(association.name)
+
       begin
         related_records = fetch_related_records(record, association)
         count = related_records.length
-        puts "    Found #{count} related #{association.name} records"
-        @collection_stats[record.class.name][:associations][association.name.to_s] ||= 0
-        @collection_stats[record.class.name][:associations][association.name.to_s] += count
 
-        related_records.each { |related_record| collect_record(related_record) }
+        # Track statistics even if we're going to skip processing
+        track_association_stats(record.class.name, association.name, count)
+
+        # Check for circular dependency after getting the related records
+        if detect_circular_dependency?(record, association)
+          puts "    Skipping circular dependency for #{association.name} on #{record.class.name}##{record.id}"
+          return
+        end
+
+        # For self-referential associations, check depth
+        if self_referential_association?(record.class, association)
+          max_self_ref_depth = 2  # Default max depth for self-referential associations
+          if depth >= max_self_ref_depth
+            puts "    Reached max self-referential depth for #{association.name}"
+            return
+          end
+        end
+
+        related_records.each { |related_record| collect_record(related_record, depth + 1) }
       rescue => e
         puts "    Error processing association #{association.name}: #{e.message}"
+      ensure
+        @association_path.pop
       end
     end
 
+    def track_association_stats(class_name, association_name, count)
+      # Initialize stats for this class if not already done
+      @collection_stats[class_name] ||= {
+        count: 0,
+        associations: Hash.new(0),
+        polymorphic_types: {}
+      }
+
+      # Update the association count
+      @collection_stats[class_name][:associations][association_name.to_s] ||= 0
+      @collection_stats[class_name][:associations][association_name.to_s] += count
+    end
+
+    def self_referential_association?(klass, association)
+      return false unless association.options[:class_name]
+      return false if association.polymorphic?
+
+      target_class_name = if association.options[:class_name].is_a?(String)
+        association.options[:class_name]
+      else
+        association.options[:class_name].name
+      end
+
+      klass.name == target_class_name
+    end
+
+    def detect_circular_dependency?(record, association)
+      return false unless association.belongs_to?
+      return false if association.polymorphic?
+
+      target_class = association.klass
+      return false unless target_class
+
+      if self_referential_association?(record.class, association)
+        track_key = "#{target_class.name}:#{association.name}"
+        return @processed_self_refs[track_key].include?(record.id)
+      end
+
+      path_key = "#{target_class.name}:#{association.name}"
+      visited_count = @association_path.count { |assoc| "#{target_class.name}:#{assoc}" == path_key }
+
+      visited_count > 1
+    end
+
     def fetch_related_records(record, association)
       case association.macro
       when :belongs_to, :has_one
@@ -135,14 +219,12 @@ module RealDataTests
       when :has_many, :has_and_belongs_to_many
         relation = record.public_send(association.name)
 
-        if limit = RealDataTests.configuration.get_association_limit(record.class, association.name)
+        if limit = RealDataTests.configuration.current_preset.get_association_limit(record.class, association.name)
           puts "    Applying configured limit of #{limit} records for #{record.class.name}.#{association.name}"
-          relation = relation.limit(limit)
+          relation = relation[0...limit]
         end
 
-        records = relation.to_a
-        records = records[0...limit] if limit # Ensure in-memory limit as well
-        records
+        relation
       else
         []
       end

data/lib/real_data_tests/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RealDataTests
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: real_data_tests
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Kevin Dias
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-13 00:00:00.000000000 Z
+date: 2025-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails