activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/validations/uniqueness.rb

@@ -1,42 +1,45 @@
-require 'active_support/core_ext/array/wrap'
-
 module ActiveRecord
   module Validations
-    class UniquenessValidator < ActiveModel::EachValidator
+    class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
       def initialize(options)
-        super(options.reverse_merge(:case_sensitive => true))
-      end
-
-      # Unfortunately, we have to tie Uniqueness validators to a class.
-      def setup(klass)
-        @klass = klass
+        if options[:conditions] && !options[:conditions].respond_to?(:call)
+          raise ArgumentError, "#{options[:conditions]} was passed as :conditions but is not callable. " \
+                               "Pass a callable instead: `conditions: -> { where(approved: true) }`"
+        end
+        super({ case_sensitive: true }.merge!(options))
+        @klass = options[:class]
       end
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
         table = finder_class.arel_table
-
-        coder = record.class.serialized_attributes[attribute.to_s]
-
-        if value && coder
-          value = coder.dump value
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        begin
+          relation = build_relation(finder_class, table, attribute, value)
+          if record.persisted?
+            if finder_class.primary_key
+              relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id))
+            else
+              raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+            end
+          end
+          relation = scope_relation(record, table, relation)
+          relation = finder_class.unscoped.where(relation)
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+        rescue RangeError
+          relation = finder_class.none
         end
 
-        relation = build_relation(finder_class, table, attribute, value)
-        relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.send(:id))) if record.persisted?
-
-        Array.wrap(options[:scope]).each do |scope_item|
-          scope_value = record.read_attribute(scope_item)
-          relation = relation.and(table[scope_item].eq(scope_value))
-        end
+        if relation.exists?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
 
-        if finder_class.unscoped.where(relation).exists?
-          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          record.errors.add(attribute, :taken, error_options)
         end
       end
 
     protected
-
       # The check for an existing value should be run from a class that
       # isn't abstract. This means working down from the current class
       # (self), to the first non-abstract class. Since classes don't know
@@ -46,67 +49,123 @@ module ActiveRecord
         class_hierarchy = [record.class]
 
         while class_hierarchy.first != @klass
-          class_hierarchy.insert(0, class_hierarchy.first.superclass)
+          class_hierarchy.unshift(class_hierarchy.first.superclass)
         end
 
         class_hierarchy.detect { |klass| !klass.abstract_class? }
       end
 
       def build_relation(klass, table, attribute, value) #:nodoc:
-        column = klass.columns_hash[attribute.to_s]
-        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if value && column.text?
+        if reflection = klass._reflect_on_association(attribute)
+          attribute = reflection.foreign_key
+          value = value.attributes[reflection.klass.primary_key] unless value.nil?
+        end
+
+        attribute_name = attribute.to_s
+
+        # the attribute may be an aliased attribute
+        if klass.attribute_aliases[attribute_name]
+          attribute = klass.attribute_aliases[attribute_name]
+          attribute_name = attribute.to_s
+        end
+
+        column = klass.columns_hash[attribute_name]
+        value  = klass.connection.type_cast(value, column)
+        if value.is_a?(String) && column.limit
+          value = value.to_s[0, column.limit]
+        end
 
         if !options[:case_sensitive] && value && column.text?
           # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
-          relation = klass.connection.case_insensitive_comparison(table, attribute, column, value)
+          klass.connection.case_insensitive_comparison(table, attribute, column, value)
         else
-          value    = klass.connection.case_sensitive_modifier(value) if value
-          relation = table[attribute].eq(value)
+          klass.connection.case_sensitive_comparison(table, attribute, column, value)
+        end
+      end
+
+      def scope_relation(record, table, relation)
+        Array(options[:scope]).each do |scope_item|
+          if reflection = record.class._reflect_on_association(scope_item)
+            scope_value = record.send(reflection.foreign_key)
+            scope_item  = reflection.foreign_key
+          else
+            scope_value = record._read_attribute(scope_item)
+          end
+          relation = relation.and(table[scope_item].eq(scope_value))
         end
 
         relation
       end
