database-model-generator 0.6.0

data/bin/dmg

@@ -0,0 +1,831 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/database_model_generator'
+require 'getopt/long'
+
+begin
+  require 'dbi/dbrc'
+rescue LoadError
+  # Do nothing. Users must specify username/password information on the
+  # command line via the -u and -p options.
+end
+
+opts = Getopt::Long.getopts(
+
+  ['--help',     '-h'],
+  ['--table',    '-t', Getopt::REQUIRED],
+  ['--view',     '-v', Getopt::REQUIRED],
+  ['--user',     '-u', Getopt::REQUIRED],
+  ['--password', '-p', Getopt::REQUIRED],
+  ['--database', '-d', Getopt::REQUIRED],
+  ['--output',   '-o', Getopt::REQUIRED],
+  ['--rails',    '-r', Getopt::REQUIRED],
+  ['--tests',    '-x', Getopt::OPTIONAL],
+  ['--class',    '-c', Getopt::OPTIONAL],
+  ['--indexes',  '-i'],
+  ['--type',     '-T', Getopt::REQUIRED],
+  ['--server',   '-s', Getopt::REQUIRED],
+  ['--port',     '-P', Getopt::REQUIRED]
+)
+
+def help
+  version = DatabaseModel::Generator::VERSION
+  %Q{
+    Available options for the Database Model Generator (version #{version}) are:
+
+    -h, --help     => Display the help text you're looking at now.
+    -t, --table    => The name of the table you wish to model.
+    -v, --view     => The name of the view you wish to model.
+    -o, --output   => The name of the file to create.
+    -u, --user     => The username used to establish a connection to the database.
+    -p, --password => The password used to establish a connection to the database.
+    -d, --database => The name of the database to connect to.
+    -s, --server   => The database server hostname (for SQL Server).
+    -P, --port     => The database server port (default: 1433 for SQL Server).
+    -T, --type     => Database type: 'oracle' or 'sqlserver' (auto-detected if not specified).
+    -r, --rails    => The version of rails you're using (2 or higher).
+    -x, --tests    => Generate tests using testunit, minitest or rspec.
+    -c, --class    => Class name for the generated table (optional)
+
+    Database Connection Examples:
+
+    Oracle (traditional):
+    dmg -T oracle -d localhost:1521/XE -u scott -p tiger -t users
+
+    SQL Server:
+    dmg -T sqlserver -s localhost -P 1433 -d mydb -u sa -p password -t users
+
+    Auto-detection (Oracle if no server specified, SQL Server if server specified):
+    dmg -d localhost:1521/XE -u scott -p tiger -t users        # Oracle
+    dmg -s localhost -d mydb -u sa -p password -t users        # SQL Server
+
+    If no user or password are supplied, then the generator will attempt to glean that
+    information using a combination of the database name and your .dbrc file.
+    If that cannot be found, then an error is raised.
+
+    If no output file is supplied then the file generated will match the name
+    of the table, minus the 's' if present, with a .rb extension. This is lazy,
+    but it is orders of magnitude easier for you to rename a file than it is
+    for me to deal with all possible permutations. Note that the output file
+    name is also used as the basis for the class name.
+
+    If no tests option is specified then a test file, using test-unit 2, will
+    be generated that includes some basic tests to backup the builtin
+    validations. Legal options are 'testunit', 'minitest', 'rspec', or 'none'.
+    If you specify 'none', then no test file is generated.
+
+    Examples:
+
+    # Create a User model for the users table (current rails)
+    dmg -d some_database -u scott -p tiger -t users
+
+    # Create a User model for the users table (rails 2)
+    dmg -d some_database -r 2 -u scott -p tiger -t users
+
+    # Same thing, using dbi-dbrc behind the scenes
+    dmg -d some_database -t users
+
+    # Create a Lily model for the lilies table, and specify the output file.
+    dmg -d some_database -u scott -p tiger -t lilies -o lily.rb
+  }
+end
+
+if opts['h']
+  puts help
+  exit!
+end
+
+unless opts['database']
+  puts "You must specify a database."
+  exit!
+end
+
+unless opts['table'] || opts['view']
+  puts "You must specify a table or view."
+  exit!
+end
+
+user = opts['user']
+pass = opts['password']
+
+# Determine database type
+database_type = opts['type']&.downcase
+unless database_type
+  if opts['server'] || opts['port']
+    database_type = 'sqlserver'
+  else
+    database_type = 'oracle'  # Default to Oracle for backward compatibility
+  end
+end
+
+unless ['oracle', 'sqlserver'].include?(database_type)
+  puts "Invalid database type: #{database_type}. Must be 'oracle' or 'sqlserver'."
+  exit!
+end
+
+unless user && pass
+  begin
+    dbrc = DBI::DBRC.new(opts['database'], user)
+    user = dbrc.user
+    pass = dbrc.passwd
+  rescue NameError
+    msg = "If you do not specify a username or password on the command line "
+    msg << "then you must use the dbi-dbrc library and create a .dbrc file in "
+    msg << "your home directory."
+    puts msg
+    exit!
+  rescue DBI::DBRC::Error
+    msg = "No user or password provided, and no dbrc entry found for '"
+    msg << opts['database'] + "'."
+    puts msg
+    exit!
+  end
+end
+
+table = opts['table']
+view  = opts['view']
+
+if table && view
+  puts "You cannot specify both a table and a view."
+  exit!
+end
+
+# Create database connection based on type
+connection = nil
+begin
+  case database_type
+  when 'oracle'
+    require 'oci8'
+    connection = OCI8.new(user, pass, opts['database'])
+  when 'sqlserver'
+    require 'tiny_tds'
+    server = opts['server'] || 'localhost'
+    port = opts['port'] || 1433
+
+    connection = TinyTds::Client.new(
+      username: user,
+      password: pass,
+      host: server,
+      port: port.to_i,
+      database: opts['database']
+    )
+  end
+rescue LoadError => e
+  case database_type
+  when 'oracle'
+    puts "Oracle support requires the 'oci8' gem. Install with: gem install oci8"
+  when 'sqlserver'
+    puts "SQL Server support requires the 'tiny_tds' gem. Install with: gem install tiny_tds"
+  end
+  exit!
+rescue => e
+  puts "Failed to connect to #{database_type.capitalize} database: #{e.message}"
+  exit!
+end
+
+# Create the appropriate generator
+omg = DatabaseModel::Generator.new(connection, type: database_type)
+omg.generate(table || view, view)
+
+# If user only wants index recommendations, show them and exit
+if opts['indexes']
+  puts "Index Recommendations for #{(table || view).upcase}"
+  puts "=" * 50
+
+  recommendations = omg.index_recommendations
+
+  [:foreign_keys, :unique_constraints, :date_queries, :status_enum, :composite, :full_text].each do |category|
+    next if recommendations[category].empty?
+
+    puts "\n#{category.to_s.gsub('_', ' ').capitalize}:"
+    puts "-" * 30
+
+    recommendations[category].each do |rec|
+      puts "  #{rec[:sql]}"
+      puts "    # #{rec[:reason]}"
+      puts "    # Type: #{rec[:type]}" if rec[:type]
+      puts
+    end
+  end
+
+  # Generate a sample migration
+  unless recommendations.values.flatten.empty?
+    puts "\nSample Rails Migration:"
+    puts "=" * 25
+    migration_name = "AddIndexesTo#{omg.model.gsub(/([a-z])([A-Z])/, '\1\2').split(/(?=[A-Z])/).join}"
+    puts "class #{migration_name} < ActiveRecord::Migration[7.0]"
+    puts "  def change"
+
+    [:foreign_keys, :unique_constraints, :date_queries, :status_enum].each do |category|
+      next if recommendations[category].empty?
+      puts "    # #{category.to_s.gsub('_', ' ').capitalize}"
+      recommendations[category].each do |rec|
+        puts "    #{rec[:sql]}"
+      end
+      puts
+    end
+
+    recommendations[:composite].each do |rec|
+      puts "    #{rec[:sql]}  # #{rec[:reason]}"
+    end
+
+    unless recommendations[:full_text].empty?
+      puts "\n    # Full-text indexes require separate DDL:"
+      recommendations[:full_text].each do |rec|
+        puts "    # #{rec[:sql]}"
+      end
+    end
+
+    puts "  end"
+    puts "end"
+  else
+    puts "\nNo index recommendations found for this table."
+  end
+
+  omg.disconnect if omg.respond_to?(:disconnect)
+  exit
+end
+ofile = opts['o']
+
+unless ofile
+  ofile = omg.table.downcase
+  ofile.chop! if ofile[-1].chr.upcase == 'S'
+  ofile += '.rb'
+end
+
+# Default to Rails 4
+rails = (opts['rails'] && opts['rails'].to_i) || 4
+
+if rails < 2
+  puts "Invalid version of Rails. Must be 2 or higher."
+  exit!
+end
+
+omg.instance_eval { @model = opts['class'] } if opts['class'] # dirty fix
+
+File.open(ofile, 'w') do |fh|
+  fh.puts "# Generated by Database Model Generator v#{DatabaseModel::Generator::VERSION}"
+  fh.puts "# Table: #{table.upcase}"
+  fh.puts "# Generated on: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+  fh.puts
+  fh.puts "require 'securerandom' if defined?(SecureRandom)"
+  fh.puts
+  fh.puts "class #{omg.model} < ActiveRecord::Base"
+  fh.puts "  set_table_name \"#{table}\""
+
+  if omg.primary_keys.size > 1
+    fh.puts "\n  # Requires the composite-primary-keys library"
+    fh.puts "  set_primary_keys " + omg.primary_keys.inspect
+  else
+    fh.puts "\n  set_primary_key " + omg.primary_keys.first.to_sym.inspect unless omg.primary_keys.first.nil?
+  end
+
+  fh.puts "\n  # Table relationships\n\n"
+  omg.belongs_to.uniq.each{ |table|
+    fh.puts "  belongs_to :#{table.downcase}"
+  }
+
+  # Polymorphic associations
+  if omg.has_polymorphic_associations?
+    fh.puts "\n  # Polymorphic associations" unless omg.belongs_to.empty?
+    omg.polymorphic_associations.each do |assoc|
+      fh.puts "  belongs_to :#{assoc[:association_name]}, polymorphic: true"
+    end
+
+    # Add suggestions for parent models
+    fh.puts "\n  # For polymorphic parent models, add these associations:"
+    omg.polymorphic_has_many_suggestions.each do |suggestion|
+      fh.puts "  # #{suggestion[:association]}  # #{suggestion[:description]}"
+    end
+  end
+
+  # Enum definitions
+  if omg.has_enum_columns?
+    fh.puts "\n  # Enums"
+    omg.enum_definitions.each do |enum_def|
+      fh.puts "  #{enum_def}"
+    end
+  end
+
+  fh.puts "\n  # Validations\n"
+
+  if rails == 2
+    # Character fields, size
+    omg.column_info.each{ |col|
+      data_type = col.data_type.to_s
+      if ['char', 'varchar', 'varchar2'].include?(data_type)
+        validation = "validates_size_of :#{col.name.downcase}, :maximum => #{col.data_size}"
+        validation << ", :allow_blank => #{col.nullable?}" if col.nullable?
+        fh.puts "  #{validation}"
+      end
+    }
+
+    fh.puts # Line break
+
+    # Fields that must be present
+    omg.column_info.each{ |col|
+      unless col.nullable?
+        validation = "validates_presence_of :#{col.name.downcase}"
+        fh.puts "  #{validation}"
+      end
+    }
+
+    fh.puts # Line break
+
+    # Numeric fields
+    omg.column_info.each{ |col|
+      if col.data_type.to_s == 'number'
+        max = ("9" * (col.precision - col.scale)).to_i
+
+        validation = "validates_numericality_of :#{col.name.downcase}"
+        validation << ", :less_than => #{max + 1}, :greater_than => -#{max + 1}"
+
+        if col.scale == 0
+          validation << ", :only_integer => true"
+        end
+
+        fh.puts "  #{validation}"
+      end
+    }
+  else
+    # Character fields, size
+    omg.column_info.each{ |col|
+
+      data_type = col.data_type.to_s
+
+      case data_type
+        when 'char', 'varchar', 'varchar2'
+          validation = "validates :#{col.name.downcase}, "
+          validation << ":length => {:maximum => #{col.data_size}}"
+
+          format_str = ",\n    :format => { :with => /[:alpha]/, :message => 'is not a string'"
+
+          if col.nullable?
+            format_str += ", :if => :#{col.name.downcase}? }"
+          else
+            format_str += " }"
+          end
+
+          validation << format_str
+          validation << ",\n    :presence => #{!col.nullable?}" unless col.nullable?
+          validation << "\n\n"
+        when 'number'
+          max = "9" * col.precision
+          max.insert(col.precision - col.scale, ".") if col.scale > 0
+
+          validation = "\n  validates :#{col.name.downcase}"
+
+          unless col.nullable?
+            validation << ", :presence => #{!col.nullable?}"
+          end
+
+          unless max.empty?
+            validation << ", :numericality => {"
+            validation << "\n    :less_than_or_equal_to => #{max}, "
+            validation << "\n    :greater_than_or_equal_to => -#{max}"
+
+            if col.scale == 0
+              validation << ",\n    :only_integer => true"
+            end
+
+            validation << "\n  }\n\n"
+          end
+
+      end
+
+      fh.puts "  #{validation}"
+    }
+  end
+
+  fh.puts # Line break
+  header_printed = false
+
+  # Date fields
+  omg.column_info.each{ |col|
+    data_type = col.data_type.to_s
+
+    if ['date', 'time'].include?(data_type)
+      if data_type == 'date'
+        validation = "validates_date :#{col.name.downcase}"
+      end
+
+      if data_type == 'timestamp'
+        validation = "validates_time :#{col.name.downcase}"
+      end
+
+      unless header_printed
+        fh.puts "  # Requires the validates_timeliness library"
+      end
+
+      fh.puts "  #{validation}"
+    end
+  }
+
+  fh.puts "end"
+end
+
+opts['x'] ||= 'rspec' # Default
+
+testunit = opts['x'] == 'testunit'
+minitest = opts['x'] == 'minitest'
+rspec    = opts['x'] == 'rspec'
+
+if testunit || minitest || rspec
+  if rspec
+    test_file = "#{ofile.gsub('.rb', '')}_spec.rb"
+  else
+    test_file = "test_#{ofile}"
+  end
+
+  File.open(test_file, "w") do |fh|
+    setup_var = omg.table.downcase
+    setup_var.chop! if setup_var[-1].chr.downcase == 's'
+    instance_var = "@#{setup_var}"
+
+    if testunit
+      fh.puts "require 'test-unit'\n\n"
+    elsif minitest
+      fh.puts "require 'minitest/autorun'\n\n"
+    else # rspec
+      fh.puts "require 'rspec'\n"
+      fh.puts "require_relative '#{ofile.gsub('.rb', '')}'\n\n"
+    end
+
+    if testunit
+      fh.puts "class TC_#{omg.model} < Test::Unit::TestCase\n"
+    elsif minitest
+      fh.puts "class TC_#{omg.model} < Minitest::Unit::TestCase\n"
+    else # rspec
+      fh.puts "RSpec.describe #{omg.model} do\n"
+    end
+
+    if rspec
+      fh.puts "  let(:#{setup_var}) { #{omg.model}.new }\n\n"
+    else
+      fh.puts "  def setup"
+      fh.puts "    #{instance_var} = #{omg.model}.new"
+      fh.puts "  end\n\n"
+    end
+
+    if testunit
+      fh.puts "  test 'table name is #{omg.table.downcase}' do"
+    elsif minitest
+      fh.puts "  def table_name_is_#{omg.table.downcase}"
+    else # rspec
+      fh.puts "  describe 'table configuration' do"
+      fh.puts "    it 'has table name #{omg.table.downcase}' do"
+    end
+
+    if rspec
+      fh.puts "      expect(#{omg.model}.table_name).to eq('#{omg.table.downcase}')"
+    else
+      fh.puts "    assert_equal('#{omg.table.downcase}', #{omg.model}.table_name)"
+    end
+
+    if rspec
+      fh.puts "    end"
+    else
+      fh.puts "  end\n\n"
+    end
+
+    if omg.primary_keys.size > 1
+      if testunit
+        test_string = "  test 'primary keys are #{omg.primary_keys.join(', ')}' do"
+      elsif minitest
+        test_string = "  def test_primary_keys_are_#{omg.primary_keys.join('_')}"
+      else # rspec
+        test_string = "    it 'has primary keys #{omg.primary_keys.join(', ')}' do"
+      end
+      fh.puts test_string
+
+      if rspec
+        fh.puts "      expect(#{omg.model}.primary_keys).to eq('#{omg.primary_keys.join(', ')}')"
+      else
+        fh.puts "    assert_equal('#{omg.primary_keys.join(', ')}', #{omg.model}.primary_keys)"
+      end
+    else
+      if testunit
+        test_string = "  test 'primary key is #{omg.primary_keys.first}' do"
+      elsif minitest
+        test_string = "  def test_primary_key_is_#{omg.primary_keys.first}"
+      else # rspec
+        test_string = "    it 'has primary key #{omg.primary_keys.first}' do"
+      end
+      fh.puts test_string
+
+      if rspec
+        fh.puts "      expect(#{omg.model}.primary_key).to eq('#{omg.primary_keys.first}')"
+      else
+        fh.puts "    assert_equal('#{omg.primary_keys.first}', #{omg.model}.primary_key)"
+      end
+    end
+
+    if rspec
+      fh.puts "    end"
+      fh.puts "  end\n"
+    else
+      fh.puts "  end\n"
+    end
+
+    omg.column_info.each{ |col|
+      data_type = col.data_type.to_s
+      column    = col.name.downcase
+
+      if rspec
+        fh.puts "\n  describe '#{column} column' do"
+        instance_reference = setup_var
+      else
+        instance_reference = instance_var
+      end
+
+      if testunit
+        fh.puts "\n  test '#{column} basic functionality' do"
+      elsif minitest
+        fh.puts "\n  def test_#{column}_basic_functionality"
+      else # rspec
+        fh.puts "    it 'responds to #{column}' do"
+      end
+
+      if rspec
+        fh.puts "      expect(#{instance_reference}).to respond_to(:#{column})"
+      else
+        fh.puts "    assert_respond_to(#{instance_reference}, :#{column})"
+        fh.puts "    assert_nothing_raised{ #{instance_reference}.#{column} }" if testunit
+      end
+
+      case data_type
+        when 'char', 'varchar', 'varchar2'
+          if col.nullable?
+            if testunit
+              fh.puts "    assert_kind_of([NilClass, String], #{instance_reference}.#{column})"
+            elsif minitest
+              fh.puts "    assert([NilClass, String].include?(#{instance_reference}.#{column}.class))"
+            else # rspec
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(String).or be_nil"
+            end
+          else
+            if rspec
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(String)"
+            else
+              fh.puts "    assert_kind_of(String, #{instance_reference}.#{column})"
+            end
+          end
+        when 'number'
+          if col.nullable?
+            if testunit
+              fh.puts "    assert_kind_of([NilClass, Numeric], #{instance_reference}.#{column})"
+            elsif minitest
+              fh.puts "    assert([NilClass, Numeric].include?(#{instance_reference}.#{column}.class))"
+            else # rspec
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(Numeric).or be_nil"
+            end
+          else
+            if rspec
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(Numeric)"
+            else
+              fh.puts "    assert_kind_of(Numeric, #{instance_reference}.#{column})"
+            end
+          end
+        when 'date'
+          if testunit
+            if col.nullable?
+              fh.puts "    assert_kind_of([NilClass, DateTime, Time], #{instance_reference}.#{column})"
+            else
+              fh.puts "    assert_kind_of([DateTime, Time], #{instance_reference}.#{column})"
+            end
+          elsif minitest
+            if col.nullable?
+              fh.puts "    assert([NilClass, DateTime, Time].include?(#{instance_reference}.#{column}.class))"
+            else
+              fh.puts "    assert([DateTime, Time].include?(#{instance_reference}.#{column}.class))"
+            end
+          else # rspec
+            if col.nullable?
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(DateTime).or be_a(Time).or be_nil"
+            else
+              fh.puts "      expect(#{instance_reference}.#{column}).to be_a(DateTime).or be_a(Time)"
+            end
+          end
+      end
+
+      if rspec
+        fh.puts "    end\n"
+      else
+        fh.puts "  end\n"
+      end
+
+      case data_type
+        when 'char', 'varchar', 'varchar2'
+          if testunit
+            test_title = "\n  test '#{column} must be a string"
+            test_title += " if present" if col.nullable?
+            test_title += "' do"
+          elsif minitest
+            test_title = "\n  def test_#{column}_must_be_a_string"
+            test_title += "_if_present" if col.nullable?
+          else # rspec
+            test_title = "    it 'validates #{column} as a string"
+            test_title += " if present" if col.nullable?
+            test_title += "' do"
+          end
+
+          fh.puts test_title
+
+          if rspec
+            fh.puts "      #{instance_reference}.#{column} = #{rand(100)}"
+            fh.puts "      expect(#{instance_reference}).not_to be_valid"
+            fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include('is not a string')"
+          else
+            fh.puts "    #{instance_reference}.#{column} = #{rand(100)}"
+            if testunit
+              fh.puts "    assert_false(#{instance_reference}.valid?)"
+              fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?('is not a string'))"
+            else
+              fh.puts "    assert(!#{instance_reference}.valid?)"
+              fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?('is not a string'))"
+            end
+          end
+          fh.puts "  end\n"
+
+          max_len = col.data_size
+          err_msg = "is too long (maximum is #{max_len} characters)"
+
+          if testunit
+            fh.puts "\n  test '#{column} cannot exceed #{max_len} characters' do"
+          elsif minitest
+            fh.puts "\n  def test_#{column}_cannot_exceed_#{max_len}_characters"
+          else # rspec
+            fh.puts "    it 'validates #{column} length cannot exceed #{max_len} characters' do"
+          end
+
+          if rspec
+            fh.puts "      #{instance_reference}.#{column} = 'a' * #{max_len + 1}"
+            fh.puts "      expect(#{instance_reference}).not_to be_valid"
+            fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include('#{err_msg}')"
+          else
+            fh.puts "    #{instance_reference}.#{column} = 'a' * #{max_len + 1}"
+            if testunit
+              fh.puts "    assert_false(#{instance_reference}.valid?)"
+              fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            else
+              fh.puts "    assert(!#{instance_reference}.valid?)"
+              fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            end
+          end
+          fh.puts "  end\n"
+        when 'number'
+          if testunit
+            test_title = "\n  test '#{column} must be a number"
+            test_title += " if present" if col.nullable?
+            test_title += "' do"
+          elsif minitest
+            test_title = "\n  def test_#{column}_must_be_a_number"
+            test_title += "_if_present" if col.nullable?
+          else # rspec
+            test_title = "    it 'validates #{column} as a number"
+            test_title += " if present" if col.nullable?
+            test_title += "' do"
+          end
+
+          fh.puts test_title
+
+          if rspec
+            fh.puts "      #{instance_reference}.#{column} = 'test_string'"
+            fh.puts "      expect(#{instance_reference}).not_to be_valid"
+            fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include('is not a number')"
+          else
+            fh.puts "    #{instance_reference}.#{column} = 'test_string'"
+            if testunit
+              fh.puts "    assert_false(#{instance_reference}.valid?)"
+              fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?('is not a number'))"
+            else
+              fh.puts "    assert(!#{instance_reference}.valid?)"
+              fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?('is not a number'))"
+            end
+          end
+
+          fh.puts "  end\n"
+
+          max = "9" * col.precision
+          max.insert(col.precision - col.scale, ".") if col.scale > 0
+          err_msg = "must be less than or equal to #{max}"
+
+          if testunit
+            fh.puts "\n  test '#{column} cannot exceed the value #{max}' do"
+          elsif minitest
+            fh.puts "\n  def test_#{column}_cannot_exceed_the_value_#{max.sub('.', '_')}"
+          else # rspec
+            fh.puts "    it 'validates #{column} cannot exceed the value #{max}' do"
+          end
+
+          if col.scale > 0
+            value_to_set = "#{max.to_f.round}"
+          else
+            value_to_set = "#{max.to_i + 1}"
+          end
+
+          if rspec
+            fh.puts "      #{instance_reference}.#{column} = #{value_to_set}"
+            fh.puts "      expect(#{instance_reference}).not_to be_valid"
+            fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include('#{err_msg}')"
+          else
+            fh.puts "    #{instance_reference}.#{column} = #{value_to_set}"
+            if testunit
+              fh.puts "    assert_false(#{instance_reference}.valid?)"
+              fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            else
+              fh.puts "    assert(!#{instance_reference}.valid?)"
+              fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            end
+          end
+
+          fh.puts "  end\n"
+
+          err_msg = "must be greater than or equal to -#{max}"
+
+          if testunit
+            fh.puts "\n  test '#{column} cannot be less than the value -#{max}' do"
+          elsif minitest
+            fh.puts "\n  def test_#{column}_cannot_be_less_than_the_value_#{max.sub('.', '_')}"
+          else # rspec
+            fh.puts "    it 'validates #{column} cannot be less than the value -#{max}' do"
+          end
+
+          if col.scale > 0
+            neg_value = "-#{max.to_f.round}"
+          else
+            neg_value = "-#{max.to_i + 1}"
+          end
+
+          if rspec
+            fh.puts "      #{instance_reference}.#{column} = #{neg_value}"
+            fh.puts "      expect(#{instance_reference}).not_to be_valid"
+            fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include('#{err_msg}')"
+          else
+            fh.puts "    #{instance_reference}.#{column} = #{neg_value}"
+            if testunit
+              fh.puts "    assert_false(#{instance_reference}.valid?)"
+              fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            else
+              fh.puts "    assert(!#{instance_reference}.valid?)"
+              fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?('#{err_msg}'))"
+            end
+          end
+          fh.puts "  end\n"
+      end
+
+      unless col.nullable?
+        err_msg = "can't be blank"
+        if testunit
+          fh.puts "\n  test '#{column} cannot be nil' do"
+        elsif minitest
+          fh.puts "\n  def test_#{column}_cannot_be_nil"
+        else # rspec
+          fh.puts "    it 'validates #{column} presence' do"
+        end
+
+        if rspec
+          fh.puts "      #{instance_reference}.#{column} = nil"
+          fh.puts "      expect(#{instance_reference}).not_to be_valid"
+          fh.puts "      expect(#{instance_reference}.errors[:#{column}]).to include(\"#{err_msg}\")"
+        else
+          fh.puts "    #{instance_reference}.#{column} = nil"
+          if testunit
+            fh.puts "    assert_false(#{instance_reference}.valid?)"
+            fh.puts "    assert_true(#{instance_reference}.errors[:#{column}].include?(\"#{err_msg}\"))"
+          else
+            fh.puts "    assert(!#{instance_reference}.valid?)"
+            fh.puts "    assert(#{instance_reference}.errors[:#{column}].include?(\"#{err_msg}\"))"
+          end
+        end
+        fh.puts "  end\n"
+      end
+
+      if rspec
+        fh.puts "  end\n"  # Close the describe block for this column
+      end
+    }
+
+    if rspec
+      # RSpec doesn't need teardown - using let handles cleanup automatically
+    else
+      fh.puts "\n  def teardown"
+      fh.puts "     @#{setup_var} = nil"
+      fh.puts "  end"
+    end
+
+    fh.puts "end"
+  end
+  puts "\nTest file '#{test_file}' generated\n"
+else
+  if opts['x'] != 'none'
+    puts "\nInvalid option to -x/--tests: " + opts['x']
+    puts "Valid options are: testunit, minitest, rspec, or none"
+  else
+    puts "\nSkipping test file generation.\n"
+  end
+end
+
+omg.disconnect if omg.respond_to?(:disconnect)
+
+puts "\nFile '#{ofile}' generated\n\n"