alexrothenberg-legacy_data 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alex Rothenberg
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,20 @@
+= legacy_data
+
+How can you start a rails project on top of a large legacy database ... use the legacy_data plugin.
+
+ 
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Alex Rothenberg. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "legacy_data"
+    gem.summary = %Q{Create ActiveRecord models from an existing database}
+    gem.description = %Q{Create ActiveRecord models from an existing database}
+    gem.email = "alex@alexrothenberg.com"
+    gem.homepage = "http://github.com/alexrothenberg/legacy_data"
+    gem.authors = ["Alex Rothenberg"]
+    gem.add_development_dependency "rspec"
+    gem.add_dependency('activerecord')
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "legacy_data #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/generators/legacy_models/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Creates models for existing tables in a legacy database
+
+Example:
+    `./script/generate legacy_models`
+

data/generators/legacy_models/legacy_models_generator.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../lib/legacy_data/schema'
+require File.dirname(__FILE__) + '/../../lib/active_record/connection_adapters/oracle_enhanced_adapter'
+
+class LegacyModelsGenerator < Rails::Generator::Base  
+  def manifest
+    record do |m|
+      m.directory File.join('app/models')
+
+      LegacyData::Schema.tables(/^tb/).each do |table_name|
+        puts "analyzing #{table_name}"
+        analysis = LegacyData::Schema.new(table_name).analyze_table
+
+        file_name = analysis[:class_name].underscore
+        m.template           'model.rb',      
+                             File.join('app/models', "#{file_name}.rb"), 
+                             :assigns => analysis
+      end
+    end
+  end
+
+  
+end

data/generators/legacy_models/templates/model.rb

@@ -0,0 +1,25 @@
+class <%= class_name -%> < ActiveRecord::Base
+  set_table_name :<%= table_name %>
+  set_primary_key :<%= primary_key %>
+  
+  # Relationships
+  <%- relations[:has_some].each do |class_name, foreign_key| 
+  -%>  has_many   <%= class_name.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 %>
+  <%- 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.first.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,62 @@
+# 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.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Rothenberg"]
+  s.date = %q{2009-09-16}
+  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",
+     "generators/legacy_models/USAGE",
+     "generators/legacy_models/legacy_models_generator.rb",
+     "generators/legacy_models/templates/model.rb",
+     "legacy_data.gemspec",
+     "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
+     "lib/legacy_data.rb",
+     "lib/legacy_data/schema.rb",
+     "spec/legacy_data_schema_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/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,50 @@
+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
+        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
+  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.rb

@@ -0,0 +1,2 @@
+require 'legacy_data/schema'
+require 'active_record/connection_adapters/oracle_enhanced_adapter'

data/lib/legacy_data/schema.rb

@@ -0,0 +1,98 @@
+module LegacyData
+  class Schema
+    attr_reader :table_name
+    
+    def initialize(table_name)
+      @table_name = table_name
+    end
+    
+    def analyze_table
+      { :table_name   => table_name,
+        :class_name   => class_name,
+        :primary_key  => primary_key,
+        :relations    => relations,
+        :constraints  => constraints
+      }
+    end
+    
+    def self.tables name_pattern=/.*/
+      connection.tables.select {|table_name| table_name =~ name_pattern }
+    end
+    
+    
+    
+    def class_name
+      class_name_for(self.table_name)
+    end
+
+    def class_name_for table
+      ActiveRecord::Base.class_name(table.downcase.pluralize)
+    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_some     => has_some_relations
+      }
+    end
+    
+    def belongs_to_relations
+      return [] unless connection.respond_to? :foreign_keys_for
+      
+      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
+      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|
+        class_name = class_name_for(relation.first).underscore.pluralize.to_sym
+        has_some[class_name] = relation.second.downcase.to_sym
+      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 non_nullable_constraints
+      connection.columns(table_name, "#{table_name} Columns").reject(&:null).map(&:name)
+    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/spec/legacy_data_schema_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe LegacyData::Schema do
+  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
+
+  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')
+    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)
+  
+      @schema.analyze_table.keys.should include(:table_name, :class_name, :primary_key, :relations, :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
+      ActiveRecord::Base.should_receive(:class_name).with('some_tables').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
+  
+    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 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([['OTHER_TABLE', 'PK'], ['THE_TABLE', 'PK']])
+      @schema.has_some_relations.should == {:other_tables => :pk, :the_tables => :pk}
+    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 => :fk_1, :the_table => :the_table_id}
+    end
+  
+    it 'should have the correct constraints'
+
+    it 'should get non-nullable constraints' do
+      @connection.should_receive(:columns).with('some_table', 'some_table Columns').and_return([col1=stub(:null=>false, :name=>'col1'), 
+                                                                                                col2=stub(:null=>true,  :name=>'col2'),
+                                                                                                col3=stub(:null=>false, :name=>'col3')])
+      @schema.non_nullable_constraints.should == ['col1', 'col3']
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+gem 'activerecord'
+gem 'activerecord-oracle_enhanced-adapter'
+require 'activerecord'
+require 'active_record/connection_adapters/oracle_enhanced_adapter'
+
+require 'legacy_data'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: alexrothenberg-legacy_data
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Rothenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Create ActiveRecord models from an existing database
+email: alex@alexrothenberg.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/legacy_models/USAGE
+- generators/legacy_models/legacy_models_generator.rb
+- generators/legacy_models/templates/model.rb
+- legacy_data.gemspec
+- lib/active_record/connection_adapters/oracle_enhanced_adapter.rb
+- lib/legacy_data.rb
+- lib/legacy_data/schema.rb
+- spec/legacy_data_schema_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/alexrothenberg/legacy_data
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Create ActiveRecord models from an existing database
+test_files: 
+- spec/legacy_data_schema_spec.rb
+- spec/spec_helper.rb