database-model-generator 0.6.0

data/certs/djberg96_pub.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEcDCCAtigAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE4MDMxODE1MjIwN1oXDTI4MDMxNTE1MjIwN1owPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBALgfaroVM6CI06cxr0/h
+A+j+pc8fgpRgBVmHFaFunq28GPC3IvW7Nvc3Y8SnAW7pP1EQIbhlwRIaQzJ93/yj
+u95KpkP7tA9erypnV7dpzBkzNlX14ACaFD/6pHoXoe2ltBxk3CCyyzx70mTqJpph
+75IB03ni9a8yqn8pmse+s83bFJOAqddSj009sGPcQO+QOWiNxqYv1n5EHcvj2ebO
+6hN7YTmhx7aSia4qL/quc4DlIaGMWoAhvML7u1fmo53CYxkKskfN8MOecq2vfEmL
+iLu+SsVVEAufMDDFMXMJlvDsviolUSGMSNRTujkyCcJoXKYYxZSNtIiyd9etI0X3
+ctu0uhrFyrMZXCedutvXNjUolD5r9KGBFSWH1R9u2I3n3SAyFF2yzv/7idQHLJJq
+74BMnx0FIq6fCpu5slAipvxZ3ZkZpEXZFr3cIBtO1gFvQWW7E/Y3ijliWJS1GQFq
+058qERadHGu1yu1dojmFRo6W2KZvY9al2yIlbkpDrD5MYQIDAQABo3cwdTAJBgNV
+HRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUFZsMapgzJimzsbaBG2Tm8j5e
+AzgwHQYDVR0RBBYwFIESZGpiZXJnOTZAZ21haWwuY29tMB0GA1UdEgQWMBSBEmRq
+YmVyZzk2QGdtYWlsLmNvbTANBgkqhkiG9w0BAQsFAAOCAYEAW2tnYixXQtKxgGXq
+/3iSWG2bLwvxS4go3srO+aRXZHrFUMlJ5W0mCxl03aazxxKTsVVpZD8QZxvK91OQ
+h9zr9JBYqCLcCVbr8SkmYCi/laxIZxsNE5YI8cC8vvlLI7AMgSfPSnn/Epq1GjGY
+6L1iRcEDtanGCIvjqlCXO9+BmsnCfEVehqZkQHeYczA03tpOWb6pon2wzvMKSsKH
+ks0ApVdstSLz1kzzAqem/uHdG9FyXdbTAwH1G4ZPv69sQAFAOCgAqYmdnzedsQtE
+1LQfaQrx0twO+CZJPcRLEESjq8ScQxWRRkfuh2VeR7cEU7L7KqT10mtUwrvw7APf
+DYoeCY9KyjIBjQXfbj2ke5u1hZj94Fsq9FfbEQg8ygCgwThnmkTrrKEiMSs3alYR
+ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
+WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
+-----END CERTIFICATE-----

data/database-model-generator.gemspec

@@ -0,0 +1,31 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'database-model-generator'
+  spec.version     = '0.6.0'
+  spec.author      = 'Daniel J. Berger'
+  spec.license     = 'Apache-2.0'
+  spec.email       = 'djberg96@gmail.com'
+  spec.homepage    = 'http://www.github.com/djberg96/database-model-generator'
+  spec.summary     = 'A Ruby library for generating Rails AR models from existing tables.'
+  spec.test_files  = Dir['spec/**/*.rb']
+  spec.files       = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.cert_chain  = spec.cert_chain = ['certs/djberg96_pub.pem']
+
+  spec.executables = 'dmg'
+
+  spec.add_dependency('getopt', '~> 1.6')
+
+  # I do not require vendor-specific gems because I do not know which vendor
+  # you may or may not be using. However, I've added them as development
+  # dependencies for testing, and as a clue for you the reader.
+  spec.add_development_dependency('rspec', '~> 3.12')
+  spec.add_development_dependency('ruby-oci8', '~> 2.2')
+  spec.add_development_dependency('tiny_tds', '~> 3.2.1')
+
+  spec.description = <<-EOF
+    The database-model-generator library allows you to generate an ActiveRecord
+    model from an existing Oracle table or view, as well as automatically
+    generate a baseline test file for test-unit or minitest.
+  EOF
+end

data/docker/README.md