+
+      def map_enum_attribute(klass, attribute, value)
+        mapping = klass.defined_enums[attribute.to_s]
+        value = mapping[value] if value && mapping
+        value
+      end
     end
 
     module ClassMethods
-      # Validates whether the value of the specified attributes are unique across the system.
-      # Useful for making sure that only one user
+      # Validates whether the value of the specified attributes are unique
+      # across the system. Useful for making sure that only one user
       # can be named "davidhh".
       #
       #   class Person < ActiveRecord::Base
       #     validates_uniqueness_of :user_name
       #   end
       #
-      # It can also validate whether the value of the specified attributes are unique based on a scope parameter:
+      # It can also validate whether the value of the specified attributes are
+      # unique based on a <tt>:scope</tt> parameter:
       #
       #   class Person < ActiveRecord::Base
-      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #     validates_uniqueness_of :user_name, scope: :account_id
       #   end
       #
-      # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
-      # per semester for a particular class.
+      # Or even multiple scope parameters. For example, making sure that a
+      # teacher can only be on the schedule once per semester for a particular
+      # class.
       #
       #   class TeacherSchedule < ActiveRecord::Base
-      #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
+      #     validates_uniqueness_of :teacher_id, scope: [:semester_id, :class_id]
+      #   end
+      #
+      # It is also possible to limit the uniqueness constraint to a set of
+      # records matching certain conditions. In this example archived articles
+      # are not being taken into consideration when validating uniqueness
+      # of the title attribute:
+      #
+      #   class Article < ActiveRecord::Base
+      #     validates_uniqueness_of :title, conditions: -> { where.not(status: 'archived') }
       #   end
       #
-      # When the record is created, a check is performed to make sure that no record exists in the database
-      # with the given value for the specified attribute (that maps to a column). When the record is updated,
+      # When the record is created, a check is performed to make sure that no
+      # record exists in the database with the given value for the specified
+      # attribute (that maps to a column). When the record is updated,
       # the same check is made but disregarding the record itself.
       #
       # Configuration options:
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
-      # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
-      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by non-text columns (+true+ by default).
-      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
-      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
-      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method, proc or string should
-      #   return or evaluate to a true or false value.
+      #
+      # * <tt>:message</tt> - Specifies a custom error message (default is:
+      #   "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of
+      #   the uniqueness constraint.
+      # * <tt>:conditions</tt> - Specify the conditions to be included as a
+      #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
+      #   (e.g. <tt>conditions: -> { where(status: 'active') }</tt>).
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+      #   non-text columns (+true+ by default).
+      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
+      #   attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   value.
       #
       # === Concurrency and integrity
       #
@@ -126,11 +185,11 @@ module ActiveRecord
       #  WHERE title = 'My Post'             |
       #                                      |
       #                                      | # User 2 does the same thing and also
-      #                                      | # infers that his title is unique.
+      #                                      | # infers that their title is unique.
       #                                      | SELECT * FROM comments
       #                                      | WHERE title = 'My Post'
       #                                      |
-      #  # User 1 inserts his comment.       |
+      #  # User 1 inserts their comment.     |
       #  INSERT INTO comments                |
       #  (title, content) VALUES             |
       #  ('My Post', 'hi!')                  |
@@ -156,22 +215,22 @@ module ActiveRecord
       # exception. You can either choose to let this error propagate (which
       # will result in the default Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
-      # that the title already exists, and asking him to re-enter the title).
-      # This technique is also known as optimistic concurrency control:
-      # http://en.wikipedia.org/wiki/Optimistic_concurrency_control
+      # that the title already exists, and asking them to re-enter the title).
+      # This technique is also known as
+      # {optimistic concurrency control}[http://en.wikipedia.org/wiki/Optimistic_concurrency_control].
       #
       # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
       # constraint errors from other types of database errors by throwing an
