alexrothenberg-legacy_data 0.0.8 → 0.0.9

data/Rakefile

@@ -29,6 +29,7 @@ Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.libs << 'lib' << 'spec'
   spec.pattern = 'spec/**/*_spec.rb'
   spec.rcov = true
+  spec.rcov_opts = ['--exclude spec,gems', '--sort coverage']
 end
 
 task :spec => :check_dependencies

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/generators/models_from_tables/models_from_tables_generator.rb

@@ -1,3 +1,4 @@
+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'
@@ -20,11 +21,11 @@ Done analyzing the tables.
       LegacyData::TableClassNameMapper.load_dictionary
 
       analyzed_tables.each do |analyzed_table|
-        analyzed_table[:class_name] = LegacyData::TableClassNameMapper.class_name_for(analyzed_table[:table_name])
+        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
+                             :assigns => analyzed_table.to_hash
       end
     end
   end

data/generators/models_from_tables/templates/model.rb

@@ -3,11 +3,14 @@ class <%= class_name -%> < ActiveRecord::Base
   <%= "set_primary_key #{primary_key.to_sym.inspect}" if primary_key %>
   
   # Relationships
-  <%- relations[:has_some].each do |table_name, foreign_key| 
-  -%>  has_many   <%= LegacyData::TableClassNameMapper.class_name_for(table_name).underscore.pluralize.to_sym.inspect %>, :foreign_key => <%= foreign_key.inspect %>
+  <%- relations[:has_some               ].each do |table_name, foreign_key| 
+  -%>  has_many                <%= LegacyData::TableClassNameMapper.class_name_for(table_name).underscore.pluralize.to_sym.inspect %>, :foreign_key => <%= foreign_key.inspect %>
   <%- end -%>
-  <%- relations[:belongs_to].each do |table_name, foreign_key| 
-  -%>  belongs_to <%= LegacyData::TableClassNameMapper.class_name_for(table_name).underscore.to_sym.inspect %>, :foreign_key => <%= foreign_key.inspect %>
+  <%- relations[:belongs_to             ].each do |table_name, foreign_key| 
+  -%>  belongs_to              <%= LegacyData::TableClassNameMapper.class_name_for(table_name).underscore.to_sym.inspect           %>, :foreign_key => <%= foreign_key.inspect %>
+  <%- end -%>
+  <%- relations[:has_and_belongs_to_many].each do |table_name, options|  
+  -%>  has_and_belongs_to_many <%= LegacyData::TableClassNameMapper.class_name_for(table_name).underscore.pluralize.to_sym.inspect %>, :foreign_key => <%= options[:foreign_key].inspect%>, :association_foreign_key => <%= options[:association_foreign_key].inspect%>, :join_table => <%= options[:join_table].inspect %>
   <%- end -%>
 
   # Constraints

data/legacy_data.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{legacy_data}
-  s.version = "0.0.8"
+  s.version = "0.0.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Rothenberg"]
-  s.date = %q{2009-09-20}
+  s.date = %q{2009-09-21}
   s.description = %q{Create ActiveRecord models from an existing database}
   s.email = %q{alex@alexrothenberg.com}
   s.extra_rdoc_files = [
@@ -31,8 +31,10 @@ Gem::Specification.new do |s|
      "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
@@ -44,6 +46,7 @@ Gem::Specification.new do |s|
   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"
   ]
 

data/lib/legacy_data.rb

@@ -1,3 +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/lib/legacy_data/schema.rb

@@ -3,50 +3,76 @@ module LegacyData
     attr_reader :table_name
     
     def self.analyze(options={})
-      analyzed_schema = []
+      initialize_tables(options[:table_name])
 
-      @tables = {}
-      if options[:table_name]
-        @tables[options[:table_name]] = :pending
-      else
-        LegacyData::Schema.tables.each {|table| @tables[table] = :pending }
-      end
-      
       while table_name = next_table_to_process
-        # puts "      Tables: #{@tables.inspect}"
-        @tables[table_name] = analyze_table(table_name)
+        table_definitions[table_name] = analyze_table(table_name)
 
         [:has_some, :belongs_to].each do |relation_type| 
-          associated_tables = @tables[table_name][:relations][relation_type].keys.map(&:to_s) 
-          associated_tables.each {|associated_table| @tables[associated_table] = :pending if @tables[associated_table].nil? }
+          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
-      @tables.values
+
+      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
-      @tables.keys.detect {|table_name| @tables[table_name] == :pending }
+      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
+      @table_name = table_name
     end
     
     def analyze_table
       puts "analyzing #{table_name} => #{class_name}"