@@ -0,0 +1,238 @@
+# Docker Support for Database Model Generator
+
+This directory contains Docker configurations for testing the Database Model Generator with different database systems.
+
+## Directory Structure
+
+- `oracle/` - Oracle database Docker configurations and documentation
+- `sqlserver/` - SQL Server database Docker configurations and documentation
+
+## Quick Start
+
+### Oracle
+```bash
+cd oracle
+docker-compose up
+```
+
+### SQL Server
+```bash
+cd sqlserver
+docker-compose up
+```
+
+## Database-Specific Documentation
+
+- [Oracle Docker Setup](oracle/README.md)
+- [SQL Server Docker Setup](sqlserver/DOCKER.md)
+- [SQL Server Testing Guide](sqlserver/TESTING.md)
+- [SQL Server Support Documentation](sqlserver/SUPPORT.md)
+
+## Requirements
+
+- Docker
+- Docker Compose
+- Ruby 3.0+ (for local development)
+
+## Testing
+
+Each database type includes its own testing scripts and documentation. See the individual directories for specific instructions.
+
+## Quick Start
+
+### Option 1: Simple Test (Recommended)
+
+Run the simple test script that handles everything automatically:
+
+```bash
+./test_sqlserver_simple.sh
+```
+
+This script will:
+- Start a SQL Server container
+- Create a test database with sample tables
+- Test the Database Model Generator
+- Show generated models and tests
+- Clean up when done
+
+### Option 2: Docker Compose (Advanced)
+
+Use Docker Compose for more control:
+
+```bash
+# Start SQL Server
+docker-compose -f docker-compose.sqlserver.yml up -d sqlserver
+
+# Wait for SQL Server to be ready (1-2 minutes)
+# Then run tests
+docker-compose -f docker-compose.sqlserver.yml up omg_test
+
+# Clean up
+docker-compose -f docker-compose.sqlserver.yml down -v
+```
+
+### Option 3: Manual Docker Setup
+
+```bash
+# Start SQL Server container
+docker run -d \
+  --name sqlserver_test \
+  -e "ACCEPT_EULA=Y" \
+  -e "SA_PASSWORD=YourStrong!Passw0rd" \
+  -e "MSSQL_PID=Express" \
+  -p 1433:1433 \
+  mcr.microsoft.com/mssql/server:2022-latest
+
+# Wait for startup (about 1 minute)
+sleep 60
+
+# Create test database
+docker exec sqlserver_test /opt/mssql-tools/bin/sqlcmd \
+  -S localhost -U sa -P YourStrong!Passw0rd \
+  -Q "CREATE DATABASE test_db"
+
+# Test the generator
+ruby bin/omg -T sqlserver -s localhost -P 1433 -d test_db \
+  -u sa -p 'YourStrong!Passw0rd' -t INFORMATION_SCHEMA.TABLES -x rspec
+
+# Clean up
+docker stop sqlserver_test && docker rm sqlserver_test
+```
+
+## Database Schema
+
+The test setup creates a sample database with the following tables:
+
+### users
+- id (INT, PRIMARY KEY, IDENTITY)
+- username (NVARCHAR(50), UNIQUE)
+- email (NVARCHAR(100), UNIQUE)
+- first_name, last_name (NVARCHAR(50))
+- age (INT)
+- salary (DECIMAL(10,2))
+- is_active (BIT)
+- status (NVARCHAR(20))
+- created_at, updated_at (DATETIME2)
+- bio (NVARCHAR(MAX))
+
+### posts
+- id (INT, PRIMARY KEY, IDENTITY)
+- user_id (INT, FOREIGN KEY → users.id)
+- title (NVARCHAR(200))
+- content (NVARCHAR(MAX))
+- status (NVARCHAR(20))
+- published_at (DATETIME2)
+- created_at (DATETIME2)
+- view_count (INT)
+
+### categories
+- id (INT, PRIMARY KEY, IDENTITY)
+- name (NVARCHAR(100), UNIQUE)
+- description (NVARCHAR(500))
+- slug (NVARCHAR(100), UNIQUE)
+- parent_id (INT, FOREIGN KEY → categories.id)
+- is_active (BIT)
+- created_at (DATETIME2)
+
+### post_categories (Junction table)
+- id (INT, PRIMARY KEY, IDENTITY)
+- post_id (INT, FOREIGN KEY → posts.id)
+- category_id (INT, FOREIGN KEY → categories.id)
+- created_at (DATETIME2)
+
+### comments
+- id (INT, PRIMARY KEY, IDENTITY)
+- post_id (INT, FOREIGN KEY → posts.id)
+- user_id (INT, FOREIGN KEY → users.id)
+- content (NVARCHAR(MAX))
+- status (NVARCHAR(20))
+- created_at, updated_at (DATETIME2)
+
+## Connection Details
+
+When testing manually:
+- **Server**: localhost:1433
+- **Username**: sa
+- **Password**: YourStrong!Passw0rd
+- **Database**: test_db
+
+## Prerequisites
+
+- Docker installed and running
+- Ruby with bundler
+- `tiny_tds` gem (automatically installed by test scripts)
+
+### Installing tiny_tds
+
+If you need to install the `tiny_tds` gem manually:
+
+**Ubuntu/Debian:**
+```bash
+sudo apt-get install build-essential freetds-dev
+gem install tiny_tds
+```
+
+**macOS:**
+```bash
+brew install freetds
+gem install tiny_tds
+```
+
+**Windows:**
+```bash
+gem install tiny_tds
+```
+
+## Test Features
+
+The test scripts verify:
+
+1. **Model Generation**: Creates ActiveRecord models from SQL Server tables
+2. **Test Generation**: Creates RSpec, Minitest, or TestUnit test files
+3. **Index Recommendations**: Analyzes tables and suggests performance indexes
+4. **Auto-detection**: Automatically detects SQL Server when server parameter is provided
+5. **Foreign Key Relationships**: Maps foreign keys to ActiveRecord associations
+6. **Data Type Mapping**: Correctly maps SQL Server types to Ruby/Rails validations
+
+## Example Usage
+
+```bash
+# Generate a User model with RSpec tests
+ruby bin/omg -T sqlserver -s localhost -P 1433 -d test_db \
+  -u sa -p 'YourStrong!Passw0rd' -t users -x rspec
+
+# Show index recommendations for posts table
+ruby bin/omg -T sqlserver -s localhost -P 1433 -d test_db \
+  -u sa -p 'YourStrong!Passw0rd' -t posts -i
+
+# Auto-detect database type (SQL Server)
+ruby bin/omg -s localhost -d test_db -u sa -p 'YourStrong!Passw0rd' -t categories
+```
+
+## Troubleshooting
+
+### SQL Server not starting
+- Wait longer (SQL Server can take 2-3 minutes to fully start)
+- Check Docker logs: `docker logs sqlserver_test`
+- Ensure port 1433 is not in use
+
+### Connection errors
+- Verify the password meets SQL Server requirements (8+ chars, mixed case, numbers, symbols)
+- Check firewall settings
+- Ensure SQL Server container is fully started
+
+### tiny_tds installation issues
+- Install system dependencies (freetds-dev on Linux, freetds on macOS)
+- Check Ruby version compatibility
+- Try using the system package manager version
+
+## Files
+
+- `docker/sqlserver/Dockerfile` - SQL Server container setup
+- `docker/sqlserver/init-db.sql` - Database initialization script
+- `docker/sqlserver/setup-db.sh` - Database setup automation
+- `docker/test/Dockerfile` - Test runner container
+- `docker/test/run_tests.sh` - Comprehensive test suite
+- `docker-compose.sqlserver.yml` - Docker Compose configuration
+- `test_sqlserver_simple.sh` - Simple all-in-one test script
+- `test_sqlserver_docker.sh` - Advanced Docker test script

