Replace method_missing with define_singleton_method and rename classes

Use define_singleton_method in initialize instead of method_missing or
anonymous subclasses. Extract metaprogramming into named private methods
(define_table_method, define_column_methods, etc).

Rename classes to use database/schema terminology:
- GeneratorProxy -> Default
- GeneratorContext -> DefaultContext
- RowDSL -> RowDefinition
- RecordBuilder -> RowBuilder
- StableId -> Key
- @generators -> @defaults
- table_def -> table

Author: bradgessler

lib/fixturebot.rb

@@ -2,13 +2,13 @@
 
 require_relative "fixturebot/version"
 require_relative "fixturebot/schema"
-require_relative "fixturebot/stable_id"
+require_relative "fixturebot/key"
 require_relative "fixturebot/row"
-require_relative "fixturebot/generator_context"
-require_relative "fixturebot/generator_proxy"
-require_relative "fixturebot/row_dsl"
+require_relative "fixturebot/default_context"
+require_relative "fixturebot/default"
+require_relative "fixturebot/row_definition"
 require_relative "fixturebot/definition"
-require_relative "fixturebot/record_builder"
+require_relative "fixturebot/row_builder"
 require_relative "fixturebot/fixture_set"
 require_relative "fixturebot/yaml_dumper"
 require_relative "fixturebot/cli"

lib/fixturebot/default.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  class Default
+    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
+end

lib/fixturebot/default_context.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  class DefaultContext
+    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

lib/fixturebot/definition.rb

@@ -2,47 +2,43 @@
 
 module FixtureBot
   class Definition
-    attr_reader :generators, :rows
+    attr_reader :defaults, :rows
 
     def initialize(schema)
       @schema = schema
-      @generators = {}
+      @defaults = {}
       @rows = []
-      @singular_to_table = {}
 
-      schema.tables.each_value do |table_def|
-        @generators[table_def.name] = {}
-        @singular_to_table[table_def.singular_name] = table_def
+      schema.tables.each_value do |table|
+        @defaults[table.name] = {}
+        define_table_method(table)
       end
     end
 
     private
 
-    def method_missing(method_name, *args, &block)
-      table_def = @singular_to_table[method_name]
-      return super unless table_def
-
-      record_name = args.first
-
-      if record_name.nil? && block.nil?
-        GeneratorProxy.new(table_def, @generators[table_def.name])
-      elsif record_name
-        row_dsl = RowDSL.new(table_def, @schema)
-        row_dsl.instance_eval(&block) if block
-        @rows << Row.new(
-          table: table_def.name,
-          name: record_name,
-          literal_values: row_dsl.literal_values,
-          association_refs: row_dsl.association_refs,
-          tag_refs: row_dsl.tag_refs
-        )
-      else
-        raise ArgumentError, "#{table_def.singular_name} requires a record name or no arguments"
+    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])
+        elsif record_name
+          add_row(table, record_name, block)
+        else
+          raise ArgumentError, "#{table.singular_name} requires a record name or no arguments"
+        end
       end
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      @singular_to_table.key?(method_name) || super
+    def add_row(table, record_name, block)
+      row_dsl = RowDefinition.new(table, @schema)
+      row_dsl.instance_eval(&block) if block
+      @rows << Row.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
+      )
     end
   end
 end

lib/fixturebot/fixture_set.rb

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

lib/fixturebot/generator_context.rb

@@ -3,7 +3,7 @@
 require "zlib"
 
 module FixtureBot
-  module StableId
+  module Key
     def self.generate(table_name, record_name)
       Zlib.crc32("#{table_name}:#{record_name}") & 0x7FFFFFFF
     end

lib/fixturebot/generator_proxy.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
 module FixtureBot
-  class RecordBuilder
-    def initialize(row:, table_def:, generators:, join_tables:)
+  class RowBuilder
+    def initialize(row:, table:, defaults:, join_tables:)
       @row = row
-      @table_def = table_def
-      @generators = generators
+      @table = table
+      @defaults = defaults
       @join_tables = join_tables
     end
 
     def id
-      @id ||= StableId.generate(@row.table, @row.name)
+      @id ||= Key.generate(@row.table, @row.name)
     end
 
     def record
       result = { id: id }
-      @table_def.columns.each do |col|
+      @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 generated_values.key?(col)
-          result[col] = generated_values[col]
+        elsif defaulted_values.key?(col)
+          result[col] = defaulted_values[col]
         end
       end
       result
@@ -39,7 +39,7 @@ def join_rows
     private
 
     def build_join_row(jt, other_table, tag_ref)
-      other_id = StableId.generate(other_table, tag_ref)
+      other_id = Key.generate(other_table, tag_ref)
 
       if jt.left_table == @row.table
         {
@@ -58,17 +58,17 @@ def build_join_row(jt, other_table, tag_ref)
 
     def foreign_key_values
       @foreign_key_values ||= @row.association_refs.each_with_object({}) do |(assoc_name, ref), hash|
-        assoc = @table_def.belongs_to_associations.find { |a| a.name == assoc_name }
-        hash[assoc.foreign_key] = StableId.generate(assoc.table, ref)
+        assoc = @table.belongs_to_associations.find { |a| a.name == assoc_name }
+        hash[assoc.foreign_key] = Key.generate(assoc.table, ref)
       end
     end
 
-    def generated_values
-      @generated_values ||= @generators.each_with_object({}) do |(col, block), result|
+    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 = GeneratorContext.new(
+        context = DefaultContext.new(
           record_name: @row.name,
           literal_values: @row.literal_values
         )

lib/fixturebot/stable_id.rb lib/fixturebot/key.rblib/fixturebot/stable_id.rb renamed to lib/fixturebot/key.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FixtureBot
+  class RowDefinition
+    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
+end