evil-seed 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfdedee7cac6da3803d6071ccbda5eaf19ee07bc07c67775b202160c304dd323
-  data.tar.gz: e04bc0672ccb683928651843c749ad05378af846c6d4b51d7e7c3d14eb43c179
+  metadata.gz: 757a2cee2b774b29a9d248270642db41faa431fdfd1b738aed0b8ea275fa358a
+  data.tar.gz: 8dc1887a03f1169aa332f9ef345ea666d5582e578ec6c8c97c6041b6f281dff4
 SHA512:
-  metadata.gz: d2973540b6fd16936419e9e76e389df4dd854313e3674ff7c73f7056c18c3e8979ca302d0c395a60e3a17abb7f9bc2b886ef4939711ad43c3df72cebc06cf944
-  data.tar.gz: cb2772174b471dc7977fcaa00bc79dc0bf45429f836a7e490487d37e625f4d8328583d1d103b13d2a8899e56736793acb24e35fd362c196aab1a60489f023159
+  metadata.gz: aea3be4c8d73fc5ec6e04457d6322306d12a70d44a4792eb1dc855162b28b3b325617815a8a5898733cdc31067e8c51fa3714909c123fe890d54e21123121f7f
+  data.tar.gz: 98ed722479590c6615d87dfa3a0262d7012f008f0c9be2c4ddb3066a01ef2959febaf3ecea60c25e362417e9eba986f7ada50fad9ce06355fb8b5dfbc75e664c

data/.github/workflows/test.yml

@@ -19,22 +19,40 @@ jobs:
           - ruby: "head"
             activerecord: "head"
             database: sqlite
+          - ruby: "3.4"
+            activerecord: "8.0"
+            database: postgresql
+          - ruby: "3.4"
+            activerecord: "8.0"
+            database: mysql
+          - ruby: "3.4"
+            activerecord: "8.0"
+            database: sqlite
           - ruby: "3.3"
-            activerecord: "7.1"
+            activerecord: "7.2"
             database: postgresql
           - ruby: "3.3"
-            activerecord: "7.1"
+            activerecord: "7.2"
             database: mysql
           - ruby: "3.3"
-            activerecord: "7.1"
+            activerecord: "7.2"
             database: sqlite
           - ruby: "3.2"
-            activerecord: "7.0"
+            activerecord: "7.1"
+            database: postgresql
+          - ruby: "3.2"
+            activerecord: "7.1"
+            database: mysql
+          - ruby: "3.2"
+            activerecord: "7.1"
             database: sqlite
           - ruby: "3.1"
-            activerecord: "6.1"
+            activerecord: "7.0"
             database: sqlite
           - ruby: "3.0"
+            activerecord: "6.1"
+            database: sqlite
+          - ruby: "2.7"
             activerecord: "6.0"
             database: sqlite
 
@@ -42,7 +60,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:16
+        image: ${{ (matrix.database == 'postgresql') && 'postgres:17' || '' }}
         env:
           POSTGRES_USER: postgres
           POSTGRES_PASSWORD: postgres
@@ -54,7 +72,7 @@ jobs:
           --health-timeout 5s
           --health-retries 5
       mysql:
-        image: mysql:8.4
+        image: ${{ (matrix.database == 'mysql') && 'mysql:9' || '' }}
         env:
           MYSQL_ALLOW_EMPTY_PASSWORD: yes
           MYSQL_DATABASE: evil_seed_test

data/CHANGELOG.md