-      { :table_name   => table_name,
-        :class_name   => class_name,
-        :primary_key  => primary_key,
-        :relations    => relations,
-        :constraints  => constraints
-      }
+      TableDefinition.new(:table_name   => table_name,
+                          :columns      => column_names,
+                          :primary_key  => primary_key,
+                          :relations    => relations,
+                          :constraints  => constraints
+                          )
     end
     
-    def self.tables name_pattern=/.*/
-      connection.tables.select {|table_name| table_name =~ name_pattern }.sort
+    def self.tables 
+      connection.tables.sort
     end
     
     def class_name
@@ -59,8 +85,9 @@ module LegacyData
     end
 
     def relations
-      { :belongs_to   => belongs_to_relations,
-        :has_some     => has_some_relations
+      { :belongs_to               => belongs_to_relations,
+        :has_some                 => has_some_relations,
+        :has_and_belongs_to_many  => {}
       }
     end
     
@@ -92,8 +119,14 @@ module LegacyData
       }
     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 = connection.columns(table_name, "#{table_name} Columns").reject(&:null).map(&:name)
+      non_nullable_constraints = columns.reject(&:null).map(&:name)
       non_nullable_constraints.reject {|col| col == primary_key}
     end
 

data/lib/legacy_data/table_class_name_mapper.rb

@@ -11,21 +11,16 @@ module LegacyData
       @dictionary ||= load_dictionary
     end
 
-    def self.naming_convention= value
-      instance.naming_convention = value
+    def self.method_missing(method_id, *arguments, &block)
+      instance.send(method_id, *arguments, &block)
     end
-    def self.load_dictionary
-      instance.load_dictionary
-    end
-    def self.save_dictionary
-      instance.save_dictionary
-    end
-    def self.dictionary_file_name
-      instance.dictionary_file_name
+
+    def clear_dictionary
+      @dictionary = nil
     end
 
     def load_dictionary
-      @dictionary = nil
+      clear_dictionary
       File.exists?(dictionary_file_name) ? YAML.load_file(dictionary_file_name) : {}
     end
 
@@ -39,8 +34,8 @@ module LegacyData
       File.join(RAILS_ROOT, 'app', 'models', 'table_mappings.yml')
     end
     
-    def self.class_name_for table_name
-      instance.lookup_class_name(table_name) || instance.compute_class_name(table_name)
+    def class_name_for table_name
+      lookup_class_name(table_name) || compute_class_name(table_name)
     end
 
     def lookup_class_name table_name

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(&: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], 
+                                                                :association_foreign_key=>join_table.belongs_to_relations[other_table_name],
+                                                                :join_table             =>join_table.table_name }
+      relations[:has_some].delete(join_table.table_name)                                                          
+    end
+  end
+end

data/spec/legacy_data/schema_spec.rb

@@ -2,27 +2,30 @@ 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_some=>{:comments=>:posts_id}})
+      @comments_analysis.stub!(:[]).with(:relations).and_return({:belongs_to=>{:posts=>:posts_id}, :has_some=>{                    }})
+    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.should_receive(:analyze_table).with('posts'   ).and_return(posts_analysis   =mock)
-      LegacyData::Schema.should_receive(:analyze_table).with('comments').and_return(comments_analysis=mock)
       
-      posts_analysis.stub!(   :[]).with(:relations).and_return({:belongs_to=>{}, :has_some=>{}})
-      comments_analysis.stub!(:[]).with(:relations).and_return({:belongs_to=>{}, :has_some=>{}})
-      
-      LegacyData::Schema.analyze.should include(posts_analysis, comments_analysis)
+      LegacyData::Schema.analyze.should include(@posts_analysis, @comments_analysis)
     end
 
     it 'should find the associated comments when starting with posts' do
-      LegacyData::Schema.should_receive(:analyze_table).with('posts'   ).and_return(posts_analysis   =mock)
-      LegacyData::Schema.should_receive(:analyze_table).with('comments').and_return(comments_analysis=mock)
-      
-      posts_analysis.stub!(   :[]).with(:relations).and_return({:belongs_to=>{                 }, :has_some=>{:comments=>:posts_id}})
-      comments_analysis.stub!(:[]).with(:relations).and_return({:belongs_to=>{:posts=>:posts_id}, :has_some=>{                    }})
-      
-      LegacyData::Schema.analyze(:table_name=>'posts').should include(posts_analysis, comments_analysis)
+      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)
@@ -34,11 +37,6 @@ describe LegacyData::Schema do
     LegacyData::Schema.tables.should == ['comments', 'people', 'posts']
   end
 
