schema_generator 0.1.0

data/README

@@ -0,0 +1,41 @@
+Schema Generator v0.1.0
+by Scott Laird, scott@sigkill.org
+http://scottstuff.net
+
+This is a SQL schema generator for Rails.  It slurps up all of the migration files in db/migrate and turns them into a single SQL schema file for each supported database type.  The schema files contains table definitions, indexes, and any seed data created by Model.create() calls in the migrations.
+
+Supported databases:
+ * MySQL
+ * PostgreSQL
+ * SQLite
+
+Usage
+-----
+
+To use, run './scripts/generate schema' on any Rails project.  This will produce three files:
+
+ * db/schema.mysql.sql
+ * db/schema.postgresql.sql
+ * db/schema.sqlite.sql
+
+If these files already exist, then Rails will prompt you before overwriting them.
+
+If your Rails project already has migrations to build its entire schema from scratch, then this will work right off the bat.  If not, you may wish to create a db/migrate/0_initial_schema.rb migration and use it to create your initial schema using the usual migration create_table methods.
+
+You can see an example in Typo (http://typo.leetsoft.com).  This generator was written to reduce the pain involved in creating new migrations for Typo, because each migration required an equivalent change to 3 different hand-edited static schema files, which was usually an error-prone process, because no one user tests all three DB types.  Now we can just use './script/generate schema' and be done with it.
+
+
+Supported Migration Actions
+---------------------------
+
+This generator currently supports create_table, add_column, drop_column, add_index, drop_index, and *.create calls.  Any model find calls will immediately return an empty array; this allows data migration blocks in migration files to be safely ignored.
+
+Column change operations aren't currently supported, but that's simply because I don't have any good test cases.  The code needed is probably only 5 lines long.
+
+
+Debugging and Troubleshooting
+-----------------------------
+
+This generator reaches deep into the guts of Rails; it has to make several changes to the DB drivers and ActiveRecord::Base in order to work.  This means that it may have issues with future Rails releases.  It has been tested with 0.13.1.  All of these changes are made on the fly using open classes, so installing this generator will not break any outside code--the modifications are only active while the generator is running.
+
+If you have any other problems, please mail me at scott@sigkill.org or post a comment on http://scottstuff.net/.  If there is enough interest, then I'll start a schema generator mailing list.

data/schema_generator.rb

@@ -0,0 +1,312 @@
+require 'pathname'
+
+class SchemaGenerator < Rails::Generator::Base
+  def initialize(*runtime_args)
+    super(*runtime_args)
+
+    migration_classes = Array.new
+
+    migration_0 = load_migration(0)
+    if(migration_0)
+      migration_classes.push migration_0
+    end
+
+    migration_number = 1
+    migration = true
+
+    while migration do
+      migration = load_migration(migration_number)
+      if(migration)
+        migration_classes.push migration
+        DBMigrator::Database.version = migration_number
+      end
+      migration_number += 1
+    end
+
+    STDERR.puts "Found #{migration_classes.size} migration classes"
+    DBMigrator::Database.disable_db
+
+    migration_classes.each do |mclass|
+      STDERR.puts "Starting migration for #{mclass}"
+      mclass.up
+    end
+
+    STDERR.puts "Migrations complete."
+    STDERR.puts " Tables found:   #{DBMigrator::Database.tables.size}"
+    STDERR.puts " Indexes found:  #{DBMigrator::Database.indexes.size}"
+    STDERR.puts " Records found:  #{DBMigrator::Database.data.size}"
+  end
+
+  def load_migration(migration_number)
+    globname = "db/migrate/#{migration_number}_*.rb"
+    file = Pathname.glob(globname).to_a.first.to_s
+    return nil unless file =~/\.rb$/
+
+    begin
+      file =~ %r{^(db/migrate/#{migration_number}_(.*)).rb$}
+      include_name = $1.to_s
+      class_base_name = $2.camelize
+
+      require include_name
+      return class_base_name.constantize
+    end
+  end
+
+  def manifest
+    record do |m|
+      m.directory File.join('db')
+
+      m.template 'schema.postgresql.sql',   File.join('db', "schema.postgresql.sql")
+      m.template 'schema.mysql.sql',   File.join('db', "schema.mysql.sql")
+      m.template 'schema.sqlite.sql',   File.join('db', "schema.sqlite.sql")
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    alias_method :old_save, :save
+
+    def dbmigrate_save
+    end
+
+    class << self
+      alias_method :old_find, :find
+      alias_method :old_create, :create
+
+      def dbmigrate_find(*args)
+        []
+      end
+
+      def dbmigrate_create(attributes = nil)
+        DBMigrator::Database.new_data(self,attributes)
+      end
+
+    end
+  end
+  
+  class Migration
+    def self.create_table(name,options={},&block)
+      if(DBMigrator::Database.tables.find {|t| t.name == name})
+        raise "Duplicate table definition on #{name}"
+      end
+      table = DBMigrator::Table.new(name)
+      table.options = options
+      DBMigrator::Database.tables.push(table)
+      block.call(table)
+    end
+
+    def self.drop_table(name)
+      DBMigrator::Database.tables.delete_if {|t| t.name == name}
+    end
+
+    def self.add_column(tablename,name,type,options={})
+      table=DBMigrator::Database.tables.find{|t| t.name == tablename}
+      if(table.fields.find{|f| f.name == name})
+        raise "Duplicate field definition for #{tablename}.#{name}"
+      end
+      table.column(name,type,options)
+    end
+
+    def self.remove_column(tablename,name)
+      table = DBMigrator::Database.tables.find{|t| t.name == tablename}
+      field = table.fields.delete_if {|f| f.name == name}
+    end
+
+    def self.add_index(tablename,name,options={})
+      if(DBMigrator::Database.indexes.find {|i| i.table == tablename and i.name == name})
+        return # duplicate
+      end
+      
+      index = DBMigrator::Index.new
+      index.table = tablename
+      index.name = name
+      DBMigrator::Database.indexes.push index
+    end
+
+    def self.remove_index(tablename,name)
+      DBMigrator::Database.indexes.delete_if {|i| i.table == tablename and i.name == name}
+    end
+  end
+end
+
+module DBMigrator
+  class Table
+    attr_accessor :name, :options, :fields
+
+    def initialize(name)
+      @name = name
+      @fields = Array.new
+    end
+
+    def column(name,type,options={})
+      f = Field.new
+      f.name = name
+      f.type = type
+      f.options = options
+      @fields.push(f)
+    end
+  end
+
+  class Index
+    attr_accessor :table, :name
+  end
+
+  class Field
+    attr_accessor :table, :name, :type, :options
+  end
+
+  class Data
+    attr_accessor :table, :data
+
+    def initialize(tablename, data)
+      @table=tablename
+      @data=data
+    end
+  end
+ 
+  class Database
+    cattr_accessor :tables, :indexes, :data, :version
+
+    @@tables = Array.new
+    @@indexes = Array.new
+    @@data = Array.new
+    @@version = 1
+
+    def self.new_data(tablename,data)
+      @@data.push(Data.new(tablename,data))
+    end
+
+    def self.execute(sql,name)
+      if(sql =~ /create table/i)
+        @@commandstring += reformat_create_table(sql)
+      else
+        @@commandstring += sql
+        @@commandstring += ";\n"
+      end
+    end
+
+    def self.dbdriver
+      @@dbdriver
+    end
+
+    def self.enable_db
+      class << ActiveRecord::Base  
+        alias find old_find
+        alias create old_create
+      end
+
+      ActiveRecord::Base.class_eval 'alias save old_save'
+    end
+
+    def self.disable_db
+      class << ActiveRecord::Base  
+        alias find dbmigrate_find
+        alias create dbmigrate_create
+      end
+      ActiveRecord::Base.class_eval 'alias save dbmigrate_save'
+    end
+
+    def self.dump(databasename)
+      @@commandstring=''
+      case databasename
+      when 'postgresql'
+        @@dbdriver = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(nil)
+      when 'mysql'
+        @@dbdriver = ActiveRecord::ConnectionAdapters::MysqlAdapter.new(nil,nil)
+      when 'sqlite'
+        @@dbdriver = ActiveRecord::ConnectionAdapters::SQLiteAdapter.new(nil)
+      else
+        raise 'Unknown driver'
+      end
+
+      class << @@dbdriver 
+        def execute(sql,name = nil)
+          DBMigrator::Database.execute(sql,name)
+        end
+
+        def columns(tablename,name = nil)
+          table = DBMigrator::Database.tables.find {|t| t.name.to_s == tablename}
+          table.fields.collect {|f| ActiveRecord::ConnectionAdapters::Column.new(f.name.to_s, nil, f.type)}
+        end
+
+        def insert(sql, name = nil, pk = nil, id_value = nil)
+          execute(sql, name = nil)
+        end
+
+        def rollback_db_transaction; end
+        def begin_db_transaction; end
+        def commit_db_transaction; end
+
+        # This is for the schema code, so we don't have security to worry about
+        # This implementation might be attackable, but it won't generally fail
+        # on reasonable strings.
+        def quote_string(string)
+          string.gsub(/\'/,"''")
+        end
+      end
+
+      @@commandstring += "-- tables \n\n"
+
+      tables.sort_by {|t| t.name.to_s}.each do |table|
+        dbdriver.create_table table.name, table.options do |t|
+          table.fields.each do |f|
+            t.column f.name, f.type, f.options
+          end
+        end
+      end
+
+      @@commandstring += "\n-- indexes \n\n" if indexes.size > 0
+
+      indexes.sort_by {|t| t.table.to_s}.each do |index|
+        dbdriver.add_index index.table, index.name.to_s
+      end
+
+      class << ActiveRecord::Base
+        def retrieve_connection
+          DBMigrator::Database.dbdriver
+        end
+      end
+
+      enable_db
+
+      ActiveRecord::Base.class_eval do
+        def attributes_from_column_definition
+          tables = DBMigrator::Database.tables
+          table = tables.find {|t| t.name.to_s == self.class.table_name}
+          table.fields.inject({}) do |a,f|
+            a[f.name.to_s]=nil
+            a
+          end
+        end
+      end
+
+      @@commandstring += "\n-- data \n\n" if @@data.size > 0
+
+      @@data.each do |data|
+        data.table.create(data.data)
+      end
+
+      @@commandstring += "\n-- schema version meta-info \n\n"
+
+      dbdriver.create_table :schema_info, :id => false do |t|
+        t.column :version, :integer
+      end
+
+      dbdriver.execute "insert into schema_info (version) values (#{version})"
+
+      disable_db
+      @@commandstring
+    end
+
+    def self.reformat_create_table(sql)
+      sql.gsub(/^(create table [^(]+\()/i,"\\1\n  ").
+        gsub(/, /,",\n  ").
+        gsub(/\) (ENGINE.*)?$\Z/,"\n) \\1;\n\n").
+        gsub(/\) ;$/,');')
+    end
+  end
+
+end
+
+$schema_generator = true

data/templates/schema.mysql.sql

@@ -0,0 +1,8 @@
+-- This file is autogenerated by the Rail schema generator, using
+-- the schema defined in db/migration/*.rb
+--
+-- Do not edit this file.  Instead, add a new migration using
+-- ./script/generate migration <name>, and then run
+-- ./script/generate schema
+
+<%= DBMigrator::Database.dump('mysql') %>

data/templates/schema.postgresql.sql

@@ -0,0 +1,8 @@
+-- This file is autogenerated by the Rail schema generator, using
+-- the schema defined in db/migration/*.rb
+--
+-- Do not edit this file.  Instead, add a new migration using
+-- ./script/generate migration <name>, and then run
+-- ./script/generate schema
+
+<%= DBMigrator::Database.dump('postgresql') %>

data/templates/schema.sqlite.sql

@@ -0,0 +1,8 @@
+-- This file is autogenerated by the Rail schema generator, using
+-- the schema defined in db/migration/*.rb
+--
+-- Do not edit this file.  Instead, add a new migration using
+-- ./script/generate migration <name>, and then run
+-- ./script/generate schema
+
+<%= DBMigrator::Database.dump('sqlite') %>

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: schema_generator
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-09-02 00:00:00 -07:00
+summary: "The rails schema generator generates complete SQL schemas from a collection of
+  rails migrations.  It currently produces one schema file each for MySQL,
+  PostgreSQL, and SQLite."
+require_paths: 
+  - lib
+email: scott@sigkill.org
+homepage: http://scottstuff.net
+rubyforge_project: 
+description: 
+autorequire: schema_generator
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Scott Laird
+files: 
+  - templates/schema.mysql.sql
+  - templates/schema.postgresql.sql
+  - templates/schema.sqlite.sql
+  - schema_generator.rb
+  - README
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []