legacy_data 0.1.0

data/generators/models_from_tables/models_from_tables_generator.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../lib/legacy_data/table_definition'
+require File.dirname(__FILE__) + '/../../lib/legacy_data/schema'
+require File.dirname(__FILE__) + '/../../lib/legacy_data/table_class_name_mapper'
+require File.dirname(__FILE__) + '/../../lib/active_record/connection_adapters/oracle_enhanced_adapter'
+
+class ModelsFromTablesGenerator < Rails::Generator::Base  
+  def manifest
+    record do |m|
+      m.directory File.join('app/models')
+
+      LegacyData::TableClassNameMapper.naming_convention = options[:table_naming_convention]
+      
+      analyzed_tables = LegacyData::Schema.analyze(:table_name=>options[:table_name])
+      LegacyData::TableClassNameMapper.save_dictionary
+      puts <<-MSG
+Done analyzing the tables.  
+  Please review the class names shown above.  If any do not look correct (for example it did not separate the words with CamelCase) please supply the correct mappings by editing the file #{LegacyData::TableClassNameMapper.dictionary_file_name}.  
+  Once you're done hit <enter> to continue generating the models"
+      MSG
+      gets
+      LegacyData::TableClassNameMapper.load_dictionary
+
+      analyzed_tables.each do |analyzed_table|
+        analyzed_table.class_name = LegacyData::TableClassNameMapper.class_name_for(analyzed_table[:table_name])
+        m.class_collisions :class_path, analyzed_table[:class_name]
+        m.template           'model.rb',      
+                             File.join('app/models', "#{analyzed_table[:class_name].underscore}.rb"), 
+                             :assigns => analyzed_table.to_hash
+      end
+    end
+  rescue => e
+    puts e.backtrace
+  end
+
+protected
+  def add_options!(opt)
+    opt.on('--table-name [ARG]', 
+          'Only generate models for given table') { |value| options[:table_name] = value }
+    opt.on('--table-naming-convention [ARG]', 
+          'Naming convention for tables in the database - will not be used when generating naming the models') { |value| options[:table_naming_convention] = value }
+  end
+  
+end

data/generators/models_from_tables/templates/model.rb

@@ -0,0 +1,31 @@
+class <%= class_name -%> < ActiveRecord::Base
+  set_table_name <%= table_name.to_sym.inspect %>
+  <%= "set_primary_key #{primary_key.to_sym.inspect}" if primary_key %>
+  
+  # Relationships
+  <%- [:has_many, :has_one, :belongs_to, :has_and_belongs_to_many].each do |relation_type|
+        relations[relation_type].each do |table_name, options| 
+          class_for_table = LegacyData::TableClassNameMapper.class_name_for(table_name)
+          is_singular_association = [:has_one, :belongs_to].include?(relation_type)
+          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)
+        -%>  <%= relation_type %> <%= association_name.to_sym.inspect %>, <%=options.keys.map {|key| "#{key.to_sym.inspect} => #{options[key].to_sym.inspect}"}.join(', ')%><%= ", :class_name=>'#{class_for_table}'" if needs_class_name %>
+  <%-   end unless relations[relation_type].nil?
+      end 
+  -%>
+
+  # Constraints
+  <%= "validates_uniqueness_of #{constraints[:unique    ].map {|cols| cols.first.downcase.to_sym.inspect}.join(', ')}" unless constraints[:unique].blank? %>
+  <%- constraints[:multi_column_unique].each do |cols| 
+  -%>  #validates_uniqueness_of_multiple_column_constraint :<%= cols.inspect %>
+  <%- end -%>
+  <%= "validates_presence_of #{constraints[:non_nullable].map {|cols| cols.downcase.to_sym.inspect}.join(', ')}" unless constraints[:non_nullable].blank? %>
+  <%- constraints[:custom].each do |name, sql_rule| 
+  -%>  validate <%= "validate_#{name}".to_sym.inspect %>
+  def <%= "validate_#{name}" %>
+    # TODO: validate this SQL constraint 
+    "<%= sql_rule %>"
+  end
+  <%- end %>
+end

