live_fixtures 3.0.0 → 4.0.0

data/lib/live_fixtures/import/insertion_order_computer.rb

@@ -1,127 +1,129 @@
-class LiveFixtures::Import
-  # :nodoc:
-  class InsertionOrderComputer
+# frozen_string_literal: true
+
+module LiveFixtures
+  class Import
     # :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
+    class InsertionOrderComputer
+      # :nodoc:
+      class Node
+        attr_reader :path, :class_name, :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
-    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 self.compute(table_names, class_names = {}, polymorphic_associations = {})
+        new(table_names, class_names, polymorphic_associations).compute
+      end
 
-    def compute
-      nodes = build_nodes
-      compute_insert_order(nodes)
-    end
+      def initialize(table_names, class_names = {}, polymorphic_associations = {})
+        @table_names = table_names
+        @class_names = class_names
+        @polymorphic_associations = polymorphic_associations
+      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)
+      def compute
+        nodes = build_nodes
+        compute_insert_order(nodes)
       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)
+      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
+            node.dependencies << association
+          end
         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
+        # Compute dependencies between nodes/classes by reflecting on their
+        # ActiveRecord associations.
+        nodes.each_value 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
-      end
 
-      # Finally sort all values by name for consistent results
-      nodes.values.sort_by { |node| node.klass.name }
-    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 = []
+      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
 
-      until nodes.empty?
-        # Pick a node that has no dependencies
-        free_node = nodes.find { |node| node.dependencies.empty? }
+          insert_order << free_node.path
 
-        if free_node.nil?
-          msg = "Can't compute an insert order.\n\n"
-          msg << "These models seem to depend on each other:\n"
+          # Delete this node from the other nodes' dependencies
           nodes.each do |node|
-            msg << "  #{node.klass.name}\n"
-            msg << "   - depends on: #{node.dependencies.map(&:name).join(", ")}\n"
+            node.dependencies.delete(free_node.klass)
           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)
+          # And delete this node because we are done with it
+          nodes.delete(free_node)
         end
 
-        # And delete this node because we are done with it
-        nodes.delete(free_node)
+        insert_order
       end
-
-      insert_order
     end
   end
 end

data/lib/live_fixtures/import.rb

@@ -1,199 +1,204 @@
+# frozen_string_literal: true
+
 require 'benchmark'
 
 # An object that facilitates the import of fixtures into a database.
-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
-
-  # Map of table_name to import routine
-  # @return [Hash<String => Proc>]
-  attr_reader :alternate_imports
-
-  # Accessor for string label for a given fixture mapping to it's db id
-  attr_reader :label_to_id
-
-  # 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> | 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.
-  # @option opts [Boolean] use_insert_order_as_table_names when true, table names will be those passed in insert_order, not read from yaml files
-  # @return [LiveFixtures::Import] an importer
-  # @see LiveFixtures::Export::Reference
-  def initialize(root_path, insert_order = nil, class_names = {}, **opts)
-    defaut_options = {
-      show_progress: true,
-      skip_missing_tables: false,
-      skip_missing_refs: false,
-      use_insert_order_as_table_names: false,
-    }
-    @options = defaut_options.merge(opts)
-    @root_path = root_path
-
-    if insert_order && @options[:use_insert_order_as_table_names]
-      @table_names = insert_order
-    else
-      @table_names = Dir.glob(File.join(@root_path, '{*,**}/*.yml')).map do |filepath|
-        File.basename filepath, ".yml"
+module LiveFixtures
+  class 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
+
+    # Map of table_name to import routine
+    # @return [Hash<String => Proc>]
+    attr_reader :alternate_imports
+
+    # Accessor for string label for a given fixture mapping to it's db id
+    attr_reader :label_to_id
+
+    # 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> | 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.
+    # @option opts [Boolean] use_insert_order_as_table_names when true, table names will be those passed in insert_order, not read from yaml files
+    # @return [LiveFixtures::Import] an importer
+    # @see LiveFixtures::Export::Reference
+    def initialize(root_path, insert_order = nil, class_names = {}, **opts)
+      defaut_options = {
+        show_progress: true,
+        skip_missing_tables: false,
+        skip_missing_refs: false,
+        use_insert_order_as_table_names: false
+      }
+      @options = defaut_options.merge(opts)
+      @root_path = root_path
+
+      @table_names = if insert_order && @options[:use_insert_order_as_table_names]
+                       insert_order
+                     else
+                       Dir.glob(File.join(@root_path, '{*,**}/*.yml')).map do |filepath|
+                         File.basename filepath, '.yml'
+                       end
+                     end
+
+      @class_names = class_names
+      @table_names.each do |n|
+        @class_names[n.tr('/', '_').to_sym] ||= n.classify if n.include?('/')
       end
-    end
 
-    @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)
 
-    @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
 
-    @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}"
+      @label_to_id = {}
+      @alternate_imports = {}
     end
 
