430 lines
9.4 KiB
Go
430 lines
9.4 KiB
Go
package main
|
||
|
||
import (
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
|
||
"github.com/landaiqing/freezelib"
|
||
)
|
||
|
||
func main() {
|
||
fmt.Println("🔍 FreezeLib Auto Language Detection Examples")
|
||
fmt.Println("=============================================")
|
||
|
||
// Create output directory
|
||
err := os.MkdirAll("output", 0755)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error creating output directory: %v\n", err)
|
||
return
|
||
}
|
||
|
||
// Run examples
|
||
basicAutoDetectionExample()
|
||
languageDetectionAPIExample()
|
||
customLanguageDetectorExample()
|
||
batchAutoDetectionExample()
|
||
languageAnalysisExample()
|
||
}
|
||
|
||
// Basic auto detection example
|
||
func basicAutoDetectionExample() {
|
||
fmt.Println("\n🎯 Basic Auto Detection")
|
||
fmt.Println("-----------------------")
|
||
|
||
freeze := freezelib.New()
|
||
|
||
// Different code samples without specifying language
|
||
codeSamples := []struct {
|
||
name string
|
||
code string
|
||
}{
|
||
{
|
||
"go_example",
|
||
`package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
fmt.Println("Hello, Go!")
|
||
|
||
// Goroutine example
|
||
go func() {
|
||
fmt.Println("Running in goroutine")
|
||
}()
|
||
}`,
|
||
},
|
||
{
|
||
"python_example",
|
||
`#!/usr/bin/env python3
|
||
|
||
def fibonacci(n):
|
||
"""Calculate fibonacci number recursively."""
|
||
if n <= 1:
|
||
return n
|
||
return fibonacci(n-1) + fibonacci(n-2)
|
||
|
||
if __name__ == "__main__":
|
||
print(f"Fibonacci(10) = {fibonacci(10)}")`,
|
||
},
|
||
{
|
||
"javascript_example",
|
||
`// Modern JavaScript with async/await
|
||
async function fetchUserData(userId) {
|
||
try {
|
||
const response = await fetch('/api/users/' + userId);
|
||
const userData = await response.json();
|
||
|
||
return {
|
||
...userData,
|
||
lastUpdated: new Date().toISOString()
|
||
};
|
||
} catch (error) {
|
||
console.error('Failed to fetch user data:', error);
|
||
throw error;
|
||
}
|
||
}`,
|
||
},
|
||
{
|
||
"rust_example",
|
||
`use std::collections::HashMap;
|
||
|
||
fn main() {
|
||
let mut scores = HashMap::new();
|
||
|
||
scores.insert(String::from("Blue"), 10);
|
||
scores.insert(String::from("Yellow"), 50);
|
||
|
||
for (key, value) in &scores {
|
||
println!("{}: {}", key, value);
|
||
}
|
||
}`,
|
||
},
|
||
}
|
||
|
||
for _, sample := range codeSamples {
|
||
fmt.Printf("🔍 Processing %s (auto-detecting language)...\n", sample.name)
|
||
|
||
// Detect language first
|
||
detectedLang := freeze.DetectLanguage(sample.code)
|
||
fmt.Printf(" Detected language: %s\n", detectedLang)
|
||
|
||
// Generate with auto detection
|
||
svgData, err := freeze.GenerateFromCodeAuto(sample.code)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error generating %s: %v\n", sample.name, err)
|
||
continue
|
||
}
|
||
|
||
filename := fmt.Sprintf("output/auto_%s.svg", sample.name)
|
||
err = os.WriteFile(filename, svgData, 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
||
continue
|
||
}
|
||
|
||
fmt.Printf("✅ Generated: %s\n", filename)
|
||
}
|
||
}
|
||
|
||
// Language detection API example
|
||
func languageDetectionAPIExample() {
|
||
fmt.Println("\n🔧 Language Detection API")
|
||
fmt.Println("-------------------------")
|
||
|
||
freeze := freezelib.New()
|
||
|
||
// Test different detection methods
|
||
testCodes := []struct {
|
||
name string
|
||
code string
|
||
filename string
|
||
}{
|
||
{
|
||
"config_file",
|
||
`{
|
||
"name": "my-app",
|
||
"version": "1.0.0",
|
||
"dependencies": {
|
||
"express": "^4.18.0",
|
||
"lodash": "^4.17.21"
|
||
}
|
||
}`,
|
||
"package.json",
|
||
},
|
||
{
|
||
"shell_script",
|
||
`#!/bin/bash
|
||
|
||
# Deploy script
|
||
set -e
|
||
|
||
echo "Starting deployment..."
|
||
|
||
if [ ! -d "dist" ]; then
|
||
echo "Building project..."
|
||
npm run build
|
||
fi
|
||
|
||
echo "Deploying to server..."
|
||
rsync -av dist/ user@server:/var/www/html/
|
||
|
||
echo "Deployment complete!"`,
|
||
"deploy.sh",
|
||
},
|
||
{
|
||
"dockerfile",
|
||
`FROM node:18-alpine
|
||
|
||
WORKDIR /app
|
||
|
||
COPY package*.json ./
|
||
RUN npm ci --only=production
|
||
|
||
COPY . .
|
||
|
||
EXPOSE 3000
|
||
|
||
CMD ["npm", "start"]`,
|
||
"Dockerfile",
|
||
},
|
||
}
|
||
|
||
for _, test := range testCodes {
|
||
fmt.Printf("🔍 Analyzing %s...\n", test.name)
|
||
|
||
// Test different detection methods
|
||
langFromContent := freeze.DetectLanguage(test.code)
|
||
langFromFilename := freeze.DetectLanguageFromFilename(test.filename)
|
||
langFromBoth := freeze.DetectLanguageFromFile(test.filename, test.code)
|
||
|
||
fmt.Printf(" Content-based: %s\n", langFromContent)
|
||
fmt.Printf(" Filename-based: %s\n", langFromFilename)
|
||
fmt.Printf(" Combined: %s\n", langFromBoth)
|
||
|
||
// Generate screenshot using the best detection
|
||
svgData, err := freeze.GenerateFromCodeAuto(test.code)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error generating %s: %v\n", test.name, err)
|
||
continue
|
||
}
|
||
|
||
filename := fmt.Sprintf("output/detection_%s.svg", test.name)
|
||
err = os.WriteFile(filename, svgData, 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
||
continue
|
||
}
|
||
|
||
fmt.Printf("✅ Generated: %s\n", filename)
|
||
}
|
||
}
|
||
|
||
// Custom language detector example
|
||
func customLanguageDetectorExample() {
|
||
fmt.Println("\n⚙️ Custom Language Detector")
|
||
fmt.Println("---------------------------")
|
||
|
||
freeze := freezelib.New()
|
||
|
||
// Get the language detector and customize it
|
||
detector := freeze.GetLanguageDetector()
|
||
|
||
// Add custom mappings
|
||
detector.AddCustomMapping(".myext", "python")
|
||
detector.AddCustomMapping(".config", "json")
|
||
|
||
// Test custom mappings
|
||
customTests := []struct {
|
||
filename string
|
||
content string
|
||
}{
|
||
{
|
||
"script.myext",
|
||
`def custom_function():
|
||
print("This is a custom extension file")
|
||
return True`,
|
||
},
|
||
{
|
||
"app.config",
|
||
`{
|
||
"database": {
|
||
"host": "localhost",
|
||
"port": 5432
|
||
}
|
||
}`,
|
||
},
|
||
}
|
||
|
||
for _, test := range customTests {
|
||
fmt.Printf("🔍 Testing custom mapping for %s...\n", test.filename)
|
||
|
||
detectedLang := freeze.DetectLanguageFromFile(test.filename, test.content)
|
||
fmt.Printf(" Detected language: %s\n", detectedLang)
|
||
|
||
svgData, err := freeze.GenerateFromCodeAuto(test.content)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error generating screenshot: %v\n", err)
|
||
continue
|
||
}
|
||
|
||
filename := fmt.Sprintf("output/custom_%s.svg", filepath.Base(test.filename))
|
||
err = os.WriteFile(filename, svgData, 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error saving %s: %v\n", filename, err)
|
||
continue
|
||
}
|
||
|
||
fmt.Printf("✅ Generated: %s\n", filename)
|
||
}
|
||
}
|
||
|
||
// Batch auto detection example
|
||
func batchAutoDetectionExample() {
|
||
fmt.Println("\n📦 Batch Auto Detection")
|
||
fmt.Println("-----------------------")
|
||
|
||
// Create sample files with different languages
|
||
sampleFiles := map[string]string{
|
||
"hello.go": `package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
fmt.Println("Hello from Go!")
|
||
}`,
|
||
"hello.py": `def main():
|
||
print("Hello from Python!")
|
||
|
||
if __name__ == "__main__":
|
||
main()`,
|
||
"hello.js": `function main() {
|
||
console.log("Hello from JavaScript!");
|
||
}
|
||
|
||
main();`,
|
||
"hello.rs": `fn main() {
|
||
println!("Hello from Rust!");
|
||
}`,
|
||
"style.css": `body {
|
||
font-family: 'Arial', sans-serif;
|
||
background-color: #f0f0f0;
|
||
margin: 0;
|
||
padding: 20px;
|
||
}
|
||
|
||
.container {
|
||
max-width: 800px;
|
||
margin: 0 auto;
|
||
background: white;
|
||
border-radius: 8px;
|
||
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
|
||
}`,
|
||
}
|
||
|
||
// Create temporary files
|
||
tempDir := "temp_files"
|
||
err := os.MkdirAll(tempDir, 0755)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error creating temp directory: %v\n", err)
|
||
return
|
||
}
|
||
defer os.RemoveAll(tempDir)
|
||
|
||
// Write sample files
|
||
for filename, content := range sampleFiles {
|
||
filePath := filepath.Join(tempDir, filename)
|
||
err := os.WriteFile(filePath, []byte(content), 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error writing %s: %v\n", filename, err)
|
||
continue
|
||
}
|
||
}
|
||
|
||
freeze := freezelib.New()
|
||
|
||
// Process each file with auto detection
|
||
for filename := range sampleFiles {
|
||
filePath := filepath.Join(tempDir, filename)
|
||
fmt.Printf("📄 Processing %s...\n", filename)
|
||
|
||
svgData, err := freeze.GenerateFromFile(filePath)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error processing %s: %v\n", filename, err)
|
||
continue
|
||
}
|
||
|
||
outputFile := fmt.Sprintf("output/batch_%s.svg", filename)
|
||
err = os.WriteFile(outputFile, svgData, 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error saving %s: %v\n", outputFile, err)
|
||
continue
|
||
}
|
||
|
||
fmt.Printf("✅ Generated: %s\n", outputFile)
|
||
}
|
||
}
|
||
|
||
// Language analysis example
|
||
func languageAnalysisExample() {
|
||
fmt.Println("\n📊 Language Analysis")
|
||
fmt.Println("--------------------")
|
||
|
||
freeze := freezelib.New()
|
||
|
||
// Get supported languages
|
||
supportedLangs := freeze.GetSupportedLanguages()
|
||
fmt.Printf("📈 Total supported languages: %d\n", len(supportedLangs))
|
||
|
||
// Show first 20 languages
|
||
fmt.Println("🔤 First 20 supported languages:")
|
||
for i, lang := range supportedLangs {
|
||
if i >= 20 {
|
||
break
|
||
}
|
||
fmt.Printf(" %d. %s\n", i+1, lang)
|
||
}
|
||
|
||
// Test language support
|
||
testLanguages := []string{"go", "python", "javascript", "rust", "unknown-lang"}
|
||
fmt.Println("\n🧪 Testing language support:")
|
||
for _, lang := range testLanguages {
|
||
supported := freeze.IsLanguageSupported(lang)
|
||
status := "❌"
|
||
if supported {
|
||
status = "✅"
|
||
}
|
||
fmt.Printf(" %s %s\n", status, lang)
|
||
}
|
||
|
||
// Create a summary file
|
||
summaryContent := fmt.Sprintf(`# FreezeLib Language Support Summary
|
||
|
||
Total supported languages: %d
|
||
|
||
## Sample of supported languages:
|
||
`, len(supportedLangs))
|
||
|
||
for i, lang := range supportedLangs {
|
||
if i >= 50 {
|
||
summaryContent += "... and more\n"
|
||
break
|
||
}
|
||
summaryContent += fmt.Sprintf("- %s\n", lang)
|
||
}
|
||
|
||
svgData, err := freeze.GenerateFromCode(summaryContent, "markdown")
|
||
if err != nil {
|
||
fmt.Printf("❌ Error generating summary: %v\n", err)
|
||
return
|
||
}
|
||
|
||
err = os.WriteFile("output/language_summary.svg", svgData, 0644)
|
||
if err != nil {
|
||
fmt.Printf("❌ Error saving summary: %v\n", err)
|
||
return
|
||
}
|
||
|
||
fmt.Printf("✅ Generated language summary: output/language_summary.svg\n")
|
||
}
|