alexrothenberg-legacy_data 0.0.6 → 0.0.7

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/generators/models_from_tables/models_from_tables_generator.rb

@@ -1,4 +1,5 @@
 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  
@@ -6,20 +7,20 @@ class ModelsFromTablesGenerator < Rails::Generator::Base
     record do |m|
       m.directory File.join('app/models')
 
-      if options[:table_name]
-        tables = [options[:table_name] ] 
-      else
-        naming_convention = options[:table_naming_convention] || '*'
-        tables = LegacyData::Schema.tables(/^#{naming_convention.gsub('*', '.*')}$/)
-      end
-      tables.each do |table_name|
-        puts "analyzing #{table_name}"
-        analysis = LegacyData::Schema.new(table_name, options[:table_naming_convention]).analyze_table
+      LegacyData::TableClassNameMapper.naming_convention = options[:table_naming_convention]
+      
+      analyzed_tables = LegacyData::Schema.analyze(:table_name=>options[:table_name])
+      LegacyData::TableClassNameMapper.save_dictionary
+      puts "Please look at #{LegacyData::TableClassNameMapper.dictionary_file_name} [hit <enter> to continue]"
+      gets
+      LegacyData::TableClassNameMapper.load_dictionary
 
-        file_name = analysis[:class_name].underscore
+      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', "#{file_name}.rb"), 
-                             :assigns => analysis
+                             File.join('app/models', "#{analyzed_table[:class_name].underscore}.rb"), 
+                             :assigns => analyzed_table
       end
     end
   end

data/generators/models_from_tables/templates/model.rb

@@ -3,11 +3,11 @@ class <%= class_name -%> < ActiveRecord::Base
   <%= "set_primary_key #{primary_key.inspect}" if primary_key %>
   
   # Relationships
-  <%- relations[:has_some].each do |class_name, foreign_key| 
-  -%>  has_many   <%= class_name.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 |class_name, foreign_key| 
-  -%>  belongs_to <%= class_name.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 -%>
 
   # Constraints

data/legacy_data.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{legacy_data}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Rothenberg"]
-  s.date = %q{2009-09-17}
+  s.date = %q{2009-09-20}
   s.description = %q{Create ActiveRecord models from an existing database}
   s.email = %q{alex@alexrothenberg.com}
   s.extra_rdoc_files = [
@@ -30,7 +30,9 @@ Gem::Specification.new do |s|
      "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
      "lib/legacy_data.rb",
      "lib/legacy_data/schema.rb",
-     "spec/legacy_data_schema_spec.rb",
+     "lib/legacy_data/table_class_name_mapper.rb",
+     "spec/legacy_data/schema_spec.rb",
+     "spec/legacy_data/table_class_name_mapper_spec.rb",
      "spec/spec_helper.rb"
   ]
   s.has_rdoc = true
@@ -40,7 +42,8 @@ Gem::Specification.new do |s|
   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/schema_spec.rb",
+     "spec/legacy_data/table_class_name_mapper_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/lib/legacy_data.rb

@@ -1,2 +1,3 @@
 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

@@ -2,13 +2,41 @@ module LegacyData
   class Schema
     attr_reader :table_name
     
-    def initialize(table_name, naming_convention=nil)
+    def self.analyze(options={})
+      analyzed_schema = []
+
+      @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)
+
+        [: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? }
+        end
+      end
+      @tables.values
+    end
+    def self.analyze_table table_name
+      new(table_name).analyze_table
+    end
+    
+    def self.next_table_to_process
+      @tables.keys.detect {|table_name| @tables[table_name] == :pending }
+    end
+    
+    def initialize(table_name)
       @table_name        = table_name
-      @naming_convention = naming_convention
-      @naming_convention = /^#{naming_convention.gsub('*', '(.*)')}$/i if @naming_convention.is_a? String
     end
     
     def analyze_table
