Replace method_missing with Class.new + define_method

DSL classes now use .for() factories that build anonymous
subclasses with real methods via define_method. Better stack
traces, faster dispatch, and visible via .methods introspection.

Author: bradgessler

lib/fixture_bot.rb

@@ -16,14 +16,14 @@ module FixtureBot
   class Error < StandardError; end
 
   def self.define(schema, &block)
-    definition = Definition.new(schema)
+    definition = Definition.for(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.new(schema)
+    definition = Definition.for(schema)
     definition.instance_eval(content, fixtures_path, 1)
     FixtureSet.new(schema, definition)
   end

lib/fixture_bot/definition.rb

@@ -4,6 +4,32 @@ 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 = {}
@@ -13,37 +39,5 @@ def initialize(schema)
         @generators[table_def.name] = {}
       end
     end
-
-    private
-
-    def method_missing(method_name, *args, &block)
-      table_def = find_table(method_name)
-      return super unless table_def
-
-      if args.empty? && block.nil?
-        GeneratorProxy.new(table_def, @generators[table_def.name])
-      elsif args.first
-        record_name = args.first
-        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, "#{method_name} requires a record name or no arguments"
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      find_table(method_name) || super
-    end
-
-    def find_table(singular_name)
-      @schema.tables.values.find { |t| t.singular_name.to_s == singular_name.to_s }
-    end
   end
 end

lib/fixture_bot/generator_context.rb

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

lib/fixture_bot/generator_proxy.rb

@@ -2,24 +2,21 @@
 
 module FixtureBot
   class GeneratorProxy
-    def initialize(table_def, generators)
-      @table_def = table_def
-      @generators = generators
-    end
-
-    private
+    def self.for(table_def, generators)
+      klass = Class.new(self)
 
-    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
+      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
+
+      klass.new(generators)
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      @table_def.columns.include?(method_name) || super
+    def initialize(generators)
+      @generators = generators
     end
   end
 end

lib/fixture_bot/record_builder.rb

@@ -68,7 +68,7 @@ def generated_values
         next if @row.literal_values.key?(col)
         next if foreign_key_values.key?(col)
 
-        context = GeneratorContext.new(
+        context = GeneratorContext.for(
           record_name: @row.name,
           table: @row.table,
           literal_values: @row.literal_values

lib/fixture_bot/row_dsl.rb

@@ -4,50 +4,40 @@ module FixtureBot
   class RowDSL
     attr_reader :literal_values, :association_refs, :tag_refs
 
-    def initialize(table_def, schema)
-      @table_def = table_def
-      @schema = schema
-      @literal_values = {}
-      @association_refs = {}
-      @tag_refs = {}
-      @join_table_map = build_join_table_map
-    end
+    def self.for(table_def, schema)
+      klass = Class.new(self)
 
-    private
+      table_def.columns.each do |col|
+        klass.define_method(col) do |value|
+          @literal_values[col] = value
+        end
+      end
 
-    def method_missing(method_name, *args)
-      if @table_def.columns.include?(method_name)
-        @literal_values[method_name] = args.first
-      elsif (assoc = find_association(method_name))
-        @association_refs[assoc.name] = args.first
-      elsif (jt_info = @join_table_map[method_name])
-        @tag_refs[jt_info[:join_table]] = { table: jt_info[:other_table], refs: args }
-      else
-        super
+      table_def.belongs_to_associations.each do |assoc|
+        klass.define_method(assoc.name) do |ref|
+          @association_refs[assoc.name] = ref
+        end
       end
-    end
 
-    def respond_to_missing?(method_name, include_private = false)
-      @table_def.columns.include?(method_name) ||
-        find_association(method_name) ||
-        @join_table_map.key?(method_name) ||
-        super
-    end
+      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
+      end
 
-    def find_association(name)
-      @table_def.belongs_to_associations.find { |a| a.name == name }
+      klass.new
     end
 
-    def build_join_table_map
-      map = {}
-      @schema.join_tables.each_value do |jt|
-        if jt.left_table == @table_def.name
-          map[jt.right_table] = { join_table: jt.name, other_table: jt.right_table }
-        elsif jt.right_table == @table_def.name
-          map[jt.left_table] = { join_table: jt.name, other_table: jt.left_table }
-        end
-      end
-      map
+    def initialize
+      @literal_values = {}
+      @association_refs = {}
+      @tag_refs = {}
     end
   end
 end