omg-activerecord 8.0.0.alpha1

data/lib/active_record/explain_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module ActiveRecord
+  # This is a thread locals registry for EXPLAIN. For example
+  #
+  #   ActiveRecord::ExplainRegistry.queries
+  #
+  # returns the collected queries local to the current thread.
+  class ExplainRegistry # :nodoc:
+    class << self
+      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+
+      private
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_explain_registry] ||= new
+        end
+    end
+
+    attr_accessor :collect
+    attr_reader :queries
+
+    def initialize
+      reset
+    end
+
+    def collect?
+      @collect
+    end
+
+    def reset
+      @collect = false
+      @queries = []
+    end
+  end
+end

data/lib/active_record/explain_subscriber.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "active_record/explain_registry"
+
+module ActiveRecord
+  class ExplainSubscriber # :nodoc:
+    def start(name, id, payload)
+      # unused
+    end
+
+    def finish(name, id, payload)
+      if ExplainRegistry.collect? && !ignore_payload?(payload)
+        ExplainRegistry.queries << payload.values_at(:sql, :binds)
+      end
+    end
+
+    # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+    # our own EXPLAINs no matter how loopingly beautiful that would be.
+    #
+    # On the other hand, we want to monitor the performance of our real database
+    # queries, not the performance of the access to the query cache.
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+    EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
+    def ignore_payload?(payload)
+      payload[:exception] ||
+        payload[:cached] ||
+        IGNORED_PAYLOADS.include?(payload[:name]) ||
+        !payload[:sql].match?(EXPLAINED_SQLS)
+    end
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", new)
+  end
+end

data/lib/active_record/fixture_set/file.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_support/configuration_file"
+
+module ActiveRecord
+  class FixtureSet
+    class File # :nodoc:
+      include Enumerable
+
+      ##
+      # Open a fixture file named +file+.  When called with a block, the block
+      # is called with the filehandle and the filehandle is automatically closed
+      # when the block finishes.
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+      def model_class
+        config_row["model_class"]
+      end
+
+      def ignored_fixtures
+        config_row["ignore"]
+      end
+
+      private
+        def rows
+          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == "_fixture" }
+        end
+
+        def config_row
+          @config_row ||= begin
+            row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
+            if row
+              validate_config_row(row.last)
+            else
+              { 'model_class': nil, 'ignore': nil }
+            end
+          end
+        end
+
+        def raw_rows
+          @raw_rows ||= begin
+            data = ActiveSupport::ConfigurationFile.parse(@file, context:
+              ActiveRecord::FixtureSet::RenderContext.create_subclass.new.get_binding)
+            data ? validate(data).to_a : []
+          rescue RuntimeError => error
+            raise Fixture::FormatError, error.message
+          end
+        end
+
+        def validate_config_row(data)
+          unless Hash === data
+            raise Fixture::FormatError, "Invalid `_fixture` section: `_fixture` must be a hash: #{@file}"
+          end
+
+          begin
+            data.assert_valid_keys("model_class", "ignore")
+          rescue ArgumentError => error
+            raise Fixture::FormatError, "Invalid `_fixture` section: #{error.message}: #{@file}"
+          end
+
+          data
+        end
+
+        # Validate our unmarshalled data.
+        def validate(data)
+          unless Hash === data || YAML::Omap === data
+            raise Fixture::FormatError, "fixture is not a hash: #{@file}"
+          end
+
+          invalid = data.reject { |_, row| Hash === row }
+          if invalid.any?
+            raise Fixture::FormatError, "fixture key is not a hash: #{@file}, keys: #{invalid.keys.inspect}"
+          end
+          data
+        end
+    end
+  end
+end