+      puts "analyzing #{table_name} => #{class_name}"
       { :table_name   => table_name,
         :class_name   => class_name,
         :primary_key  => primary_key,
@@ -21,16 +49,8 @@ module LegacyData
       connection.tables.select {|table_name| table_name =~ name_pattern }.sort
     end
     
-    
-    
     def class_name
-      class_name_for(self.table_name)
-    end
-
-    def class_name_for table
-      table =~ @naming_convention
-      stripped_table_name = $1 || table
-      ActiveRecord::Base.class_name(stripped_table_name.downcase.pluralize)
+      TableClassNameMapper.class_name_for(self.table_name)
     end
 
     def primary_key
@@ -49,8 +69,7 @@ module LegacyData
       
       belongs_to = {}
       connection.foreign_keys_for(table_name).each do |relation|
-        class_name = class_name_for(relation.first).underscore.to_sym
-        belongs_to[class_name] = relation.second.downcase.to_sym
+        belongs_to[relation.first.downcase] = relation.second.downcase.to_sym
       end
       belongs_to
     end
@@ -59,8 +78,7 @@ module LegacyData
 
       has_some = {}
       connection.foreign_keys_of(table_name).each do |relation|
-        class_name = class_name_for(relation.first).underscore.pluralize.to_sym
-        has_some[class_name] = relation.second.downcase.to_sym
+        has_some[relation.first.downcase] = relation.second.downcase.to_sym
       end
       has_some
     end

data/lib/legacy_data/table_class_name_mapper.rb

@@ -0,0 +1,57 @@
+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.naming_convention= value
+      instance.naming_convention = value
+    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
+    end
+
+    def load_dictionary
+      @dictionary = nil
+      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.yaml')
+    end
+    
+    def self.class_name_for table_name
+      instance.lookup_class_name(table_name) || instance.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/spec/{legacy_data_schema_spec.rb → legacy_data/schema_spec.rb}

@@ -1,6 +1,29 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe LegacyData::Schema do
+  describe 'following associations' do
+    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)
+    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)
+    end
+  end
+  
   before :each do
     LegacyData::Schema.instance_variable_set('@conn', nil)
     ActiveRecord::Base.stub(:connection).and_return(@connection=stub(:connection))
@@ -19,14 +42,14 @@ describe LegacyData::Schema do
   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.should_receive(:class_name)
-      @schema.should_receive(:primary_key)
-      @schema.should_receive(:relations)
-      @schema.should_receive(:constraints)
-  
+    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)
     end
     
@@ -35,32 +58,10 @@ describe LegacyData::Schema do
     end
   
     it 'should have the correct class name' do
-      ActiveRecord::Base.should_receive(:class_name).with('some_tables').and_return('SomeClass')
+      LegacyData::TableClassNameMapper.should_receive(:class_name_for).with('some_table').and_return('SomeClass')
       @schema.class_name.should == 'SomeClass'
     end
   
-    it 'should handle tables with a singular name that ends with s' do
-      @schema.class_name_for('ADDRESS').should == 'Address'
-    end
-  
-    it 'should handle tables with an irregular pluralization name' do
-      @schema.class_name_for('TBPERSON').should == 'Tbperson'
-    end
-    
-    describe 'ignore the table prefix naming convention when figuring out the model name' do
-      before :each do
-        @schema = LegacyData::Schema.new('some_table', /^TB(.*)$/)
-      end
-      
-      it 'should strip off the prefix' do
-        @schema.class_name_for('TBPERSON').should == 'Person'
-      end
-
-      it 'should work on tables that do not have the prefix' do
-        @schema.class_name_for('PERSON').should == 'Person'
-      end
-    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'
@@ -74,7 +75,7 @@ describe LegacyData::Schema do
     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_tables => :pk, :the_tables => :pk}
+      @schema.has_some_relations.should == {'other_table' => :pk, 'the_table' => :pk}
     end
   
     it 'should give no "belongs_to" when the adapter does not support foreign keys' do
@@ -85,7 +86,7 @@ describe LegacyData::Schema do
     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}
+      @schema.belongs_to_relations.should == {'other_table' => :fk_1, 'the_table' => :the_table_id}
     end
   
     it 'should have the correct constraints'

data/spec/legacy_data/table_class_name_mapper_spec.rb

@@ -0,0 +1,21 @@
+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.instance.stub!(:load_dictionary).and_return({})
+    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 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
+end    

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: alexrothenberg-legacy_data
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Alex Rothenberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-17 00:00:00 -07:00
+date: 2009-09-20 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,7 +55,9 @@ files:
 - lib/active_record/connection_adapters/oracle_enhanced_adapter.rb
 - lib/legacy_data.rb
 - lib/legacy_data/schema.rb
-- spec/legacy_data_schema_spec.rb
+- lib/legacy_data/table_class_name_mapper.rb
+- spec/legacy_data/schema_spec.rb
+- spec/legacy_data/table_class_name_mapper_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/alexrothenberg/legacy_data
@@ -85,5 +87,6 @@ signing_key:
 specification_version: 3
 summary: Create ActiveRecord models from an existing database
 test_files: 
-- spec/legacy_data_schema_spec.rb
+- spec/legacy_data/schema_spec.rb
+- spec/legacy_data/table_class_name_mapper_spec.rb
 - spec/spec_helper.rb