-      # ActiveRecord::RecordNotUnique exception.
-      # For other adapters you will have to parse the (database-specific) exception
-      # message to detect such a case.
+      # ActiveRecord::RecordNotUnique exception. For other adapters you will
+      # have to parse the (database-specific) exception message to detect such
+      # a case.
+      #
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
-      # * ActiveRecord::ConnectionAdapters::MysqlAdapter
-      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      # * ActiveRecord::ConnectionAdapters::SQLiteAdapter
-      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
-      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
       #
+      # * ActiveRecord::ConnectionAdapters::MysqlAdapter.
+      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
+      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_of(*attr_names)
         validates_with UniquenessValidator, _merge_attributes(attr_names)
       end

data/lib/active_record/validations.rb

@@ -5,16 +5,17 @@ module ActiveRecord
   # +record+ method to retrieve the record which did not validate.
   #
   #   begin
-  #     complex_operation_that_calls_save!_internally
+  #     complex_operation_that_internally_calls_save!
   #   rescue ActiveRecord::RecordInvalid => invalid
   #     puts invalid.record.errors
   #   end
   class RecordInvalid < ActiveRecordError
     attr_reader :record
+
     def initialize(record)
       @record = record
       errors = @record.errors.full_messages.join(", ")
-      super(I18n.t("activerecord.errors.messages.record_invalid", :errors => errors))
+      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
     end
   end
 
@@ -29,38 +30,26 @@ module ActiveRecord
     extend ActiveSupport::Concern
     include ActiveModel::Validations
 
-    module ClassMethods
-      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
-      # so an exception is raised if the record is invalid.
-      def create!(attributes = nil, options = {}, &block)
-        if attributes.is_a?(Array)
-          attributes.collect { |attr| create!(attr, options, &block) }
-        else
-          object = new(attributes, options)
-          yield(object) if block_given?
-          object.save!
-          object
-        end
-      end
-    end
-
-    # The validation process on save can be skipped by passing <tt>:validate => false</tt>. The regular Base#save method is
-    # replaced with this when the validations module is mixed in, which it is by default.
+    # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The regular Base#save method is replaced with this when the validations
+    # module is mixed in, which it is by default.
     def save(options={})
       perform_validations(options) ? super : false
     end
 
-    # Attempts to save the record just like Base#save but will raise a +RecordInvalid+ exception instead of returning false
-    # if the record is not valid.
+    # Attempts to save the record just like Base#save but will raise a +RecordInvalid+
+    # exception instead of returning +false+ if the record is not valid.
     def save!(options={})
-      perform_validations(options) ? super : raise(RecordInvalid.new(self))
+      perform_validations(options) ? super : raise_record_invalid
     end
 
-    # Runs all the validations within the specified context. Returns true if no errors are found,
-    # false otherwise.
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, +false+ otherwise.
+    #
+    # Aliased as validate.
     #
-    # If the argument is false (default is +nil+), the context is set to <tt>:create</tt> if
-    # <tt>new_record?</tt> is true, and to <tt>:update</tt> if it is not.
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
     #
     # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
     # some <tt>:on</tt> option will only run in the specified context.
@@ -70,14 +59,32 @@ module ActiveRecord
       errors.empty? && output
     end
 
+    alias_method :validate, :valid?
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, raises +RecordInvalid+ otherwise.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def validate!(context = nil)
+      valid?(context) || raise_record_invalid
+    end
+
   protected
 
-    def perform_validations(options={})
-      perform_validation = options[:validate] != false
-      perform_validation ? valid?(options[:context]) : true
+    def raise_record_invalid
+      raise(RecordInvalid.new(self))
+    end
+
+    def perform_validations(options={}) # :nodoc:
+      options[:validate] == false || valid?(options[:context])
     end
   end
 end
 
 require "active_record/validations/associated"
 require "active_record/validations/uniqueness"
+require "active_record/validations/presence"

data/lib/active_record/version.rb

@@ -1,10 +1,8 @@
-module ActiveRecord
-  module VERSION #:nodoc:
-    MAJOR = 3
-    MINOR = 2
-    TINY  = 22
-    PRE   = "5"
+require_relative 'gem_version'
 
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+module ActiveRecord
+  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
   end
 end

