588 lines
14 KiB
Go
588 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/landaiqing/freezelib"
|
|
)
|
|
|
|
func main() {
|
|
fmt.Println("🔧 Advanced Configuration Examples")
|
|
fmt.Println("===================================")
|
|
|
|
// Create output directory
|
|
os.MkdirAll("output", 0755)
|
|
|
|
// Run advanced examples
|
|
customFontExample()
|
|
advancedLayoutExample()
|
|
performanceOptimizationExample()
|
|
responsiveDesignExample()
|
|
brandingExample()
|
|
|
|
fmt.Println("\n✅ Advanced examples completed!")
|
|
fmt.Println("📁 Check the 'output' directory for generated files.")
|
|
}
|
|
|
|
// Custom font example
|
|
func customFontExample() {
|
|
fmt.Println("\n🔤 Custom Font Examples")
|
|
fmt.Println("-----------------------")
|
|
|
|
code := `interface UserRepository {
|
|
findById(id: string): Promise<User | null>;
|
|
findByEmail(email: string): Promise<User | null>;
|
|
create(user: CreateUserDto): Promise<User>;
|
|
update(id: string, updates: UpdateUserDto): Promise<User>;
|
|
delete(id: string): Promise<void>;
|
|
}
|
|
|
|
class PostgresUserRepository implements UserRepository {
|
|
constructor(private db: Database) {}
|
|
|
|
async findById(id: string): Promise<User | null> {
|
|
const result = await this.db.query(
|
|
'SELECT * FROM users WHERE id = $1',
|
|
[id]
|
|
);
|
|
return result.rows[0] || null;
|
|
}
|
|
|
|
async create(user: CreateUserDto): Promise<User> {
|
|
const { name, email, role } = user;
|
|
const result = await this.db.query(
|
|
'INSERT INTO users (name, email, role) VALUES ($1, $2, $3) RETURNING *',
|
|
[name, email, role]
|
|
);
|
|
return result.rows[0];
|
|
}
|
|
}`
|
|
|
|
// Different font configurations
|
|
fontConfigs := []struct {
|
|
name string
|
|
family string
|
|
size float64
|
|
desc string
|
|
}{
|
|
{"monospace_small", "Courier New", 12, "Small monospace font"},
|
|
{"monospace_large", "JetBrains Mono", 16, "Large modern monospace"},
|
|
{"system_font", "system-ui", 14, "System default font"},
|
|
{"serif_font", "Georgia", 14, "Serif font for readability"},
|
|
{"condensed_font", "SF Mono", 13, "Condensed font for more content"},
|
|
}
|
|
|
|
for _, config := range fontConfigs {
|
|
fmt.Printf("🔤 Generating %s example...\n", config.name)
|
|
|
|
freeze := freezelib.New().
|
|
WithTheme("github-dark").
|
|
WithFont(config.family, config.size).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(15, 0, 8).
|
|
WithPadding(25)
|
|
|
|
svgData, err := freeze.GenerateFromCode(code, "typescript")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/font_%s.svg", config.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s - %s\n", filename, config.desc)
|
|
}
|
|
}
|
|
|
|
// Advanced layout example
|
|
func advancedLayoutExample() {
|
|
fmt.Println("\n📐 Advanced Layout Examples")
|
|
fmt.Println("---------------------------")
|
|
|
|
code := `from dataclasses import dataclass
|
|
from typing import List, Optional, Dict, Any
|
|
from datetime import datetime
|
|
import asyncio
|
|
import aiohttp
|
|
|
|
@dataclass
|
|
class APIResponse:
|
|
status_code: int
|
|
data: Dict[str, Any]
|
|
headers: Dict[str, str]
|
|
timestamp: datetime
|
|
|
|
class AsyncAPIClient:
|
|
def __init__(self, base_url: str, timeout: int = 30):
|
|
self.base_url = base_url.rstrip('/')
|
|
self.timeout = aiohttp.ClientTimeout(total=timeout)
|
|
self.session: Optional[aiohttp.ClientSession] = None
|
|
|
|
async def __aenter__(self):
|
|
self.session = aiohttp.ClientSession(timeout=self.timeout)
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc_val, exc_tb):
|
|
if self.session:
|
|
await self.session.close()
|
|
|
|
async def get(self, endpoint: str, params: Optional[Dict] = None) -> APIResponse:
|
|
if not self.session:
|
|
raise RuntimeError("Client not initialized. Use async context manager.")
|
|
|
|
url = f"{self.base_url}/{endpoint.lstrip('/')}"
|
|
|
|
async with self.session.get(url, params=params) as response:
|
|
data = await response.json()
|
|
return APIResponse(
|
|
status_code=response.status,
|
|
data=data,
|
|
headers=dict(response.headers),
|
|
timestamp=datetime.now()
|
|
)
|
|
|
|
# Usage example
|
|
async def main():
|
|
async with AsyncAPIClient("https://api.example.com") as client:
|
|
response = await client.get("/users", {"page": 1, "limit": 10})
|
|
print(f"Status: {response.status_code}")
|
|
print(f"Data: {response.data}")
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())`
|
|
|
|
// Different layout configurations
|
|
layouts := []struct {
|
|
name string
|
|
config func() *freezelib.Freeze
|
|
desc string
|
|
}{
|
|
{
|
|
"compact",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("SF Mono", 11).
|
|
WithPadding(10).
|
|
WithMargin(5).
|
|
WithWindow(false).
|
|
WithLineNumbers(true).
|
|
WithDimensions(600, 800)
|
|
},
|
|
"Compact layout for maximum content",
|
|
},
|
|
{
|
|
"spacious",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github-dark").
|
|
WithFont("JetBrains Mono", 16).
|
|
WithPadding(40).
|
|
WithMargin(30).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(25, 0, 15).
|
|
WithDimensions(1000, 1200)
|
|
},
|
|
"Spacious layout for presentations",
|
|
},
|
|
{
|
|
"mobile_friendly",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("dracula").
|
|
WithFont("Menlo", 13).
|
|
WithPadding(15).
|
|
WithMargin(10).
|
|
WithWindow(false).
|
|
WithLineNumbers(false).
|
|
WithDimensions(400, 600)
|
|
},
|
|
"Mobile-friendly narrow layout",
|
|
},
|
|
{
|
|
"print_optimized",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("Times New Roman", 12).
|
|
WithPadding(20).
|
|
WithMargin(15).
|
|
WithWindow(false).
|
|
WithLineNumbers(true).
|
|
WithShadow(0, 0, 0). // No shadow for print
|
|
WithBackground("#ffffff").
|
|
WithDimensions(800, 1000)
|
|
},
|
|
"Print-optimized layout",
|
|
},
|
|
}
|
|
|
|
for _, layout := range layouts {
|
|
fmt.Printf("📐 Creating %s layout...\n", layout.name)
|
|
|
|
freeze := layout.config()
|
|
svgData, err := freeze.GenerateFromCode(code, "python")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/layout_%s.svg", layout.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s - %s\n", filename, layout.desc)
|
|
}
|
|
}
|
|
|
|
// Performance optimization example
|
|
func performanceOptimizationExample() {
|
|
fmt.Println("\n⚡ Performance Optimization")
|
|
fmt.Println("---------------------------")
|
|
|
|
// Short code for performance testing
|
|
shortCode := `fn quicksort<T: Ord>(arr: &mut [T]) {
|
|
if arr.len() <= 1 {
|
|
return;
|
|
}
|
|
|
|
let pivot_index = partition(arr);
|
|
let (left, right) = arr.split_at_mut(pivot_index);
|
|
|
|
quicksort(left);
|
|
quicksort(&mut right[1..]);
|
|
}
|
|
|
|
fn partition<T: Ord>(arr: &mut [T]) -> usize {
|
|
let pivot_index = arr.len() - 1;
|
|
let mut i = 0;
|
|
|
|
for j in 0..pivot_index {
|
|
if arr[j] <= arr[pivot_index] {
|
|
arr.swap(i, j);
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
arr.swap(i, pivot_index);
|
|
i
|
|
}`
|
|
|
|
// Performance-optimized configurations
|
|
perfConfigs := []struct {
|
|
name string
|
|
config func() *freezelib.Freeze
|
|
desc string
|
|
}{
|
|
{
|
|
"minimal_overhead",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("monospace", 12).
|
|
WithWindow(false).
|
|
WithLineNumbers(false).
|
|
WithShadow(0, 0, 0).
|
|
WithPadding(10).
|
|
WithMargin(0)
|
|
},
|
|
"Minimal processing overhead",
|
|
},
|
|
{
|
|
"optimized_svg",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("system-ui", 13).
|
|
WithWindow(false).
|
|
WithLineNumbers(true).
|
|
WithShadow(0, 0, 0).
|
|
WithPadding(15).
|
|
WithDimensions(600, 400) // Fixed dimensions
|
|
},
|
|
"SVG-optimized configuration",
|
|
},
|
|
{
|
|
"batch_processing",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("monokai").
|
|
WithFont("Courier", 12).
|
|
WithWindow(false).
|
|
WithLineNumbers(false).
|
|
WithPadding(12).
|
|
WithDimensions(500, 300)
|
|
},
|
|
"Optimized for batch processing",
|
|
},
|
|
}
|
|
|
|
for _, config := range perfConfigs {
|
|
fmt.Printf("⚡ Testing %s...\n", config.name)
|
|
|
|
freeze := config.config()
|
|
|
|
// Generate multiple times to test performance
|
|
for i := 0; i < 3; i++ {
|
|
svgData, err := freeze.GenerateFromCode(shortCode, "rust")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
break
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/perf_%s_%d.svg", config.name, i+1)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
break
|
|
}
|
|
}
|
|
|
|
fmt.Printf("✅ Generated 3 files for %s - %s\n", config.name, config.desc)
|
|
}
|
|
}
|
|
|
|
// Responsive design example
|
|
func responsiveDesignExample() {
|
|
fmt.Println("\n📱 Responsive Design")
|
|
fmt.Println("--------------------")
|
|
|
|
code := `@media (max-width: 768px) {
|
|
.container {
|
|
padding: 1rem;
|
|
margin: 0;
|
|
}
|
|
|
|
.grid {
|
|
grid-template-columns: 1fr;
|
|
gap: 1rem;
|
|
}
|
|
|
|
.card {
|
|
margin-bottom: 1rem;
|
|
}
|
|
|
|
.navigation {
|
|
flex-direction: column;
|
|
}
|
|
|
|
.nav-item {
|
|
width: 100%;
|
|
text-align: center;
|
|
padding: 0.75rem;
|
|
}
|
|
}
|
|
|
|
@media (min-width: 769px) and (max-width: 1024px) {
|
|
.container {
|
|
max-width: 750px;
|
|
padding: 2rem;
|
|
}
|
|
|
|
.grid {
|
|
grid-template-columns: repeat(2, 1fr);
|
|
gap: 1.5rem;
|
|
}
|
|
}
|
|
|
|
@media (min-width: 1025px) {
|
|
.container {
|
|
max-width: 1200px;
|
|
padding: 3rem;
|
|
}
|
|
|
|
.grid {
|
|
grid-template-columns: repeat(3, 1fr);
|
|
gap: 2rem;
|
|
}
|
|
|
|
.hero {
|
|
height: 60vh;
|
|
display: flex;
|
|
align-items: center;
|
|
justify-content: center;
|
|
}
|
|
}`
|
|
|
|
// Different screen size simulations
|
|
screenSizes := []struct {
|
|
name string
|
|
width float64
|
|
height float64
|
|
desc string
|
|
}{
|
|
{"mobile", 375, 600, "Mobile phone size"},
|
|
{"tablet", 768, 800, "Tablet size"},
|
|
{"desktop", 1200, 800, "Desktop size"},
|
|
{"ultrawide", 1600, 900, "Ultrawide monitor"},
|
|
}
|
|
|
|
for _, size := range screenSizes {
|
|
fmt.Printf("📱 Creating %s responsive example...\n", size.name)
|
|
|
|
freeze := freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("system-ui", 13).
|
|
WithDimensions(size.width, size.height).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithPadding(20).
|
|
WithShadow(10, 0, 5)
|
|
|
|
svgData, err := freeze.GenerateFromCode(code, "css")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/responsive_%s.svg", size.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s (%dx%d) - %s\n",
|
|
filename, size.width, size.height, size.desc)
|
|
}
|
|
}
|
|
|
|
// Branding example
|
|
func brandingExample() {
|
|
fmt.Println("\n🎨 Branding Examples")
|
|
fmt.Println("--------------------")
|
|
|
|
code := `public class BrandService {
|
|
private final Logger logger = LoggerFactory.getLogger(BrandService.class);
|
|
private final BrandRepository brandRepository;
|
|
private final CacheManager cacheManager;
|
|
|
|
public BrandService(BrandRepository brandRepository, CacheManager cacheManager) {
|
|
this.brandRepository = brandRepository;
|
|
this.cacheManager = cacheManager;
|
|
}
|
|
|
|
@Cacheable("brands")
|
|
public Brand getBrandById(Long id) {
|
|
logger.info("Fetching brand with id: {}", id);
|
|
|
|
return brandRepository.findById(id)
|
|
.orElseThrow(() -> new BrandNotFoundException("Brand not found: " + id));
|
|
}
|
|
|
|
@Transactional
|
|
public Brand createBrand(CreateBrandRequest request) {
|
|
validateBrandRequest(request);
|
|
|
|
Brand brand = Brand.builder()
|
|
.name(request.getName())
|
|
.description(request.getDescription())
|
|
.logoUrl(request.getLogoUrl())
|
|
.primaryColor(request.getPrimaryColor())
|
|
.secondaryColor(request.getSecondaryColor())
|
|
.createdAt(Instant.now())
|
|
.build();
|
|
|
|
Brand savedBrand = brandRepository.save(brand);
|
|
cacheManager.evictCache("brands");
|
|
|
|
logger.info("Created new brand: {}", savedBrand.getName());
|
|
return savedBrand;
|
|
}
|
|
|
|
private void validateBrandRequest(CreateBrandRequest request) {
|
|
if (StringUtils.isBlank(request.getName())) {
|
|
throw new ValidationException("Brand name is required");
|
|
}
|
|
|
|
if (brandRepository.existsByName(request.getName())) {
|
|
throw new ValidationException("Brand name already exists");
|
|
}
|
|
}
|
|
}`
|
|
|
|
// Different brand styles
|
|
brandStyles := []struct {
|
|
name string
|
|
config func() *freezelib.Freeze
|
|
desc string
|
|
}{
|
|
{
|
|
"corporate_blue",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("Arial", 14).
|
|
WithBackground("#f8f9fa").
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(8, 2, 4).
|
|
WithBorder(2, 8, "#0066cc").
|
|
WithPadding(30)
|
|
},
|
|
"Corporate blue branding",
|
|
},
|
|
{
|
|
"startup_green",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github-dark").
|
|
WithFont("Inter", 14).
|
|
WithBackground("#0d1117").
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(15, 0, 10).
|
|
WithBorder(1, 12, "#00d084").
|
|
WithPadding(25)
|
|
},
|
|
"Startup green branding",
|
|
},
|
|
{
|
|
"creative_purple",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("dracula").
|
|
WithFont("Poppins", 14).
|
|
WithBackground("#1a1a2e").
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(20, 0, 15).
|
|
WithBorder(2, 16, "#8b5cf6").
|
|
WithPadding(35)
|
|
},
|
|
"Creative purple branding",
|
|
},
|
|
}
|
|
|
|
for _, style := range brandStyles {
|
|
fmt.Printf("🎨 Creating %s style...\n", style.name)
|
|
|
|
freeze := style.config()
|
|
svgData, err := freeze.GenerateFromCode(code, "java")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/brand_%s.svg", style.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s - %s\n", filename, style.desc)
|
|
}
|
|
}
|