data/legacy_data.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{legacy_data}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Rothenberg"]
+  s.date = %q{2009-10-01}
+  s.description = %q{Create ActiveRecord models from an existing database}
+  s.email = %q{alex@alexrothenberg.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/j2ee_petstore.sql",
+     "generators/models_from_tables/USAGE",
+     "generators/models_from_tables/models_from_tables_generator.rb",
+     "generators/models_from_tables/templates/model.rb",
+     "legacy_data.gemspec",
+     "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
+     "lib/legacy_data.rb",
+     "lib/legacy_data/schema.rb",
+     "lib/legacy_data/table_class_name_mapper.rb",
+     "lib/legacy_data/table_definition.rb",
+     "spec/legacy_data/schema_spec.rb",
+     "spec/legacy_data/table_class_name_mapper_spec.rb",
+     "spec/legacy_data/table_definition_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/alexrothenberg/legacy_data}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Create ActiveRecord models from an existing database}
+  s.test_files = [
+    "spec/legacy_data/schema_spec.rb",
+     "spec/legacy_data/table_class_name_mapper_spec.rb",
+     "spec/legacy_data/table_definition_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -0,0 +1,61 @@
+module OracleEnhancedAdapterConstraintsMethods
+
+  def foreign_keys_for(table_name)
+    (owner, table_name) = @connection.describe(table_name)
+
+    # RSI: changed select from all_constraints to user_constraints - much faster in large data dictionaries
+    fks = select_rows(<<-SQL, 'Foreign Keys')
+      select parent_c.table_name, cc.column_name
+        from user_constraints c, user_constraints parent_c, user_cons_columns cc
+      where c.owner = '#{owner}'
+        and c.table_name = '#{table_name}'
+        and c.r_constraint_name = parent_c.constraint_name
+        and c.constraint_type = 'R'
+        and cc.owner = c.owner
+        and cc.constraint_name = c.constraint_name
+    SQL
+  end
+  def foreign_keys_of(table_name)
+    (owner, table_name) = @connection.describe(table_name)
+
+    # RSI: changed select from all_constraints to user_constraints - much faster in large data dictionaries
+    fks = select_rows(<<-SQL, 'Remote Foriegn Keys')
+      select c.table_name, cc.column_name, c.delete_rule 
+        from user_constraints c, user_constraints parent_c, user_cons_columns cc
+      where c.owner = '#{owner}'
+        and parent_c.table_name = '#{table_name}'
+        and c.r_constraint_name = parent_c.constraint_name
+        and c.constraint_type = 'R'
+        and cc.owner = c.owner
+        and cc.constraint_name = c.constraint_name
+    SQL
+    fks.map do |row| 
+      dependent = case row[2] 
+        when 'CASCADE'
+          :destroy
+        when 'SET NULL'
+          :nullify
+        end
+      options = {:to_table => row[0].downcase, :foreign_key =>row[1].downcase.to_sym }
+      options[:dependent] = dependent unless dependent.nil?
+      options
+    end
+  end
+
+  def constraints(table_name)
+    (owner, table_name) = @connection.describe(table_name)
+
+    # RSI: changed select from all_constraints to user_constraints - much faster in large data dictionaries
+    fks = select_rows(<<-SQL, 'User Contraints')
+      select c.constraint_name, c.search_condition
+        from user_constraints c
+      where c.owner = '#{owner}'
+        and c.table_name = '#{table_name}'
+        and c.constraint_type = 'C'
+        and c.generated = 'USER NAME'
+        and c.status = 'ENABLED'
+    SQL
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.send(:include, OracleEnhancedAdapterConstraintsMethods) if defined? ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter

data/lib/legacy_data/schema.rb

@@ -0,0 +1,155 @@
+module LegacyData
+  class Schema
+    attr_reader :table_name
+    
+    def self.analyze(options={})
+      initialize_tables(options[:table_name])
+
+      while table_name = next_table_to_process
+        table_definitions[table_name] = analyze_table(table_name)
+
+        [:has_many, :belongs_to].each do |relation_type| 
+          associated_tables = table_definitions[table_name][:relations][relation_type].keys.map(&:to_s) 
+          associated_tables.each {|associated_table| add_pending_table(associated_table) }
+        end
+      end
+
+      remove_join_tables
+    end
+    def self.analyze_table table_name
+      new(table_name).analyze_table
+    end
+    
+    
+    def self.initialize_tables(table_name)
+      clear_table_definitions
+      if table_name
+        add_pending_table(table_name)
+      else
+        LegacyData::Schema.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 }
+    end
+    def self.clear_table_definitions
+      @tables = {}
+    end
+    def self.table_definitions
+      @tables ||= {}
+    end
+    def self.next_join_table
+      table_definitions.keys.detect {|table_name| table_definitions[table_name].join_table? }
+    end
+    def self.remove_join_tables
+      join_tables, other_tables = table_definitions.values.partition &:join_table?
+
+      join_tables.each { |join_table| convert_to_habtm(join_table) }
+
+      other_tables
+    end
+    def self.convert_to_habtm join_table
+      join_table.belongs_to_tables.each do |table|
+        table_definitions[table].convert_has_many_to_habtm(join_table)
+      end
+    end
+    
+    def initialize(table_name)
+      @table_name = table_name
+    end
+    
+    def analyze_table
+      puts "analyzing #{table_name} => #{class_name}"
+      TableDefinition.new(:table_name   => table_name,
+                          :columns      => column_names,
+                          :primary_key  => primary_key,
+                          :relations    => relations,
+                          :constraints  => constraints
+                          )
+    end
+    
+    def self.tables 
+      connection.tables.sort
+    end
+    
+    def class_name
+      TableClassNameMapper.class_name_for(self.table_name)
+    end
+
+    def primary_key
+      pk_and_sequence_for = connection.pk_and_sequence_for(table_name)
+      pk_and_sequence_for.first if pk_and_sequence_for.respond_to? :first
+    end
+
+    def relations
+      { :belongs_to               => belongs_to_relations,
+        :has_many                 => has_some_relations,
+        :has_and_belongs_to_many  => {}
+      }
+    end
+    
+    def belongs_to_relations
+      return [] unless connection.respond_to? :foreign_keys_for
+      
+      belongs_to = {}
+      connection.foreign_keys_for(table_name).each do |relation|
+        belongs_to[relation.first.downcase] = {:foreign_key=>relation.second.downcase.to_sym}
+      end
+      belongs_to
+    end
+    def has_some_relations
+      return [] unless connection.respond_to? :foreign_keys_of
+
+      has_some = {}
+      connection.foreign_keys_of(table_name).each do |relation|
+        has_some[relation.delete(:to_table).downcase] = relation
+      end
+      has_some
+    end
+
+    def constraints
+      unique, multi_column_unique = unique_constraints.partition {|columns| columns.size == 1}
+      { :unique              => unique,
+        :multi_column_unique => multi_column_unique,
+        :non_nullable        => non_nullable_constraints,
+        :custom              => custom_constraints
+      }
+    end
+    
+    def columns
+      @columns ||= connection.columns(table_name, "#{table_name} Columns")
+    end
+    def column_names
+      columns.map(&:name)
+    end
+    def non_nullable_constraints
+      non_nullable_constraints = columns.reject(&:null).map(&:name)
+      non_nullable_constraints.reject {|col| col == primary_key}
+    end
+
+    def unique_constraints
+      connection.indexes(table_name).select(&:unique).map(&:columns)
+    end
+    
+    def custom_constraints
+      return [] unless connection.respond_to? :constraints
+      user_constraints = {}
+      connection.constraints(table_name).each do |constraint|
+        user_constraints[constraint.first.underscore.to_sym] = constraint.second
+      end
+      user_constraints
+    end    
+    private
+    def self.connection 
+      @conn ||= ActiveRecord::Base.connection
+    end
+    def connection
+      self.class.connection
+    end
+
+
+  end
+end

data/lib/legacy_data/table_class_name_mapper.rb

@@ -0,0 +1,52 @@
+module LegacyData
+  class TableClassNameMapper
+    include Singleton
+    
+    attr_accessor :naming_convention, :dictionary
+    def naming_convention= naming_convention
+      @naming_convention = (naming_convention || '*').gsub('*', '(.*)')
+    end
+    
+    def dictionary
+      @dictionary ||= load_dictionary
+    end
+
+    def self.method_missing(method_id, *arguments, &block)
+      instance.send(method_id, *arguments, &block)
+    end
+
+    def clear_dictionary
+      @dictionary = nil
+    end
+
+    def load_dictionary
+      clear_dictionary
+      File.exists?(dictionary_file_name) ? YAML.load_file(dictionary_file_name) : {}
+    end
+
+    def save_dictionary
+      File.open(dictionary_file_name, 'w') do |out|
+        YAML.dump(dictionary, out)
+      end
+    end
+    
+    def dictionary_file_name
+      File.join(RAILS_ROOT, 'app', 'models', 'table_mappings.yml')
+    end
+    
+    def class_name_for table_name
+      lookup_class_name(table_name) || compute_class_name(table_name)
+    end
+
+    def lookup_class_name table_name
+      dictionary[table_name]
+    end
+    
+    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)
+    end
+  end
+
+end

