drf-to-mkdoc 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

drf_to_mkdoc/conf/defaults.py

@@ -7,6 +7,7 @@ DEFAULTS = {
     "CUSTOM_SCHEMA_FILE": "docs/configs/custom_schema.json",  # Path to custom schema file
     "PATH_PARAM_SUBSTITUTE_FUNCTION": None,
     "PATH_PARAM_SUBSTITUTE_MAPPING": {},
+    "FIELD_GENERATORS": {},
     # AI documentation settings
     "ENABLE_AI_DOCS": False,
     "AI_CONFIG_DIR_NAME": "ai_code",  # Directory name for AI-generated code files

drf_to_mkdoc/conf/settings.py

@@ -138,8 +138,6 @@ class DRFToMkDocSettings:
         self._validate_range(key, value)
         self._validate_dir(key, value)
 
-        if value is None:
-            raise AttributeError(f"Invalid DRF_TO_MKDOC setting: '{key}'")
         return value
 
     def __getattr__(self, key):

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/form-manager.js

@@ -0,0 +1,172 @@
+// Form management functionality
+const FormManager = {
+    addQueryParam: function() {
+        const container = document.getElementById('queryParams');
+        if (!container) return;
+
+        const kvItem = this.createKvItem('Parameter name', 'Parameter value', true);
+        container.appendChild(kvItem);
+        
+        // Focus on the first input
+        const firstInput = kvItem.querySelector('input');
+        if (firstInput) {
+            firstInput.focus();
+        }
+    },
+
+    addHeader: function() {
+        const container = document.getElementById('requestHeaders');
+        if (!container) return;
+
+        const kvItem = this.createKvItem('Header name', 'Header value', true);
+        container.appendChild(kvItem);
+        
+        // Focus on the first input
+        const firstInput = kvItem.querySelector('input');
+        if (firstInput) {
+            firstInput.focus();
+        }
+    },
+
+    createKvItem: function(namePlaceholder, valuePlaceholder, removable = true) {
+        const kvItem = document.createElement('div');
+        kvItem.className = 'kv-item';
+
+        const nameInput = document.createElement('input');
+        nameInput.type = 'text';
+        nameInput.placeholder = namePlaceholder;
+
+        const valueInput = document.createElement('input');
+        valueInput.type = 'text';
+        valueInput.placeholder = valuePlaceholder;
+
+        kvItem.appendChild(nameInput);
+        kvItem.appendChild(valueInput);
+
+        if (removable) {
+            const removeBtn = document.createElement('button');
+            removeBtn.className = 'remove-btn';
+            removeBtn.textContent = '✕';
+            removeBtn.addEventListener('click', () => this.removeKvItem(removeBtn));
+            kvItem.appendChild(removeBtn);
+        }
+
+        return kvItem;
+    },
+
+    removeKvItem: function(button) {
+        if (button && button.parentElement) {
+            button.parentElement.remove();
+        }
+    },
+
+    validateRequiredParams: function() {
+        const requiredInputs = document.querySelectorAll('#pathParams input[required]');
+        const errors = [];
+
+        requiredInputs.forEach(input => {
+            const errorElement = input.parentElement.querySelector('.error-message');
+            
+            if (!input.value.trim()) {
+                const paramName = input.getAttribute('data-param');
+                errors.push(paramName);
+                input.classList.add('error');
+                
+                if (errorElement) {
+                    errorElement.textContent = `${paramName} is required`;
+                    errorElement.classList.add('show');
+                }
+                
+                // Remove error on input
+                input.addEventListener('input', () => {
+                    input.classList.remove('error');
+                    if (errorElement) {
+                        errorElement.classList.remove('show');
+                    }
+                }, { once: true });
+            } else {
+                input.classList.remove('error');
+                if (errorElement) {
+                    errorElement.classList.remove('show');
+                }
+            }
+        });
+
+        return errors;
+    },
+
+    addSuggestion: function(input, suggestion) {
+        input.value = suggestion;
+        input.focus();
+    },
+
+    buildRequestUrl: function() {
+        const baseUrl = document.getElementById('baseUrl').value.trim();
+        const pathDisplay = document.querySelector('.path-display').textContent.trim();
+        
+        let url = baseUrl + pathDisplay;
+        
+        // Replace path parameters
+        const pathParams = document.querySelectorAll('#pathParams input');
+        pathParams.forEach(input => {
+            const paramName = input.getAttribute('data-param');
+            const paramValue = input.value.trim();
+            if (paramName && paramValue) {
+                url = url.replace(`{${paramName}}`, encodeURIComponent(paramValue));
+            }
+        });
+        
+        // Add query parameters
+        const queryParams = [];
+        const queryInputs = document.querySelectorAll('#queryParams .kv-item');
+        queryInputs.forEach(item => {
+            const inputs = item.querySelectorAll('input');
+            if (inputs.length === 2) {
+                const name = inputs[0].value.trim();
+                const value = inputs[1].value.trim();
+                if (name && value) {
+                    queryParams.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+                }
+            }
+        });
+        
+        if (queryParams.length > 0) {
+            url += '?' + queryParams.join('&');
+        }
+        
+        return url;
+    },
+
+    getRequestHeaders: function() {
+        const headers = {};
+        const headerInputs = document.querySelectorAll('#requestHeaders .kv-item');
+        
+        headerInputs.forEach(item => {
+            const inputs = item.querySelectorAll('input');
+            if (inputs.length === 2) {
+                const name = inputs[0].value.trim();
+                const value = inputs[1].value.trim();
+                if (name && value) {
+                    headers[name] = value;
+                }
+            }
+        });
+        
+        return headers;
+    },
+
+    getRequestBody: function() {
+        const bodyTextarea = document.getElementById('requestBody');
+        if (bodyTextarea && bodyTextarea.value.trim()) {
+            try {
+                return JSON.parse(bodyTextarea.value);
+            } catch (e) {
+                return bodyTextarea.value;
+            }
+        }
+        return null;
+    }
+};
+
+// Export for global access
+window.FormManager = FormManager;

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/main.js

@@ -0,0 +1,22 @@
+// Main try-out functionality - combines all components
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize tabs
+    TabManager.init();
+    
+    // Initialize suggestions if available
+    if (window.TryOutSuggestions) {
+        TryOutSuggestions.init();
+    }
+});
+
+// Legacy compatibility - maintain old interface
+window.TryOutSidebar = {
+    openTryOut: () => ModalManager.openTryOut(),
+    closeTryOut: () => ModalManager.closeTryOut(),
+    closeResponseModal: () => ModalManager.closeResponseModal(),
+    showResponseModal: (status, responseText, responseTime) => ModalManager.showResponseModal(status, responseText, responseTime),
+    addQueryParam: () => FormManager.addQueryParam(),
+    addHeader: () => FormManager.addHeader(),
+    removeKvItem: (button) => FormManager.removeKvItem(button),
+    validateRequiredParams: () => FormManager.validateRequiredParams()
+};

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/modal.js

