Cambiare tipo di ActiveRecord classe in Rails con Single Table Inheritance

Question

Ho due tipi di classi:

BaseUser < ActiveRecord::Base 

e

User < BaseUser 

che acts_as_authentic che utilizzano il sistema di autenticazione di Authlogic. Questa ereditarietà è implementata utilizzando l'ereditarietà della tabella singola

Se un nuovo utente si registra, lo registro come utente. Tuttavia, se ho già un BaseUser con la stessa email, mi piacerebbe cambiare BaseUser in un Utente nel database senza semplicemente copiare tutti i dati sull'Utente da BaseUser e creare un nuovo Utente (cioè con un nuovo id). È possibile? Grazie.

Answer 1

È possibile impostare il campo del tipo su "Utente" e salvare il record. L'oggetto in memoria mostrerà ancora come un BaseUser, ma la prossima volta che ricaricare l'oggetto in memoria sarà un utente

>> b=BaseUser.new 
>> b.class # = BaseUser 

# Set the Type. In-Memory object is still a BaseUser 
>> b.type='User' 
>> b.class # = BaseUser 
>> b.save 

# Retrieve the records through both models (Each has the same class) 

>> User.find(1).class # = User 
>> BaseUser.find(1).class # User 

Answer 2

opere risposta di Steve, ma dal momento che l'istanza è di classe BaseUser quando save viene chiamato, convalide e le callback definite in User non verranno eseguite. Probabilmente si vorrà convertire l'istanza utilizzando il metodo becomes:

user = BaseUser.where(email: "user@example.com").first_or_initialize 
user = user.becomes(User) # convert to instance from BaseUser to User 
user.type = "User" 
user.save! 

Answer 3

Sulla base delle altre risposte, mi aspettavo questo lavoro in Rails 4.1:

def update 
    @company = Company.find(params[:id]) 
    # This separate step is required to change Single Table Inheritance types 
    new_type = params[:company][:type] 
    if new_type != @company.type && Company::COMPANY_TYPES.include?(new_type) 
     @company.becomes!(new_type.constantize) 
     @company.type = new_type 
     @company.save! 
    end 

    @company.update(company_params) 
    respond_with(@company) 
    end 

Essa non ha, come il tipo il cambiamento non persisterebbe. Invece, sono andato con questo approccio meno elegante, che funziona correttamente:

def update 
    @company = Company.find(params[:id]) 
    # This separate step is required to change Single Table Inheritance types 
    new_type = params[:company][:type] 
    if new_type != @company.type && Company::COMPANY_TYPES.include?(new_type) 
     @company.update_column :type, new_type 
    end 

    @company.update(company_params) 
    respond_with(@company) 
    end 

Ed ecco le prove del controller che ho usato per confermare la soluzione:

describe 'Single Table Inheritance (STI)' do 

    class String 
     def articleize 
     %w(a e i o u).include?(self[0].to_s.downcase) ? "an #{self}" : "a #{self}" 
     end 
    end 

    Company::COMPANY_TYPES.each do |sti_type| 
     it "a newly assigned Company of type #{sti_type} " \ 
     "should be #{sti_type.articleize}" do 
     post :create, { company: attributes_for(:company, type: sti_type) }, 
      valid_session 
     expect(assigns(:company)).to be_a(sti_type.constantize) 
     end 
    end 

    Company::COMPANY_TYPES.each_index do |i| 
     sti_type, next_sti_type = Company::COMPANY_TYPES[i - 1], 
           Company::COMPANY_TYPES[i] 
     it "#{sti_type.articleize} changed to type #{next_sti_type} " \ 
     "should be #{next_sti_type.articleize}" do 
     company = Company.create! attributes_for(:company, type: sti_type) 
     put :update, { id: company.to_param, company: { type: next_sti_type } }, 
      valid_session 
     reloaded_company = Company.find(company.to_param) 
     expect(reloaded_company).to be_a(next_sti_type.constantize) 
     end 
    end 
    end