Group into Row and Default modules

- Row module: Row::Declaration (data), Row::Definition (DSL),
  Row::Builder (resolves keys and defaults)
- Default module: Default::Definition (registers defaults),
  Default::Context (evaluation scope for default blocks)
- Remove separate row_definition.rb, row_builder.rb, default_context.rb

Author: bradgessler

lib/fixturebot.rb

@@ -4,10 +4,7 @@
 require_relative "fixturebot/schema"
 require_relative "fixturebot/key"
 require_relative "fixturebot/default"
-require_relative "fixturebot/default_context"
 require_relative "fixturebot/row"
-require_relative "fixturebot/row_definition"
-require_relative "fixturebot/row_builder"
 require_relative "fixturebot/definition"
 require_relative "fixturebot/fixture_set"
 require_relative "fixturebot/yaml_dumper"

lib/fixturebot/default.rb

@@ -1,19 +1,43 @@
 # frozen_string_literal: true
 
 module FixtureBot
-  class Default
-    def initialize(table, defaults)
-      @defaults = defaults
-      define_column_methods(table)
+  module Default
+    class Definition
+      def initialize(table, defaults)
+        @defaults = defaults
+        define_column_methods(table)
+      end
+
+      private
+
+      def define_column_methods(table)
+        table.columns.each do |col|
+          define_singleton_method(col) do |&block|
+            raise ArgumentError, "#{col} requires a block" unless block
+            @defaults[col] = block
+          end
+        end
+      end
     end
 
-    private
+    class Context
+      def initialize(record_name:, literal_values: {})
+        define_name_method(record_name, literal_values)
+        define_literal_value_methods(literal_values)
+      end
+
+      private
+
+      def define_name_method(record_name, literal_values)
+        define_singleton_method(:name) do
+          literal_values.key?(:name) ? literal_values[:name] : record_name
+        end
+      end
 
-    def define_column_methods(table)
-      table.columns.each do |col|
-        define_singleton_method(col) do |&block|
-          raise ArgumentError, "#{col} requires a block" unless block
-          @defaults[col] = block
+      def define_literal_value_methods(literal_values)
+        literal_values.each do |col, val|
+          next if col == :name
+          define_singleton_method(col) { val }
         end
       end
     end

lib/fixturebot/default_context.rb

@@ -20,7 +20,7 @@ def initialize(schema)
     def define_table_method(table)
       define_singleton_method(table.singular_name) do |record_name = nil, &block|
         if record_name.nil? && block.nil?
-          Default.new(table, @defaults[table.name])
+          Default::Definition.new(table, @defaults[table.name])
         elsif record_name
           add_row(table, record_name, block)
         else
@@ -30,14 +30,14 @@ def define_table_method(table)
     end
 
     def add_row(table, record_name, block)
-      row_dsl = RowDefinition.new(table, @schema)
-      row_dsl.instance_eval(&block) if block
-      @rows << Row.new(
+      row_def = Row::Definition.new(table, @schema)
+      row_def.instance_eval(&block) if block
+      @rows << Row::Declaration.new(
         table: table.name,
         name: record_name,
-        literal_values: row_dsl.literal_values,
-        association_refs: row_dsl.association_refs,
-        tag_refs: row_dsl.tag_refs
+        literal_values: row_def.literal_values,
+        association_refs: row_def.association_refs,
+        tag_refs: row_def.tag_refs
       )
     end
   end

lib/fixturebot/definition.rb

@@ -11,7 +11,7 @@ def initialize(schema, definition)
       schema.join_tables.each_key { |name| @tables[name] = {} }
 
       definition.rows.each do |row|
-        builder = RowBuilder.new(
+        builder = Row::Builder.new(
           row: row,
           table: schema.tables[row.table],
           defaults: definition.defaults[row.table],

lib/fixturebot/fixture_set.rb

@@ -1,5 +1,129 @@
 # frozen_string_literal: true
 
 module FixtureBot
-  Row = Data.define(:table, :name, :literal_values, :association_refs, :tag_refs)
+  module Row
+    Declaration = Data.define(:table, :name, :literal_values, :association_refs, :tag_refs)
+
+    class Definition
+      attr_reader :literal_values, :association_refs, :tag_refs
+
+      def initialize(table, schema)
+        @literal_values = {}
+        @association_refs = {}
+        @tag_refs = {}
+
+        define_column_methods(table)
+        define_association_methods(table)
+        define_join_table_methods(table, schema)
+      end
+
+      private
+
+      def define_column_methods(table)
+        table.columns.each do |col|
+          define_singleton_method(col) do |value|
+            @literal_values[col] = value
+          end
+        end
+      end
+
+      def define_association_methods(table)
+        table.belongs_to_associations.each do |assoc|
+          define_singleton_method(assoc.name) do |ref|
+            @association_refs[assoc.name] = ref
+          end
+        end
+      end
+
+      def define_join_table_methods(table, schema)
+        schema.join_tables.each_value do |jt|
+          if jt.left_table == table.name
+            define_singleton_method(jt.right_table) do |*refs|
+              @tag_refs[jt.name] = { table: jt.right_table, refs: refs }
+            end
+          elsif jt.right_table == table.name
+            define_singleton_method(jt.left_table) do |*refs|
+              @tag_refs[jt.name] = { table: jt.left_table, refs: refs }
+            end
+          end
+        end
+      end
+    end
+
+    class Builder
+      def initialize(row:, table:, defaults:, join_tables:)
+        @row = row
+        @table = table
+        @defaults = defaults
+        @join_tables = join_tables
+      end
+
+      def id
+        @id ||= Key.generate(@row.table, @row.name)
+      end
+
+      def record
+        result = { id: id }
+        @table.columns.each do |col|
+          if @row.literal_values.key?(col)
+            result[col] = @row.literal_values[col]
+          elsif foreign_key_values.key?(col)
+            result[col] = foreign_key_values[col]
+          elsif defaulted_values.key?(col)
+            result[col] = defaulted_values[col]
+          end
+        end
+        result
+      end
+
+      def join_rows
+        @row.tag_refs.flat_map do |join_table_name, tag_info|
+          jt = @join_tables[join_table_name]
+          tag_info[:refs].map do |tag_ref|
+            build_join_row(jt, tag_info[:table], tag_ref)
+          end
+        end
+      end
+
+      private
+
+      def build_join_row(jt, other_table, tag_ref)
+        other_id = Key.generate(other_table, tag_ref)
+
+        if jt.left_table == @row.table
+          {
+            key: :"#{@row.name}_#{tag_ref}",
+            join_table: jt.name,
+            row: { jt.left_foreign_key => id, jt.right_foreign_key => other_id }
+          }
+        else
+          {
+            key: :"#{tag_ref}_#{@row.name}",
+            join_table: jt.name,
+            row: { jt.left_foreign_key => other_id, jt.right_foreign_key => id }
+          }
+        end
+      end
+
+      def foreign_key_values
+        @foreign_key_values ||= @row.association_refs.each_with_object({}) do |(assoc_name, ref), hash|
+          assoc = @table.belongs_to_associations.find { |a| a.name == assoc_name }
+          hash[assoc.foreign_key] = Key.generate(assoc.table, ref)
+        end
+      end
+
+      def defaulted_values
+        @defaulted_values ||= @defaults.each_with_object({}) do |(col, block), result|
+          next if @row.literal_values.key?(col)
+          next if foreign_key_values.key?(col)
+
+          context = Default::Context.new(
+            record_name: @row.name,
+            literal_values: @row.literal_values
+          )
+          result[col] = context.instance_eval(&block)
+        end
+      end
+    end
+  end
 end