@@ -7,6 +7,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2025-02-07
+
+### Added
+
+ - Options to exclude all `has_many` and `has_one` or optional `belongs_to` associations by default. [@Envek]
+
+   ```ruby
+   root.exclude_has_relations
+   root.exclude_optional_belongs_to
+   ```
+
+   Excluded associations can be re-included by `include` with matching pattern.
+
+ - Exclusion and inclusion patterns can be specified as hashes and/or arrays. [@Envek]
+
+   ```ruby
+   config.root('Forum', featured: true) do |forum|
+     forum.include(parent: {questions: %i[answers votes]})
+   end
+   ```
+
+   Which is equivalent to:
+
+   ```ruby
+   config.root('Forum', featured: true) do |forum|
+     forum.include(/\Aforum(\.parent(\.questions(\.answers))?)?)?\z/)
+     forum.include(/\Aforum(\.parent(\.questions(\.votes))?)?)?\z/)
+   end
+   ```
+
+ - Association limits also can be specified as hashes and/or arrays. [@Envek]
+
+    ```ruby
+   config.root('Forum', featured: true) do |forum|
+     forum.limit_associations_size(15, questions: %i[answers votes])
+   end
+   ```
+
+   Which is equivalent to:
+
+   ```ruby
+   config.root('Forum', featured: true) do |forum|
+     forum.limit_associations_size(15, 'forum.questions.answers')
+     forum.limit_associations_size(15, 'forum.questions.votes')
+   end
+   ```
+
+
+ - Print reason of association exclusion or inclusion in verbose mode. [@Envek]
+
+ - Allow to apply custom scoping to included associations. [@Envek]
+
+   ```ruby
+   config.root('Forum', featured: true) do |forum|
+     forum.include('questions.answers') do
+       order(created_at: :desc)
+     end
+   end
+   ```
+
+### Fixed
+
+ - Error when dumping single-column tables. [@lsantobuono]
+ - Bug with null foreign key to back to auxiliary `has_one` association with not matching names. E.g. user has many profiles and has one default profile, profile belongs to user.
+ - Ignored columns handling.
+ - Dump relations for records that were dumped earlier with relations excluded.
+
 ## [0.6.0] - 2024-06-18
 
 ### Added
@@ -72,3 +139,4 @@ Initial release. [@palkan], [@Envek]
 [@cmer]: https://github.com/cmer "Carl Mercier"
 [@nhocki]: https://github.com/nhocki "Nicolás Hock-Isaza"
 [@gazay]: https://github.com/gazay "Alex Gaziev"
+[@lsantobuono]: https://github.com/lsantobuono ""

data/Gemfile

@@ -5,7 +5,7 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in evil-seed.gemspec
 gemspec
 
-activerecord_version = ENV.fetch("ACTIVERECORD_VERSION", "~> 7.1")
+activerecord_version = ENV.fetch("ACTIVERECORD_VERSION", "~> 8.0")
 case activerecord_version.upcase
 when "HEAD"
   git "https://github.com/rails/rails.git" do
@@ -15,5 +15,10 @@ when "HEAD"
 else
   activerecord_version = "~> #{activerecord_version}.0" if activerecord_version.match?(/^\d+\.\d+$/)
   gem "activerecord", activerecord_version
-  gem "sqlite3", "~> 1.4"
+  if Gem::Version.new("7.2") > Gem::Version.new(activerecord_version.scan(/\d+\.\d+/).first)
+    gem "sqlite3", "~> 1.4"
+    gem "concurrent-ruby", "< 1.3.5"
+  end
 end
+
+gem "debug"

data/README.md

@@ -48,21 +48,37 @@ EvilSeed.configure do |config|
   # First, you should specify +root models+ and their +constraints+ to limit the number of dumped records:
   # This is like Forum.where(featured: true).all
   config.root('Forum', featured: true) do |root|
+    # You can limit number of records to be dumped
+    root.limit(100)
+    # Specify order for records to be selected for dump
+    root.order(created_at: :desc)
+
     # It's possible to remove some associations from dumping with pattern of association path to exclude
     #
     # Association path is a dot-delimited string of association chain starting from model itself:
     # example: "forum.users.questions"
     root.exclude(/\btracking_pixels\b/, 'forum.popular_questions', /\Aforum\.parent\b/)
 