data/lib/legacy_data/table_definition.rb

@@ -0,0 +1,41 @@
+module LegacyData
+  class TableDefinition
+    attr_accessor :class_name, :table_name, :columns, :primary_key, :relations, :constraints
+
+    def initialize(options)
+      options.each {|key, value| self.send("#{key}=", value) }
+    end
+    
+    def [] key
+      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
+    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)
+    end
+    
+    def belongs_to_relations
+      return {} if relations.nil? or relations[:belongs_to].nil?
+      relations[:belongs_to]
+    end
+
+    def belongs_to_tables
+      return [] if belongs_to_relations == {}
+      belongs_to_relations.keys
+    end
+    
+    def convert_has_many_to_habtm(join_table)
+      other_table_name = join_table.belongs_to_tables.detect {|table_name| table_name != self.table_name}
+      relations[:has_and_belongs_to_many][other_table_name] = { :foreign_key            =>join_table.belongs_to_relations[table_name][:foreign_key], 
+                                                                :association_foreign_key=>join_table.belongs_to_relations[other_table_name][:foreign_key],
+                                                                :join_table             =>join_table.table_name.to_sym }
+      relations[:has_many].delete(join_table.table_name)                                                          
+    end
+  end
+end

data/lib/legacy_data.rb

@@ -0,0 +1,4 @@
+require 'legacy_data/table_definition'
+require 'legacy_data/schema'
+require 'legacy_data/table_class_name_mapper'
+require 'active_record/connection_adapters/oracle_enhanced_adapter'

