legacy_data 0.1.8 → 0.1.9

data/lib/legacy_data.rb

@@ -1,12 +1,15 @@
+require 'foreigner' #matthuhiggens-foreigner
+
 require 'legacy_data/table_definition'
 require 'legacy_data/schema'
 require 'legacy_data/table_class_name_mapper'
 
-
 module ActiveRecord  
   Base.class_eval do
     if ['OracleEnhanced'].include? connection.adapter_name
-      require "#{File.dirname(__FILE__)}/active_record/connection_adapters/#{connection.adapter_name.underscore}_adapter"
+      # require "#{File.dirname(__FILE__)}/active_record/connection_adapters/#{connection.adapter_name.underscore}_adapter"
+      require "#{File.dirname(__FILE__)}/active_record/connection_adapters/#{connection.adapter_name.downcase}_adapter"
     end
   end
 end
+

data/lib/legacy_data/schema.rb

@@ -28,14 +28,14 @@ module LegacyData
       if table_name
         add_pending_table(table_name)
       else
-        LegacyData::Schema.tables.each {|table| add_pending_table(table) }
+        self.tables.each {|table| add_pending_table(table) }
       end
     end
     def self.add_pending_table table_name
       table_definitions[table_name] = :pending if table_definitions[table_name].nil?
     end
     def self.next_table_to_process
-      table_definitions.keys.detect {|table_name| table_definitions[table_name] == :pending }
+      table_definitions.keys.map(&:to_s).sort.detect {|table_name| table_definitions[table_name] == :pending }
     end
     def self.clear_table_definitions
       @tables = {}
@@ -88,6 +88,7 @@ module LegacyData
         elsif connection.respond_to?(:primary_key)
           @pk = connection.primary_key(table_name)
         end
+        @pk = 'no_primary_key' if @pk.nil?
       end
       @pk
     end
@@ -100,11 +101,13 @@ module LegacyData
     end
     
     def belongs_to_relations
-      return {} unless connection.respond_to? :foreign_keys_for
-      
+      return {} unless connection.respond_to? :foreign_keys
+
       belongs_to = {}
-      connection.foreign_keys_for(table_name).each do |relation|
-        belongs_to[relation.first.downcase] = {:foreign_key=>relation.second.downcase.to_sym}
+      connection.foreign_keys(table_name).each do |foreign_key|
+        options = {:foreign_key=>foreign_key.options[:column].downcase.to_sym}
+        options[:dependent] = :destroy if foreign_key.options[:dependent] == :delete
+        belongs_to[foreign_key.to_table.downcase] = options
       end
       belongs_to
     end
@@ -200,7 +203,7 @@ module LegacyData
     
     private
     def self.connection 
-      @conn ||= ActiveRecord::Base.connection
+      ActiveRecord::Base.connection
     end
     def connection
       self.class.connection

data/lib/legacy_data/table_class_name_mapper.rb

@@ -56,7 +56,7 @@ Done analyzing the tables.
     def compute_class_name table_name
       table_name =~ /#{naming_convention}/i
       stripped_table_name = $1 || table_name
-      dictionary[table_name] = ActiveRecord::Base.class_name(stripped_table_name.downcase.pluralize)
+      dictionary[table_name] = ActiveRecord::Base.class_name(stripped_table_name.underscore.downcase.pluralize)
     end
     
     def self.log msg

data/lib/legacy_data/table_definition.rb

@@ -10,14 +10,129 @@ module LegacyData
       self.send(key)
     end
     