-    # Include back only certain associations
-    root.include(/\Aforum(\.parent(\.questions(\.answers)?)?)?\z/)
+    # Include back only certain association chains
+    root.include(parent: {questions: %i[answers votes]})
+    # which is the same as
+    root.include(/\Aforum(\.parent(\.questions(\.(answers|votes))?)?)?\z/)
+
+    # You can also specify custom scoping for associations
+    root.include(questions: { answers: :reactions }) do
+      order(created_at: :desc) # Any ActiveRecord query method is allowed
+    end
 
     # It's possible to limit the number of included into dump has_many and has_one records for every association
     # Note that belongs_to records for all not excluded associations are always dumped to keep referential integrity.
     root.limit_associations_size(100)
 
     # Or for certain association only
-    root.limit_associations_size(10, 'forum.questions')
+    root.limit_associations_size(5, 'forum.questions')
+    root.limit_associations_size(15, 'forum.questions.answers')
+    # or
+    root.limit_associations_size(5, :questions)
+    root.limit_associations_size(15, questions: :answers)
 
     # Limit the depth of associations to be dumped from the root level
     # All traverses through has_many, belongs_to, etc are counted

data/evil-seed.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activerecord', '>= 5.0'
 
-  spec.add_development_dependency 'rake',     '~> 12.0'
+  spec.add_development_dependency 'rake',     '~> 13.0'
   spec.add_development_dependency 'minitest', '~> 5.0'
   spec.add_development_dependency 'pg',       '>= 0.20'
   spec.add_development_dependency 'mysql2'

data/lib/evil_seed/configuration/root.rb

@@ -4,7 +4,7 @@ module EvilSeed
   class Configuration
     # Configuration for dumping some root model and its associations
     class Root
-      attr_reader :model, :constraints
+      attr_reader :model, :constraints, :limit, :order
       attr_reader :total_limit, :association_limits, :deep_limit, :dont_nullify
       attr_reader :exclusions, :inclusions
 
@@ -14,7 +14,7 @@ module EvilSeed
         @model = model
         @constraints = constraints
         @exclusions = []
-        @inclusions = []
+        @inclusions = {}
         @association_limits = {}
         @deep_limit = nil
         @dont_nullify = dont_nullify
@@ -23,23 +23,69 @@ module EvilSeed
       # Exclude some of associations from the dump
       # @param association_patterns Array<String, Regex> Patterns to exclude associated models from dump
       def exclude(*association_patterns)