data/lib/active_record.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2011 David Heinemeier Hansson
+# Copyright (c) 2004-2014 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -22,24 +22,51 @@
 #++
 
 require 'active_support'
-require 'active_support/i18n'
+require 'active_support/rails'
 require 'active_model'
 require 'arel'
 
 require 'active_record/version'
+require 'active_record/attribute_set'
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  # ActiveRecord::SessionStore depends on the abstract store in Action Pack.
-  # Eager loading this class would break client code that eager loads Active
-  # Record standalone.
-  #
-  # Note that the Rails application generator creates an initializer specific
-  # for setting the session store. Thus, albeit in theory this autoload would
-  # not be thread-safe, in practice it is because if the application uses this
-  # session store its autoload happens at boot time.
-  autoload :SessionStore
+  autoload :Attribute
+  autoload :Base
+  autoload :Callbacks
+  autoload :Core
+  autoload :ConnectionHandling
+  autoload :CounterCache
+  autoload :DynamicMatchers
+  autoload :Enum
+  autoload :Explain
+  autoload :Inheritance
+  autoload :Integration
+  autoload :Migration
+  autoload :Migrator, 'active_record/migration'
+  autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :NoTouching
+  autoload :Persistence
+  autoload :QueryCache
+  autoload :Querying
+  autoload :ReadonlyAttributes
+  autoload :RecordInvalid, 'active_record/validations'
+  autoload :Reflection
+  autoload :RuntimeRegistry
+  autoload :Sanitization
+  autoload :Schema
+  autoload :SchemaDumper
+  autoload :SchemaMigration
+  autoload :Scoping
+  autoload :Serialization
+  autoload :StatementCache
+  autoload :Store
+  autoload :Timestamp
+  autoload :Transactions
+  autoload :Translation
+  autoload :Validations
 
   eager_autoload do
     autoload :ActiveRecordError, 'active_record/errors'
@@ -48,11 +75,15 @@ module ActiveRecord
 
     autoload :Aggregations
     autoload :Associations
-    autoload :AttributeMethods
     autoload :AttributeAssignment
+    autoload :AttributeMethods
     autoload :AutosaveAssociation
 
+    autoload :LegacyYamlAdapter
+
     autoload :Relation
+    autoload :AssociationRelation
+    autoload :NullRelation
 
     autoload_under 'relation' do
       autoload :QueryMethods
@@ -61,45 +92,15 @@ module ActiveRecord
       autoload :PredicateBuilder
       autoload :SpawnMethods
       autoload :Batches
-      autoload :Explain
       autoload :Delegation
     end
 
-    autoload :Base
-    autoload :Callbacks
-    autoload :CounterCache
-    autoload :DynamicMatchers
-    autoload :DynamicFinderMatch
-    autoload :DynamicScopeMatch
-    autoload :Explain
-    autoload :IdentityMap
-    autoload :Inheritance
-    autoload :Integration
-    autoload :Migration
-    autoload :Migrator, 'active_record/migration'
-    autoload :ModelSchema
-    autoload :NestedAttributes
-    autoload :Observer
-    autoload :Persistence
-    autoload :QueryCache
-    autoload :Querying
-    autoload :ReadonlyAttributes
-    autoload :Reflection
     autoload :Result
-    autoload :Sanitization
-    autoload :Schema
-    autoload :SchemaDumper
-    autoload :Scoping
-    autoload :Serialization
-    autoload :Store
-    autoload :Timestamp
-    autoload :Transactions
-    autoload :Translation
-    autoload :Validations
   end
 
   module Coders
     autoload :YAMLColumn, 'active_record/coders/yaml_column'
+    autoload :JSON, 'active_record/coders/json'
   end
 
   module AttributeMethods
@@ -114,7 +115,6 @@ module ActiveRecord
       autoload :TimeZoneConversion
       autoload :Write
       autoload :Serialization
-      autoload :DeprecatedUnderscoreRead
     end
   end
 
@@ -145,12 +145,32 @@ module ActiveRecord
     end
   end
 