data/spec/legacy_data/schema_spec.rb

@@ -0,0 +1,179 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe LegacyData::Schema do
+  describe 'following associations' do
+    before :each do
+      LegacyData::Schema.stub!(:analyze_table).with('posts'   ).and_return(@posts_analysis   =mock(:posts,    {:join_table? =>false}))
+      LegacyData::Schema.stub!(:analyze_table).with('comments').and_return(@comments_analysis=mock(:comments, {:join_table? =>false}))
+      @posts_analysis.stub!(   :[]).with(:relations).and_return({:belongs_to=>{                                 }, :has_many=>{:comments=>{:foreign_key=>:posts_id}}})
+      @comments_analysis.stub!(:[]).with(:relations).and_return({:belongs_to=>{:posts=>{:foreign_key=>:posts_id}}, :has_many=>{                                    }})
+    end
+    
+    it 'should analyze all tables when not given a table to start with' do
+      LegacyData::Schema.should_receive(:tables).and_return(['posts', 'comments'])
+      
+      LegacyData::Schema.analyze.should include(@posts_analysis, @comments_analysis)
+    end
+
+    it 'should find the associated comments when starting with posts' do
+      LegacyData::Schema.analyze(:table_name=>'posts').should include(@posts_analysis, @comments_analysis)
+    end
+  end
+    
+  it 'should analyze a single table' do
+    LegacyData::Schema.should_receive(:new).with('some_table').and_return(schema=mock)
+    schema.should_receive(:analyze_table).and_return(analysis=mock)
+
+    LegacyData::Schema.analyze_table('some_table').should == analysis
+  end
+  
+  before :each do
+    LegacyData::Schema.instance_variable_set('@conn', nil)
+    ActiveRecord::Base.stub(:connection).and_return(@connection=stub(:connection))
+  end
+
+  it "should get a list of the tables from the database" do
+    @connection.should_receive(:tables).and_return(['comments', 'people', 'posts'])
+    LegacyData::Schema.tables.should == ['comments', 'people', 'posts']
+  end
+
+  describe 'analyzing a table' do
+    before :each do
+      @schema = LegacyData::Schema.new('some_table')
+      @schema.stub!(:puts)
+    end
+    
+    it 'should have all the information about the table' do  
+      @schema.stub!(:class_name  ).and_return(class_name =mock)
+      @schema.stub!(:column_names).and_return(columns    =mock)
+      @schema.stub!(:primary_key ).and_return(primary_key=mock)
+      @schema.stub!(:relations   ).and_return(relations  =mock)
+      @schema.stub!(:constraints ).and_return(constraints=mock)
+      @schema.analyze_table[:table_name ].should == 'some_table'
+      @schema.analyze_table[:columns    ].should == columns
+      @schema.analyze_table[:primary_key].should == primary_key
+      @schema.analyze_table[:relations  ].should == relations
+      @schema.analyze_table[:constraints].should == constraints
+    end
+    
+    it 'should have the correct table name' do
+      @schema.table_name.should == 'some_table'
+    end
+  
+    it 'should have the correct class name' do
+      LegacyData::TableClassNameMapper.should_receive(:class_name_for).with('some_table').and_return('SomeClass')
+      @schema.class_name.should == 'SomeClass'
+    end
+  
+    it 'should have the correct primary_key' do
+      @connection.should_receive(:pk_and_sequence_for).with('some_table').and_return(['PK', 'SEQ'])
+      @schema.primary_key.should == 'PK'
+    end
+  
+    it 'should have the names of all columns' do
+      @schema.should_receive(:columns).and_return([col1=mock(:col1, :name=>'Col1'), col2=mock(:col2, :name=>'Col2')])
+      @schema.column_names.sort.should == ['Col1', 'Col2'] 
+    end
+  
+    describe 'relations' do
+      it 'should have the different types of relations' do
+        @schema.stub!(:belongs_to_relations).and_return([belongs_to=mock])
+        @schema.stub!(:has_some_relations  ).and_return([has_some  =mock])
+
+        @schema.relations.should == {:belongs_to=>[belongs_to], :has_many=>[has_some], :has_and_belongs_to_many=>{}}
+      end
+
+      
+      it 'should give no "has_some" (has_many and has_one) relationships when the adapter does not support foreign keys' do
+        @connection.should_receive(:respond_to?).with(:foreign_keys_of).and_return(false)
+        @schema.has_some_relations.should == []
+      end
+  
+      it 'should get all "has_some" (has_many and has_one) relationships when my primary key is the foreign key in another table ' do
+        @connection.should_receive(:respond_to?).with(:foreign_keys_of).and_return(true)
+        @connection.should_receive(:foreign_keys_of).and_return([ {:to_table=>'other_table', :foreign_key=>:pk, :dependent=>:destroy}, 
+                                                                  {:to_table=>'the_table',   :foreign_key=>:pk, :dependent=>:destroy} ])
+        @schema.has_some_relations.should == {'other_table' => {:foreign_key=>:pk, :dependent=>:destroy}, 
+                                              'the_table' => {:foreign_key=>:pk, :dependent=>:destroy}}
+      end
+  
+      it 'should give no "belongs_to" when the adapter does not support foreign keys' do
+        @connection.should_receive(:respond_to?).with(:foreign_keys_for).and_return(false)
+        @schema.belongs_to_relations.should == []
+      end
+  
+      it 'should get all "belongs_to" relationships when a foreign key is in my table' do
+        @connection.should_receive(:respond_to?).with(:foreign_keys_for).and_return(true)
+        @connection.should_receive(:foreign_keys_for).and_return([['OTHER_TABLE', 'FK_1'], ['THE_TABLE', 'the_table_id']])
+        @schema.belongs_to_relations.should == {'other_table' => {:foreign_key=>:fk_1        }, 
+                                                'the_table'   => {:foreign_key=>:the_table_id} }
+      end
+    end
+
+    describe 'constraints' do
+      it 'should have the different types of constraints' do
+        @schema.stub!(:unique_constraints      ).and_return([['unique_col'], ['col1', 'col2']])
+        @schema.stub!(:non_nullable_constraints).and_return([non_nullable=mock               ])
+        @schema.stub!(:custom_constraints      ).and_return([custom      =mock               ])
+
+        @schema.constraints.should == {:unique=>[['unique_col']], :multi_column_unique=>[['col1', 'col2']], :non_nullable=>[non_nullable], :custom=>[custom]}
+      end
+
+      it 'should get non-nullable constraints as all columns that do not allow null except the primary key' do
+        @schema.stub(:primary_key).and_return('col1')   
+        @connection.should_receive(:columns).with('some_table', 'some_table Columns').and_return([col1=stub(:null=>false, :name=>'col1'), 
+                                                                                                  col2=stub(:null=>false, :name=>'col2'),
+                                                                                                  col3=stub(:null=>true,  :name=>'col3'),
+                                                                                                  col3=stub(:null=>false, :name=>'col4')])
+        @schema.non_nullable_constraints.should == ['col2', 'col4']
+      end
+  
+      it 'should get uniqueness constraints' do
+        @connection.should_receive(:indexes).with('some_table').and_return([idx1=stub(:unique=>true,  :columns=>['col1']), 
+                                                                            idx2=stub(:unique=>false, :columns=>['col2']), 
+                                                                            idx3=stub(:unique=>true,  :columns=>['col3', 'col4'])])
+        @schema.unique_constraints.should == [['col1'], ['col3', 'col4']]
+      end
+    
+      it 'should give no custom constraints when the adapter does not support it' do
+        @connection.should_receive(:respond_to?).with(:constraints).and_return(false)
+        @schema.custom_constraints.should == []
+      end
+  
+      it 'should get all "belongs_to" relationships when a foreign key is in my table' do
+        @connection.should_receive(:respond_to?).with(:constraints).and_return(true)
+        @connection.should_receive(:constraints).and_return([['SomeConstraint', 'custom sql 1'], ['anotherconstraint', 'more custom sql']])
+        @schema.custom_constraints.should == {:some_constraint => 'custom sql 1', :anotherconstraint => 'more custom sql'}
+      end
+    end  
+  end
+  
+  describe 'convert join tables into HABTM relations' do
+    before :each do
+      LegacyData::Schema.clear_table_definitions
+      LegacyData::Schema.table_definitions['posts'    ] = @posts_table         =mock(:posts,     :join_table? => false)
+      LegacyData::Schema.table_definitions['tags'     ] = @tags_table          =mock(:tags,      :join_table? => false)
+      LegacyData::Schema.table_definitions['tag_posts'] = @tag_posts_join_table=mock(:tag_posts, :join_table? => true )
+    end
+
+    it 'should remove the join table from the list of tables' do
+      @tag_posts_join_table.stub!(:belongs_to_tables).and_return(['posts', 'tags'])
+      @posts_table.should_receive(:convert_has_many_to_habtm).with(@tag_posts_join_table)
+      @tags_table.should_receive( :convert_has_many_to_habtm).with(@tag_posts_join_table)
+
+      analyzed_tables = LegacyData::Schema.remove_join_tables
+
+      analyzed_tables.should      include(@posts_table, @tags_table)
+      analyzed_tables.size.should == 2
+    end
+    
+    it 'should find the next join table' do
+      LegacyData::Schema.next_join_table.should == 'tag_posts'
+    end
+
+    it 'should know when there are no join tables' do
+      LegacyData::Schema.table_definitions.delete('tag_posts')
+      LegacyData::Schema.next_join_table.should == nil
+    end
+  end
+end