Merge pull request #481 from Dynamoid/add-field-aliases

Add field aliases

Author: andrykonchin

README.md

@@ -365,6 +365,26 @@ field :actions_taken, :integer, default: 0
 field :joined_at, :datetime, default: -> { Time.now }
 ```
 
+#### Aliases
+
+It might be helpful to define an alias for already existing field when
+naming convention used for a table differs from conventions common in
+Ruby:
+
+```ruby
+field firstName, :string, alias: :first_name
+```
+
+This way there will be generated
+setters/getters/`<name>?`/`<name>_before_type_cast` methods for both
+original field name (`firstName`) and an alias (`first_name`).
+
+```ruby
+user = User.new(first_name: 'Michael')
+user.first_name # => 'Michael'
+user.firstName # => 'Michael'
+```
+
 #### Custom Types
 
 To use a custom type for a field, suppose you have a `Money` type.
@@ -632,7 +652,7 @@ u.email = '[email protected]'
 u.save
 ```
 
-Save forces persistence to the datastore: a unique ID is also assigned,
+Save forces persistence to the data store: a unique ID is also assigned,
 but it is a string and not an auto-incrementing number.
 
 ```ruby

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.
@@ -43,15 +45,15 @@ module ClassMethods
       #   end
       #
       # Its type determines how it is coerced when read in and out of the
-      # datastore. You can specify +string+, +integer+, +number+, +set+, +array+,
+      # data store. You can specify +string+, +integer+, +number+, +set+, +array+,
       # +map+, +datetime+, +date+, +serialized+, +raw+, +boolean+ and +binary+
       # or specify a class that defines a serialization strategy.
       #
       # By default field type is +string+.
       #
       # Set can store elements of the same type only (it's a limitation of
-      # DynamoDB itself). If a set should store elements only some particular
-      # type +of+ option should be specified:
+      # DynamoDB itself). If a set should store elements only of some particular
+      # type then +of+ option should be specified:
       #
       #   field :hobbies, :set, of: :string
       #
@@ -126,41 +128,31 @@ module ClassMethods
       #   user.age # => 21 - integer
       #   user.age_before_type_cast # => '21' - string
       #
+      # There is also an option +alias+ which allows to use another name for a
+      # field:
+      #
+      #   class User
+      #     include Dynamoid::Document
+      #
+      #     field :firstName, :string, alias: :first_name
+      #   end
+      #
+      #   user = User.new(firstName: 'Michael')
+      #   user.firstName # Michael
+      #   user.first_name # Michael
+      #
       # @param name [Symbol] name of the field
       # @param type [Symbol] type of the field (optional)
       # @param options [Hash] any additional options for the field type (optional)
       #
       # @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
+        Dynamoid::Fields::Declare.new(self, name, type, options).call
       end
 
       # Declare a table range key.
@@ -273,21 +265,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,86 @@
+# 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
+        # only local variable is visible in `module_eval` block
+        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
+        # only local variable is visible in `module_eval` block
+        name = @name
+
+        alias_name = @options[:alias].to_sym
+
+        @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

lib/dynamoid/loadable.rb

@@ -10,7 +10,7 @@ def load(attrs)
       end
     end
 
-    # Reload an object from the database -- if you suspect the object has changed in the datastore and you need those
+    # Reload an object from the database -- if you suspect the object has changed in the data store and you need those
     # changes to be reflected immediately, you would call this method. This is a consistent read.
     #
     # @return [Dynamoid::Document] the document this method was called on

lib/dynamoid/persistence.rb

@@ -12,8 +12,8 @@
 
 # encoding: utf-8
 module Dynamoid
-  #   # Persistence is responsible for dumping objects to and marshalling objects from the datastore. It tries to reserialize
-  #   # values to be of the same type as when they were passed in, based on the fields in the class.
+  # Persistence is responsible for dumping objects to and marshalling objects from the data store. It tries to reserialize
+  # values to be of the same type as when they were passed in, based on the fields in the class.
   module Persistence
     extend ActiveSupport::Concern
 

spec/dynamoid/fields_spec.rb

@@ -6,7 +6,40 @@
   let(:address) { Address.new }
 
   describe '.field' do
-    context 'generated method overrided existing one' do
+    context 'when :alias option specified' do
+      let(:klass) do
+        new_class do
+          field :Name, :string, alias: :name
+        end
+      end
+
+      it 'generates getter and setter for alias' do
+        object = klass.new
+
+        object.Name = 'Alex'
+        expect(object.name).to eq('Alex')
+
+        object.name = 'Michael'
+        expect(object.name).to eq('Michael')
+      end
+
+      it 'generates <name>? method' do
+        object = klass.new
+
+        expect(object.name?).to eq false
+        object.name = 'Alex'
+        expect(object.name?).to eq true
+      end
+
+      it 'generates <name>_before_type_cast method' do
+        object = klass.new(name: :Alex)
+
+        expect(object.name).to eq 'Alex'
+        expect(object.name_before_type_cast).to eq :Alex
+      end
+    end
+
+    context 'when new generated method overrides existing one' do
       let(:module_with_methods) do
         Module.new do
           def foo; end