-    @label_to_id = {}
-    @alternate_imports = {}
-  end
-
-  # Within a transaction, import all the fixtures into the database.
-  #
-  # The very similar method: ActiveRecord::FixtureSet.create_fixtures has the
-  # unfortunate side effect of truncating each table!!
-  #
-  # Therefore, we have reproduced the relevant sections here, without DELETEs,
-  # 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
-    connection = ActiveRecord::Base.connection
-    show_progress = @options[:show_progress]
-
-    # TODO: should be additive with alternate_imports so we can delete the fixture file
-    files_to_read = @table_names
-
-    return if files_to_read.empty?
-
-    connection.transaction(requires_new: true) do
-      files_to_read.each do |path|
-        table_name = path.tr '/', '_'
-        if alternate = @alternate_imports[table_name]
-          time = Benchmark.ms do
-            alternate.call(@label_to_id)
-          end
-          puts "Imported %s in %.0fms" % [table_name, time] if show_progress
-        else
-          class_name = @class_names[table_name.to_sym] || table_name.classify
-
-          ff = Fixtures.new(connection,
-                            table_name,
-                            class_name,
-                            ::File.join(@root_path, path),
-                            @label_to_id,
-                            skip_missing_refs: @options[:skip_missing_refs])
-
-          conn = ff.model_connection || connection
-
-          iterator = show_progress ? ProgressBarIterator : SimpleIterator
-          iterator.new(ff).each do |tname, label, row|
-            conn.insert_fixture(row, tname)
-            @label_to_id[label] = conn.send(:last_inserted_id, tname) unless label == NO_LABEL
+    # Within a transaction, import all the fixtures into the database.
+    #
+    # The very similar method: ActiveRecord::FixtureSet.create_fixtures has the
+    # unfortunate side effect of truncating each table!!
+    #
+    # Therefore, we have reproduced the relevant sections here, without DELETEs,
+    # 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
+      connection = ActiveRecord::Base.connection
+      show_progress = @options[:show_progress]
+
+      # TODO: should be additive with alternate_imports so we can delete the fixture file
+      files_to_read = @table_names
+
+      return if files_to_read.empty?
+
+      connection.transaction(requires_new: true) do
+        files_to_read.each do |path|
+          table_name = path.tr '/', '_'
+          if (alternate = @alternate_imports[table_name])
+            time = Benchmark.ms do
+              alternate.call(@label_to_id)
+            end
+            puts format('Imported %s in %.0fms', table_name, time) if show_progress
+          else
+            class_name = @class_names[table_name.to_sym] || table_name.classify
+
+            ff = Fixtures.new(connection,
+                              table_name,
+                              class_name,
+                              ::File.join(@root_path, path),
+                              @label_to_id,
+                              skip_missing_refs: @options[:skip_missing_refs])
+
+            conn = ff.model_connection || connection
+
+            iterator = show_progress ? ProgressBarIterator : SimpleIterator
+            iterator.new(ff).each do |tname, label, row|
+              last_inserted_id = conn.insert(conn.send(:build_fixture_sql, Array.wrap(row), tname))
+              @label_to_id[label] = last_inserted_id unless label == NO_LABEL
+            end
           end
         end
       end
     end
-  end
 
-  # Override import of table using a callable object
-  # @param table_name [String] table to use callable instead of fixture file
-  # @param callable [Proc] Proc/lambda that will be called with @label_to_id
-  def override(table_name, callable)
-    @alternate_imports[table_name] = callable
-    self
-  end
+    # Override import of table using a callable object
+    # @param table_name [String] table to use callable instead of fixture file
+    # @param callable [Proc] Proc/lambda that will be called with @label_to_id
+    def override(table_name, callable)
+      @alternate_imports[table_name] = callable
+      self
+    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 }
 
-  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.
+      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_value do |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
-    end
 
-    polymorphic_associations
-  end
-
-  class ProgressBarIterator
-    def initialize(ff)
-      @ff = ff
-      @bar = LiveFixtures.get_progress_bar(
-        total: ff.fixtures.size,
-        title: ff.model_class.name
-      )
+      polymorphic_associations
     end
 
-    def each
-      @ff.each_table_row_with_label do |*args|
-        yield(*args)
-        @bar.increment unless @bar.finished?
+    class ProgressBarIterator
+      def initialize(ff)
+        @ff = ff
+        @bar = LiveFixtures.get_progress_bar(
+          total: ff.fixtures.size,
+          title: ff.model_class.name
+        )
       end
-      @bar.finish
-    end
-  end
 
-  class SimpleIterator
-    def initialize(ff)
-      @ff = ff
+      def each
+        @ff.each_table_row_with_label do |*args|
+          yield(*args)
+          @bar.increment unless @bar.finished?
+        end
+        @bar.finish
+      end
     end
 
-    def each
-      puts @ff.model_class.name
-      @ff.each_table_row_with_label do |*args|
-        yield(*args)
+    class SimpleIterator
+      def initialize(ff)
+        @ff = ff
+      end
+
+      def each
+        puts @ff.model_class.name
+        @ff.each_table_row_with_label do |*args|
+          yield(*args)
+        end
       end
     end
   end

data/lib/live_fixtures/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LiveFixtures
-  VERSION = "3.0.0"
+  VERSION = '4.0.0'
 end

data/lib/live_fixtures.rb

@@ -1,19 +1,22 @@
-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"
+# frozen_string_literal: true
+
+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
-  def get_progress_bar total:, title:
+
+  def get_progress_bar(total:, title:)
     ProgressBar.create(
       total: total,
       title: title,
-      format:'%t: |%B| %P% %E',
+      format: '%t: |%B| %P% %E',
       throttle_rate: 0.1
     )
   end