live_fixtures 3.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43a4d648f92b357bd4751c7f4961b57d6f5d306b90c97ebb0dff6be7f7b4c932
-  data.tar.gz: 89c802bf38daaa3ab9238073af9f6bdf761bd0b67b234c2283b9f0fd7270129d
+  metadata.gz: 44657be02cbaa2b748a3b9391e43e96aba4590b228f9b25203f65e877ec2137c
+  data.tar.gz: 5ef93aeac3ebf8d6ec8ae6908b558c2fc28d481faa5ea68765d9fcbe6bf55694
 SHA512:
-  metadata.gz: eecf0c868c069a33fcdb2d1ac38dce617409b28eba873149bab74fbcb802324b2b2921d0afb982de1142bc02036e467cef658de71ddaacd0a9e51b514f0a6f51
-  data.tar.gz: c37c360ccf11eb29c09308827cde01948fab84201ba6b2228b50eec31352d8c106a5e263e6ee8207f11dbb35f2788d8866e2e1182f8250a867b4ec63a8fd25f7
+  metadata.gz: 050b48d22551468a7dfa49daf66b03c0965a8c1e392b8620430a6a37e641407ac541ca4d6e57ee078c630c3e02e1561740b8896aefe1ea73e5fc13aa72ce2108
+  data.tar.gz: 79958eed4b5831daa43c5af847fd3e74bafce50bec42943528c1f6ad1939179890d82517f0c995b2ee2da063fb1786ace7c7b1dfc54c268b468ac9a99e03526f

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/).
 
+## [4.0.0] - Unreleased
+### Added
+Support for Ruby 3.2, active record 7
+
+### Removed
+Dropped support for Ruby < 3.2, Rails < 7.0
+
 ## [3.1.1] - 2024-04-04
 ### Fixed
 Expose the `skip_attributes` option in LiveFixtures::Export.

data/README.md

@@ -285,11 +285,31 @@ reflected in the order of the `@table_names` array.
 
 ## Development
 
