Refactoring. Move .field implementation into a separate class Dynamoid::Fields::Declare

Author: andrykonchin

lib/dynamoid/fields.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dynamoid/fields/declare'
+
 module Dynamoid
   # All fields on a Dynamoid::Document must be explicitly defined -- if you have fields in the database that are not
   # specified with field, then they will be ignored.
@@ -132,46 +134,12 @@ module ClassMethods
       #
       # @since 0.2.0
       def field(name, type = :string, options = {})
-        named = name.to_s
         if type == :float
           Dynamoid.logger.warn("Field type :float, which you declared for '#{name}', is deprecated in favor of :number.")
           type = :number
         end
-        self.attributes = attributes.merge(name => { type: type }.merge(options))
-
-        # should be called before `define_attribute_methods` method because it defines a getter itself
-        warn_about_method_overriding(name, name)
-        warn_about_method_overriding("#{named}=", name)
-        warn_about_method_overriding("#{named}?", name)
-        warn_about_method_overriding("#{named}_before_type_cast?", name)
-
-        define_attribute_method(name) # Dirty API
-
-        generated_methods.module_eval do
-          define_method(named) { read_attribute(named) }
-          define_method("#{named}?") do
-            value = read_attribute(named)
-            case value
-            when true        then true
-            when false, nil  then false
-            else
-              !value.nil?
-            end
-          end
-          define_method("#{named}=") { |value| write_attribute(named, value) }
-          define_method("#{named}_before_type_cast") { read_attribute_before_type_cast(named) }
-        end
-
-        if options[:alias]
-          alias_name = options[:alias].to_s
 
-          generated_methods.module_eval do
-            alias_method alias_name, named
-            alias_method "#{alias_name}=", "#{named}="
-            alias_method "#{alias_name}?", "#{named}?"
-            alias_method "#{alias_name}_before_type_cast", "#{named}_before_type_cast"
-          end
-        end
+        Dynamoid::Fields::Declare.new(self, name, type, options).call
       end
 
       # Declare a table range key.
@@ -284,21 +252,14 @@ def timestamps_enabled?
         options[:timestamps] || (options[:timestamps].nil? && Dynamoid::Config.timestamps)
       end
 
-      private
-
+      # @private
       def generated_methods
         @generated_methods ||= begin
           Module.new.tap do |mod|
             include(mod)
           end
         end
       end
-
-      def warn_about_method_overriding(method_name, field_name)
-        if instance_methods.include?(method_name.to_sym)
-          Dynamoid.logger.warn("Method #{method_name} generated for the field #{field_name} overrides already existing method")
-        end
-      end
     end
 
     # You can access the attributes of an object directly on its attributes method, which is by default an empty hash.

lib/dynamoid/fields/declare.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Fields
+    # @private
+    class Declare
+      def initialize(source, name, type, options)
+        @source = source
+        @name = name.to_sym
+        @type = type
+        @options = options
+      end
+
+      def call
+        # Register new field metadata
+        @source.attributes = @source.attributes.merge(
+          @name => { type: @type }.merge(@options)
+        )
+
+        # Should be called before `define_attribute_methods` method because it
+        # defines an attribute getter itself
+        warn_about_method_overriding
+
+        # Dirty API
+        @source.define_attribute_method(@name)
+
+        # Generate getters and setters as well as other helper methods
+        generate_instance_methods
+
+        # If alias name specified - generate the same instance methods
+        if @options[:alias]
+          generate_instance_methods_for_alias
+        end
+      end
+
+      private
+
+      def warn_about_method_overriding
+        warn_if_method_exists(@name)
+        warn_if_method_exists("#{@name}=")
+        warn_if_method_exists("#{@name}?")
+        warn_if_method_exists("#{@name}_before_type_cast?")
+      end
+
+      def generate_instance_methods
+        name = @name
+
+        @source.generated_methods.module_eval do
+          define_method(name) { read_attribute(name) }
+          define_method("#{name}?") do
+            value = read_attribute(name)
+            case value
+            when true        then true
+            when false, nil  then false
+            else
+              !value.nil?
+            end
+          end
+          define_method("#{name}=") { |value| write_attribute(name, value) }
+          define_method("#{name}_before_type_cast") { read_attribute_before_type_cast(name) }
+        end
+      end
+
+      def generate_instance_methods_for_alias
+        alias_name = @options[:alias].to_sym
+        name = @name
+
+        @source.generated_methods.module_eval do
+          alias_method alias_name, name
+          alias_method "#{alias_name}=", "#{name}="
+          alias_method "#{alias_name}?", "#{name}?"
+          alias_method "#{alias_name}_before_type_cast", "#{name}_before_type_cast"
+        end
+      end
+
+      def warn_if_method_exists(method)
+        if @source.instance_methods.include?(method.to_sym)
+          Dynamoid.logger.warn("Method #{method} generated for the field #{@name} overrides already existing method")
+        end
+      end
+    end
+  end
+end