@@ -0,0 +1,79 @@
+// Modal management functionality
+const ModalManager = {
+    openTryOut: function() {
+        const modal = document.getElementById('tryOutModal');
+        if (modal) {
+            modal.classList.add('show');
+            modal.style.display = 'flex';
+            document.body.classList.add('modal-open');
+            
+            // Focus management
+            const firstInput = modal.querySelector('input, button');
+            if (firstInput) {
+                firstInput.focus();
+            }
+        }
+    },
+
+    closeTryOut: function() {
+        const modal = document.getElementById('tryOutModal');
+        if (modal) {
+            modal.classList.remove('show');
+            modal.style.display = 'none';
+            document.body.classList.remove('modal-open');
+        }
+    },
+
+    openResponseModal: function() {
+        const modal = document.getElementById('responseModal');
+        if (modal) {
+            modal.classList.add('show');
+            modal.style.display = 'flex';
+        }
+    },
+
+    closeResponseModal: function() {
+        const modal = document.getElementById('responseModal');
+        if (modal) {
+            modal.classList.remove('show');
+            modal.style.display = 'none';
+        }
+    },
+
+    showResponseModal: function(status, responseText, responseTime) {
+        const modal = document.getElementById('responseModal');
+        const statusBadge = document.getElementById('modalStatusBadge');
+        const responseBody = document.getElementById('modalResponseBody');
+        const responseInfo = document.getElementById('responseInfo');
+
+        if (modal && statusBadge && responseBody) {
+            statusBadge.textContent = String(status);
+            const code = Number(status);
+            statusBadge.className = 'status-badge' + (Number.isFinite(code) ? ` status-${Math.floor(code/100)*100}` : '');
+
+            try {
+                const jsonResponse = JSON.parse(responseText);
+                responseBody.textContent = JSON.stringify(jsonResponse, null, 2);
+            } catch (e) {
+                responseBody.textContent = responseText;
+            }
+
+            if (responseInfo && responseTime) {
+                responseInfo.textContent = `Response time: ${responseTime}ms`;
+            }
+
+            this.openResponseModal();
+        }
+    }
+};
+
+// Keyboard navigation
+document.addEventListener('keydown', function(e) {
+    if (e.key === 'Escape') {
+        ModalManager.closeTryOut();
+        ModalManager.closeResponseModal();
+    }
+});
+
+// Export for global access
+window.ModalManager = ModalManager;

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/request-executor.js