+This project uses nix to manage the dev environment.
+
+This project additionally uses
+- [direnv](https://github.com/direnv/direnv)
+- flakes
+
+If you don't have flakes enabled, you can enable them by adding `experimental-features = flakes` to your `~/.config/nix/nix.conf` file.
+(or running )
+
+typing `direnv allow` loads the dev environment including a compatible ruby, sqlite, and gems.
+
+To modify gem dependencies, use the bundle wrappers
+- `bundle-lock` to update the lockfile
+- `bundle-update` to update gems & the lockfile
+then run `bundix` to update the `gemset.nix` file.
+
+### Usage Without Nix
+
+Usage without nix is unsupported but may work anyways. Try the following:
+
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
-Please remember to update the docs on your PR if you change anything. You can see the YARD docs live while you change them by running `yard server --reload`.
+Note: We only support adding gems and dependencies using nix.
 
 ## Contributing
 

data/lib/live_fixtures/export/fixture.rb

@@ -1,81 +1,87 @@
+# frozen_string_literal: true
+
 # Exposes functionality to serialize an ActiveRecord record (a model) into a
 # YAML fixture.
-module LiveFixtures::Export::Fixture
-  module_function
-  # YAML-Serializes the provided model, including any references and additional
-  # attribtues.
-  # @param model [ActiveRecord::Base] an ActiveRecord record to serialize
-  # @param references [Symbol, Array<Symbol>] the names of associations whose foreign_keys should be replaced with references
-  # @param more_attributes [Hash{String => Time, DateTime, Date, Hash, String, LiveFixtures::Export::Template, LiveFixtures::Export::Reference, #to_s}] a hash of additional attributes to serialize with each record.
-  # @param skip_attributes [Array<String>] a list of attributes to skip when serializing the model
-  # @return [String] the model serialized in YAML, with specified foreign_keys replaced by references, including additional attributes.
-  def to_yaml(model, references = [], more_attributes = {}, skip_attributes: [])
-    table_name = model.class.table_name
+module LiveFixtures
+  module Export
+    module Fixture
+      module_function
 
-    more_attributes.merge! attributes_from_references(model, references)
+      # YAML-Serializes the provided model, including any references and additional
+      # attribtues.
+      # @param model [ActiveRecord::Base] an ActiveRecord record to serialize
+      # @param references [Symbol, Array<Symbol>] the names of associations whose foreign_keys should be replaced with references
+      # @param more_attributes [Hash{String => Time, DateTime, Date, Hash, String, LiveFixtures::Export::Template, LiveFixtures::Export::Reference, #to_s}] a hash of additional attributes to serialize with each record.
+      # @param skip_attributes [Array<String>] a list of attributes to skip when serializing the model
+      # @return [String] the model serialized in YAML, with specified foreign_keys replaced by references, including additional attributes.
+      def to_yaml(model, references = [], more_attributes = {}, skip_attributes: [])
+        table_name = model.class.table_name
 
-    <<-YML
-#{table_name}_#{model.id || SecureRandom.uuid.underscore}:
-  #{yml_attributes(model, more_attributes, skip_attributes)}
+        more_attributes.merge! attributes_from_references(model, references)
 
-    YML
-  end
+        <<~YML
+          #{table_name}_#{model.id || SecureRandom.uuid.underscore}:
+            #{yml_attributes(model, more_attributes, skip_attributes)}
 
-  private_class_method def attributes_from_references(model, references)
-    {}.tap do |options|
-      Array(references).each do |assoc_name|
+        YML
+      end
 
-        if model.respond_to? assoc_name # need to check #respond_to? because some assoc only exist in certain subclasses
-          assoc_model = model.send assoc_name
-        end
+      private_class_method def attributes_from_references(model, references)
+        {}.tap do |options|
+          Array(references).each do |assoc_name|
+            if model.respond_to? assoc_name # need to check #respond_to? because some assoc only exist in certain subclasses
+              assoc_model = model.send assoc_name
+            end
 
-        if assoc_model.present?
-          options["#{assoc_name}_id"] = LiveFixtures::Export::Reference.new(assoc_name, assoc_model)
+            if assoc_model.present?
+              options["#{assoc_name}_id"] = LiveFixtures::Export::Reference.new(assoc_name, assoc_model)
+            end
+          end
         end
       end
-    end
-  end
 
-  private_class_method def yml_attributes(model, more_attributes, skip_attributes)
-    model.attributes.except("id").merge(more_attributes).map do |name, value|
-      next if value.nil?
-      next if skip_attributes.include?(name)
+      private_class_method def yml_attributes(model, more_attributes, skip_attributes)
+        model.attributes.except('id').merge(more_attributes).map do |name, value|
+          next if value.nil?
+          next if skip_attributes.include?(name)
 
-      serialize_attribute(model, name, value)
-    end.compact.join("\n  ")
-  end
+          serialize_attribute(model, name, value)
+        end.compact.join("\n  ")
+      end
 
-  private_class_method def serialize_attribute(model, name, value)
-    attribute_type = model.class.type_for_attribute(name)
+      private_class_method def serialize_attribute(model, name, value)
+        attribute_type = model.class.type_for_attribute(name)
 
-    if attribute_type.is_a?(ActiveRecord::Type::Serialized)
-      value = attribute_type.serialize(value) unless value.is_a?(String)
+        if attribute_type.is_a?(ActiveRecord::Type::Serialized)
+          value = attribute_type.serialize(value) unless value.is_a?(String)
 
-      "#{name}: |-\n#{value.to_s.indent(4)}" unless value.nil?
-    elsif value.is_a? LiveFixtures::Export::Reference
-      "#{value.name}: #{yml_value(value)}"
-    else
-      "#{name}: #{yml_value(value)}"
-    end
-  end
+          "#{name}: |-\n#{value.to_s.indent(4)}" unless value.nil?
+        elsif value.is_a? LiveFixtures::Export::Reference
+          "#{value.name}: #{yml_value(value)}"
+        else
+          "#{name}: #{yml_value(value)}"
+        end
+      end
 
-  private_class_method def yml_value(value)
-    case value
-    when Time, DateTime
-      value.utc.to_s(:db)
-    when Date
-      value.to_s(:db)
-    when Hash
-      value.to_yaml.inspect
-    when String
-      value.inspect
-    when LiveFixtures::Export::Template
-      value.code
-    when LiveFixtures::Export::Reference
-      reference_value = value.value
-      "#{reference_value.class.table_name}_#{reference_value.id}"
-    else
-      value.to_s
+      private_class_method def yml_value(value)
+        case value
+        when Time, DateTime
+          value.utc.to_fs(:db)
+        when Date
+          value.to_fs(:db)
+        when Hash
+          value.to_yaml.inspect
+        when String
+          value.inspect
+        when LiveFixtures::Export::Template
+          value.code
+        when LiveFixtures::Export::Reference
+          reference_value = value.value
+          "#{reference_value.class.table_name}_#{reference_value.id}"
+        else
+          value.to_s
+        end
+      end
     end
   end
 end

data/lib/live_fixtures/export.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 # This module is meant to be `include`ed into your export class.
 #
@@ -8,100 +10,100 @@ require 'fileutils'
 #    one yml file for each db table. Do *not* call export_fixtures multiple
 #    times for the same db table - that will overwrite the file each time!
 
-module LiveFixtures::Export
-  # Templates allow you to export fixtures containing erb, that will be evaluated at the time of fixture import.
-  # You should initialize them with a String containing the erb to evaluate, like
-  # @example A template with export and import times.
-  #    Template.new("<%= \"I was exported at #{Time.now} and imported at \" + Time.now.to_s %>")
-  Template  = Struct.new(:code)
-
-  # References represent associations between fixtures, in the same way that foreign_keys do for records.
-  # These will be initialized for you based on the contents of `with_references` passed to `export_fixtures`.
-  # They will be initialized with the name of the association (a Symbol) and the particular associated model.
-  Reference = Struct.new(:name, :value)
-
-  private
-
-  # Specify the directory into which to export the yml files containing your fixtures.
-  # The directory will be created if it does not yet exist.
-  # @param dir [String] a path to a directory into which the fixtures will be exported.
-  def set_export_dir(dir)
-    @dir = dir
-    FileUtils.mkdir_p(@dir) unless File.directory?(@dir)
-  end
+module LiveFixtures
+  module Export
+    # Templates allow you to export fixtures containing erb, that will be evaluated at the time of fixture import.
+    # You should initialize them with a String containing the erb to evaluate, like
+    # @example A template with export and import times.
+    #    Template.new("<%= \"I was exported at #{Time.now} and imported at \" + Time.now.to_s %>")
+    Template  = Struct.new(:code)
 
-  # Specify the options to use when exporting your fixtures.
-  # @param [Hash] opts export configuration options
-  # @option opts [Boolean] show_progress whether or not to show the progress bar
-  def set_export_options(**opts)
-    defaults = { show_progress: true }
-    @export_options = defaults.merge(opts)
-  end
+    # References represent associations between fixtures, in the same way that foreign_keys do for records.
+    # These will be initialized for you based on the contents of `with_references` passed to `export_fixtures`.
+    # They will be initialized with the name of the association (a Symbol) and the particular associated model.
+    Reference = Struct.new(:name, :value)
 
-  # The options to use when exporting your fixtures.
-  # @return [Hash] export configuration options
-  def export_options
-    @export_options ||= set_export_options
-  end
+    private
 
-  ##
-  # Export models to a yml file named after the corresponding table.
-  # @param models [Enumerable] an Enumerable containing ActiveRecord models.
-  # @param with_references [Array<Symbol>] the associations whose foreign_keys should be replaced with references.
-  # @param skip_attributes [Array<String>] the attributes to skip when exporting the model.
-  #
-  # Takes an optional block that will be invoked for each model.
-  # The block should return a hash of attributes to be merged and
-  # saved with the model's attributes.
-  # @yield [model] an optional block that will be invoked for each model.
-  # @yieldparam model [ActiveRecord::Base] each successive model.
-  # @yieldreturn [Hash{String => Object}] a hash of attributes to be merged and saved with the model's attributes.
-  def export_fixtures(models, with_references = [], skip_attributes: [])
-    return [] unless models.present?
-
-    model_class = models.first.class
-
-    File.open(File.join(@dir, model_class.table_name + '.yml'), 'w') do |file|
-      file.write <<~PRELUDE
-        _fixture:
-          model_class: #{model_class.name}
-      PRELUDE
-
-      iterator = export_options[:show_progress] ? ProgressBarIterator : SimpleIterator
-
-      iterator.new(models).each do |model|
-        more_attributes = block_given? ? yield(model) : {}
-        file.write Fixture.to_yaml(model, with_references, more_attributes, skip_attributes: skip_attributes)
-      end
+    # Specify the directory into which to export the yml files containing your fixtures.
+    # The directory will be created if it does not yet exist.
+    # @param dir [String] a path to a directory into which the fixtures will be exported.
+    def set_export_dir(dir)
+      @dir = dir
+      FileUtils.mkdir_p(@dir) unless File.directory?(@dir)
+    end
+
+    # Specify the options to use when exporting your fixtures.
+    # @param [Hash] opts export configuration options
+    # @option opts [Boolean] show_progress whether or not to show the progress bar
+    def set_export_options(**opts)
+      defaults = { show_progress: true }
+      @export_options = defaults.merge(opts)
     end
-  end
 
-  class ProgressBarIterator
-    def initialize(models)
-      @models = models
-      @bar = LiveFixtures.get_progress_bar(
-        total:models.size,
-        title: models.first.class.name
-      )
+    # The options to use when exporting your fixtures.
+    # @return [Hash] export configuration options
+    def export_options
+      @export_options ||= set_export_options
     end
 
-    def each
-      @models.each do |model|
-        yield model
-        @bar.increment
+    ##
+    # Export models to a yml file named after the corresponding table.
+    # @param models [Enumerable] an Enumerable containing ActiveRecord models.
+    # @param with_references [Array<Symbol>] the associations whose foreign_keys should be replaced with references.
+    # @param skip_attributes [Array<String>] the attributes to skip when exporting the model.
+    #
+    # Takes an optional block that will be invoked for each model.
+    # The block should return a hash of attributes to be merged and
+    # saved with the model's attributes.
+    # @yield [model] an optional block that will be invoked for each model.
+    # @yieldparam model [ActiveRecord::Base] each successive model.
+    # @yieldreturn [Hash{String => Object}] a hash of attributes to be merged and saved with the model's attributes.
+    def export_fixtures(models, with_references = [], skip_attributes: [])
+      return [] unless models.present?
+
+      model_class = models.first.class
+
+      File.open(File.join(@dir, "#{model_class.table_name}.yml"), 'w') do |file|
+        file.write <<~PRELUDE
+          _fixture:
+            model_class: #{model_class.name}
+        PRELUDE
+
+        iterator = export_options[:show_progress] ? ProgressBarIterator : SimpleIterator
+
+        iterator.new(models).each do |model|
+          more_attributes = block_given? ? yield(model) : {}
+          file.write Fixture.to_yaml(model, with_references, more_attributes, skip_attributes: skip_attributes)
+        end
       end
     end
-  end
 
-  class SimpleIterator
-    def initialize(models)
-      @models = models
+    class ProgressBarIterator
+      def initialize(models)
+        @models = models
+        @bar = LiveFixtures.get_progress_bar(
+          total: models.size,
+          title: models.first.class.name
+        )
+      end
+
+      def each
+        @models.each do |model|
+          yield model
+          @bar.increment
+        end
+      end
     end
 
-    def each
-      puts @models.first.class.name
-      @models.each do |model|
-        yield model
+    class SimpleIterator
+      def initialize(models)
+        @models = models
+      end
+
+      def each(&)
+        puts @models.first.class.name
+        @models.each(&)
       end
     end
   end

data/lib/live_fixtures/import/fixtures.rb

@@ -1,52 +1,55 @@
+# frozen_string_literal: true
+
 require 'active_record/fixtures'
 
-class LiveFixtures::Import
-  # A labeled reference was not found.
-  # Maybe the referenced model was not exported, or the insert order attempted
-  # to import the reference before the referenced model?
-  LiveFixtures::MissingReferenceError = Class.new(KeyError)
-
-  class Fixtures
-    delegate :model_class, :table_name, :fixtures, to: :ar_fixtures
-    # ActiveRecord::FixtureSet for delegation
-    attr_reader :ar_fixtures
-
-    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection to the database into which to import the data.
-    # @param table_name [String] name of the database table to populate with models
-    # @param class_name [Constant] the model's class name
-    # @param filepath [String] path to the yml file containing the fixtures
-    # @param label_to_id [Hash{String => Int}] map from a reference's label to its new id.
-    def initialize(connection, table_name, class_name, filepath, label_to_id, skip_missing_refs: false)
-      @skip_missing_refs = skip_missing_refs
-      @ar_fixtures = ActiveRecord::FixtureSet.new connection,
-        table_name,
-        class_name,
-        filepath
-      @label_to_id = label_to_id
-    end
+module LiveFixtures
+  class Import
+    # A labeled reference was not found.
+    # Maybe the referenced model was not exported, or the insert order attempted
+    # to import the reference before the referenced model?
+    LiveFixtures::MissingReferenceError = Class.new(KeyError)
+
+    class Fixtures
+      delegate :model_class, :table_name, :fixtures, to: :ar_fixtures
+      # ActiveRecord::FixtureSet for delegation
+      attr_reader :ar_fixtures
+
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection to the database into which to import the data.
+      # @param table_name [String] name of the database table to populate with models
+      # @param class_name [Constant] the model's class name
+      # @param filepath [String] path to the yml file containing the fixtures
+      # @param label_to_id [Hash{String => Int}] map from a reference's label to its new id.
+      def initialize(connection, table_name, class_name, filepath, label_to_id, skip_missing_refs: false)
+        @skip_missing_refs = skip_missing_refs
+        @ar_fixtures = ActiveRecord::FixtureSet.new connection,
+                                                    table_name,
+                                                    class_name,
+                                                    filepath
+        @label_to_id = label_to_id
+      end
 
-    # Rewritten to take advantage of @label_to_id instead of AR::FixtureSet#identify,
-    # and to make an iterator.
-    #
-    # @yieldparam table_name [String] the database table's name
-    # @yieldparam label [String] the label for the model being currently imported
-    # @yieldparam row [Hash{String => Value}] the model's attributes to be imported
-    # Iterator which yields [table_name, label, row] for each fixture
-    # (and for any implicit join table records). The block is expected to insert
-    # the row and update @label_to_id with the record's newly assigned id.
-    # @see https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/fixtures.rb#L611
-    def each_table_row_with_label
-      join_table_rows = Hash.new { |h,table| h[table] = [] }
+      # Rewritten to take advantage of @label_to_id instead of AR::FixtureSet#identify,
+      # and to make an iterator.
+      #
+      # @yieldparam table_name [String] the database table's name
+      # @yieldparam label [String] the label for the model being currently imported
+      # @yieldparam row [Hash{String => Value}] the model's attributes to be imported
+      # Iterator which yields [table_name, label, row] for each fixture
+      # (and for any implicit join table records). The block is expected to insert
+      # the row and update @label_to_id with the record's newly assigned id.
+      # @see https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/fixtures.rb#L611
+      def each_table_row_with_label
+        join_table_rows = Hash.new { |h, table| h[table] = [] }
 
-      fixtures.map do |label, fixture|
-        row = fixture.to_hash
+        fixtures.map do |label, fixture|
+          row = fixture.to_hash
 
-        reflection_class = reflection_class_for row
+          reflection_class = reflection_class_for row
 
-        reflection_class.reflect_on_all_associations.each do |association|
-          next unless row[association.name.to_s]
+          reflection_class.reflect_on_all_associations.each do |association|
+            next unless row[association.name.to_s]
 
-          case association.macro
+            case association.macro
             when :belongs_to
               maybe_convert_association_to_foreign_key row, association
 
@@ -59,77 +62,78 @@ class LiveFixtures::Import
               join_table_rows[join_table_name] << { targets: targets,
                                                     association: association,
                                                     label: label }
+            end
           end
-        end
 
-        yield [table_name, label, row]
-      end
+          yield [table_name, label, row]
+        end
 
-      join_table_rows.each do |table_name, rows|
-        rows.each do |row|
-          row[:targets].each do |target|
-            assoc_fk = @label_to_id[target] || target
-            row_with_fk = { row[:association].foreign_key             => fetch_id_for_label(row[:label]),
-                            row[:association].association_foreign_key => assoc_fk }
-            yield [table_name, NO_LABEL, row_with_fk]
+        join_table_rows.each do |table_name, rows|
+          rows.each do |row|
+            row[:targets].each do |target|
+              assoc_fk = @label_to_id[target] || target
+              row_with_fk = { row[:association].foreign_key => fetch_id_for_label(row[:label]),
+                              row[:association].association_foreign_key => assoc_fk }
+              yield [table_name, NO_LABEL, row_with_fk]
+            end
           end
         end
       end
-    end
 
-    def model_connection
-      model_class.connection if model_class.respond_to? :connection
-    end
+      def model_connection
+        model_class.connection if model_class.respond_to? :connection
+      end
 
-    private
+      private
 
-    def inheritance_column_name
-      @inheritance_column_name ||= model_class && model_class.inheritance_column
-    end
+      def inheritance_column_name
+        @inheritance_column_name ||= model_class&.inheritance_column
+      end
 
-    # If STI is used, find the correct subclass for association reflection
-    def reflection_class_for(row)
-      return model_class unless row.include?(inheritance_column_name)
+      # If STI is used, find the correct subclass for association reflection
+      def reflection_class_for(row)
+        return model_class unless row.include?(inheritance_column_name)
 
-      row[inheritance_column_name].constantize
-    rescue
-      model_class
-    end
+        row[inheritance_column_name].constantize
+      rescue StandardError
+        model_class
+      end
 
-    def maybe_convert_association_to_foreign_key(row, association)
-      fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
+      def maybe_convert_association_to_foreign_key(row, association)
+        fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
 
-      # Do not replace association name with association foreign key if they are named the same
-      return if association.name.to_s == fk_name
+        # Do not replace association name with association foreign key if they are named the same
+        return if association.name.to_s == fk_name
 
-      value = row.delete(association.name.to_s)
+        value = row.delete(association.name.to_s)
 
-      # support polymorphic belongs_to as "label (Type)"
-      if association.options[:polymorphic] && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-        row[association.foreign_type] = $1
-      end
+        # support polymorphic belongs_to as "label (Type)"
+        row[association.foreign_type] = ::Regexp.last_match(1) if association.options[:polymorphic] && value.sub!(
+          /\s*\(([^\)]*)\)\s*$/, ''
+        )
 
