the_mechanic_2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d9dcefb28ca750b5d08ffb9d386fe32e8d34a900c0ee1dffcf553b2ac6749709
+  data.tar.gz: 252eb9d7182588e6b1f26013ab1b59917b02c09e11726190fb6f426aa44e2f53
+SHA512:
+  metadata.gz: 1e7a45220f066f260365325abd65e857ef8ea82cd3a6cf6c187c880c1b01fdd5d6904ab9629fda45d70fc2fdb5cc8007ae547f7b44f6a8bb5cf887f8176a6170
+  data.tar.gz: 64f74833b90beaffe0cafdb1f90e757ecc7b21353e842f6ad4b57dfa77587aae451702dec77ba463e0699f1c094c88cc94d5044ea1c8681a37ee25675528104d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright mrpandapants
+
+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.md

@@ -0,0 +1,254 @@
+# The Mechanic 2 🔧
+
+A Rails Engine for benchmarking Ruby code with full access to your application's classes and dependencies.
+
+## Features
+
+- **Rails Engine Integration**: Mount directly into any Rails application
+- **Full Application Context**: Benchmark code with access to all your models, services, and gems
+- **Side-by-Side Comparison**: Compare two code snippets with detailed performance metrics
+- **Security First**: Built-in code validation prevents dangerous operations
+- **Zero Configuration**: Just add the gem and mount the route
+- **Self-Contained**: All assets (CSS & JavaScript) are inlined - no asset pipeline required
+- **Export Results**: Download results as JSON or Markdown
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'the_mechanic_2', path: 'path/to/the_mechanic_2'
+# or from git
+gem 'the_mechanic_2', git: 'https://github.com/yourusername/the_mechanic_2'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### 1. Mount the Engine
+
+Add this to your `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+  mount TheMechanic2::Engine => '/ask_the_mechanic_2'
+  
+  # Your other routes...
+end
+```
+
+### 2. Start Your Rails Server
+
+```bash
+rails server
+```
+
+### 3. Access The Mechanic
+
+Navigate to: `http://localhost:3000/ask_the_mechanic_2`
+
+That's it! No additional setup required.
+
+## Example Usage
+
+### Basic Comparison
+
+**Shared Setup:**
+```ruby
+arr = (1..1000).to_a
+```
+
+**Code A:**
+```ruby
+arr.sum
+```
+
+**Code B:**
+```ruby
+arr.reduce(:+)
+```
+
+### With ActiveRecord Models
+
+**Shared Setup:**
+```ruby
+users = User.limit(100)
+```
+
+**Code A:**
+```ruby
+users.map(&:full_name)
+```
+
+**Code B:**
+```ruby
+users.pluck(:first_name, :last_name).map { |f, l| "#{f} #{l}" }
+```
+
+## Configuration (Optional)
+
+Create an initializer at `config/initializers/the_mechanic_2.rb`:
+
+```ruby
+TheMechanic2.configure do |config|
+  # Set custom timeout (default: 30 seconds)
+  config.timeout = 60
+  
+  # Enable authentication (default: false)
+  config.enable_authentication = true
+  
+  # Set authentication callback
+  config.authentication_callback = ->(controller) {
+    controller.current_user&.admin?
+  }
+end
+```
+
+### Configuration Options
+
+- **timeout**: Maximum execution time per benchmark (1-300 seconds, default: 30)
+- **enable_authentication**: Require authentication before allowing benchmarks (default: false)
+- **authentication_callback**: Proc that receives the controller and returns true/false
+
+## Security
+
+The Mechanic includes comprehensive security validation:
+
+- ✅ **Process Isolation**: Each benchmark runs in a separate Rails runner process
+- ✅ **Code Validation**: Blocks dangerous operations before execution
+- ✅ **Timeout Protection**: Automatically terminates long-running code
+- ✅ **Read-Only Database**: Write operations are blocked
+- ✅ **No File System Access**: File operations are forbidden
+- ✅ **No Network Access**: Network operations are blocked
+- ✅ **No System Calls**: System-level operations are prevented
+
+### Forbidden Operations
+
+The following operations are automatically blocked:
+
+- System calls (`system`, `exec`, `spawn`, backticks)
+- File operations (`File.open`, `File.read`, `File.write`)
+- Network operations (`Net::HTTP`, `Socket`, `URI.open`)
+- Database writes (`save`, `update`, `destroy`, `create`)
+- Thread creation (`Thread.new`)
+- Dangerous evals (`eval`, `instance_eval`, `class_eval`)
+
+## API Endpoints
+
+The engine provides the following endpoints:
+
+- `GET /ask_the_mechanic_2` - Main UI
+- `POST /ask_the_mechanic_2/validate` - Validate code without executing
+- `POST /ask_the_mechanic_2/run` - Execute benchmark
+- `POST /ask_the_mechanic_2/export` - Export results (JSON or Markdown)
+
+## Platform Requirements
+
+- **Ruby**: 2.7.0 or higher
+- **Rails**: 6.0 or higher
+- **Platform**: Linux, macOS, BSD, Unix, Windows
+
+## Performance Metrics
+
+The Mechanic measures:
+
+- **IPS**: Iterations per second
+- **Standard Deviation**: Performance consistency
+- **Objects Allocated**: Memory allocation count
+- **Memory Usage**: Total memory in MB
+- **Execution Time**: Single run duration
+
+## Development
+
+### Running Tests
+
+```bash
+cd the_mechanic_2
+bundle exec rspec
+```
+
+### Test Coverage
+
+- 163 tests covering all services, models, and controllers
+- Comprehensive security validation tests
+- Integration tests with dummy Rails app
+
+## How It Works
+
+1. **Code Submission**: User submits two code snippets via the web interface
+2. **Security Validation**: Code is validated for dangerous operations
+3. **Process Spawning**: Each snippet runs in a separate `rails runner` process
+4. **Measurement**: Performance and memory metrics are collected
+5. **Comparison**: Results are compared and a winner is determined
+6. **Display**: Results are shown side-by-side with detailed metrics
+
+## Architecture
+
+```
+TheMechanic2::Engine
+├── BenchmarksController    # HTTP endpoints
+├── BenchmarkService        # Orchestrates benchmarking
+├── RailsRunnerService      # Spawns isolated processes
+├── SecurityService         # Validates code safety
+├── BenchmarkRequest        # Request validation
+└── BenchmarkResult         # Result formatting & export
+```
+
+## Troubleshooting
+
+### Benchmarks are slow
+
+- Reduce the timeout value
+- Simplify your code snippets
+- Check if your Rails app has slow boot time
+
+### "Timeout exceeded" errors
+
+- Increase the timeout in configuration
+- Simplify your benchmark code
+- Check for infinite loops
+
+### Can't access my models
+
+- Ensure your Rails app is fully loaded
+- Check that models are properly defined
+- Verify the engine is mounted correctly
+
+### Authentication not working
+
+- Verify `enable_authentication` is set to `true`
+- Check your authentication callback logic
+- Ensure the callback has access to the controller
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Credits
+
+Inspired by the original [The Mechanic](https://github.com/yourusername/the_mechanic_2) standalone application.
+
+Built with:
+- [benchmark-ips](https://github.com/evanphx/benchmark-ips) - Performance measurement
+- [memory_profiler](https://github.com/SamSaffron/memory_profiler) - Memory tracking
+
+## Support
+
+For issues and questions, please open an issue on GitHub.
+
+---
+
+**Made with ❤️ for the Ruby community**

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/setup"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/javascripts/the_mechanic_2/application.js

@@ -0,0 +1,426 @@
+// The Mechanic 2 - Inline JavaScript
+// Provides UI functionality without external dependencies
+
+(function() {
+  'use strict';
+  
+  // Get the base path from the current URL
+  const basePath = window.location.pathname.replace(/\/$/, '');
+  
+  // State management
+  const state = {
+    results: null,
+    logs: null,
+    isRunning: false,
+    logsExpanded: false,
+    activeLogTab: 'summary'
+  };
+  
+  // Initialize the application
+  function init() {
+    setupEventListeners();
+    initializeEditors();
+  }
+  
+  // Setup event listeners
+  function setupEventListeners() {
+    // Validate button
+    const validateBtn = document.getElementById('validate-btn');
+    if (validateBtn) {
+      validateBtn.addEventListener('click', handleValidate);
+    }
+    
+    // Run button
+    const runBtn = document.getElementById('run-btn');
+    if (runBtn) {
+      runBtn.addEventListener('click', handleRun);
+    }
+    
+    // Reset button
+    const resetBtn = document.getElementById('reset-btn');
+    if (resetBtn) {
+      resetBtn.addEventListener('click', handleReset);
+    }
+    
+    // Logs toggle
+    const logsToggle = document.getElementById('logs-toggle');
+    if (logsToggle) {
+      logsToggle.addEventListener('click', toggleLogs);
+    }
+    
+    // Log tabs
+    const logTabs = document.querySelectorAll('.log-tab');
+    logTabs.forEach(tab => {
+      tab.addEventListener('click', () => switchLogTab(tab.dataset.tab));
+    });
+  }
+  
+  // Initialize simple text editors (fallback if Monaco is not available)
+  function initializeEditors() {
+    // For now, use simple textareas
+    // Monaco Editor can be added later if needed
+    const sharedSetup = document.getElementById('shared-setup');
+    const codeA = document.getElementById('code-a');
+    const codeB = document.getElementById('code-b');
+    
+    if (sharedSetup) sharedSetup.style.fontFamily = 'Monaco, Menlo, monospace';
+    if (codeA) codeA.style.fontFamily = 'Monaco, Menlo, monospace';
+    if (codeB) codeB.style.fontFamily = 'Monaco, Menlo, monospace';
+  }
+  
+  // Handle validate button click
+  async function handleValidate() {
+    clearMessages();
+    
+    const sharedSetup = document.getElementById('shared-setup').value;
+    const codeA = document.getElementById('code-a').value;
+    const codeB = document.getElementById('code-b').value;
+    
+    try {
+      const response = await fetch(`${basePath}/validate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content
+        },
+        body: JSON.stringify({
+          shared_setup: sharedSetup,
+          code_a: codeA,
+          code_b: codeB
+        })
+      });
+      
+      const data = await response.json();
+      
+      if (data.valid) {
+        showSuccess('All code is valid and safe to run!');
+      } else {
+        showError('Validation failed', data.errors);
+      }
+    } catch (error) {
+      showError('Validation error', [error.message]);
+    }
+  }
+  
+  // Handle run button click
+  async function handleRun() {
+    if (state.isRunning) return;
+    
+    clearMessages();
+    hideResults();
+    
+    const sharedSetup = document.getElementById('shared-setup').value;
+    const codeA = document.getElementById('code-a').value;
+    const codeB = document.getElementById('code-b').value;
+    const timeout = parseInt(document.getElementById('timeout').value) || 30;
+    
+    if (!codeA.trim() || !codeB.trim()) {
+      showError('Missing code', ['Both Code A and Code B are required']);
+      return;
+    }
+    
+    setRunning(true);
+    
+    try {
+      const response = await fetch(`${basePath}/run`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content
+        },
+        body: JSON.stringify({
+          shared_setup: sharedSetup,
+          code_a: codeA,
+          code_b: codeB,
+          timeout: timeout
+        })
+      });
+      
+      const data = await response.json();
+      
+      if (response.ok) {
+        state.results = data;
+        displayResults(data);
+        showSuccess('Benchmark completed successfully!');
+      } else {
+        showError(data.error || 'Benchmark failed', data.errors || [data.message]);
+      }
+    } catch (error) {
+      showError('Benchmark error', [error.message]);
+    } finally {
+      setRunning(false);
+    }
+  }
+  
+  // Handle reset button click
+  function handleReset() {
+    if (confirm('Are you sure you want to reset? This will clear all inputs and results.')) {
+      document.getElementById('shared-setup').value = '';
+      document.getElementById('code-a').value = '';
+      document.getElementById('code-b').value = '';
+      document.getElementById('timeout').value = '30';
+      clearMessages();
+      hideResults();
+      state.results = null;
+      state.logs = null;
+    }
+  }
+  
+
+  
+  // Display results
+  function displayResults(data) {
+    const resultsSection = document.getElementById('results-section');
+    if (!resultsSection) return;
+    
+    resultsSection.classList.remove('hidden');
+    
+    // Display Code A metrics
+    displayMetrics('code-a', data.code_a_metrics, data.winner === 'code_a');
+    
+    // Display Code B metrics
+    displayMetrics('code-b', data.code_b_metrics, data.winner === 'code_b');
+    
+    // Display summary
+    const summaryText = document.getElementById('summary-text');
+    if (summaryText) {
+      summaryText.textContent = data.summary;
+    }
+    
+    // Show runtime logs section
+    const logsSection = document.getElementById('runtime-logs-section');
+    if (logsSection) {
+      logsSection.classList.remove('hidden');
+    }
+    
+    // Update log panels
+    updateLogPanels(data);
+  }
+  
+  // Display metrics for a code snippet
+  function displayMetrics(codeId, metrics, isWinner) {
+    const card = document.getElementById(`${codeId}-card`);
+    if (!card) return;
+    
+    if (isWinner) {
+      card.classList.add('winner');
+    } else {
+      card.classList.remove('winner');
+    }
+    
+    const winnerBadge = card.querySelector('.winner-badge');
+    if (winnerBadge) {
+      winnerBadge.classList.toggle('hidden', !isWinner);
+    }
+    
+    // Update metrics
+    updateMetric(card, 'ips', formatNumber(metrics.ips));
+    updateMetric(card, 'stddev', formatNumber(metrics.stddev));
+    updateMetric(card, 'objects', formatNumber(metrics.objects));
+    updateMetric(card, 'memory', formatNumber(metrics.memory_mb) + ' MB');
+    updateMetric(card, 'time', formatNumber(metrics.execution_time) + ' sec');
+  }
+  
+  // Update a single metric
+  function updateMetric(card, metricName, value) {
+    const element = card.querySelector(`[data-metric="${metricName}"]`);
+    if (element) {
+      element.textContent = value;
+    }
+  }
+  
+  // Format number for display
+  function formatNumber(num) {
+    if (num === null || num === undefined) return '0';
+    
+    if (typeof num === 'number') {
+      if (num < 0.01) {
+        return num.toFixed(6);
+      } else if (num < 1) {
+        return num.toFixed(4);
+      } else if (num < 100) {
+        return num.toFixed(2);
+      } else {
+        return Math.round(num).toLocaleString();
+      }
+    }
+    
+    return num.toString();
+  }
+  
+  // Update log panels with benchmark data
+  function updateLogPanels(data) {
+    // Summary log
+    const summaryLog = document.getElementById('summary-log');
+    if (summaryLog) {
+      summaryLog.textContent = `${data.summary}
+
+Code A Performance:
+  IPS: ${formatNumber(data.code_a_metrics.ips)} iterations/sec
+  Std Dev: ±${formatNumber(data.code_a_metrics.stddev)}
+  Objects: ${formatNumber(data.code_a_metrics.objects)}
+  Memory: ${formatNumber(data.code_a_metrics.memory_mb)} MB
+  Time: ${formatNumber(data.code_a_metrics.execution_time)} sec
+
+Code B Performance:
+  IPS: ${formatNumber(data.code_b_metrics.ips)} iterations/sec
+  Std Dev: ±${formatNumber(data.code_b_metrics.stddev)}
+  Objects: ${formatNumber(data.code_b_metrics.objects)}
+  Memory: ${formatNumber(data.code_b_metrics.memory_mb)} MB
+  Time: ${formatNumber(data.code_b_metrics.execution_time)} sec`;
+    }
+    
+    // Benchmark log
+    const benchmarkLog = document.getElementById('benchmark-log');
+    if (benchmarkLog) {
+      benchmarkLog.textContent = `Benchmark.ips Results:
+
+Code A: ${formatNumber(data.code_a_metrics.ips)} i/s
+Code B: ${formatNumber(data.code_b_metrics.ips)} i/s
+
+Winner: ${data.winner === 'code_a' ? 'Code A' : data.winner === 'code_b' ? 'Code B' : 'Tie'}
+Performance Ratio: ${data.performance_ratio}×`;
+    }
+    
+    // Memory log
+    const memoryLog = document.getElementById('memory-log');
+    if (memoryLog) {
+      memoryLog.textContent = `Memory Profiling Results:
+
+Code A:
+  Total Objects Allocated: ${formatNumber(data.code_a_metrics.objects)}
+  Total Memory: ${formatNumber(data.code_a_metrics.memory_mb)} MB
+
+Code B:
+  Total Objects Allocated: ${formatNumber(data.code_b_metrics.objects)}
+  Total Memory: ${formatNumber(data.code_b_metrics.memory_mb)} MB`;
+    }
+    
+    // GC log
+    const gcLog = document.getElementById('gc-log');
+    if (gcLog) {
+      gcLog.textContent = `Garbage Collection Statistics:
+
+Note: GC statistics collection is not yet implemented.
+This will show Ruby GC stats during benchmark execution.`;
+    }
+  }
+  
+  // Toggle logs visibility
+  function toggleLogs() {
+    state.logsExpanded = !state.logsExpanded;
+    const logsContent = document.getElementById('logs-content');
+    const logsToggle = document.getElementById('logs-toggle');
+    const chevron = logsToggle?.querySelector('.logs-chevron');
+    const toggleText = logsToggle?.querySelector('.logs-toggle-text');
+    
+    if (logsContent) {
+      logsContent.classList.toggle('hidden');
+    }
+    
+    if (chevron) {
+      chevron.classList.toggle('expanded');
+    }
+    
+    if (toggleText) {
+      toggleText.textContent = state.logsExpanded ? 'Click to collapse' : 'Click to expand';
+    }
+    
+    if (logsToggle) {
+      logsToggle.setAttribute('aria-expanded', state.logsExpanded);
+    }
+  }
+  
+  // Switch log tab
+  function switchLogTab(tabName) {
+    state.activeLogTab = tabName;
+    
+    // Update tab buttons
+    document.querySelectorAll('.log-tab').forEach(tab => {
+      tab.classList.toggle('active', tab.dataset.tab === tabName);
+    });
+    
+    // Update panels
+    document.querySelectorAll('.log-panel').forEach(panel => {
+      panel.classList.toggle('hidden', panel.dataset.panel !== tabName);
+    });
+  }
+  
+  // Set running state
+  function setRunning(running) {
+    state.isRunning = running;
+    
+    const runBtn = document.getElementById('run-btn');
+    const validateBtn = document.getElementById('validate-btn');
+    
+    if (runBtn) {
+      runBtn.disabled = running;
+      runBtn.innerHTML = running ? 
+        '<span class="loading-spinner"></span> Running...' : 
+        'Run Benchmark';
+    }
+    
+    if (validateBtn) {
+      validateBtn.disabled = running;
+    }
+  }
+  
+  // Show success message
+  function showSuccess(message) {
+    const container = document.getElementById('message-container');
+    if (!container) return;
+    
+    container.innerHTML = `
+      <div class="success-message">
+        ${message}
+      </div>
+    `;
+  }
+  
+  // Show error message
+  function showError(title, errors) {
+    const container = document.getElementById('message-container');
+    if (!container) return;
+    
+    const errorList = errors && errors.length > 0 ? `
+      <ul class="error-list">
+        ${errors.map(e => `<li>${e}</li>`).join('')}
+      </ul>
+    ` : '';
+    
+    container.innerHTML = `
+      <div class="error-message">
+        <strong>${title}</strong>
+        ${errorList}
+      </div>
+    `;
+  }
+  
+  // Clear messages
+  function clearMessages() {
+    const container = document.getElementById('message-container');
+    if (container) {
+      container.innerHTML = '';
+    }
+  }
+  
+  // Hide results
+  function hideResults() {
+    const resultsSection = document.getElementById('results-section');
+    if (resultsSection) {
+      resultsSection.classList.add('hidden');
+    }
+    
+    const logsSection = document.getElementById('runtime-logs-section');
+    if (logsSection) {
+      logsSection.classList.add('hidden');
+    }
+  }
+  
+  // Initialize when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+})();