@@ -0,0 +1,111 @@
+// Request execution functionality
+const RequestExecutor = {
+    async executeRequest() {
+        const executeBtn = document.getElementById('executeBtn');
+        if (!executeBtn) return;
+
+        // Validate required parameters
+        const emptyParams = FormManager.validateRequiredParams();
+        if (emptyParams.length > 0) {
+            // Switch to parameters tab if we're on a different tab
+            const activeTab = document.querySelector('.try-out-form .tab.active');
+            if (activeTab && activeTab.getAttribute('data-tab') !== 'parameters') {
+                const parametersTab = document.querySelector('.try-out-form .tab[data-tab="parameters"]');
+                if (parametersTab) {
+                    TabManager.switchTab(parametersTab);
+                }
+            }
+            
+            this.showValidationError(`Please fill in the required parameters: ${emptyParams.join(', ')}`);
+            return;
+        }
+
+        // Show loading state
+        this.setLoadingState(executeBtn, true);
+
+        try {
+            const startTime = Date.now();
+            const url = FormManager.buildRequestUrl();
+            const headers = FormManager.getRequestHeaders();
+            const body = FormManager.getRequestBody();
+            const method = document.querySelector('.try-out-form')?.getAttribute('data-method') || 'GET';
+
+            const requestOptions = {
+                method: method.toUpperCase(),
+                headers: headers
+            };
+
+            // Add body for non-GET requests
+            if (body && !['GET', 'HEAD'].includes(method.toUpperCase())) {
+                if (typeof body === 'string') {
+                    requestOptions.body = body;
+                } else {
+                    requestOptions.body = JSON.stringify(body);
+                    if (!headers['Content-Type']) {
+                        requestOptions.headers['Content-Type'] = 'application/json';
+                    }
+                }
+            }
+
+            const response = await fetch(url, requestOptions);
+            const responseTime = Date.now() - startTime;
+            const responseText = await response.text();
+
+            ModalManager.showResponseModal(response.status, responseText, responseTime);
+
+        } catch (error) {
+            let errorMessage = error.message || 'Unknown error occurred';
+            ModalManager.showResponseModal('Error', errorMessage);
+        } finally {
+            this.setLoadingState(executeBtn, false);
+        }
+    },
+
+    setLoadingState(button, loading) {
+        button.disabled = loading;
+        button.innerHTML = '';
+        
+        if (loading) {
+            const spinner = document.createElement('div');
+            spinner.className = 'spinner';
+            const text = document.createTextNode(' Sending...');
+            button.appendChild(spinner);
+            button.appendChild(text);
+        } else {
+            const playIcon = document.createElement('span');
+            playIcon.textContent = '▶';
+            const text = document.createTextNode(' Execute Request');
+            button.appendChild(playIcon);
+            button.appendChild(text);
+        }
+    },
+
+    showValidationError(message) {
+        // Create or update validation error display
+        let errorDiv = document.getElementById('validation-error');
+        if (!errorDiv) {
+            errorDiv = document.createElement('div');
+            errorDiv.id = 'validation-error';
+            errorDiv.className = 'error-message show';
+            
+            const executeBtn = document.getElementById('executeBtn');
+            if (executeBtn) {
+                executeBtn.parentNode.insertBefore(errorDiv, executeBtn);
+            }
+        }
+        
+        errorDiv.textContent = message;
+        errorDiv.classList.add('show');
+        
+        // Auto-hide after 5 seconds
+        setTimeout(() => {
+            errorDiv.classList.remove('show');
+        }, 5000);
+    }
+};
+
+// Global function for onclick handlers
+window.executeRequest = () => RequestExecutor.executeRequest();
+
+// Export for global access
+window.RequestExecutor = RequestExecutor;

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/suggestions.js