-        @exclusions += association_patterns
+        association_patterns.each do |pattern|
+          case pattern
+          when String, Regexp
+            @exclusions << pattern
+          else
+            path_prefix = model.constantize.model_name.singular
+            @exclusions += compile_patterns(pattern, prefix: path_prefix).map { |p| Regexp.new(/\A#{p}\z/) }
+          end
+        end
       end
 
       # Include some excluded associations back to the dump
       # @param association_patterns Array<String, Regex> Patterns to exclude associated models from dump
-      def include(*association_patterns)
-        @inclusions += association_patterns
+      def include(*association_patterns, &block)
+        association_patterns.each do |pattern|
+          case pattern
+          when String, Regexp
+            @inclusions[pattern] = block
+          else
+            path_prefix = model.constantize.model_name.singular
+            compile_patterns(pattern, prefix: path_prefix).map do |p|
+              @inclusions[Regexp.new(/\A#{p}\z/)] = block
+            end
+          end
+        end
+      end
+
+      def exclude_has_relations
+        @excluded_has_relations = :exclude_has_relations
+      end
+
+      def exclude_optional_belongs_to
+        @excluded_optional_belongs_to = :exclude_optional_belongs_to
+      end
+
+      def limit(limit = nil)
+        return @limit if limit.nil?
+
+        @limit = limit
+      end
+
+      def order(order = nil)
+        return @order if order.nil?
+
+        @order = order
       end
 
       # Limit number of records in all (if pattern is not provided) or given  associations to include into dump
       # @param limit               [Integer]       Maximum number of records in associations to include into dump
-      # @param association_pattern [String, Regex] Pattern to limit number of records for certain associated models
-      def limit_associations_size(limit, association_pattern = nil)
-        if association_pattern
-          @association_limits[association_pattern] = limit
-        else
-          @total_limit = limit
+      # @param association_pattern Array<String, Regex, Hash> Pattern to limit number of records for certain associated models
+      def limit_associations_size(limit, *association_patterns)
+        return @total_limit = limit if association_patterns.empty?
+
+        association_patterns.each do |pattern|
+          case pattern
+          when String, Regexp
+            @association_limits[pattern] = limit
+          else
+            path_prefix = model.constantize.model_name.singular
+            compile_patterns(pattern, prefix: path_prefix, partial: false).map do |p|
+              @association_limits[Regexp.new(/\A#{p}\z/)] = limit
+            end
+          end
         end
       end
 
@@ -54,11 +100,49 @@ module EvilSeed
       end
 
       def excluded?(association_path)
-        exclusions.any? { |exclusion| association_path.match(exclusion) } #.match(association_path) }
+        exclusions.find { |exclusion| association_path.match(exclusion) } #.match(association_path) }
       end
 
       def included?(association_path)
-        inclusions.any? { |inclusion| association_path.match(inclusion) } #.match(association_path) }
+        inclusions.find { |inclusion, _block| association_path.match(inclusion) }
+      end
+
+      def excluded_has_relations?
+        @excluded_has_relations
+      end
+
+      def excluded_optional_belongs_to?
+        @excluded_optional_belongs_to
+      end
+
+      private
+
+      def compile_patterns(pattern, prefix: "", partial: true)
+        wrap = -> (p) { partial ? "(?:\\.#{p})?" : "\\.#{p}" }
+        case pattern
+        when String, Symbol
+          ["#{prefix}#{wrap.(pattern.to_s)}"]
+        when Regexp
+          ["#{prefix}#{wrap.("(?:#{pattern.source})")}"]
+        when Array
+          pattern.map { |p| compile_patterns(p, prefix: prefix, partial: partial) }.flatten
+        when Hash
+          pattern.map do |k, v|
+            next nil unless v
+            subpatterns = compile_patterns(v, partial: partial)
+            next "#{prefix}#{wrap.(k)}" if subpatterns.empty?
+
+            subpatterns.map do |p|
+              "#{prefix}#{wrap.("#{k}#{p}")}"
+            end
+          end.compact.flatten
+        when false, nil
+          nil
+        when true
+          [prefix]
+        else
+          raise ArgumentError, "Unknown pattern type: #{pattern.class} for #{pattern.inspect}"
+        end
       end
     end
   end

data/lib/evil_seed/configuration.rb

@@ -39,7 +39,7 @@ module EvilSeed
     end
 
     def ignore_columns(model_class, *columns)
-      @ignored_columns[model_class] += columns
+      @ignored_columns[model_class.to_s] += columns.map(&:to_s)
     end
 
     # Customizer objects for every model

data/lib/evil_seed/dumper.rb

@@ -7,7 +7,7 @@ module EvilSeed
   # This class initiates dump creation for every root model of configuration
   # and then concatenates dumps from all roots into one single IO.
   class Dumper
-    attr_reader :configuration, :loaded_map
+    attr_reader :configuration, :loaded_map, :to_load_map
 
     # @param configuration [Configuration]
     def initialize(configuration)
@@ -18,6 +18,7 @@ module EvilSeed
     # @param output [IO] Stream to write SQL dump into
     def call(output)
       @loaded_map = Hash.new { |h, k| h[k] = Set.new } # stores primary keys of already dumped records for every table
+      @to_load_map = Hash.new { |h, k| h[k] = Set.new } # stores primary keys of records we're going to dump to avoid cycles
       @output = output
       configuration.roots.each do |root|
         table_outputs = RootDumper.new(root, self).call

data/lib/evil_seed/record_dumper.rb

@@ -9,7 +9,7 @@ module EvilSeed
 
     attr_reader :model_class, :configuration, :relation_dumper
 
-    delegate :loaded_map, to: :relation_dumper
+    delegate :loaded_map, :to_load_map, to: :relation_dumper
 
     def initialize(model_class, configuration, relation_dumper)
       @model_class     = model_class
@@ -38,8 +38,10 @@ module EvilSeed
 
     def loaded!(attributes)
       id = model_class.primary_key && attributes[model_class.primary_key] || attributes
-      return false if loaded_map[model_class.table_name].include?(id)
-      loaded_map[model_class.table_name] << id
+      !loaded_map[model_class.table_name].include?(id).tap do
+        loaded_map[model_class.table_name] << id
+        to_load_map[model_class.table_name].delete(id)
+      end
     end
 
     def transform_and_anonymize(attributes)
@@ -51,9 +53,10 @@ module EvilSeed
     end
 
     def insertable_column_names
-      model_class.columns_hash.reject do |k,v|
-        v.respond_to?(:virtual?) ? v.virtual? : false
-      end.keys
+      @insertable_column_names ||=
+        model_class.columns_hash.reject do |_k, v|
+          v.respond_to?(:virtual?) ? v.virtual? : false
+        end.keys - configuration.ignored_columns_for(model_class.to_s)
     end
 
     def insert_statement
@@ -81,9 +84,11 @@ module EvilSeed
     end
 
     def finalize!
-      return unless @header_written && @tuples_written > 0
+      return true if @finalized
+      return false unless @header_written && @tuples_written > 0
       @output.write(";\n\n")
       @tuples_written = 0
+      @finalized = true
     end
 
     def prepare(attributes)

data/lib/evil_seed/relation_dumper.rb

@@ -24,24 +24,27 @@ module EvilSeed
     MAX_IDENTIFIERS_IN_IN_STMT = 1_000
 
     attr_reader :relation, :root_dumper, :model_class, :association_path, :search_key, :identifiers, :nullify_columns,
-                :belongs_to_reflections, :has_many_reflections, :foreign_keys, :loaded_ids, :to_load_map,
-                :record_dumper, :inverse_reflection, :table_names, :options,
-                :current_deep, :verbose
+                :belongs_to_reflections, :has_many_reflections, :foreign_keys, :loaded_ids, :local_load_map,
+                :records, :record_dumper, :inverse_reflection, :table_names, :options,
+                :current_deep, :verbose, :custom_scope
 
-    delegate :root, :configuration, :dont_nullify, :total_limit, :deep_limit, :loaded_map, to: :root_dumper
+    delegate :root, :configuration, :dont_nullify, :total_limit, :deep_limit, :loaded_map, :to_load_map, to: :root_dumper
 
     def initialize(relation, root_dumper, association_path, **options)
+      puts("- #{association_path}") if root_dumper.configuration.verbose
+
       @relation               = relation
       @root_dumper            = root_dumper
       @verbose                = configuration.verbose
       @identifiers            = options[:identifiers]
-      @to_load_map            = Hash.new { |h, k| h[k] = [] }
+      @local_load_map         = Hash.new { |h, k| h[k] = [] }
       @foreign_keys           = Hash.new { |h, k| h[k] = [] }
       @loaded_ids             = []
       @model_class            = relation.klass
       @search_key             = options[:search_key] || model_class.primary_key
       @association_path       = association_path
       @inverse_reflection     = options[:inverse_of]
+      @records                = []
       @record_dumper          = configuration.record_dumper_class.new(model_class, configuration, self)
       @nullify_columns        = []
       @table_names            = {}
@@ -50,8 +53,7 @@ module EvilSeed
       @options                = options
       @current_deep           = association_path.split('.').size
       @dont_nullify           = dont_nullify
-
-      puts("- #{association_path}") if verbose
+      @custom_scope           = options[:custom_scope]
     end
 
     # Generate dump and write it into +io+
@@ -59,11 +61,13 @@ module EvilSeed
     def call
       dump!
       if deep_limit and current_deep > deep_limit
-        [record_dumper.result].flatten.compact
+        [dump_records!].flatten.compact
       else
-        belongs_to_dumps = dump_belongs_to_associations!
-        has_many_dumps   = dump_has_many_associations!
-        [belongs_to_dumps, record_dumper.result, has_many_dumps].flatten.compact
+        [
+          dump_belongs_to_associations!,
+          dump_records!,
+          dump_has_many_associations!,
+        ].flatten.compact
       end
     end
 
@@ -73,7 +77,15 @@ module EvilSeed
       original_ignored_columns = model_class.ignored_columns
       model_class.ignored_columns += Array(configuration.ignored_columns_for(model_class.sti_name))
       model_class.send(:reload_schema_from_cache) if ActiveRecord.version < Gem::Version.new("6.1.0.rc1") # See https://github.com/rails/rails/pull/37581
-      if identifiers.present?
+      if custom_scope
+        puts("  # #{search_key} (with scope)") if verbose
+        attrs = fetch_attributes(relation)
+        puts(" -- dumped #{attrs.size}") if verbose
+        attrs.each do |attributes|
+          next unless check_limits!
+          dump_record!(attributes)
+        end
+      elsif identifiers.present?
         puts("  # #{search_key} => #{identifiers}") if verbose
         # Don't use AR::Base#find_each as we will get error on Oracle if we will have more than 1000 ids in IN statement
         identifiers.in_groups_of(MAX_IDENTIFIERS_IN_IN_STMT).each do |ids|
@@ -105,40 +117,49 @@ module EvilSeed
           attributes[nullify_column] = nil
         end
       end
-      return unless record_dumper.call(attributes)
+      records << attributes
       foreign_keys.each do |reflection_name, fk_column|
         foreign_key = attributes[fk_column]
-        next if foreign_key.nil? || loaded_map[table_names[reflection_name]].include?(foreign_key)
-        to_load_map[reflection_name] << foreign_key
+        next if foreign_key.nil? || loaded_map[table_names[reflection_name]].include?(foreign_key) || to_load_map[table_names[reflection_name]].include?(foreign_key)
+        local_load_map[reflection_name] << foreign_key
+        to_load_map[table_names[reflection_name]] << foreign_key
       end
       loaded_ids << attributes[model_class.primary_key]
     end
 
+    def dump_records!
+      records.each do |attributes|
+        record_dumper.call(attributes)
+      end
+      record_dumper.result
+    end
+
     def dump_belongs_to_associations!
       belongs_to_reflections.map do |reflection|
-        next if to_load_map[reflection.name].empty?
+        next if local_load_map[reflection.name].empty?
         RelationDumper.new(
           build_relation(reflection),
           root_dumper,
           "#{association_path}.#{reflection.name}",
           search_key:       reflection.association_primary_key,
-          identifiers:      to_load_map[reflection.name],
+          identifiers:      local_load_map[reflection.name],
           limitable:        false,
         ).call
       end
     end
 
     def dump_has_many_associations!
-      has_many_reflections.map do |reflection|
+      has_many_reflections.map do |reflection, custom_scope|
         next if loaded_ids.empty? || total_limit.try(:zero?)
         RelationDumper.new(
-          build_relation(reflection),
+          build_relation(reflection, custom_scope),
           root_dumper,
           "#{association_path}.#{reflection.name}",
           search_key:       reflection.foreign_key,
-          identifiers:      loaded_ids,
+          identifiers:      loaded_ids - local_load_map[reflection.name],
           inverse_of:       reflection.inverse_of.try(:name),
           limitable:        true,
+          custom_scope:     custom_scope,
         ).call
       end
     end
@@ -148,7 +169,7 @@ module EvilSeed
     # @return [Array<Hash{String => String, Integer, Float, Boolean, nil}>]
     def fetch_attributes(relation)
       relation.pluck(*model_class.column_names).map do |row|
-        Hash[model_class.column_names.zip(row)]
+        Hash[model_class.column_names.zip(Array(row))]
       end
     end
 
@@ -157,13 +178,14 @@ module EvilSeed
       root_dumper.check_limits!(association_path)
     end
 
-    def build_relation(reflection)
+    def build_relation(reflection, custom_scope = nil)
       if configuration.unscoped
         relation = reflection.klass.unscoped
       else
         relation = reflection.klass.all
       end
       relation = relation.instance_eval(&reflection.scope) if reflection.scope
+      relation = relation.instance_eval(&custom_scope) if custom_scope
       relation = relation.where(reflection.type => model_class.to_s) if reflection.options[:as] # polymorphic
       relation
     end
@@ -172,7 +194,10 @@ module EvilSeed
       model_class.reflect_on_all_associations(:belongs_to).reject do |reflection|
         next false if reflection.options[:polymorphic] # TODO: Add support for polymorphic belongs_to
         included = root.included?("#{association_path}.#{reflection.name}")
-        excluded = root.excluded?("#{association_path}.#{reflection.name}") || reflection.name == inverse_reflection
+        excluded = reflection.options[:optional] && root.excluded_optional_belongs_to?
+        excluded ||= root.excluded?("#{association_path}.#{reflection.name}")
+        inverse = reflection.name == inverse_reflection
+        puts " -- belongs_to #{reflection.name} #{"excluded by #{excluded}" if excluded} #{"re-included by #{included}" if included}" if verbose
         if excluded and not included
           if model_class.column_names.include?(reflection.foreign_key)
             puts(" -- excluded #{reflection.foreign_key}") if verbose
@@ -182,7 +207,7 @@ module EvilSeed
           foreign_keys[reflection.name] = reflection.foreign_key
           table_names[reflection.name]  = reflection.table_name
         end
-        excluded and not included
+        excluded and not included or inverse
       end
     end
 
@@ -190,14 +215,21 @@ module EvilSeed
     def setup_has_many_reflections
       puts(" -- reflections #{model_class._reflections.keys}") if verbose
       model_class._reflections.select do |_reflection_name, reflection|
+        next false unless %i[has_one has_many].include?(reflection.macro)
+
         next false if model_class.primary_key.nil?
 
         next false if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
 
         included = root.included?("#{association_path}.#{reflection.name}")
-        excluded = root.excluded?("#{association_path}.#{reflection.name}") || reflection.name == inverse_reflection
-        %i[has_one has_many].include?(reflection.macro) && !(excluded and not included)
-      end.map(&:second)
+        excluded = :inverse if reflection.name == inverse_reflection
+        excluded ||= root.excluded_has_relations?
+        excluded ||= root.excluded?("#{association_path}.#{reflection.name}")
+        puts " -- #{reflection.macro} #{reflection.name} #{"excluded by #{excluded}" if excluded} #{"re-included by #{included}" if included}" if verbose
+        !(excluded and not included)
+      end.map do |_reflection_name, reflection|
+        [reflection, root.included?("#{association_path}.#{reflection.name}")&.last]
+      end
     end
   end
 end

data/lib/evil_seed/root_dumper.rb

@@ -7,12 +7,11 @@ module EvilSeed
   class RootDumper
     attr_reader :root, :dumper, :model_class, :total_limit, :deep_limit, :dont_nullify, :association_limits
 
-    delegate :loaded_map, :configuration, to: :dumper
+    delegate :loaded_map, :to_load_map, :configuration, to: :dumper
 
     def initialize(root, dumper)
       @root   = root
       @dumper = dumper
-      @to_load_map = {}
       @total_limit = root.total_limit
       @deep_limit = root.deep_limit
       @dont_nullify = root.dont_nullify
@@ -28,6 +27,8 @@ module EvilSeed
       relation = model_class.all
       relation = relation.unscoped if configuration.unscoped
       relation = relation.where(*root.constraints) if root.constraints.any? # without arguments returns not a relation
+      relation = relation.limit(root.limit) if root.limit
+      relation = relation.order(root.order) if root.order
       RelationDumper.new(relation, self, association_path).call
     end
 

data/lib/evil_seed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EvilSeed
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: evil-seed
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Andrey Novikov
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2025-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -175,7 +175,7 @@ homepage: https://github.com/palkan/evil-seed
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -190,8 +190,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Create partial and anonymized production database dumps for use in development
 test_files: []