-  it "should get a filtered list of the tables from the database" do
-    @connection.should_receive(:tables).and_return(['comments', 'people', 'posts'])
-    LegacyData::Schema.tables(/^p/).should == ['people', 'posts']
-  end
-  
   describe 'analyzing a table' do
     before :each do
       @schema = LegacyData::Schema.new('some_table')
@@ -46,11 +44,16 @@ describe LegacyData::Schema do
     end
     
     it 'should have all the information about the table' do  
-      @schema.stub!(:class_name)
-      @schema.stub!(:primary_key)
-      @schema.stub!(:relations)
-      @schema.stub!(:constraints)
-      @schema.analyze_table.keys.should include(:table_name, :class_name, :primary_key, :relations, :constraints)
+      @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
@@ -67,56 +70,107 @@ describe LegacyData::Schema do
       @schema.primary_key.should == 'PK'
     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 == []
+    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
   
-    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([['OTHER_TABLE', 'PK'], ['THE_TABLE', 'PK']])
-      @schema.has_some_relations.should == {'other_table' => :pk, 'the_table' => :pk}
-    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_some=>[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 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 "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([['OTHER_TABLE', 'PK'], ['THE_TABLE', 'PK']])
+        @schema.has_some_relations.should == {'other_table' => :pk, 'the_table' => :pk}
+      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' => :fk_1, 'the_table' => :the_table_id}
-    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 have the correct constraints'
-
-    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']
+      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' => :fk_1, 'the_table' => :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
   
-    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']]
+  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 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 == []
+    it 'should find the next join table' do
+      LegacyData::Schema.next_join_table.should == 'tag_posts'
     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'}
+
+    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

data/spec/legacy_data/table_class_name_mapper_spec.rb

@@ -1,21 +1,91 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe LegacyData::TableClassNameMapper do
-  describe 'computing class names without an input dictionary' do
+  before :each do
+    LegacyData::TableClassNameMapper.clear_dictionary 
+  end
+
+  describe 'without an input dictionary' do
     before :each do
       LegacyData::TableClassNameMapper.instance.stub!(:load_dictionary).and_return({})
     end
+    
+    describe 'without any naming convention' do
+      before :each do
+        LegacyData::TableClassNameMapper.naming_convention = nil
+      end
+
+      it 'should handle tables with a singular name that ends with s' do
+        LegacyData::TableClassNameMapper.class_name_for('ADDRESS').should == 'Address'
+      end
 
-    it 'should handle tables with a singular name that ends with s' do
-      LegacyData::TableClassNameMapper.class_name_for('ADDRESS').should == 'Address'
+      it 'should handle tables with an irregular pluralization name' do
+        LegacyData::TableClassNameMapper.class_name_for('TBPERSON').should == 'Tbperson'
+      end
+
+      it 'should work on tables that do not have the prefix' do
+        LegacyData::TableClassNameMapper.class_name_for('PERSON').should == 'Person'
+      end
     end
+    
+    describe "with a 'tables start with TB' naming convention" do
+      before :each do
+        LegacyData::TableClassNameMapper.naming_convention = 'TB*'
+      end
+
+      it 'should use the wildcard portion when the naming convention applied' do
+        LegacyData::TableClassNameMapper.class_name_for('TBPERSON').should == 'Person'
+      end
 
-    it 'should handle tables with an irregular pluralization name' do
-      LegacyData::TableClassNameMapper.class_name_for('TBPERSON').should == 'Tbperson'
+      it 'should use the full table name when the naming convention does not match' do
+        LegacyData::TableClassNameMapper.class_name_for('PERSON').should == 'Person'
+      end
+    end
+  end
+  
+  describe 'with an input dictionary' do
+    before :each do
+      LegacyData::TableClassNameMapper.instance.stub!(:load_dictionary).and_return({'some_table' => 'CustomClassName'})
     end
 
-    it 'should work on tables that do not have the prefix' do
-      LegacyData::TableClassNameMapper.class_name_for('PERSON').should == 'Person'
+    it 'should use the dictionary mapping when one exists' do
+      LegacyData::TableClassNameMapper.class_name_for('some_table').should == 'CustomClassName'
     end
+
+    it 'should use the algorithm when no dictionary mapping  exists' do
+      LegacyData::TableClassNameMapper.class_name_for('ANOTHER_TABLE').should == 'AnotherTable'
+    end
+  end
+  
+  describe 'persisting the dictionary' do
+    before :each do
+      RAILS_ROOT = 'test_rails_root'
+      @dictionary_file_name = LegacyData::TableClassNameMapper.dictionary_file_name
+    end
+    after :each do
+      Object.send(:remove_const, :RAILS_ROOT) if RAILS_ROOT=='test_rails_root'
+    end
+
+    it 'should load the dictionary from a file' do
+      File.should_receive(:exists?  ).with(@dictionary_file_name).and_return(true)
+      YAML.should_receive(:load_file).with(@dictionary_file_name).and_return(dictionary_from_file=mock)
+      
+      LegacyData::TableClassNameMapper.dictionary.should == dictionary_from_file
+    end
+
+    it 'should give empty dictionary when file does not exist' do
+      File.should_receive(:exists?  ).with(@dictionary_file_name).and_return(false)
+      
+      LegacyData::TableClassNameMapper.dictionary.should == {}
+    end
+
+    it 'should save the dictionary to a file' do
+      File.should_receive(:open).with(@dictionary_file_name, 'w').and_yield(file=mock) 
+      LegacyData::TableClassNameMapper.instance.should_receive(:dictionary).and_return(dictionary=mock)
+      YAML.should_receive(:dump).with(dictionary, file).and_return(yaml_dictionary=mock)
+      
+      LegacyData::TableClassNameMapper.save_dictionary
+    end
+
   end
 end    

data/spec/legacy_data/table_definition_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe LegacyData::TableDefinition do
+  [:table_name, :columns, :primary_key, :relations, :constraints].each do |option|
+    it "should save the #{option} on initialization" do
+      LegacyData::TableDefinition.new({option=>'some value'})[option].should == 'some value'
+    end
+    
+    it 'should allow you to set class_name' do
+      table_definition = LegacyData::TableDefinition.new({})
+      table_definition.class_name = 'NewClassName'
+      table_definition[:class_name].should == 'NewClassName'
+    end
+    
+    it 'should reveal itself as a hash' do
+      params = {}
+      [:class_name, :table_name, :columns, :primary_key, :relations, :constraints].each { |field| params[field] = "#{field}_value" } 
+      table_definition = LegacyData::TableDefinition.new(params)
+      table_definition.to_hash.should == params
+    end
+  end
+  
+  describe 'join table' do
+    before :each do
+      @foreign_key_columns = ['one_table_id',               'another_table_id']
+      @belongs_to_relation = {'one_table' => :one_table_id, 'another_table' => :another_table_id}
+    end
+    it 'should be a join table when it has only 2 columns and both are foreign keys' do
+      table_definition = LegacyData::TableDefinition.new(:columns=>@foreign_key_columns,                       :relations=> {:belongs_to=>@belongs_to_relation})
+      table_definition.should be_join_table
+    end
+
+    it 'should not be a join table when it has additional columns' do
+      table_definition = LegacyData::TableDefinition.new(:columns=>@foreign_key_columns.push(:another_column), :relations=> {:belongs_to=>@belongs_to_relation})
+      table_definition.should_not be_join_table
+    end
+
+    it 'should not be a join table when it does not have the belongs_to relation' do
+      table_definition = LegacyData::TableDefinition.new(:columns=>@foreign_key_columns,                       :relations=> {})
+      table_definition.should_not be_join_table
+    end
+    
+    describe 'creating habtm' do
+      before :each do
+        @posts     = LegacyData::TableDefinition.new(:table_name=>'posts',     :relations=>{:has_some=>{'tag_posts' => :posts_id}, :has_and_belongs_to_many=>{}})
+        @tags      = LegacyData::TableDefinition.new(:table_name=>'tags',      :relations=>{:has_some=>{'tag_posts' => :tags_id }, :has_and_belongs_to_many=>{}})
+        @tag_posts = LegacyData::TableDefinition.new(:table_name=>'tag_posts', :relations=>{:belongs_to=>{'posts' => :posts_id, 'tags' => :tags_id}})
+      end
+
+      describe 'belonging to tables' do
+        it 'should tell you when it does not' do
+          @posts.belongs_to_tables.should == []
+        end
+        it 'should tell you when it belongs to 2 tables' do
+          @tag_posts.belongs_to_tables.sort.should == ['posts', 'tags']
+        end
+      end
+      it 'should convert a has_many into a habtm' do
+        @posts.convert_has_many_to_habtm(@tag_posts)
+        
+        @posts.relations[:has_some               ].should == {}
+        @posts.relations[:has_and_belongs_to_many].should == {'tags' => {:foreign_key=>:posts_id, :association_foreign_key=>:tags_id, :join_table=>"tag_posts"} }
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: alexrothenberg-legacy_data
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors: 
 - Alex Rothenberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-20 00:00:00 -07:00
+date: 2009-09-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,8 +56,10 @@ files:
 - 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
 has_rdoc: true
 homepage: http://github.com/alexrothenberg/legacy_data
@@ -89,4 +91,5 @@ summary: Create ActiveRecord models from an existing database
 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