real_data_tests 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1db1628bca035d2b5e5f402b39ceaabd5c78b5bf957cd7bcd7856e5819889334
-  data.tar.gz: 477319961d6795bd6005c8d5819cc7d26ded26ba46704cc3bc6ab2c5e701227e
+  metadata.gz: 1c5ba3c2d2b4bb4f9ec9a6c539ddd809b6840d3eb7e6cbfb33d02f524177b3ff
+  data.tar.gz: e64f18ddd2a0bab9c0f3aad9ab628fb7bd86097644807c5d99596aa3c3af55c4
 SHA512:
-  metadata.gz: 30b473701dfd16d6337803a481caf8e358cf87c04877c076a66b2079da57bd68d0896d321c16c2cf1ecab1ce08b5179aba7f9845b0b28d58ecf9e67fb8d9f2b7
-  data.tar.gz: f0ea756e2384a7d43f5d40a36d018b569fc5abdba092f5635ade2d11ec1bf24a33c1ba219d1d983fbc7a918fbf842bd2a85436a644cc65fa40d2ea0fb07a923d
+  metadata.gz: 14a8d12cb5fd01582b2bf22d47d7fa518f2f0be2258e15c477f42c29c1c95b9d362fc20f486fe583f655eeac5b15ceba48c888eb49e9bc47444ab3ffcf79feb6
+  data.tar.gz: 1c2a99d52fa1b740c07152bf12d6802711bba8af8af38d94924d66ddda06d2eab76e6f459b532af3c29e2a0767bfd4ee7977aa23293b3a616225a5b340010a89

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [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
 
     def initialize
       @association_filter_mode = nil
@@ -70,6 +73,26 @@ module RealDataTests
       @association_limits = {}
       @prevent_reciprocal_loading = {}
       @anonymization_rules = {}
+      @prevented_reciprocals = Set.new
+      @max_depth = 10
+    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 +132,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,6 +6,10 @@ module RealDataTests
       @record = record
       @collected_records = Set.new
       @collection_stats = {}
+      @processed_associations = Set.new
+      @association_path = []
+      @current_depth = 0
+      @visited_associations = {}
 
       # Initialize stats for the record's class
       @collection_stats[record.class.name] = {
@@ -20,9 +24,6 @@ module RealDataTests
         end
       end
 
-      @processed_associations = Set.new
-      @association_path = []
-
       puts "\nInitializing RecordCollector for #{record.class.name}##{record.id}"
       record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
         if assoc.polymorphic?
@@ -35,45 +36,30 @@ module RealDataTests
 
     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}"
-
-      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
-        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 +77,106 @@ 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 should_process_association?(record, association, depth = 0)
+      return false if depth >= RealDataTests.configuration.current_preset.max_depth
+
+      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)
+      puts "  Configuration says: #{should_process}"
+
+      if should_process
+        @processed_associations.add(association_key)
+        true
+      else
+        false
       end
     end
 
-    def process_association(record, association)
+    def process_association(record, association, depth)
+      @association_path.push(association.name)
+
       begin
+        if detect_circular_dependency?(record, association)
+          puts "    Skipping circular dependency for #{association.name} on #{record.class.name}##{record.id}"
+          return
+        end
+
         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) }
+        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 self_referential_association?(klass, association)
+      return false unless association.options[:class_name]
+      return false if association.polymorphic?
+      association.options[:class_name] == klass.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
+
+      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 +184,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.1"
 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.1
 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