live_fixtures 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c62185d78a809ced340e94cea4d55cf2149ffe83f3d01629db553df1b37dd10e
-  data.tar.gz: cea4216a648c7483612dc608ae00d72c0a78bce29b98e53a78534f47506d5f06
+  metadata.gz: 4555eba9da64e35ef61d763132a1d2e5a280c785d0b2583fcb9055e6800eae74
+  data.tar.gz: fb54c037ff212fecb9bdbe2fd0c961df6d0acba9a0ed6dab7579c5e487656b0f
 SHA512:
-  metadata.gz: 679e1f0bf3bc5d4d423258ab29b049f81d468889fb17f58de07a3d3bc0a3755466c09b88a853c9dd86b90e475f933c9c102f186fd8405cda0cebec598a6ebae0
-  data.tar.gz: 5417590a883f45a64ce359a79553a9cf1e826696e7b65f5c9ff0d15d3d28b3a05807578e8dad6672a91daaf3b2f53e38bd28a8dc842f28237c8ee044f01cf970
+  metadata.gz: 6f0af7f78d0638a22f2dc607b6a21b0cf24b95497fe974c4f0c1b1d7c4b895048deac44ec55576391ccf67bc297e8aa318e841ed1ef1669eb286b8cdeba3f932
+  data.tar.gz: 12a8488d4e93c45462e7362926f057571f54f4afe2640ff94dc422b8c3bbc9a4ff0a6b4a064962e15ca13b75c2abb60e1f016495189a28e3d14b627504152c32

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.0.0] - 2020-11-11
+### Breaking changes
+This is a breaking change because LiveFixtures::Import.new now needs to receive the class_names Hash to be able to correctly compute the insert_order in case there are some unconventional class names associations. And the class_names argument is removed from import_all. But this is the only change.
+
+### Added
+  - compute insert_order automatically (#33)
+
 ## [1.0.1] - 2019-04-10
 ### Fixed
   - fixed incompatibility with mysql

data/README.md

@@ -76,7 +76,7 @@ The `LiveFixtures::Export` module is meant to be included into your export class
 
 ### Importing
 
-The `LiveFixtures::Import` class allows you to specify the location of your fixtures and the order in which to import them. Once you've done that, you can import them directly to your database.
+The `LiveFixtures::Import` class allows you to specify the location of your fixtures and, optionally, the order in which to import them. If you don't specify an order, the order will be computed from the ActiveRecord models associations. Once you've done that, you can import them directly to your database.
 
 
     module Seed::User

data/lib/live_fixtures.rb

@@ -1,9 +1,11 @@
 require "live_fixtures/version"
 require "live_fixtures/import"
 require "live_fixtures/import/fixtures"
+require "live_fixtures/import/insertion_order_computer"
 require "live_fixtures/export"
 require "live_fixtures/export/fixture"
 require "ruby-progressbar"
+require "yaml"
 
 module LiveFixtures
   module_function

data/lib/live_fixtures/import.rb

@@ -2,35 +2,48 @@
 class LiveFixtures::Import
   NO_LABEL = nil
 
+  # Returns the insert order that was specified in the constructor or
+  # the inferred one if none was specified.
+  attr_reader :insert_order
+
   # Instantiate a new Import with the directory containing your fixtures, and
   # the order in which to import them. The order should ensure fixtures
   # containing references to another fixture are imported AFTER the referenced
   # fixture.
   # @raise [ArgumentError] raises an argument error if not every element in the insert_order has a corresponding yml file.
   # @param root_path [String] path to the directory containing the yml files to import.
-  # @param insert_order [Array<String>] a list of yml files (without .yml extension) in the order they should be imported.
+  # @param insert_order [Array<String> | Nil] a list of yml files (without .yml extension) in the order they should be imported, or `nil` if these order is to be inferred by this class.
+  # @param class_names [Hash{Symbol => String}] a mapping table name => Model class, for any that don't follow convention.
   # @param [Hash] opts export configuration options
   # @option opts [Boolean] show_progress whether or not to show the progress bar
   # @option opts [Boolean] skip_missing_tables when false, an error will be raised if a yaml file isn't found for each table in insert_order
   # @option opts [Boolean] skip_missing_refs when false, an error will be raised if an ID isn't found for a label.
   # @return [LiveFixtures::Import] an importer
   # @see LiveFixtures::Export::Reference
-  def initialize(root_path, insert_order, **opts)
+  def initialize(root_path, insert_order = nil, class_names = {}, **opts)
     defaut_options = { show_progress: true, skip_missing_tables: false, skip_missing_refs: false }
     @options = defaut_options.merge(opts)
     @root_path = root_path
     @table_names = Dir.glob(File.join(@root_path, '{*,**}/*.yml')).map do |filepath|
       File.basename filepath, ".yml"
     end
-    @table_names = insert_order.select {|table_name| @table_names.include? table_name}
-    if @table_names.size < insert_order.size && !@options[:skip_missing_tables]
-      raise ArgumentError, "table(s) mentioned in `insert_order` which has no yml file to import: #{insert_order - @table_names}"
+
+    @class_names = class_names
+    @table_names.each { |n|
+      @class_names[n.tr('/', '_').to_sym] ||= n.classify if n.include?('/')
+    }
+
+    @insert_order = insert_order
+    @insert_order ||= InsertionOrderComputer.compute(@table_names, @class_names, compute_polymorphic_associations)
+
+    @table_names = @insert_order.select {|table_name| @table_names.include? table_name}
+    if @table_names.size < @insert_order.size && !@options[:skip_missing_tables]
+      raise ArgumentError, "table(s) mentioned in `insert_order` which has no yml file to import: #{@insert_order - @table_names}"
     end
     @label_to_id = {}
   end
 
   # Within a transaction, import all the fixtures into the database.
-  # @param class_names [Hash{Symbol => String}] a mapping table name => Model class, for any that don't follow convention.
   #
   # The very similar method: ActiveRecord::FixtureSet.create_fixtures has the
   # unfortunate side effect of truncating each table!!
@@ -39,11 +52,7 @@ class LiveFixtures::Import
   # with calling {LiveFixtures::Import::Fixtures#each_table_row_with_label} instead of
   # `AR::Fixtures#table_rows`, and using those labels to populate `@label_to_id`.
   # @see https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/fixtures.rb#L496
-  def import_all(class_names = {})
-    @table_names.each { |n|
-      class_names[n.tr('/', '_').to_sym] ||= n.classify if n.include?('/')
-    }
-
+  def import_all
     connection = ActiveRecord::Base.connection
 
     files_to_read = @table_names
@@ -52,7 +61,7 @@ class LiveFixtures::Import
       connection.transaction(requires_new: true) do
         files_to_read.each do |path|
           table_name = path.tr '/', '_'
-          class_name = class_names[table_name.to_sym] || table_name.classify
+          class_name = @class_names[table_name.to_sym] || table_name.classify
 
           ff = Fixtures.new(connection,
                             table_name,
@@ -72,6 +81,52 @@ class LiveFixtures::Import
     end
   end
 
+  private
+
+  # Here we go through each of the fixture YAML files to see what polymorphic
+  # dependencies exist for each of the models.
+  # We do this by inspecting the value of any field that ends with `_type`,
+  # for example `author_type`, `assignment_type`, etc.
+  # Becuase we can't know all the possible types of a polymorphic association
+  # we compute them from the YAML file contents.
+  # Returns a Hash[Class => Set[Class]]
+  def compute_polymorphic_associations
+    polymorphic_associations = Hash.new { |h, k| h[k] = Set.new }
+
+    connection = ActiveRecord::Base.connection
+    files_to_read = @table_names
+
+    files_to_read.each do |path|
+      table_name = path.tr '/', '_'
+      class_name = @class_names[table_name.to_sym] || table_name.classify
+
+      # Here we use the yaml file and YAML.load instead of ActiveRecord::FixtureSet.new
+      # because it's faster and we can also check whether we actually need to
+      # load the file: only if it includes "_type" in it, otherwise there will be
+      # no polymorphic types in there.
+
+      filename = ::File.join(@root_path, "#{path}.yml")
+      file = File.read(filename)
+      next unless file =~ /_type/
+
+      yaml = YAML.load(file)
+      yaml.each do |key, object|
+        object.each do |field, value|
+          next unless  field.ends_with?("_type")
+
+          begin
+            polymorphic_associations[class_name.constantize] << value.constantize
+          rescue NameError
+            # It might be the case that the `..._type` field doesn't actually
+            # refer to a type name, so we just ignore it.
+          end
+        end
+      end
+    end
+
+    polymorphic_associations
+  end
+
   class ProgressBarIterator
     def initialize(ff)
       @ff = ff

data/lib/live_fixtures/import/insertion_order_computer.rb

@@ -0,0 +1,127 @@
+class LiveFixtures::Import
+  # :nodoc:
+  class InsertionOrderComputer
+    # :nodoc:
+    class Node
+      attr_reader :path
+      attr_reader :class_name
+      attr_reader :klass
+
+      # The classes this node depends on
+      attr_reader :dependencies
+
+      def initialize(path, class_name, klass)
+        @path = path
+        @class_name = class_name
+        @klass = klass
+        @dependencies = Set.new
+      end
+    end
+
+    def self.compute(table_names, class_names = {}, polymorphic_associations = {})
+      new(table_names, class_names, polymorphic_associations).compute
+    end
+
+    def initialize(table_names, class_names = {}, polymorphic_associations = {})
+      @table_names = table_names
+      @class_names = class_names
+      @polymorphic_associations = polymorphic_associations
+    end
+
+    def compute
+      nodes = build_nodes
+      compute_insert_order(nodes)
+    end
+
+    private
+
+    # Builds an Array of Nodes, each containing dependencies to other nodes
+    # using their class names.
+    def build_nodes
+      # Create a Hash[Class => Node] for each table/class
+      nodes = {}
+      @table_names.each do |path|
+        table_name = path.tr "/", "_"
+        class_name = @class_names[table_name.to_sym] || table_name.classify
+        klass = class_name.constantize
+        nodes[klass] = Node.new(path, class_name, klass)
+      end
+
+      # First iniitalize dependencies from polymorphic associations that we
+      # explicitly found in the yaml files.
+      @polymorphic_associations.each do |klass, associations|
+        associations.each do |association|
+          node = nodes[klass]
+          next unless node
+          next unless nodes.key?(association)
+
+          node.dependencies << association
+        end
+      end
+
+      # Compute dependencies between nodes/classes by reflecting on their
+      # ActiveRecord associations.
+      nodes.each do |_, node|
+        klass = node.klass
+        klass.reflect_on_all_associations.each do |assoc|
+          # We can't handle polymorphic associations, but the concrete types
+          # should have been deduced from the yaml files contents
+          next if assoc.polymorphic?
+
+          # Don't add a dependency if the class is not in the given table names
+          next unless nodes.key?(assoc.klass)
+
+          # A class might depend on itself, but we don't add it as a dependency
+          # because otherwise we'll never make it (the class can probably be created
+          # just fine and these dependencies are optional/nilable)
+          next if klass == assoc.klass
+
+          case assoc.macro
+          when :belongs_to
+            node.dependencies << assoc.klass
+          when :has_one, :has_many
+            # Skip `through` association becuase it will be already computed
+            # for the related `has_one`/`has_many` association
+            next if assoc.options[:through]
+
+            nodes[assoc.klass].dependencies << klass
+          end
+        end
+      end
+
+      # Finally sort all values by name for consistent results
+      nodes.values.sort_by { |node| node.klass.name }
+    end
+
+    def compute_insert_order(nodes)
+      insert_order = []
+
+      until nodes.empty?
+        # Pick a node that has no dependencies
+        free_node = nodes.find { |node| node.dependencies.empty? }
+
+        if free_node.nil?
+          msg = "Can't compute an insert order.\n\n"
+          msg << "These models seem to depend on each other:\n"
+          nodes.each do |node|
+            msg << "  #{node.klass.name}\n"
+            msg << "   - depends on: #{node.dependencies.map(&:name).join(", ")}\n"
+          end
+          raise msg
+        end
+
+        insert_order << free_node.path
+
+        # Delete this node from the other nodes' dependencies
+        nodes.each do |node|
+          node.dependencies.delete(free_node.klass)
+        end
+
+        # And delete this node because we are done with it
+        nodes.delete(free_node)
+      end
+
+      insert_order
+    end
+  end
+end

data/lib/live_fixtures/version.rb

@@ -1,3 +1,3 @@
 module LiveFixtures
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: live_fixtures
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - jleven
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-04-10 00:00:00.000000000 Z
+date: 2020-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -178,7 +178,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - josh@noredink.com
 executables: []
@@ -193,12 +193,13 @@ files:
 - lib/live_fixtures/export/fixture.rb
 - lib/live_fixtures/import.rb
 - lib/live_fixtures/import/fixtures.rb
+- lib/live_fixtures/import/insertion_order_computer.rb
 - lib/live_fixtures/version.rb
-homepage: 
+homepage:
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -214,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Tools for exporting and importing between databases managed by ActiveRecord.
 test_files: []