authorails 1.0.0

data/controllers/tables_controller.rb

@@ -0,0 +1,714 @@
+class TablesController < ApplicationController
+  
+  def index
+    list
+    render :action => 'list'
+  end
+
+  # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+  verify :method => :post, :only => [ :destroy, :create, :update, :create_field, :update_field, :destroy_field ],
+         :redirect_to => { :action => :list }
+   
+  verify :session => :superuser, :redirect_to => {:controller => :admin}, :add_flash => {:notice => "Please login first!"} 
+         
+  skip_before_filter :authorize       
+
+  def list
+    @table_pages, @tables = paginate :tables, :per_page => 10
+  end
+
+  def show
+    @table = Table.find(params[:id],:include => :table_fields)
+  end
+
+  def new
+    @table = Table.new
+  end
+
+  def create
+   if params[:table][:name]==""
+    flash[:notice] = "Table name can't be blank!"
+    redirect_to :action => 'new'
+   else
+     @table = Table.new(:name =>prepare_for_table(params[:table][:name].pluralize))
+     if @table.save
+      flash[:notice] = 'Define the attributes to complete the table\'s creation.'
+      redirect_to :action => 'attributes', :id => @table
+     else
+      @table.name=params[:table][:name]
+      render :action => 'new'
+     end
+   end 
+  end
+
+  def edit
+    @table = Table.find(params[:id])
+    @table[:name]=@table[:name].singularize
+  end
+
+  def update
+   if params[:table][:name]==""
+    flash[:notice] = "Table name can't be blank!"
+    redirect_to :action => 'edit', :id => params[:id]
+   else  
+   if params[:table][:name]==params[:old_name]
+    flash[:notice] = 'Table named unchanged.'
+    redirect_to :action => 'list'
+   else 
+    @table = Table.find(params[:id])
+    params[:table][:name]=prepare_for_table(params[:table][:name].pluralize)
+      #we need to update the foreign key names
+      related=find_related("#{params[:old_name].pluralize}")
+      related.each do |relation|
+       if (relation.relation_type=="one-to-many" or relation.relation_type=="one-to-one") and relation.referenced == params[:old_name].pluralize #if the old table was referenced,we have to rename the OLDTABLENAME_id in NEWTABLENAME_id
+        table_field=TableField.find(relation.table_field_id)
+        table_field.name = "#{params[:table][:name].singularize}_id"
+        table_field.save
+        ActiveRecord::Migration.rename_column relation.referencing,"#{params[:old_name]}_id","#{params[:table][:name].singularize}_id"
+       end 
+      end
+    if @table.update_attributes(params[:table])
+      
+      related=find_related(@table.name)
+      related.each do |relation|
+       if relation.relation_type=="many-to-many"
+       if relation.referencing == @table.name 
+        if @table.name < relation.referenced
+         join_table_name="#{@table.name}_#{relation.referenced}"
+        else 
+         join_table_name="#{relation.referenced}_#{@table.name}"
+        end 
+       else
+        if relation.referencing < @table.name
+         join_table_name="#{relation.referencing}_#{@table.name}"
+        else 
+         join_table_name="#{@table.name}_#{relation.referencing}"
+        end         
+       end
+
+        ActiveRecord::Migration.rename_table relation.join_table, join_table_name #renaming the join table of database
+        join=Table.find_by_name(relation.join_table) #renaming the join table from the list of the tables in Tables
+        join.name=join_table_name
+        join.save
+        r=Relation.find(relation.id_r) #renaming the join table name from the relation row
+        r.join_table=join_table_name
+        r.save
+        
+        #finding old join table name for update the join table name in the 1-n relations for join table 
+        r=Relation.find_by_sql("SELECT t2.name as referencing,t1.name as referenced,join_table,r.id as id_r  
+            FROM relations r,table_fields tf,tables t1,tables t2 
+            WHERE r.table_field_id=tf.id and r.table_id=t1.id and tf.table_id=t2.id and for_join_table=\"yes\" and t2.name=\"#{join_table_name}\"")
+        r.each {|row|
+        rel=Relation.find(row.id_r)
+        rel.join_table=join_table_name
+        rel.save           
+        }    
+        end
+      end
+       
+      ActiveRecord::Migration.rename_table params[:old_name].pluralize, @table[:name]
+     
+      if join=Relation.find_all_by_join_table(params[:old_name].pluralize) #if the renamed table is a join table 
+       join.each {|r|
+         r.join_table=@table.name
+         r.save
+         }
+         
+       end
+     
+      flash[:notice] = 'Table was successfully updated.'
+      redirect_to :action => 'show', :id => @table
+    else
+      @table.name=Table.find(params[:id]).name.singularize
+      render :action => 'edit'
+    end
+    end
+   end 
+  end
+
+  def destroy
+    table=Table.find(params[:id])
+
+    #finding if the table to destroy contains relations
+    related=find_related(table.name)
+    to_erase=[]
+    #deleting relation from model files
+    related.each do |row|
+     if row.relation_type=="one-to-one" || row.relation_type=="one-to-many"
+      TableField.destroy(row.table_field_id) #removing column REFERENCEDTABLE_id from list of table fields
+      begin
+       ActiveRecord::Migration.remove_column row.referencing,"#{row.referenced.singularize}_id" #removing column REFERENCEDTABLE_id from the referencing table
+      rescue
+      end
+     end
+     if row.relation_type=="many-to-many" #if the table has a many-to-many relation,we have to destroy the join table
+      to_erase << row.join_table #but first we have to remove all column of 1-1 and 1-n relations, else an exception will be thrown
+     end
+     end
+    to_erase.each do |t|
+      begin
+       ActiveRecord::Migration.drop_table t #destroying join tables
+       Table.find_by_name(t).destroy
+    
+      rescue
+      end 
+    end
+    begin
+     ActiveRecord::Migration.drop_table table.name #drop the table destroyed
+    rescue
+    end
+    
+    #deleting relations if table deleted is a join table
+    Relation.find_all_by_join_table(table.name).each {|r| r.destroy}
+       
+    table.destroy
+ 
+    flash[:notice] = 'Table was succesfully deleted.'
+    redirect_to :action => 'list'
+  end
+  
+  def attributes
+    @table = Table.find(params[:id])
+    @attr_types = AttrType.find(:all)
+    session[:rows] = 1
+  end
+  
+  def add_field
+    @attr_types = AttrType.find(:all)
+    session[:rows]+=1
+    render :partial => "field"
+  end
+  
+  def generate_table
+   rows=session[:rows]
+   table_id=params[:table_id]
+   table_name=params[:table_name]
+   if rows > 0
+    #we insert the primary key into the table containing the table fields
+    id_integer=AttrType.find_by_name("integer").id
+    TableField.create(:name => "id", :attr_type_id => id_integer, :table_id => table_id)
+    
+    i=1
+    while i <= rows
+     unless params["table_field#{i}"]["attr_name"]==""
+      TableField.create(:name => prepare_for_table(params["table_field#{i}"]["attr_name"]), :attr_type_id => params["table_field#{i}"]["attr_type"], :is_unique => params["table_field#{i}"]["unique"],:is_not_null => params["table_field#{i}"]["not_null"], :table_id => table_id)
+     end
+     i+=1
+    end 
+      
+   ActiveRecord::Migration.create_table table_name, :force => true do |t|
+    i=1
+    @unique_fields=[] #will contain all fields that must be unique
+    while i <= rows
+     unless params["table_field#{i}"]["attr_name"]==""
+      if params["table_field#{i}"]["not_null"]=="1" #if the not-null checkbox has been checked
+       null = false
+      else
+       null = true
+      end 
+      if params["table_field#{i}"]["unique"]=="1" #if the unique checkbox has been checked
+       @unique_fields << params["table_field#{i}"]["attr_name"].gsub(/ +/,"_").downcase
+      end 
+       t.column params["table_field#{i}"]["attr_name"].gsub(/ +/,"_").downcase, AttrType.find(params["table_field#{i}"]["attr_type"]).name, :null =>  null
+     end
+     i+=1
+    end   
+   end
+   @unique_fields.each {|f|
+   ActiveRecord::Migration.add_index table_name, f, :unique => true
+   }
+     flash[:notice] = "Table's attributes were succesfully created."
+     redirect_to :action => 'list', :controller => 'tables'
+   end  
+  end
+  
+  def relations
+   @relations=Relation.find(:all, :conditions => "for_join_table <> \"yes\"")
+  end
+  
+  def add_relation
+   
+    @all_tables=Table.find_all.map {|u| [u.name,u.id] }
+    @tables="<option></option>"
+    @all_tables.each {|t| string="<option value='#{t[1]}'>#{t[0]}</option>"
+           @tables += string}
+   render :partial => "tables"
+  end
+  
+  def check_tables
+    @first_table=params[:first_table]
+    @second_table=params[:second_table]
+    @all_tables=Table.find_all.map {|u| [u.name,u.id] }
+    @tables="<option></option>"
+    @all_tables.each {|t| string="<option value='#{t[1]}'>#{t[0]}</option>"
+           @tables += string}
+    if @first_table.empty? or @second_table.empty?
+     @error="Please select the tables!"
+     render :partial => "tables"
+    else
+     if @first_table==@second_table
+      @error="Please select different tables!"
+      render :partial => "tables"     
+     else
+      @first=Table.find(@first_table)
+      @second=Table.find(@second_table)
+      render :partial => "relation_types"
+     end
+    end    
+   else 
+  end
+      
+  def foreign_key
+    @field=TableField.find(params[:id])
+    @tables=Table.find_all
+    @type=params[:type].to_s
+    render :partial => "fk"
+  end
+  
+  def join_table_name
+   @first=Table.find(params[:first])
+   @second=Table.find(params[:second])
+   session[:rows] = 0
+   render :partial => "join_table_name"
+  end
+  
+  def cascade
+   @relation=params[:relation_type] 
+   @referencing=Table.find(params[:second])
+   @referenced=Table.find(params[:first])  
+   render :partial => "cascade"
+  end
+  
+  def generate_fk
+   relation=params[:relation_type]   
+   dependent=params[:cascade]
+   
+   #for one-to-one and one-to-many relations, we need to add a column "REFERENTED_TABLE_id" into the referenting table
+   if relation=="one-to-one" or relation=="one-to-many"
+    referenting_table=Table.find(params[:second])
+    referented_table=Table.find(params[:first])
+    create_column(referenting_table,referented_table)
+    create_relation(referenting_table,referented_table,relation,dependent,"no","")
+   end
+   
+   #name of the tables with many-to-many relation
+   first_table=Table.find(params[:first])
+   second_table=Table.find(params[:second])
+   
+   if relation=="many-to-many"
+    #the name of the join table 
+    if params[:table_name] != "" #a name for the join table has been selected
+     table_name=prepare_for_table(params[:table_name].pluralize)
+    else #we create a default name composed of the two table names in alphabetical order
+     if first_table.name < second_table.name
+      table_name="#{first_table.name}_#{second_table.name}"
+     else
+      table_name="#{second_table.name}_#{first_table.name}"
+     end
+    end   
+    
+    #the join table must be found or added in Tables table
+    unless join_table=Table.find_by_name(table_name)
+     join_table=Table.create(:name => table_name)
+    end
+    
+    #the number of rows of the join table
+    rows=session[:rows]
+    if rows > 0 #if columns are added
+     i=1
+     while i <= rows
+      unless params["table_field#{i}"]["attr_name"]==""
+       TableField.create(:name => prepare_for_table(params["table_field#{i}"]["attr_name"]), :attr_type_id => params["table_field#{i}"]["attr_type"], :is_unique => params["table_field#{i}"]["unique"], :is_not_null => params["table_field#{i}"]["not_null"], :table_id => join_table.id)
+      end
+      i+=1
+     end 
+    end
+    
+    #we need to create a join table that will contains the relations between tables
+    
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+     i=1
+     while i <= rows
+      @unique_fields=[] #will contain all fields that must be unique
+      unless params["table_field#{i}"]["attr_name"]==""
+       if params["table_field#{i}"]["not_null"]=="1" #if the not-null checkbox has been checked
+        null = false
+       else
+        null = true
+       end 
+       if params["table_field#{i}"]["unique"]=="1" #if the unique checkbox has been checked
+        @unique_fields << params["table_field#{i}"]["attr_name"].gsub(/ +/,"_").downcase
+       end 
+       t.column prepare_for_table(params["table_field#{i}"]["attr_name"]), AttrType.find(params["table_field#{i}"]["attr_type"]).name, :null => null
+      end
+      i+=1
+     end
+    end 
+     @unique_fields.each {|f|
+   ActiveRecord::Migration.add_index table_name, f, :unique => true
+   }
+ 
+    
+   
+    create_column(join_table,first_table)
+    create_column(join_table,second_table)
+    create_relation(join_table,first_table,"one-to-many",dependent,"yes",join_table.name)
+    create_relation(join_table,second_table,"one-to-many",dependent,"yes",join_table.name)
+    create_relation(first_table,second_table,"many-to-many",dependent,"no",join_table.name)
+   end
+   
+   flash[:notice] = "Relation succesfully created."
+   redirect_to :action => "relations"
+  end
+  
+  def destroy_relation
+   relation=find_related_table(params[:id])
+   
+    if relation.relation_type=="many-to-many"
+     table=Table.find_by_name(relation.join_table).destroy
+    end
+     
+    if relation.relation_type=="one-to-one" || relation.relation_type=="one-to-many"
+     begin
+      ActiveRecord::Migration.remove_column relation.referencing,"#{relation.referenced.singularize}_id"
+     rescue
+     end
+    end 
+   Relation.find(params[:id]).destroy
+   flash[:notice]="Relation was succesfully destroy."
+   redirect_to :action => "relations"
+  end
+  
+  
+  def scaffold
+   scaffolds = Scaffold.find_all #list of all scaffolds created
+   scaffolds.each do |l| #deleting all scaffolds
+    system("ruby script/destroy scaffold #{l.name}")
+    FileUtils.remove_dir("app/views/#{l.name.pluralize}" , :force => true)  
+    l.destroy  
+   end
+   tables = Table.find_by_sql("SELECT name FROM tables") #selecting all tables
+   tables.each do |t|
+    system("ruby script/generate scaffold #{t.name.singularize} -f") #creating scaffolds for the tables
+    Scaffold.create(:name => t.name.singularize)
+   end
+   relations = find_all_relations
+   relations.each do |r|
+   if r.relation_type=="one-to-many" and r.for_join_table=="no"
+    write_into_model_file(r.referencing.singularize,"belongs_to",r.referenced.singularize,"")
+    write_into_model_file(r.referenced.singularize,"has_many",r.referencing,",:dependent => :#{r.dependent}")
+   end
+   
+   if r.relation_type=="one-to-one"
+    write_into_model_file(r.referencing.singularize,"belongs_to",r.referenced.singularize,"")
+    write_into_model_file(r.referenced.singularize,"has_one",r.referencing.singularize,",:dependent => :#{r.dependent}")
+   end   
+   
+   if r.relation_type=="many-to-many"
+    #relations between the join table and the first table
+    write_into_model_file(r.join_table.singularize,"belongs_to",r.referencing.singularize,"")
+    write_into_model_file(r.referencing.singularize,"has_many",r.join_table,",:dependent => :#{r.dependent}")
+    #relations between the join table and the second table
+    write_into_model_file(r.join_table.singularize,"belongs_to",r.referenced.singularize,"")
+    write_into_model_file(r.referenced.singularize,"has_many",r.join_table,",:dependent => :#{r.dependent}")
+    write_validation(r.join_table.singularize,r.join_table.singularize.camelize,r.referencing.singularize,r.referenced.singularize)
+   end
+    
+   end
+   flash[:notice]="Scaffolds succesfully created."
+   redirect_to :controller => "begin"
+  end
+  
+  def new_field
+    @table = Table.find(params[:id])
+    @attr_types = AttrType.find(:all)
+  end
+  
+  def create_field
+   @table=Table.find(params[:id])
+   if params[:table_field]=="" #field name can't be blank
+    flash[:notice]="Field name can't be blank!"
+    redirect_to :action => "new_field", :id => @table
+   else 
+    field_name=prepare_for_table(params[:table_field])
+    #field name can't be the same of another field of the same table
+    TableField.find_all_by_table_id(params[:id]).each {|f| 
+      if f.name==field_name and f.id.to_i!=params[:id].to_i
+       flash[:notice]="Field name already exists!"
+       redirect_to :action => "new_field", :id => @table and return
+      end      
+      }
+    TableField.transaction do 
+      if params["not_null"]=="1" #if the not-null checkbox has been checked
+       null = false
+      else
+       null = true
+      end 
+      if params["unique"]=="1" #if the not-null checkbox has been checked
+       unique = true
+      else
+       unique = false
+      end 
+     TableField.create(:name => field_name, :attr_type_id => params[:type], :is_not_null => !null, :is_unique => unique, :table_id => @table.id) 
+     begin
+      ActiveRecord::Migration.add_column(@table.name,field_name,AttrType.find(params[:type]).name.to_sym, :null => null) 
+     rescue
+      ActiveRecord::Migration.create_table @table.name do |f| end
+      id_integer=AttrType.find_by_name("integer").id
+      TableField.create(:name => "id", :attr_type_id => id_integer, :table_id => @table.id) 
+      ActiveRecord::Migration.add_column(@table.name,field_name,AttrType.find(params[:type]).name.to_sym, :null => null)
+     end
+     if params["unique"]=="1" #if the unique checkbox has been checked
+      ActiveRecord::Migration.add_index(@table.name,field_name,:unique => true)
+     end  
+    end
+    flash[:notice]="Field succesfully created."
+    redirect_to :action => "show", :id => @table 
+   end
+  end
+  
+  def edit_field
+   @field=TableField.find(params[:id],:include => :table)
+   @attr_types = AttrType.find(:all)
+  end
+  
+  def update_field
+   @field=TableField.find(params[:id],:include => :table)
+   if params[:table_field]=="" #field name can't be blank
+    flash[:notice]="Field name can't be blank!"
+    redirect_to :action => "edit_field", :id => @field
+   else 
+    field_name=prepare_for_table(params[:table_field])
+    #field name can't be the same of another field of the same table
+    TableField.find_all_by_table_id(@field.table.id).each {|f| 
+      if f.name==field_name and f.id.to_i!=params[:id].to_i
+       flash[:notice]="Field name already exists!"
+       redirect_to :action => "edit_field", :id => @field and return
+      end      
+      }
+      if params[:is_not_null].nil?
+       is_not_null=0
+       null=true
+      else
+       is_not_null=1
+       null=false
+      end  
+      if params[:is_unique].nil?
+       is_unique=0
+       #removing the index if the column was unique
+       ActiveRecord::Migration.remove_index(@field.table.name,field_name) if @field.is_unique
+      else
+       is_unique=1
+       #adding the index if the column wasn't unique
+       ActiveRecord::Migration.add_index(@field.table.name,field_name,:unique => true) unless @field.is_unique
+      end  
+    TableField.find(@field).update_attributes(:name => field_name, :attr_type_id => params[:type], :is_not_null => is_not_null, :is_unique => is_unique)
+    ActiveRecord::Migration.rename_column(@field.table.name,params[:old_field_name],field_name)  
+    ActiveRecord::Migration.change_column(@field.table.name,field_name,AttrType.find(params[:type]).name.to_sym, :null => null) 
+    
+    flash[:notice]="Field name succesfully updated."
+    redirect_to :action => "show", :id => @field.table 
+   end
+  end
+  
+  def destroy_field
+   field=TableField.find(params[:id],:include => :table)
+   TableField.transaction do
+    ActiveRecord::Migration.remove_column(field.table.name,field.name)
+    field.destroy
+   end
+   flash[:notice]="Field was succesfully destroy."
+   redirect_to :action => "show", :id => field.table 
+  end
+    
+  private
+  
+  def prepare_for_table(string)
+   string.gsub(/ +/,"_").downcase
+  end
+  
+  def create_column(referenting_table,referented_table)
+   begin
+     #normally,the column REFERENTED_TABLE_id doesn't exists and should be created. But if exists,an exception will be thrown. So,we need to manage this kind of exception
+     ActiveRecord::Migration.add_column referenting_table.name, "#{referented_table.name.singularize}_id", :integer
+     id_integer=AttrType.find_by_name("integer").id
+     TableField.create(:name => "#{referented_table.name.singularize}_id", :attr_type_id => id_integer, :table_id => referenting_table.id)
+    rescue
+    end
+   end
+  
+  def create_relation(referenting_table,referented_table,relation_type,cascade,for_join,join_table)
+   if relation_type=="one-to-one" or relation_type=="one-to-many"
+    field=TableField.find_by_name_and_table_id("#{referented_table.name.singularize}_id",referenting_table.id)
+   end
+   if relation_type=="many-to-many"
+    field=TableField.find_by_name_and_table_id("id",referenting_table.id)
+   end 
+   if existing=Relation.find_by_table_field_id_and_table_id(field.id,referented_table.id)
+    existing.destroy
+   end
+   Relation.create(:table_field_id => field.id, :table_id => referented_table.id, :relation_type => relation_type, :dependent => cascade, :for_join_table => for_join, :join_table => join_table)
+  end
+  
+    
+  def write_into_model_file(model_file,relation,related_table,option)
+   find_num_lines(model_file)
+   write_relation(model_file,relation,related_table,option)
+  end
+  
+  #calculating model file's number of rows
+  def find_num_lines(file)
+   File.open "app/models/#{file}.rb", "r" do |file|
+    @num_lines=0
+    file.each {|l| @num_lines+=1}
+   end
+  end
+  
+  #inserting the relation in the referented model
+  def write_relation(file_to_open,relation,related_table,dependency)
+   File.open "app/models/#{file_to_open}.rb", "r+" do |file|
+    file.each {|l| 
+     if file.lineno==@num_lines-1 
+      file << "\n#{relation} :#{related_table}#{dependency}\nend"
+     end}    
+   end
+  end 
+  
+  #inserting the validation into join table model
+  def write_validation(file_to_open,join_table_class,table1,table2)
+   find_num_lines(file_to_open)
+   File.open "app/models/#{file_to_open}.rb", "r+" do |file|
+    file.each {|l| 
+     if file.lineno==@num_lines-1 
+      file << "\ndef validate\nif !#{table1}_id.nil? and !#{table2}_id.nil? and #{join_table_class}.find_by_#{table1}_id_and_#{table2}_id(#{table1}_id,#{table2}_id)\nobject_id=#{join_table_class}.find_by_#{table1}_id_and_#{table2}_id(#{table1}_id,#{table2}_id).id\n if object_id!=id\n  errors.add_to_base(\"(#{table1},#{table2}) already exists\")\nend\nend\nend\nend"
+     end}    
+   end
+  end
+  
+  def destroy_many_to_many_relation(table_name)
+   begin #if the table is a join table,we need to destroy the relation between the related tables 
+    if relation=Relation.find_by_join_table(table_name)
+     related=find_related_table(relation.id)
+     delete_relation_from_file(related)
+     relation.destroy
+    end
+   rescue
+   end
+  end
+  
+  def find_related_table(id_r)
+   return Relation.find_by_sql("SELECT t2.name as referencing,t1.name as referenced,relation_type,join_table,for_join_table  
+            FROM relations r,table_fields tf,tables t1,tables t2 
+            WHERE r.table_field_id=tf.id and r.table_id=t1.id and tf.table_id=t2.id and r.id=#{id_r}").first
+  
+  end
+  
+  def find_related(table_name)
+   return Relation.find_by_sql("SELECT t2.name as referencing,t1.name as referenced,relation_type,join_table,for_join_table,table_field_id,r.id as id_r  
+            FROM relations r,table_fields tf,tables t1,tables t2 
+            WHERE r.table_field_id=tf.id and r.table_id=t1.id and tf.table_id=t2.id and (t1.name=\"#{table_name}\" or t2.name=\"#{table_name}\")")  
+  end
+  
+  def find_all_relations()
+   return Relation.find_by_sql("SELECT t2.name as referencing,t1.name as referenced,relation_type,dependent,join_table,for_join_table,table_field_id,r.id as id_r  
+            FROM relations r,table_fields tf,tables t1,tables t2 
+            WHERE r.table_field_id=tf.id and r.table_id=t1.id and tf.table_id=t2.id")
+  
+  end
+  
+  def delete_relation_from_file(object)
+   if object.relation_type == "one-to-one"
+      #reading the file
+       read_file(object.referencing)
+     
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /:#{object.referenced.singularize}/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referencing) 
+      
+      read_file(object.referenced)
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /:#{object.referencing.singularize}/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referenced)               
+          
+   end
+   
+   if object.relation_type == "one-to-many"
+      #reading the file
+       read_file(object.referencing)
+
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /belongs_to :#{object.referenced.singularize}/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referencing)
+      
+      read_file(object.referenced)
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /has_many :#{object.referencing}/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referenced)      
+          
+   end
+   
+   if object.relation_type == "many-to-many"  
+   
+        read_file(object.referencing)
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /has_many :(#{object.join_table}|#{object.referenced})/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referencing)
+      
+       read_file(object.referenced)
+      @old_file.each {|row|
+      #in the new file the row to erase will not be present
+      if row =~ /has_many :(#{object.join_table}|#{object.referencing})/
+      else
+       @new_file << row
+      end
+      }
+      write_file(object.referenced)
+
+    FileUtils.remove_dir("app/views/#{object.join_table}" , :force => true)
+   
+   end
+
+  end
+   
+  def read_file(object)
+   @old_file=[]
+   File.open "app/models/#{object.singularize}.rb", "r+" do |file|
+    file.each {|l| @old_file << l}
+   end
+   @new_file=[]
+  end 
+  
+  def write_file(object)
+   File.open "app/models/#{object.singularize}.rb", "w" do |file|
+    @new_file.each do |row|
+     file << row
+    end 
+   end   
+  end
+   
+end