data/lib/active_record/fixture_set/model_metadata.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FixtureSet
+    class ModelMetadata # :nodoc:
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def primary_key_name
+        @primary_key_name ||= @model_class && @model_class.primary_key
+      end
+
+      def primary_key_type
+        @primary_key_type ||= @model_class && column_type(@model_class.primary_key)
+      end
+
+      def column_type(column_name)
+        @column_type ||= {}
+        return @column_type[column_name] if @column_type.key?(column_name)
+
+        @column_type[column_name] = @model_class && @model_class.type_for_attribute(column_name).type
+      end
+
+      def has_column?(column_name)
+        column_names.include?(column_name)
+      end
+
+      def column_names
+        @column_names ||= @model_class ? @model_class.columns.map(&:name).to_set : Set.new
+      end
+
+      def timestamp_column_names
+        @model_class.all_timestamp_attributes_in_model
+      end
+
+      def inheritance_column_name
+        @inheritance_column_name ||= @model_class && @model_class.inheritance_column
+      end
+    end
+  end
+end

data/lib/active_record/fixture_set/render_context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "base64"
+
+# NOTE: This class has to be defined in compact style in
+# order for rendering context subclassing to work correctly.
+class ActiveRecord::FixtureSet::RenderContext # :nodoc:
+  def self.create_subclass
+    Class.new(ActiveRecord::FixtureSet.context_class) do
+      def get_binding
+        binding()
+      end
+
+      def binary(path)
+        %(!!binary "#{Base64.strict_encode64(File.binread(path))}")
+      end
+    end
+  end
+end