-  autoload :TestCase
+  module Tasks
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseTasks
+    autoload :SQLiteDatabaseTasks, 'active_record/tasks/sqlite_database_tasks'
+    autoload :MySQLDatabaseTasks,  'active_record/tasks/mysql_database_tasks'
+    autoload :PostgreSQLDatabaseTasks,
+      'active_record/tasks/postgresql_database_tasks'
+  end
+
   autoload :TestFixtures, 'active_record/fixtures'
+
+  def self.eager_load!
+    super
+    ActiveRecord::Locking.eager_load!
+    ActiveRecord::Scoping.eager_load!
+    ActiveRecord::Associations.eager_load!
+    ActiveRecord::AttributeMethods.eager_load!
+    ActiveRecord::ConnectionAdapters.eager_load!
+  end
 end
 
 ActiveSupport.on_load(:active_record) do
   Arel::Table.engine = self
 end
 
-I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+end

data/lib/rails/generators/active_record/migration/migration_generator.rb

@@ -1,25 +1,70 @@
 require 'rails/generators/active_record'
 
 module ActiveRecord
-  module Generators
-    class MigrationGenerator < Base
+  module Generators # :nodoc:
+    class MigrationGenerator < Base # :nodoc:
       argument :attributes, :type => :array, :default => [], :banner => "field[:type][:index] field[:type][:index]"
 
       def create_migration_file
         set_local_assigns!
-        migration_template "migration.rb", "db/migrate/#{file_name}.rb"
+        validate_file_name!
+        migration_template @migration_template, "db/migrate/#{file_name}.rb"
       end
 
       protected
-        attr_reader :migration_action
+      attr_reader :migration_action, :join_tables
 
-        def set_local_assigns!
-          if file_name =~ /^(add|remove)_.*_(?:to|from)_(.*)/
-            @migration_action = $1
-            @table_name       = $2.pluralize
+      # sets the default migration template that is being used for the generation of the migration
+      # depending on the arguments which would be sent out in the command line, the migration template 
+      # and the table name instance variables are setup.
+
+      def set_local_assigns!
+        @migration_template = "migration.rb"
+        case file_name
+        when /^(add|remove)_.*_(?:to|from)_(.*)/
+          @migration_action = $1
+          @table_name       = normalize_table_name($2)
+        when /join_table/
+          if attributes.length == 2
+            @migration_action = 'join'
+            @join_tables      = pluralize_table_names? ? attributes.map(&:plural_name) : attributes.map(&:singular_name)
+
+            set_index_names
+          end
+        when /^create_(.+)/
+          @table_name = normalize_table_name($1)
+          @migration_template = "create_table_migration.rb"
+        end
+      end
+
+      def set_index_names
+        attributes.each_with_index do |attr, i|
+          attr.index_name = [attr, attributes[i - 1]].map{ |a| index_name_for(a) }
+        end
+      end
+
+      def index_name_for(attribute)
+        if attribute.foreign_key?
+          attribute.name
+        else
+          attribute.name.singularize.foreign_key
+        end.to_sym
+      end
+
+      private
+        def attributes_with_index
+          attributes.select { |a| !a.reference? && a.has_index? }
+        end
+
+        def validate_file_name!
+          unless file_name =~ /^[_a-z0-9]+$/
+            raise IllegalMigrationNameError.new(file_name)
           end
         end
 
+        def normalize_table_name(_table_name)
+          pluralize_table_names? ? _table_name.pluralize : _table_name.singularize
+        end
     end
   end
 end

data/lib/rails/generators/active_record/{model/templates/migration.rb → migration/templates/create_table_migration.rb}

@@ -2,10 +2,14 @@ class <%= migration_class_name %> < ActiveRecord::Migration
   def change
     create_table :<%= table_name %> do |t|
 <% attributes.each do |attribute| -%>
+<% if attribute.password_digest? -%>
+      t.string :password_digest<%= attribute.inject_options %>
+<% else -%>
       t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
 <% end -%>
+<% end -%>
 <% if options[:timestamps] %>
-      t.timestamps
+      t.timestamps null: false
 <% end -%>
     end
 <% attributes_with_index.each do |attribute| -%>