@@ -0,0 +1,216 @@
+// Query parameter suggestions functionality
+const TryOutSuggestions = {
+    init: function() {
+        this.suggestions = this.getAvailableSuggestions();
+        this.setupAutocomplete();
+    },
+
+    setupAutocomplete: function() {
+        // Setup event listeners for all query parameter inputs
+        document.addEventListener('click', (e) => {
+            // Hide all suggestion dropdowns when clicking outside
+            if (!e.target.matches('#queryParams input')) {
+                this.hideAllSuggestions();
+            }
+        });
+
+        // Initial setup for existing inputs
+        this.setupExistingInputs();
+
+        // Setup for the add button to attach listeners to new inputs
+        const addBtn = document.querySelector('.add-btn');
+        if (addBtn) {
+            addBtn.addEventListener('click', () => {
+                // Wait for DOM to update
+                setTimeout(() => {
+                    this.setupExistingInputs();
+                }, 10);
+            });
+        }
+    },
+
+    setupExistingInputs: function() {
+        // Find all parameter name inputs
+        const paramInputs = document.querySelectorAll('#queryParams .kv-item input:first-child');
+        paramInputs.forEach(input => {
+            // Skip if already initialized
+            if (input.dataset.autocompleteInitialized) return;
+            
+            // Mark as initialized
+            input.dataset.autocompleteInitialized = 'true';
+            
+            // Create suggestions container for this input
+            const suggestionsContainer = document.createElement('div');
+            suggestionsContainer.className = 'param-suggestions';
+            suggestionsContainer.id = 'suggestions-' + Math.random().toString(36).substr(2, 9);
+            input.parentNode.style.position = 'relative';
+            input.parentNode.appendChild(suggestionsContainer);
+            
+            // Store reference to container
+            input.dataset.suggestionsContainer = suggestionsContainer.id;
+            
+            // Add event listeners
+            input.addEventListener('focus', () => this.showSuggestions(input));
+            input.addEventListener('input', () => this.filterSuggestions(input));
+            input.addEventListener('keydown', (e) => this.handleKeyNavigation(e, input));
+        });
+    },
+
+    getAvailableSuggestions: function() {
+        const suggestions = [];
+        
+        // Try to get query parameters from the page context
+        if (window.queryParametersData) {
+            const data = window.queryParametersData;
+            
+            // Add filter fields
+            if (data.filter_fields && data.filter_fields.length > 0) {
+                suggestions.push(...data.filter_fields);
+            }
+            
+            // Add search if available
+            if (data.search_fields && data.search_fields.length > 0) {
+                suggestions.push('search');
+            }
+            
+            // Add ordering if available
+            if (data.ordering_fields && data.ordering_fields.length > 0) {
+                suggestions.push('ordering');
+            }
+            
+            // Add pagination
+            if (data.pagination_fields && data.pagination_fields.length > 0) {
+                suggestions.push(...data.pagination_fields);
+            }
+        }
+        
+        // Default common parameters
+        if (suggestions.length === 0) {
+            suggestions.push('search', 'ordering', 'page', 'page_size');
+        }
+        
+        // Remove duplicates and return
+        return [...new Set(suggestions)];
+    },
+
+    showSuggestions: function(input) {
+        const container = document.getElementById(input.dataset.suggestionsContainer);
+        if (!container) return;
+        
+        // Clear existing suggestions
+        container.innerHTML = '';
+        
+        // Filter suggestions based on input value
+        const inputValue = input.value.toLowerCase();
+        const filteredSuggestions = this.suggestions.filter(suggestion => 
+            suggestion.toLowerCase().includes(inputValue)
+        );
+        
+        if (filteredSuggestions.length === 0) {
+            container.classList.remove('show');
+            return;
+        }
+        
+        // Add suggestions to container
+        filteredSuggestions.forEach(suggestion => {
+            const suggestionElement = document.createElement('div');
+            suggestionElement.className = 'param-suggestion';
+            suggestionElement.textContent = suggestion;
+            suggestionElement.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.selectSuggestion(input, suggestion);
+            });
+            container.appendChild(suggestionElement);
+        });
+        
+        // Show suggestions
+        container.classList.add('show');
+    },
+    
+    filterSuggestions: function(input) {
+        // Just re-show suggestions with current filter
+        this.showSuggestions(input);
+    },
+    
+    hideAllSuggestions: function() {
+        document.querySelectorAll('.param-suggestions').forEach(container => {
+            container.classList.remove('show');
+        });
+    },
+    
+    selectSuggestion: function(input, suggestion) {
+        // Set input value
+        input.value = suggestion;
+        
+        // Hide suggestions
+        const container = document.getElementById(input.dataset.suggestionsContainer);
+        if (container) {
+            container.classList.remove('show');
+        }
+        
+        // Focus on value input
+        const valueInput = input.nextElementSibling;
+        if (valueInput) {
+            valueInput.focus();
+        }
+    },
+    
+    handleKeyNavigation: function(event, input) {
+        const container = document.getElementById(input.dataset.suggestionsContainer);
+        if (!container || !container.classList.contains('show')) return;
+        
+        const suggestions = container.querySelectorAll('.param-suggestion');
+        if (suggestions.length === 0) return;
+        
+        // Find currently selected suggestion
+        const selectedIndex = Array.from(suggestions).findIndex(el => el.classList.contains('selected'));
+        
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.navigateSuggestion(suggestions, selectedIndex, 1);
+                break;
+                
+            case 'ArrowUp':
+                event.preventDefault();
+                this.navigateSuggestion(suggestions, selectedIndex, -1);
+                break;
+                
+            case 'Enter':
+                event.preventDefault();
+                if (selectedIndex >= 0) {
+                    this.selectSuggestion(input, suggestions[selectedIndex].textContent);
+                } else if (suggestions.length > 0) {
+                    this.selectSuggestion(input, suggestions[0].textContent);
+                }
+                break;
+                
+            case 'Escape':
+                event.preventDefault();
+                container.classList.remove('show');
+                break;
+        }
+    },
+    
+    navigateSuggestion: function(suggestions, currentIndex, direction) {
+        // Remove current selection
+        if (currentIndex >= 0) {
+            suggestions[currentIndex].classList.remove('selected');
+        }
+        
+        // Calculate new index
+        let newIndex;
+        if (currentIndex < 0) {
+            newIndex = direction > 0 ? 0 : suggestions.length - 1;
+        } else {
+            newIndex = (currentIndex + direction + suggestions.length) % suggestions.length;
+        }
+        
+        // Select new suggestion
+        suggestions[newIndex].classList.add('selected');
+        suggestions[newIndex].scrollIntoView({ block: 'nearest' });
+    }
+};
+
+// Export for global access
+window.TryOutSuggestions = TryOutSuggestions;

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/tabs.js

@@ -0,0 +1,34 @@
+// Tab management functionality
+const TabManager = {
+    init: function() {
+        document.querySelectorAll('.try-out-form .tab').forEach(tab => {
+            tab.addEventListener('click', () => {
+                this.switchTab(tab);
+            });
+        });
+    },
+
+    switchTab: function(activeTab) {
+        // Remove active class from all tabs and contents
+        document.querySelectorAll('.try-out-form .tab').forEach(t => t.classList.remove('active'));
+        document.querySelectorAll('.try-out-form .tab-content').forEach(c => c.classList.remove('active'));
+
+        // Add active class to clicked tab
+        activeTab.classList.add('active');
+        
+        // Show corresponding content
+        const tabName = activeTab.getAttribute('data-tab');
+        const content = document.getElementById(tabName + 'Tab');
+        if (content) {
+            content.classList.add('active');
+        }
+    }
+};
+
+// Initialize tabs when DOM is ready
+document.addEventListener('DOMContentLoaded', function() {
+    TabManager.init();
+});
+
+// Export for global access
+window.TabManager = TabManager;