Group related classes into Row and Default namespaces

- Row::Definition (was RowDefinition) and Row::Builder (was RowBuilder)
  now live inside Row class in row.rb
- Default::Context (was DefaultContext) now lives inside Default class
  in default.rb
- Remove row_definition.rb, row_builder.rb, default_context.rb

Author: bradgessler

lib/fixturebot.rb

@@ -3,12 +3,9 @@
 require_relative "fixturebot/version"
 require_relative "fixturebot/schema"
 require_relative "fixturebot/key"
-require_relative "fixturebot/row"
-require_relative "fixturebot/default_context"
 require_relative "fixturebot/default"
-require_relative "fixturebot/row_definition"
+require_relative "fixturebot/row"
 require_relative "fixturebot/definition"
-require_relative "fixturebot/row_builder"
 require_relative "fixturebot/fixture_set"
 require_relative "fixturebot/yaml_dumper"
 require_relative "fixturebot/cli"

lib/fixturebot/default.rb

@@ -17,5 +17,27 @@ def define_column_methods(table)
         end
       end
     end
+
+    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_literal_value_methods(literal_values)
+        literal_values.each do |col, val|
+          next if col == :name
+          define_singleton_method(col) { val }
+        end
+      end
+    end
   end
 end

lib/fixturebot/default_context.rb

@@ -30,7 +30,7 @@ def define_table_method(table)
     end
 
     def add_row(table, record_name, block)
-      row_dsl = RowDefinition.new(table, @schema)
+      row_dsl = Row::Definition.new(table, @schema)
       row_dsl.instance_eval(&block) if block
       @rows << Row.new(
         table: table.name,

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,127 @@
 # frozen_string_literal: true
 
 module FixtureBot
-  Row = Data.define(:table, :name, :literal_values, :association_refs, :tag_refs)
+  class Row < 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