Replace Class.new + define_method with method_missing

Simpler DSL dispatch using standard method_missing/respond_to_missing?
instead of anonymous subclasses with baked-in define_method closures.

Author: bradgessler

lib/fixturebot.rb

@@ -16,14 +16,14 @@ module FixtureBot
   class Error < StandardError; end
 
   def self.define(schema, &block)
-    definition = Definition.for(schema)
+    definition = Definition.new(schema)
     definition.instance_eval(&block)
     FixtureSet.new(schema, definition)
   end
 
   def self.define_from_file(schema, fixtures_path)
     content = File.read(fixtures_path)
-    definition = Definition.for(schema)
+    definition = Definition.new(schema)
     definition.instance_eval(content, fixtures_path, 1)
     FixtureSet.new(schema, definition)
   end

lib/fixturebot/definition.rb

@@ -4,40 +4,45 @@ module FixtureBot
   class Definition
     attr_reader :generators, :rows
 
-    def self.for(schema)
-      klass = Class.new(self)
-
-      schema.tables.each_value do |table_def|
-        klass.define_method(table_def.singular_name) do |record_name = nil, &block|
-          if record_name.nil? && block.nil?
-            GeneratorProxy.for(table_def, @generators[table_def.name])
-          elsif record_name
-            row_dsl = RowDSL.for(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"
-          end
-        end
-      end
-
-      klass.new(schema)
-    end
-
     def initialize(schema)
       @schema = schema
       @generators = {}
       @rows = []
+      @singular_to_table = {}
 
       schema.tables.each_value do |table_def|
         @generators[table_def.name] = {}
+        @singular_to_table[table_def.singular_name] = table_def
+      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"
       end
     end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @singular_to_table.key?(method_name) || super
+    end
   end
 end

lib/fixturebot/generator_context.rb

@@ -2,16 +2,27 @@
 
 module FixtureBot
   class GeneratorContext
-    def self.for(record_name:, table:, literal_values: {})
-      klass = Class.new(self)
+    def initialize(record_name:, literal_values: {})
+      @record_name = record_name
+      @literal_values = literal_values
+    end
+
+    def name
+      @literal_values.key?(:name) ? @literal_values[:name] : @record_name
+    end
 
-      klass.define_method(:name) { record_name }
+    private
 
-      literal_values.each do |col, val|
-        klass.define_method(col) { val }
+    def method_missing(method_name, *args, &block)
+      if @literal_values.key?(method_name)
+        @literal_values[method_name]
+      else
+        super
       end
+    end
 
-      klass.new
+    def respond_to_missing?(method_name, include_private = false)
+      @literal_values.key?(method_name) || super
     end
   end
 end

lib/fixturebot/generator_proxy.rb

@@ -2,21 +2,24 @@
 
 module FixtureBot
   class GeneratorProxy
-    def self.for(table_def, generators)
-      klass = Class.new(self)
+    def initialize(table_def, generators)
+      @table_def = table_def
+      @generators = generators
+    end
 
-      table_def.columns.each do |col|
-        klass.define_method(col) do |&block|
-          raise ArgumentError, "#{col} requires a block" unless block
-          @generators[col] = block
-        end
-      end
+    private
 
-      klass.new(generators)
+    def method_missing(method_name, *args, &block)
+      if @table_def.columns.include?(method_name)
+        raise ArgumentError, "#{method_name} requires a block" unless block
+        @generators[method_name] = block
+      else
+        super
+      end
     end
 
-    def initialize(generators)
-      @generators = generators
+    def respond_to_missing?(method_name, include_private = false)
+      @table_def.columns.include?(method_name) || super
     end
   end
 end

lib/fixturebot/record_builder.rb

@@ -68,9 +68,8 @@ def generated_values
         next if @row.literal_values.key?(col)
         next if foreign_key_values.key?(col)
 
-        context = GeneratorContext.for(
+        context = GeneratorContext.new(
           record_name: @row.name,
-          table: @row.table,
           literal_values: @row.literal_values
         )
         result[col] = context.instance_eval(&block)

lib/fixturebot/row_dsl.rb

@@ -4,40 +4,44 @@ module FixtureBot
   class RowDSL
     attr_reader :literal_values, :association_refs, :tag_refs
 
-    def self.for(table_def, schema)
-      klass = Class.new(self)
-
-      table_def.columns.each do |col|
-        klass.define_method(col) do |value|
-          @literal_values[col] = value
-        end
-      end
+    def initialize(table_def, schema)
+      @table_def = table_def
+      @schema = schema
+      @literal_values = {}
+      @association_refs = {}
+      @tag_refs = {}
+    end
 
-      table_def.belongs_to_associations.each do |assoc|
-        klass.define_method(assoc.name) do |ref|
-          @association_refs[assoc.name] = ref
-        end
-      end
+    private
 
-      schema.join_tables.each_value do |jt|
-        if jt.left_table == table_def.name
-          klass.define_method(jt.right_table) do |*refs|
-            @tag_refs[jt.name] = { table: jt.right_table, refs: refs }
-          end
-        elsif jt.right_table == table_def.name
-          klass.define_method(jt.left_table) do |*refs|
-            @tag_refs[jt.name] = { table: jt.left_table, refs: refs }
-          end
-        end
+    def method_missing(method_name, *args, &block)
+      if @table_def.columns.include?(method_name)
+        @literal_values[method_name] = args.first
+      elsif (assoc = @table_def.belongs_to_associations.find { |a| a.name == method_name })
+        @association_refs[assoc.name] = args.first
+      elsif (jt = find_join_table(method_name))
+        @tag_refs[jt[:join_table].name] = { table: jt[:other_table], refs: args }
+      else
+        super
       end
+    end
 
-      klass.new
+    def respond_to_missing?(method_name, include_private = false)
+      @table_def.columns.include?(method_name) ||
+        @table_def.belongs_to_associations.any? { |a| a.name == method_name } ||
+        !!find_join_table(method_name) ||
+        super
     end
 
-    def initialize
-      @literal_values = {}
-      @association_refs = {}
-      @tag_refs = {}
+    def find_join_table(method_name)
+      @schema.join_tables.each_value do |jt|
+        if jt.left_table == @table_def.name && jt.right_table == method_name
+          return { join_table: jt, other_table: jt.right_table }
+        elsif jt.right_table == @table_def.name && jt.left_table == method_name
+          return { join_table: jt, other_table: jt.left_table }
+        end
+      end
+      nil
     end
   end
 end