-    def to_hash
-      hash = {}
-      [:class_name, :table_name, :columns, :primary_key, :relations, :constraints].each {|field| hash[field] = self.send(field) }
-      hash
+    def unconventional_table_name?
+      table_name != class_name.underscore.pluralize
+    end
+
+    def unconventional_primary_key?
+      puts self.inspect if primary_key.nil?
+      primary_key != 'id'
+    end
+
+    def relationships_to_s
+      relationships_text = []
+      [:has_many, :has_one, :belongs_to, :has_and_belongs_to_many].each do |relation_type|
+        is_singular_association = [:has_one, :belongs_to].include?(relation_type)
+        unless relations[relation_type].nil?
+          association_with_longest_name = longest_association_name(relations[relation_type], is_singular_association)
+          
+          relations[relation_type].keys.sort.each do |table_name|
+            options =  relations[relation_type][table_name]
+            class_for_table = TableDefinition.class_name_for(table_name)
+            association_name = class_for_table.underscore
+            association_name = association_name.pluralize unless is_singular_association
+            needs_class_name = (ActiveRecord::Base.class_name(association_name.pluralize) != class_for_table)
+            options[:class_name] = class_for_table if needs_class_name
+
+            spaces = association_with_longest_name.size - association_name.size
+            relationships_text << "#{relation_type} #{association_name.to_sym.inspect},#{' ' * spaces} #{options_to_s(options)}"
+          end
+        end
+      end
+      relationships_text.join "\n  "
+    end
+
+    def class_name
+      TableDefinition.class_name_for table_name
+    end
+    
+    def self.class_name_for table_name
+      LegacyData::TableClassNameMapper.class_name_for(table_name)
+    end
+    
+    def longest_association_name(associations, is_singular_association)
+      association_names = associations.keys.map do |assoc| 
+        association_name = TableDefinition.class_name_for(assoc).underscore
+        association_name = association_name.pluralize unless is_singular_association
+        association_name
+      end
+      association_with_longest_name = association_names.max { |a,b| a.length <=> b.length }
+    end
+
+    def options_to_s options
+      alphabetized_option_keys = options.keys.map(&:to_s).sort
+      alphabetized_option_keys.map do |key|
+        "#{key.to_sym.inspect} => #{options[key.to_sym].inspect}"
+      end.join(', ')
+    end
+    
+    def constraints_to_s
+      alphabetized_constraints_types = constraints.keys.map(&:to_s).sort
+      constraints_text = alphabetized_constraints_types.map do |constraint_type|
+        self.send("#{constraint_type}_constraints_to_s") unless constraints[constraint_type.to_sym].blank?
+      end
+      constraints_text.flatten.reject(&:nil?).join("\n  ")
+    end
+    
+    def unique_constraints_to_s
+      cols_list = constraints[:unique].map {|cols| cols.downcase.to_sym.inspect}.join(', ')
+      "validates_uniqueness_of #{cols_list}" 
+    end
+
+    def multi_column_unique_constraints_to_s
+      constraints[:multi_column_unique].map do |cols| 
+        "#validates_uniqueness_of_multiple_column_constraint #{cols.inspect}"
+      end
+    end
+
+    def presence_of_constraints_to_s
+      cols_list = constraints[:presence_of].map {|cols| cols.downcase.to_sym.inspect}.join(', ')
+      "validates_presence_of #{cols_list}"
+    end
+
+    def inclusion_of_constraints_to_s
+      constraints[:inclusion_of].keys.map do |col|
+        <<-OUTPUT
+  def self.possible_values_for_#{col}
+    #{constraints[:inclusion_of][col].inspect}
+  end
+  validates_inclusion_of #{col.to_sym.inspect},
+                         :in      => possible_values_for_#{col}, 
+                         :message => "is not one of (\#{possible_values_for_#{col}.join(', ')})"
+        OUTPUT
+      end
+    end
+
+    def numericality_of_constraints_to_s
+      [:allow_nil, :do_not_allow_nil].map do |nullable| 
+        if constraints[:numericality_of][nullable].blank? 
+          []
+        else
+          cols_list = constraints[:numericality_of][nullable].map {|cols| cols.downcase.to_sym.inspect}.join(', ')
+          "validates_numericality_of #{cols_list}#{", {:allow_nil=>true}" if nullable == :allow_nil }"
+        end
+      end unless constraints[:numericality_of].blank? 
+    end
+
+    def custom_constraints_to_s
+      constraints[:custom].keys.map do |name|
+        <<-OUTPUT
+  validate #{"validate_#{name}".to_sym.inspect }
+  def validate_#{name}
+    # TODO: validate this SQL constraint
+    <<-SQL
+      #{constraints[:custom][name]}
+    SQL
+  end
+        OUTPUT
+      end
     end
     
     def join_table?
-      (columns.size == 2) and relations[:belongs_to] and (relations[:belongs_to].values.map {|value| value[:foreign_key]}.map(&:to_s) == columns)
+      return false unless (columns.size == 2) and relations[:belongs_to] and (relations[:belongs_to].values.size == 2)
+      column_names      = columns.map(&:name)
+      foreign_key_names = relations[:belongs_to].values.map {|value| value[:foreign_key]}.map(&:to_s) 
+      return column_names.sort == foreign_key_names.sort
     end
     
     def belongs_to_relations

data/spec/expected/post.rb

@@ -1,12 +1,12 @@
 class Post < ActiveRecord::Base
-  set_table_name :posts
-  set_primary_key :id
+  
+  
   
   # Relationships
   has_many :comments, :foreign_key => :comment_id
 
   # Constraints
-  validates_uniqueness_of :title
   validates_presence_of :body
+  validates_uniqueness_of :title
 end
 