-      row[fk_name] = fetch_id_for_label(value)
-    end
+        row[fk_name] = fetch_id_for_label(value)
+      end
 
-    # Uses the underlying map of labels to return the referenced model's newly
-    # assigned ID.
-    # @raise [LiveFixtures::MissingReferenceError] if the label isn't found.
-    # @param label_to_fetch [String] the label of the referenced model.
-    # @return [Integer] the newly assigned ID of the referenced model.
-    def fetch_id_for_label(label_to_fetch)
-      @label_to_id.fetch(label_to_fetch)
-    rescue KeyError
-      return nil if @skip_missing_refs
-
-      raise LiveFixtures::MissingReferenceError, <<-ERROR.squish
+      # Uses the underlying map of labels to return the referenced model's newly
+      # assigned ID.
+      # @raise [LiveFixtures::MissingReferenceError] if the label isn't found.
+      # @param label_to_fetch [String] the label of the referenced model.
+      # @return [Integer] the newly assigned ID of the referenced model.
+      def fetch_id_for_label(label_to_fetch)
+        @label_to_id.fetch(label_to_fetch)
+      rescue KeyError
+        return nil if @skip_missing_refs
+
+        raise LiveFixtures::MissingReferenceError, <<-ERROR.squish
       Unable to find ID for model referenced by label #{label_to_fetch} while
       importing #{model_class} from #{table_name}.yml. Perhaps it isn't included
       in these fixtures or it is too late in the insert_order and has not yet
       been imported.
-      ERROR
-    end
+        ERROR
+      end
 
-    private :ar_fixtures
+      private :ar_fixtures
+    end
   end
 end