data/lib/active_record/fixture_set/table_row.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FixtureSet
+    class TableRow # :nodoc:
+      class ReflectionProxy # :nodoc:
+        def initialize(association)
+          @association = association
+        end
+
+        def join_table
+          @association.join_table
+        end
+
+        def name
+          @association.name
+        end
+
+        def primary_key_type
+          @association.klass.type_for_attribute(@association.klass.primary_key).type
+        end
+      end
+
+      class HasManyThroughProxy < ReflectionProxy # :nodoc:
+        def rhs_key
+          @association.foreign_key
+        end
+
+        def lhs_key
+          @association.through_reflection.foreign_key
+        end
+
+        def join_table
+          @association.through_reflection.table_name
+        end
+
+        def timestamp_column_names
+          @association.through_reflection.klass.all_timestamp_attributes_in_model
+        end
+      end
+
+      class PrimaryKeyError < StandardError # :nodoc:
+        def initialize(label, association, value)
+          super(<<~MSG)
+            Unable to set #{association.name} to #{value} because the association has a
+            custom primary key (#{association.join_primary_key}) that does not match the
+            associated table's primary key (#{association.klass.primary_key}).
+
+            To fix this, change your fixture from
+
+            #{label}:
+              #{association.name}: #{value}
+
+            to
+
+            #{label}:
+              #{association.foreign_key}: **value**
+
+            where **value** is the #{association.join_primary_key} value for the
+            associated #{association.klass.name} record.
+          MSG
+        end
+      end
+
+      def initialize(fixture, table_rows:, label:, now:)
+        @table_rows = table_rows
+        @label = label
+        @now = now
+        @row = fixture.to_hash
+        fill_row_model_attributes
+      end
+
+      def to_hash
+        @row
+      end
+
+      private
+        def model_metadata
+          @table_rows.model_metadata
+        end
+
+        def model_class
+          @table_rows.model_class
+        end
+
+        def fill_row_model_attributes
+          return unless model_class
+          fill_timestamps
+          interpolate_label
+          model_class.composite_primary_key? ? generate_composite_primary_key : generate_primary_key
+          resolve_enums
+          resolve_sti_reflections
+        end
+
+        def reflection_class
+          @reflection_class ||= if @row.include?(model_metadata.inheritance_column_name)
+            @row[model_metadata.inheritance_column_name].constantize rescue model_class
+          else
+            model_class
+          end
+        end
+
+        def fill_timestamps
+          # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
+          if model_class.record_timestamps
+            model_metadata.timestamp_column_names.each do |c_name|
+              @row[c_name] = @now unless @row.key?(c_name)
+            end
+          end
+        end
+
+        def interpolate_label
+          # interpolate the fixture label
+          @row.each do |key, value|
+            @row[key] = value.gsub("$LABEL", @label.to_s) if value.is_a?(String)
+          end
+        end
+
+        def generate_primary_key
+          pk = model_metadata.primary_key_name
+
+          unless column_defined?(pk)
+            @row[pk] = ActiveRecord::FixtureSet.identify(@label, model_metadata.column_type(pk))
+          end
+        end
+
+        def generate_composite_primary_key
+          composite_key = ActiveRecord::FixtureSet.composite_identify(@label, model_metadata.primary_key_name)
+          composite_key.each do |column, value|
+            next if column_defined?(column)
+
+            @row[column] = value
+          end
+        end
+
+        def column_defined?(col)
+          !model_metadata.has_column?(col) || @row.include?(col)
+        end
+
+        def resolve_enums
+          reflection_class.defined_enums.each do |name, values|
+            if @row.include?(name)
+              @row[name] = values.fetch(@row[name], @row[name])
+            end
+          end
+        end
+
+        def resolve_sti_reflections
+          # If STI is used, find the correct subclass for association reflection
+          reflection_class._reflections.each_value do |association|
+            case association.macro
+            when :belongs_to
+              # Do not replace association name with association foreign key if they are named the same
+              fk_name = association.join_foreign_key
+
+              if association.name.to_s != fk_name && value = @row.delete(association.name.to_s)
+                if association.polymorphic?
+                  if value.sub!(/\s*\(([^)]*)\)\s*$/, "")
+                    # support polymorphic belongs_to as "label (Type)"
+                    @row[association.join_foreign_type] = $1
+                  end
+                elsif association.join_primary_key != association.klass.primary_key
+                  raise PrimaryKeyError.new(@label, association, value)
+                end
+
+                if fk_name.is_a?(Array)
+                  composite_key = ActiveRecord::FixtureSet.composite_identify(value, fk_name)
+                  composite_key.each do |column, value|
+                    next if column_defined?(column)
+
+                    @row[column] = value
+                  end
+                else
+                  fk_type = reflection_class.type_for_attribute(fk_name).type
+                  @row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
+                end
+              end
+            when :has_many
+              if association.options[:through]
+                add_join_records(HasManyThroughProxy.new(association))
+              end
+            end
+          end
+        end
+
+        def add_join_records(association)
+          # This is the case when the join table has no fixtures file
+          if (targets = @row.delete(association.name.to_s))
+            table_name  = association.join_table
+            column_type = association.primary_key_type
+            lhs_key     = association.lhs_key
+            rhs_key     = association.rhs_key
+
+            targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
+            joins   = targets.map do |target|
+              join = { lhs_key => @row[model_metadata.primary_key_name],
+                       rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
+              association.timestamp_column_names.each do |col|
+                join[col] = @now
+              end
+              join
+            end
+            @table_rows.tables[table_name].concat(joins)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/fixture_set/table_rows.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "active_record/fixture_set/table_row"
+require "active_record/fixture_set/model_metadata"
+
+module ActiveRecord
+  class FixtureSet
+    class TableRows # :nodoc:
+      def initialize(table_name, model_class:, fixtures:)
+        @model_class = model_class
+
+        # track any join tables we need to insert later
+        @tables = Hash.new { |h, table| h[table] = [] }
+
+        # ensure this table is loaded before any HABTM associations
+        @tables[table_name] = nil
+
+        build_table_rows_from(table_name, fixtures)
+      end
+
+      attr_reader :tables, :model_class
+
+      def to_hash
+        @tables.transform_values { |rows| rows.map(&:to_hash) }
+      end
+
+      def model_metadata
+        @model_metadata ||= ModelMetadata.new(model_class)
+      end
+
+      private
+        def build_table_rows_from(table_name, fixtures)
+          now = ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
+
+          @tables[table_name] = fixtures.map do |label, fixture|
+            TableRow.new(
+              fixture,
+              table_rows: self,
+              label: label,
+              now: now,
+            )
+          end
+        end
+    end
+  end
+end