data/spec/functional/blog_adapterspec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/functional_spec_helper')
+
+
+describe "Generating models from a blog #{ENV['ADAPTER']} database" do
+  before :all do
+    @adapter = ENV['ADAPTER']
+    @example = :blog
+
+    connection_info = connection_info_for(@example, @adapter) 
+    pending("The #{@example} spec does not run for #{@adapter}") if connection_info.nil?
+    initialize_connection connection_info
+
+    require File.expand_path(File.dirname(__FILE__) + '/../../examples/blog_migration')
+    create_blog_tables
+        
+    silence_warnings { RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../output/functional/#{@example}_#{@adapter}") } 
+    FileUtils.mkdir_p(RAILS_ROOT + '/app/models')
+    FileUtils.mkdir_p(RAILS_ROOT + '/spec')
+    
+    LegacyData::Schema.stub!(:log)    
+
+    @expected_directory = File.expand_path("#{File.dirname(__FILE__)}/../../examples/generated/#{@example}_#{@adapter}") 
+  end
+  after :all do
+    Object.send(:remove_const, :RAILS_ROOT)
+  end
+  
+  before :each do #
+    pending("oracle does not yet work with t.foreign_key table creation") if @adapter == 'oracle'
+    FileUtils.rm(RAILS_ROOT + '/spec/factories.rb', :force => true)
+    invoke_generator('models_from_tables', ["--with-factories"], :create)
+  end
+
+  %w( post comment tag ).each do |model|
+    it "should generate the expected #{model} model" do
+      File.read(RAILS_ROOT + "/app/models/#{model}.rb").should == File.read("#{@expected_directory}/#{model}.rb")
+    end
+  end
+
+  it "should  generated the expected factories" do
+    File.read(RAILS_ROOT + '/spec/factories.rb').should == File.read("#{@expected_directory}/factories.rb")
+  end
+  
+end
+

data/spec/functional/database.yml

@@ -0,0 +1,45 @@
+# CREATE DATABASE legacy_data_blog;
+mysql_blog:
+  adapter:  mysql
+  database: legacy_data_blog
+  username: root
+  password: 
+
+sqlite3_blog:
+  adapter:  sqlite3
+  database: ':memory:'
+
+# CREATE USER legacy_data_blog IDENTIFIED BY legacy_data_blog;
+# GRANT ALL PRIVILEGES TO legacy_data_blog;
+oracle_blog:
+  adapter:  oracle_enhanced
+  database: localhost:1521/XE
+  username: legacy_data_blog
+  password: legacy_data_blog
+
+# CREATE DATABASE drupal_6_14;
+mysql_drupal:
+  adapter:  mysql
+  database: drupal_6_14
+  username: root
+  password: 
+
+# CREATE DATABASE j2ee_petstore;
+mysql_j2ee_petstore:
+  adapter:  mysql
+  database: j2ee_petstore
+  username: root
+  password: 
+
+sqlite3_j2ee_petstore:
+  adapter:  sqlite3
+  database: ':memory:'
+
+# CREATE USER petstore IDENTIFIED BY petstore;
+# GRANT ALL PRIVILEGES TO petstore;
+oracle_j2ee_petstore:
+  adapter:  oracle_enhanced
+  database: localhost:1521/XE
+  username: petstore
+  password: petstore
+

data/spec/functional/drupal_adapterspec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/functional_spec_helper')
+
+if ENV['ADAPTER'] == 'mysql'
+
+  def create_drupal_schema
+    execute_sql_script(File.expand_path(File.dirname(__FILE__) + '/../../examples/drupal_6_14.sql'))
+  end
+
+  describe "Generating models from a drupal 6.14 #{ENV['ADAPTER']} database" do
+    before :all do
+      @adapter = ENV['ADAPTER']
+      @example = :drupal
+      
+      connection_info = connection_info_for(@example, @adapter) 
+      pending("The #{@example} spec does not run for #{@adapter}") if connection_info.nil?
+      initialize_connection connection_info
+      create_drupal_schema
+        
+      silence_warnings { RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../output/functional/#{@example}_#{@adapter}") } 
+      FileUtils.mkdir_p(RAILS_ROOT + '/app/models')
+      FileUtils.mkdir_p(RAILS_ROOT + '/spec')
+      
+      LegacyData::Schema.stub!(:log)    
+
+      @expected_directory = File.expand_path("#{File.dirname(__FILE__)}/../../examples/generated/#{@example}_#{@adapter}") 
+      
+      LegacyData::TableClassNameMapper.dictionary['files'] = 'UploadedFiles'  #to avoid collision with Ruby File class
+      LegacyData::TableClassNameMapper.dictionary['cache'] = 'Cache'          #don't strip the e to make it cach
+
+      FileUtils.rm(RAILS_ROOT + '/spec/factories.rb', :force => true)
+      invoke_generator('models_from_tables', ["--with-factories"], :create)
+    
+    end
+    after :all do
+      Object.send(:remove_const, :RAILS_ROOT)
+    end
+      
+    %w( access       action        actions_aid  authmap        batch                  block        blocks_role 
+        box          cache         cache_block  cache_filter   cache_form             cache_menu   cache_page 
+        cache_update comment       filter       filter_format  flood                  history      menu_custom 
+        menu_link    menu_router   node         node_access    node_comment_statistic node_counter node_revision 
+        node_type    permission    role         session        system                 term_data    term_hierarchy 
+        term_node    term_relation term_synonym uploaded_files url_alias              user         users_role 
+        variable     vocabulary    vocabulary_node_type        watchdog ).each do |model|
+      it "should generate the expected #{model} model" do
+        File.read(RAILS_ROOT + "/app/models/#{model}.rb").should == File.read("#{@expected_directory}/#{model}.rb")
+      end
+    end
+    
+    it "should  generated the expected factories" do
+      File.read(RAILS_ROOT + '/spec/factories.rb').should == File.read("#{@expected_directory}/factories.rb")
+    end
+  end
+end

data/spec/functional/functional_spec_helper.rb

@@ -1,3 +1,27 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
+ADAPTER = ENV['ADAPTER']
 
+
+def initialize_connection connection_info
+  ActiveRecord::Base.establish_connection(connection_info)
+
+  begin
+    require "foreigner/connection_adapters/#{ActiveRecord::Base.connection.adapter_name.downcase}_adapter"
+  rescue LoadError
+    #foreigner does not support all adapters (i.e. sqlite3)
+  end
+end
+  
+
+def connection_info_for example, adapter
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  config["#{adapter}_#{example}"]
+end
+
+def execute_sql_script script_filename
+  sql_script = File.read script_filename
+  sql_script.split(';').each do |sql_statement|
+    ActiveRecord::Base.connection.execute(sql_statement) unless sql_statement.blank?
+  end
+end

data/spec/functional/j2ee_petstore_adapterspec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/functional_spec_helper')
+
+def create_j2ee_petstore_schema
+  execute_sql_script(File.expand_path(File.dirname(__FILE__) + '/../../examples/delete_j2ee_petstore.sql') ) unless ENV['ADAPTER'] == 'sqlite3' rescue nil
+  execute_sql_script(File.expand_path(File.dirname(__FILE__) + '/../../examples/create_j2ee_petstore.sql') )
+end
+
+describe "Generating models from j2ee petstore #{ENV['ADAPTER']} database" do
+  before :all do
+    @adapter = ENV['ADAPTER']
+    @example = :j2ee_petstore
+    
+    connection_info = connection_info_for(@example, @adapter) 
+    pending("The #{@example} spec does not run for #{@adapter}") if connection_info.nil?
+    initialize_connection connection_info
+    create_j2ee_petstore_schema
+      
+    silence_warnings { RAILS_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../output/functional/#{@example}_#{@adapter}") } 
+    FileUtils.mkdir_p(RAILS_ROOT + '/app/models')
+    FileUtils.mkdir_p(RAILS_ROOT + '/spec')
+  
+    LegacyData::Schema.stub!(:log)    
+
+    @expected_directory = File.expand_path("#{File.dirname(__FILE__)}/../../examples/generated/#{@example}_#{@adapter}") 
+    
+    LegacyData::TableClassNameMapper.dictionary['files'] = 'UploadedFiles'  #to avoid collision with Ruby File class
+    LegacyData::TableClassNameMapper.dictionary['cache'] = 'Cache'          #don't strip the e to make it cach
+
+    FileUtils.rm(RAILS_ROOT + '/spec/factories.rb', :force => true)
+    invoke_generator('models_from_tables', ["--with-factories"], :create)
+
+  end
+  
+  
+  after :all do
+    Object.send(:remove_const, :RAILS_ROOT)
+  end
+
+  models =  %w( address   category     id_gen       item           
+                product   tag          ziplocation       )
+  
+  if ENV['ADAPTER'] == 'oracle'              
+    models + %w( sellercontactinfo   ) 
+  else
+    models + %w( seller_contact_info tag_info) 
+  end
+                
+  models.each do |model|
+    it "should generate the expected #{model} model" do
+      File.read(RAILS_ROOT + "/app/models/#{model}.rb").should == File.read("#{@expected_directory}/#{model}.rb")
+    end
+  end
+  
+  it "should  generated the expected factories" do
+    File.read(RAILS_ROOT + '/spec/factories.rb').should == File.read("#{@expected_directory}/factories.rb")
+  end
+end