rafaelp-dbdesigner_migration_generator 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Rafael Lima (http://rafael.adm.br)
+
+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.mkdn

@@ -0,0 +1,48 @@
+# DBDesigner Migration Generator
+
+## DESCRIPTION
+
+This gem generates ActiveRecord Migration files from a DB Designer 4 xml file.
+
+## REQUIREMENTS
+
+* activerecord
+
+## INSTALLATION
+
+    $ sudo gem sources -a http://gems.github.com (you only have to do this once)
+    $ sudo gem install rafaelp-dbdesigner_migration_generator
+
+Inset line below in your *config/environments/development.rb*
+
+    require 'dbdesigner_migration_generator'
+
+## USAGE
+
+Save you model in *db/dbdesigner_model.xml*, then run:
+
+  $ ruby script/generate dbdesigner_migration [MigrationName] [only|except] [table1] [table2] [table3]
+
+### Example 1
+
+  $ ruby script/generate dbdesigner_migration CompleteDatabase
+
+### Example 2
+
+  $ ruby script/generate dbdesigner_migration CreateAccountsAndUsers only accounts users
+
+### Example 3
+
+  $ ruby script/generate dbdesigner_migration CreateOtherTables except accounts users
+
+### Tricks
+
+You can put the magical keyword *ignore* on first line of table comments, on your model at DB Designer, to automatically ignore the table on migration generation.
+
+## LICENSE
+
+DBDesigner Migration Generator is released under the MIT License.
+
+## AUTHOR
+
+[Rafael Lima](http://rafael.adm.br) at [BielSystems](http://bielsystems.com.br) and [Myfreecomm](http://myfreecomm.com.br)

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the dbdesigner_migration_generator plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the dbdesigner_migration_generator plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DbdesignerMigrationGenerator'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/dbdesigner_migration_generator.rb

@@ -0,0 +1,366 @@
+require 'rails_generator'
+require 'getoptlong'
+require 'rexml/document'
+
+class DbdesignerMigrationGenerator < Rails::Generator::NamedBase
+
+  attr_accessor :migration_name, :tables, :relations
+
+  def manifest
+    @migration_name = class_name
+
+    if args.include? "except" and args.include? "only"
+      raise "It is not possible to use 'except' and 'only' parameters togheter. Try again."
+    end
+
+    @tables = []
+    track = nil
+    args.each do |arg|
+      @tables << arg unless track.nil?
+      arg = arg.to_sym
+      track = arg if arg.eql? :except or arg.eql? :only
+    end
+
+    if track.eql? :except
+      puts "Ignoring table(s) #{@tables.join(',')}\n"
+      DBDesignerMigration::Model.ignore_tables = @tables 
+    elsif track.eql? :only
+      puts "Processing only table(s) #{@tables.join(',')}\n"
+      DBDesignerMigration::Model.only_tables = @tables 
+    end
+
+    begin
+      dbmodel_path = File.join('db', 'dbdesigner_model.xml')
+      unless File.exist?(dbmodel_path)
+        raise "Could not find any database model in db/dbdesigner_model.xml"
+      end
+
+      xml = REXML::Document.new(File.open(dbmodel_path))
+
+      # Verify that this is a DBDesigner XML file
+      if xml.elements['DBMODEL'].nil? or xml.elements['DBMODEL'].attributes["Version"] != '4.0'
+        raise "File '#{dbmodel_path}' is not a DBDesigner 4 XML file. Skipping..."
+      else
+        puts "Reading the datamodel XML (#{dbmodel_path}) from DBDesigner..." if not $silent
+        xml.elements.each("//DATATYPE") { |d| DBDesignerMigration::Model.add_datatype(d) }
+        xml.elements.each("//TABLE") { |t| DBDesignerMigration::Model.add_table(t) }
+        xml.elements.each("//RELATION") { |r| DBDesignerMigration::Model.add_relation(r) }
+      end
+    rescue Exception => ex
+      puts ex.message
+      puts ex.backtrace.find {|str| str =~ /\.rb/ } || ""
+      exit(1)
+    end
+
+    @tables = DBDesignerMigration::Model.tables
+    @tables.delete_if {|table| table.ignore? }
+    
+    @relations = DBDesignerMigration::Model.relations
+    @relations.delete_if {|relation| relation.from_table.ignore? or relation.to_table.ignore? }
+
+    if @tables.empty? and @relations.empty?
+      puts "Nothing to do!"
+      exit(0)
+    end
+
+    record do |m|
+      m.directory File.join('db')
+      m.migration_template 'dbdesigner_migration.rb',"db/migrate", :migration_file_name => "#{file_path}"
+    end
+
+  end
+
+end
+
+module DBDesignerMigration
+
+  class Model
+    @datatypes = []
+    @tables = []
+    @relations = []
+    @only_tables = nil
+    @ignore_tables = nil
+ 
+    def self.only_tables=(tables)
+      @only_tables = tables
+    end
+
+    def self.ignore_tables=(tables)
+      @ignore_tables = tables
+    end
+ 
+    def self.datatypes
+      @datatypes
+    end
+
+    def self.tables
+      @tables
+    end
+    
+    def self.relations
+      @relations
+    end
+
+    def self.add_datatype(xmlobj)
+      id = xmlobj.attributes['ID']
+      name = xmlobj.attributes['TypeName']
+
+      if(@datatypes.find {|d| d.id == id})
+        raise "Duplicate datatype definition on #{name}"
+      end
+
+      @datatypes << Datatype.new(xmlobj)
+    end
+
+    def self.add_table(xmlobj)
+      id = xmlobj.attributes['ID']
+      name = xmlobj.attributes['TableName']
+
+      if(@tables.find {|t| t.id == id})
+        raise "Duplicate table definition on #{name}"
+      end
+
+      @tables << Table.new(xmlobj)
+    end
+
+    def self.add_relation(xmlobj)
+      id = xmlobj.attributes['ID']
+      name = xmlobj.attributes['RelationName']
+
+      if(@relations.find {|t| t.id == id})
+        raise "Duplicate table definition on #{name}"
+      end
+
+      @relations << Relation.new(xmlobj)
+    end
+
+=begin
+PREPARED TO USE FOR MODELS
+
+    def self.add_relationship(r)
+      src_table = @tables.find {|t| t.id == r.attributes['SrcTable']}
+      dest_table = @tables.find {|t| t.id == r.attributes['DestTable']}
+
+      relationship = r.attributes['RelationName']
+      if relationship =~ /\s*habtm\s*:(\w+)/
+        relationship = "  has_and_belongs_to_many :#{$1}"
+      else
+        # If we are inserting the other side of a relationship (non-habtm),
+        # we need to mirror the relationship.
+        # NOTE: in the DB model, links should be labeled 'has_one' or 'has_many'
+        #       not 'belongs_to' since that label is ambiguous 1:1 or 1:n
+        if relationship =~ /has_one/ or relationship =~ /has_many/
+          dest_table.relationships << '  belongs_to :' + src_table.name
+        else relationship !~ /has_and_belongs_to_many/
+          puts "error: relationships must be labeled 'has_one :x', 'has_many :x', 'habtm :x' or 'has_and_belongs_to_many :x'"
+          return
+        end
+        relationship = '  ' + relationship
+      end
+      src_table.relationships << relationship
+    end
+=end    
+  def self.format_options(options)
+    return if options.empty?
+
+    formatted = ""
+    options.each do |k,v|
+      if v.is_a? Symbol
+        formatted << ", :#{k} => :#{v}"
+      elsif v.is_a? String
+        formatted << ", :#{k} => '#{v}'"
+      else
+        formatted << ", :#{k} => #{v}"
+      end
+    end
+
+    formatted
+  end
+  
+  protected
+    def self.include_table?(table_name)
+      return ((!@only_tables.nil? and @only_tables.include? table_name) or (@only_tables.nil? and @ignore_tables.nil?) or (!@ignore_tables.nil? and !@ignore_tables.include? table_name))
+    end
+  end
+  
+  class Datatype
+    attr_accessor :id, :name, :description, :physical
+
+    def initialize(xmlobj)
+      @id = xmlobj.attributes['ID']
+      @name = @physical = xmlobj.attributes['TypeName'].downcase
+      @description = xmlobj.attributes['Description']
+      @physical = xmlobj.attributes['PhysicalTypeName'].downcase if not xmlobj.attributes['PhysicalTypeName'].empty?
+    end
+  end
+
+  class Table
+    attr_accessor :id, :name, :comments, :columns, :indexes, :relationships, :options, :references
+
+    alias_method :fields, :columns
+
+    def initialize(xmlobj)
+      @id = xmlobj.attributes['ID']
+      @name = xmlobj.attributes['Tablename']
+      @comments = xmlobj.attributes['Comments'].split("\\n")
+      @columns = []
+      @indexes = []
+      @relationships = []
+      @references = []
+      @options = {}
+      @process = ((Model.include_table? @name) and (@comments.empty? or @comments.first.downcase.strip != "ignore"))
+
+      if @name == @name.singularize
+          puts "Warning: table #{@name} is not in plural\n"
+      end
+
+      xmlobj.elements.each("COLUMNS/COLUMN") { |c| self.add_column(c) }
+      xmlobj.elements.each("INDICES/INDEX") { |i| self.add_index(i) }
+    end
+
+    def process?
+      @process
+    end
+
+    def ignore?
+      !@process
+    end
+
+    def add_column(xmlobj)
+      id = xmlobj.attributes['ID']
+      name = xmlobj.attributes['ColName']
+      if("id" == name.downcase)
+        return
+      end
+
+      if(@columns.find {|c| c.id == id})
+        raise "Duplicate column definition on #{self.name} #{name}"
+      end
+
+      @columns << Column.new(xmlobj)
+    end
+
+    def add_index(xmlobj)
+      id = xmlobj.attributes['ID']
+      name = xmlobj.attributes['IndexName']
+
+      xmlobj.elements.each("INDEXCOLUMNS/INDEXCOLUMN") { |i| 
+	      if(self.columns.find {|c| c.id == i.attributes['idColumn']}.nil?)
+	        return
+	      end
+      }
+
+      if(@indexes.find {|i| i.id == id})
+        raise "Duplicate index definition on #{self.name} #{name} (#{id})"
+      end
+
+      @indexes << Index.new(self, xmlobj)
+    end
+
+    def add_references(reference)
+      @references << reference
+    end
+
+  end
+  
+  class Column
+    attr_accessor :id, :name, :datatype, :params, :notnull, :default, :comments, :options
+
+    def initialize(xmlobj)
+      @id = xmlobj.attributes['ID']
+      @name = xmlobj.attributes['ColName']
+      @datatype = Model.datatypes.find {|c| c.id == xmlobj.attributes['idDatatype']}.physical
+      @params = xmlobj.attributes['DatatypeParams']
+      @notnull = xmlobj.attributes['NotNull']
+      @default = xmlobj.attributes['DefaultValue']
+      @comments = xmlobj.attributes['Comments']
+      @comments = "# #{@comments.split("\\n").join(', ')}" unless @comments.empty?
+
+      options = {}
+      options['default'] = @default unless @default.empty?
+      options['null'] = ("1" == @notnull) ? false : true
+      if not @params.empty?
+        if float = /\(([0-9]+),([0-9]+)\)/.match(@params)
+          options['precision'] = float[1].to_i 
+          options['scale'] = float[2].to_i
+        else
+          options['limit'] = /\(([0-9]*)\)/.match(@params)[1].to_i
+        end
+      end
+#      @options['limit'] = (eval(@params) rescue nil) if not @params.empty?
+
+      @options = Model.format_options(options)
+
+    end
+
+  end
+  
+  class Index
+    attr_accessor :id, :table, :name, :columns, :unique, :options
+    
+    def initialize(table, xmlobj)
+      @id = xmlobj.attributes['ID']
+      @name = xmlobj.attributes['IndexName']
+      @table = table.name
+      columns = Array.new
+      xmlobj.elements.each("INDEXCOLUMNS/INDEXCOLUMN") { |i| 
+        columns << table.columns.find {|c| c.id == i.attributes['idColumn']}.name
+      }
+      @columns = "[:#{columns.join(',:')}]" unless columns.nil?
+      @unique = xmlobj.attributes['IndexKind'] == "2"
+      if @unique
+        options = {}
+        options['unique'] = @unique
+        @options = Model.format_options(options)
+      end
+    end
+  end
+
+  class Relation
+    attr_accessor :id, :name, :from_table, :from_column, :to_table, :to_column, :options
+
+    def initialize(xmlobj)
+      # DBDesigner codes      
+      # 0 = restrict
+      # 1 = cascade
+      # 2 = set null
+      # 3 = no action
+      # 4 = set default
+      @dbdesigner_codes = ['restrict','cascade','set null','no action','set default']
+
+      @id = xmlobj.attributes['ID']
+      @name = xmlobj.attributes['RelationName'].downcase
+      @from_table = Model.tables.find {|t| t.id == xmlobj.attributes['DestTable']}
+      @to_table = Model.tables.find {|t| t.id == xmlobj.attributes['SrcTable']}
+      fields = xmlobj.attributes['FKFields'].strip.split("=")
+      @from_column = fields[1].match(/([a-zA-Z_-])*/).to_s
+      @to_column = fields[0].match(/([a-zA-Z_-])*/).to_s
+
+      options = {}
+
+      on_delete = xmlobj.attributes['RefDef'].match(/OnDelete=([0-4]{1})/)
+      if on_delete
+        @on_delete = @dbdesigner_codes[on_delete[1].to_i]
+        options['on_delete'] = @on_delete unless on_delete[1] == '3'
+      end
+
+      on_update = xmlobj.attributes['RefDef'].match(/OnUpdate=([0-4]{1})/)
+      if on_update
+        @on_update = @dbdesigner_codes[on_update[1].to_i]
+        options['on_update'] = @on_update unless on_update[1] == '3'
+      end
+      @options = Model.format_options(options)
+      
+      if(@from_table.process? and @to_table.process?)
+        if (@from_column == 'parent_id' and @from_table.name != @to_table.name) or
+           (@from_column != 'parent_id' and @from_column != "#{@to_table.name.singularize}_#{@to_column}")
+            puts "Warning: foreign_key #{@from_table.name}.#{@from_column} => #{@to_table.name}.#{@to_column}\n"
+        end
+      end
+      
+      @from_table.add_references(@to_table) if @to_column.eql? 'id'
+    end
+  end
+
+end
+

data/templates/dbdesigner_migration.rb

@@ -0,0 +1,43 @@
+require 'postgresql_migrations'
+
+<% tables.each do |table| -%>
+# script/generate rspec_model -c --skip-migration <%= table.name.camelize %> <% table.references.each do |table| -%><%= table.name %>:reference <% end -%> <% table.fields.each do |field| -%><%= "#{field.name}:#{field.datatype}" %> <% end -%>
+
+<% end -%>
+
+class <%= migration_name.underscore.camelize %> < ActiveRecord::Migration
+  def self.up<% tables.each do |table| -%>
+<% table.comments.each do |comment| -%>
+      <%= "\# #{comment}" %>
+<% end -%>
+
+    create_table "<%= table.name %>"<% table.options.each do |k,v| %>, :<%= k %> => <%= v %><% end %>, :force => true do |t|
+<% table.fields.each do |field| -%>
+      t.<%= field.datatype %> "<%= field.name %>" <%= field.options %> <%= field.comments %>
+<% end -%>
+      t.timestamps
+    end
+
+<% table.indexes.sort_by {|index| index.table.to_s}.each do |index| -%>
+    <%= "add_index :#{index.table}, #{index.columns} #{index.options}" %>
+<% end -%>
+<% end -%>
+
+<% relations.each do |relation| -%>
+    <%= "add_foreign_key :#{relation.from_table.name}, :#{relation.from_column}, :#{relation.to_table.name}, :#{relation.to_column} #{relation.options}" %>
+<% end -%>
+  end
+
+  def self.down
+<% relations.each do |relation| -%>
+    <%= "remove_foreign_key :#{relation.from_table.name}, :#{relation.from_column}" %>
+<% end -%>
+<% tables.sort_by {|table| table.name.to_s }.each do |table| -%>
+<% table.indexes.sort_by {|index| index.table.to_s}.each do |index| -%>
+    <%= "remove_index :#{index.table}, #{index.columns}" %>
+<% end -%>
+    <%= "drop_table :#{table.name}" %>
+<% end -%>
+  end
+end
+

data/test/dbdesigner_migration_generator_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class DbdesignerGeneratorTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+require File.dirname(__FILE__) + '/../lib/dbdesigner_migration_generator'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rafaelp-dbdesigner_migration_generator
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Rafael Lima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: 
+email: contato@rafael.adm.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.mkdn
+files: 
+- MIT-LICENSE
+- Rakefile
+- README.mkdn
+- dbdesigner_migration_generator.rb
+- templates/dbdesigner_migration.rb
+has_rdoc: true
+homepage: http://rafael.adm.br
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Generates ActiveRecord Migration files from a DB Designer 4 xml file.
+test_files: 
+- test/test_helper.rb
+- test/dbdesigner_migration_generator_test.rb