`validates_acceptance_of` shouldn't require a database connection

The implementation of `attribute_method?` on Active Record requires
establishing a database connection and querying the schema. As a general
rule, we don't want to require database connections for any class macro,
as the class should be able to be loaded without a database (e.g. for
things like compiling assets).

Instead of eagerly defining these methods, we do it lazily the first
time they are accessed via `method_missing`. This should not cause any
performance hits, as it will only hit `method_missing` once for the
entire class.

1 files changed, 51 insertions, 4 deletions

diff --git a/activemodel/lib/active_model/validations/acceptance.rb b/activemodel/lib/active_model/validations/acceptance.rb
index 1bcfedb35d..c5c0cd4636 100644
--- a/activemodel/lib/active_model/validations/acceptance.rb
+++ b/activemodel/lib/active_model/validations/acceptance.rb
@@ -14,16 +14,63 @@ module ActiveModel
       end
 
       private
+
       def setup!(klass)
-        attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-        attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-        klass.send(:attr_reader, *attr_readers)
-        klass.send(:attr_writer, *attr_writers)
+        klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
       end
 
       def acceptable_option?(value)
         Array(options[:accept]).include?(value)
       end
+
+      class LazilyDefineAttributes < Module
+        def initialize(attribute_definition)
+          define_method(:respond_to_missing?) do |method_name, include_private=false|
+            super(method_name, include_private) || attribute_definition.matches?(method_name)
+          end
+
+          define_method(:method_missing) do |method_name, *args, &block|
+            if attribute_definition.matches?(method_name)
+              attribute_definition.define_on(self.class)
+              send(method_name, *args, &block)
+            else
+              super(method_name, *args, &block)
+            end
+          end
+        end
+      end
+
+      class AttributeDefinition
+        def initialize(attributes)
+          @attributes = attributes.map(&:to_s)
+        end
+
+        def matches?(method_name)
+          attr_name = convert_to_reader_name(method_name)
+          attributes.include?(attr_name)
+        end
+
+        def define_on(klass)
+          attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+          attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+          klass.send(:attr_reader, *attr_readers)
+          klass.send(:attr_writer, *attr_writers)
+        end
+
+        protected
+
+        attr_reader :attributes
+
+        private
+
+        def convert_to_reader_name(method_name)
+          attr_name = method_name.to_s
+          if attr_name.end_with?("=")
+            attr_name = attr_name[0..-2]
+          end
+          attr_name
+        end
+      end
     end
 
     module HelperMethods