data/docker/oracle/Dockerfile

@@ -0,0 +1,87 @@
+# Dockerfile for testing oracle-model-generator library
+FROM ruby:3.1-bullseye
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    unzip \
+    libaio1 \
+    libaio-dev \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Download and install Oracle Instant Client
+WORKDIR /opt/oracle
+RUN wget https://download.oracle.com/otn_software/linux/instantclient/1913000/instantclient-basic-linux.x64-19.13.0.0.0dbru.zip && \
+    wget https://download.oracle.com/otn_software/linux/instantclient/1913000/instantclient-sdk-linux.x64-19.13.0.0.0dbru.zip && \
+    unzip instantclient-basic-linux.x64-19.13.0.0.0dbru.zip && \
+    unzip instantclient-sdk-linux.x64-19.13.0.0.0dbru.zip && \
+    rm -f *.zip
+
+# Set Oracle environment variables
+ENV ORACLE_HOME=/opt/oracle/instantclient_19_13
+ENV LD_LIBRARY_PATH=$ORACLE_HOME
+ENV PATH=$ORACLE_HOME:$PATH
+
+# Create symbolic links for OCI8 compilation
+RUN cd $ORACLE_HOME && \
+    ln -sf libclntsh.so.19.1 libclntsh.so && \
+    ln -sf libocci.so.19.1 libocci.so
+
+# Set working directory for the application
+WORKDIR /app
+
+# Copy gemspec and Gemfile first for better Docker layer caching
+COPY oracle-model-generator.gemspec Gemfile ./
+
+# Install Ruby dependencies
+RUN bundle config set --local deployment false && \
+    bundle install --verbose
+
+# Copy the rest of the application
+COPY . .
+
+# Create a script to run tests with Oracle connection
+RUN echo '#!/bin/bash\n\
+echo "Starting Oracle Model Generator test environment..."\n\
+echo ""\n\
+echo "This Docker container includes:"\n\
+echo "- Ruby $(ruby --version)"\n\
+echo "- Oracle Instant Client 19.13"\n\
+echo "- All required gems for oracle-model-generator"\n\
+echo ""\n\
+echo "To run tests, you need to:"\n\
+echo "1. Have an Oracle database running (Oracle XE recommended)"\n\
+echo "2. Ensure the '\''hr'\'' schema is available with sample data"\n\
+echo "3. Update connection parameters in test file if needed"\n\
+echo ""\n\
+echo "Available commands:"\n\
+echo "  bundle exec ruby test/test_oracle_model_generator.rb  # Run tests"\n\
+echo "  bundle exec ruby -Ilib bin/omg --help                # Run CLI tool"\n\
+echo "  irb -I lib -r oracle/model/generator                 # Interactive Ruby"\n\
+echo ""\n\
+echo "Current Oracle environment:"\n\
+echo "  ORACLE_HOME: $ORACLE_HOME"\n\
+echo "  LD_LIBRARY_PATH: $LD_LIBRARY_PATH"\n\
+echo ""\n\
+\n\
+# Check if arguments were passed to run specific commands\n\
+if [ $# -eq 0 ]; then\n\
+    echo "No command specified. Starting bash shell..."\n\
+    exec /bin/bash\n\
+else\n\
+    exec "$@"\n\
+fi' > /app/run_tests.sh
+
+RUN chmod +x /app/run_tests.sh
+
+# Expose any ports that might be needed (none for this library)
+# EXPOSE 8080
+
+# Set the default command
+CMD ["/app/run_tests.sh"]
+
+# Add some helpful labels
+LABEL maintainer="Testing Environment for oracle-model-generator"
+LABEL description="Docker image for testing the oracle-model-generator Ruby library with Oracle Instant Client"
+LABEL version="1.0"

data/docker/oracle/README.md

@@ -0,0 +1,140 @@
+# Docker Testing Environment for Oracle Model Generator
+
+This directory contains a complete Docker setup for testing the oracle-model-generator Ruby library with Oracle database connectivity.
+
+## Files Created
+
+### Docker Configuration
+- `Dockerfile` - Production-ready Docker image with Oracle connectivity
+- `docker-compose.yml` - Complete testing environment with Oracle XE database
+- `.dockerignore` - Optimizes Docker build context
+
+### Testing Files
+- `test/test_oracle_model_generator_docker.rb` - Docker-optimized test suite
+- `DOCKER.md` - Detailed documentation and troubleshooting guide
+
+## Quick Start
+
+### Option 1: Full Testing Environment (with Oracle Database)
+
+1. **Start the complete environment:**
+   ```bash
+   docker-compose up -d
+   ```
+
+2. **Wait for Oracle database to be ready:**
+   ```bash
+   docker-compose logs -f oracle-db
+   # Wait for "DATABASE IS READY TO USE!" message
+   ```
+
+3. **Run tests:**
+   ```bash
+   docker-compose exec app ruby test/test_oracle_model_generator_docker.rb
+   ```
+
+4. **Interactive shell for development:**
+   ```bash
+   docker-compose exec app bash
+   ```
+
+### Option 2: Build and Test Application Only
+
+1. **Build the image:**
+   ```bash
+   docker build -t oracle-model-generator .
+   ```
+
+2. **Run with external database:**
+   ```bash
+   docker run -e ORACLE_HOST=your-db-host \
+              -e ORACLE_PORT=1521 \
+              -e ORACLE_SID=your-sid \
+              -e ORACLE_USER=your-user \
+              -e ORACLE_PASSWORD=your-password \
+              oracle-model-generator
+   ```
+
+## Environment Variables
+
+The Docker environment supports these variables for database connection:
+
+- `ORACLE_HOST` - Database hostname (default: oracle-db)
+- `ORACLE_PORT` - Database port (default: 1521)
+- `ORACLE_SID` - Database SID (default: XE)
+- `ORACLE_USER` - Database username (default: hr)
+- `ORACLE_PASSWORD` - Database password (default: oracle)
+
+## What's Included
+
+### Oracle Instant Client 19.13
+- Full Oracle connectivity libraries
+- Properly configured environment variables
+- Native compilation support for ruby-oci8
+
+### Ruby Environment
+- Ruby 3.1 with bundler
+- All project dependencies installed
+- Optimized for Oracle development
+
+### Test Database (via docker-compose)
+- Oracle Express Edition 21c
+- Pre-configured HR sample schema
+- Ready-to-use test data
+
+## Development Workflow
+
+1. **Make code changes** in your local workspace
+2. **Rebuild the image:** `docker-compose build app`
+3. **Run tests:** `docker-compose exec app ruby test/test_oracle_model_generator_docker.rb`
+4. **Debug interactively:** `docker-compose exec app bash`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **ruby-oci8 compilation errors:**
+   - Ensure Oracle Instant Client is properly installed
+   - Check environment variables are set correctly
+   - Verify build-essential package is installed
+
+2. **Database connection failures:**
+   - Wait for Oracle container to fully initialize
+   - Check network connectivity between containers
+   - Verify database credentials
+
+3. **Permission issues:**
+   - Ensure Docker has necessary permissions
+   - Check file ownership in mounted volumes
+
+### Debugging Commands
+
+```bash
+# Check Oracle client installation
+docker-compose exec app ls -la /opt/oracle/instantclient_19_13/
+
+# Test database connectivity
+docker-compose exec app sqlplus hr/oracle@oracle-db:1521/XE
+
+# Check environment variables
+docker-compose exec app env | grep ORACLE
+
+# View bundler gem installation
+docker-compose exec app bundle list
+```
+
+## Performance Notes
+
+- Initial build takes 10-15 minutes (Oracle client compilation)
+- Subsequent builds use Docker layer caching
+- Oracle database initialization takes 2-3 minutes
+- Consider using volumes for persistent development
+
+## Security Considerations
+
+- Default passwords are for development only
+- Use Docker secrets for production deployments
+- Limit network exposure in production environments
+- Regular security updates for base images
+
+For detailed information, see `DOCKER.md`.

data/docker/oracle/docker-compose.yml

@@ -0,0 +1,41 @@
+services:
+  # Oracle Express Edition database for testing
+  oracle-db:
+    image: gvenzl/oracle-xe:21-slim
+    environment:
+      - ORACLE_PASSWORD=oracle
+      - APP_USER=hr
+      - APP_USER_PASSWORD=hr
+    ports:
+      - "1521:1521"
+    volumes:
+      - oracle_data:/opt/oracle/oradata
+    shm_size: 1g
+    healthcheck:
+      test: ["CMD", "healthcheck.sh"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 60s
+
+  # Oracle Model Generator testing environment
+  oracle-model-generator:
+    build: .
+    depends_on:
+      oracle-db:
+        condition: service_healthy
+    environment:
+      - ORACLE_HOST=oracle-db
+      - ORACLE_PORT=1521
+      - ORACLE_SID=freepdb1
+      - ORACLE_USER=hr
+      - ORACLE_PASSWORD=hr
+    volumes:
+      - .:/app
+    working_dir: /app
+    stdin_open: true
+    tty: true
+    command: ["rake"]  # This will run tests with automatic setup
+
+volumes:
+  oracle_data:

data/docker/oracle/test.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+echo "=== Oracle Model Generator Test ==="
+echo
+
+# Check if Docker is available
+if ! docker --version > /dev/null 2>&1; then
+    echo "❌ Docker is not available"
+    exit 1
+fi
+
+echo "✅ Docker is available"
+
+# Start Oracle database
+echo "🚀 Starting Oracle database with Docker Compose..."
+docker-compose up -d
+
+echo "⏳ Waiting for Oracle to be ready..."
+# Wait for Oracle to be healthy
+timeout=300
+elapsed=0
+while [ $elapsed -lt $timeout ]; do
+    if docker-compose logs oracle-db 2>/dev/null | grep -q "DATABASE IS READY TO USE"; then
+        echo "✅ Oracle database is ready"
+        break
+    fi
+    sleep 5
+    elapsed=$((elapsed + 5))
+    echo "   Still waiting... (${elapsed}s/${timeout}s)"
+done
+
+if [ $elapsed -ge $timeout ]; then
+    echo "❌ Oracle database failed to start within ${timeout} seconds"
+    docker-compose logs oracle-db
+    exit 1
+fi
+
+echo "🧪 Oracle database is ready for testing"
+echo "📋 You can now run Oracle Model Generator tests"
+echo
+echo "To stop the database:"
+echo "  docker-compose down"
+echo
+echo "To connect to Oracle:"
+echo "  docker-compose exec oracle-db sqlplus hr/oracle@//localhost:1521/XEPDB1"