compressfs

ExampleAlgorithmRules demonstrates custom algorithm rules

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	// Define custom rules for different file types
	config := &compressfs.Config{
		Algorithm: compressfs.AlgorithmZstd,
		Level:     3,
		AlgorithmRules: []compressfs.AlgorithmRule{
			// Critical data: maximum compression
			{
				Pattern:   `^/important/`,
				Algorithm: compressfs.AlgorithmBrotli,
				Level:     11,
			},
			// Logs: fast compression
			{
				Pattern:   `\.log$`,
				Algorithm: compressfs.AlgorithmLZ4,
				Level:     0,
			},
			// Cache files: very fast
			{
				Pattern:   `^/cache/`,
				Algorithm: compressfs.AlgorithmSnappy,
				Level:     0,
			},
		},
		PreserveExtension: true,
		StripExtension:    true,
	}

	fs, _ := compressfs.New(memfs, config)

	// Each file uses the algorithm matching its pattern
	fs.Create("/important/data.txt") // Uses Brotli level 11
	fs.Create("app.log")             // Uses LZ4
	fs.Create("/cache/temp.dat")     // Uses Snappy
	fs.Create("regular.txt")         // Uses default Zstd level 3

	fmt.Println("Files compressed with custom rules")
}

Output:

Files compressed with custom rules

ExampleArchivalConfig demonstrates maximum compression for archival

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	// Optimized for maximum compression
	// - Brotli level 11 (best compression)
	// - Custom rules for different file types
	fs, _ := compressfs.NewWithArchival(memfs)

	// Compress for long-term storage
	file, _ := fs.Create("archive.txt")
	file.Write([]byte("Important data to archive with maximum compression"))
	file.Close()

	fmt.Println("Data compressed for archival storage")
}

Output:

Data compressed for archival storage

ExampleAutoTuning demonstrates automatic compression level adjustment

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	config := &compressfs.Config{
		Algorithm:             compressfs.AlgorithmZstd,
		Level:                 6, // High compression by default
		EnableAutoTuning:      true,
		AutoTuneSizeThreshold: 1024 * 1024, // 1MB
		PreserveExtension:     true,
		StripExtension:        true,
	}

	fs, _ := compressfs.New(memfs, config)

	// Small files (< 1MB) use level 6 (high compression)
	smallFile, _ := fs.Create("small.txt")
	smallFile.Write(make([]byte, 100*1024)) // 100KB
	smallFile.Close()

	// Large files (> 1MB) automatically use lower level for speed
	// Level is reduced to 1-2 for faster compression
	largeFile, _ := fs.Create("large.dat")
	largeFile.Write(make([]byte, 10*1024*1024)) // 10MB
	largeFile.Close()

	fmt.Println("Compression levels auto-tuned based on file size")
}

Output:

Compression levels auto-tuned based on file size

package main

import (
	"fmt"
	"io"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	// Create an in-memory filesystem for demonstration
	base := compressfs.NewMemFS()

	// Wrap with compression using gzip
	cfs, err := compressfs.New(base, &compressfs.Config{
		Algorithm:         compressfs.AlgorithmGzip,
		Level:             6,
		PreserveExtension: true,
		StripExtension:    true,
	})
	if err != nil {
		log.Fatal(err)
	}

	// Write a file - it will be automatically compressed
	f, err := cfs.Create("data.txt")
	if err != nil {
		log.Fatal(err)
	}

	data := []byte("Hello, compressed world! This data will be automatically compressed.")
	_, err = f.Write(data)
	if err != nil {
		log.Fatal(err)
	}

	err = f.Close()
	if err != nil {
		log.Fatal(err)
	}

	// Read the file back - it will be automatically decompressed
	f, err = cfs.Open("data.txt")
	if err != nil {
		log.Fatal(err)
	}

	readData, err := io.ReadAll(f)
	if err != nil {
		log.Fatal(err)
	}

	err = f.Close()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(readData))
}

Output:

Hello, compressed world! This data will be automatically compressed.

ExampleCombinedFeatures demonstrates using multiple advanced features together

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	// Combine algorithm rules, auto-tuning, and dictionaries
	config := &compressfs.Config{
		Algorithm: compressfs.AlgorithmZstd,
		Level:     3,
		AlgorithmRules: []compressfs.AlgorithmRule{
			{Pattern: `\.log$`, Algorithm: compressfs.AlgorithmLZ4},
			{Pattern: `\.json$`, Algorithm: compressfs.AlgorithmZstd, Level: 6},
		},
		EnableAutoTuning:      true,
		AutoTuneSizeThreshold: 1024 * 1024,
		ZstdDictionary:        []byte("sample dictionary"),
		SkipPatterns: []string{
			`\.(jpg|png|zip)$`, // Skip already compressed
		},
		PreserveExtension: true,
		StripExtension:    true,
	}

	fs, _ := compressfs.New(memfs, config)

	// Each file is handled optimally
	fs.Create("app.log")   // LZ4 (rule)
	fs.Create("data.json") // Zstd level 6 (rule)
	fs.Create("large.txt") // Auto-tuned level
	fs.Create("photo.jpg") // Skipped (already compressed)

	fmt.Println("Combined features for optimal compression")
}

Output:

Combined features for optimal compression

ExampleHighPerformanceConfig demonstrates high-throughput configuration

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	// Optimized for maximum speed
	// - LZ4 algorithm (fastest)
	// - Large buffers (256KB)
	// - Parallel compression enabled
	fs, _ := compressfs.NewWithHighPerformance(memfs)

	// Compress data at maximum speed
	file, _ := fs.Create("data.bin")
	file.Write(make([]byte, 1024*1024)) // 1MB
	file.Close()

	fmt.Println("Data compressed at high speed")
}

Output:

Data compressed at high speed

package main

import (
	"fmt"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	base := compressfs.NewMemFS()

	cfs, err := compressfs.New(base, &compressfs.Config{
		Algorithm:         compressfs.AlgorithmGzip,
		MinSize:           100, // Only compress files >= 100 bytes
		PreserveExtension: true,
		StripExtension:    true,
	})
	if err != nil {
		log.Fatal(err)
	}

	// Small file - won't be compressed
	f, _ := cfs.Create("small.txt")
	f.Write([]byte("tiny"))
	f.Close()

	// Large file - will be compressed
	f, _ = cfs.Create("large.txt")
	largeData := make([]byte, 200)
	for i := range largeData {
		largeData[i] = 'a'
	}
	f.Write(largeData)
	f.Close()

	stats := cfs.GetStats()
	fmt.Printf("Files compressed: %d\n", stats.FilesCompressed)
	fmt.Printf("Files skipped: %d\n", stats.FilesSkipped)

}

Output:

Files compressed: 1
Files skipped: 1

package main

import (
	"fmt"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	base := compressfs.NewMemFS()

	// Configure to skip already-compressed formats
	cfs, err := compressfs.New(base, &compressfs.Config{
		Algorithm:         compressfs.AlgorithmGzip,
		PreserveExtension: true,
		StripExtension:    true,
		SkipPatterns: []string{
			`\.(jpg|jpeg|png|gif)$`, // Images
			`\.(zip|gz|bz2)$`,       // Archives
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	// This file will NOT be compressed (matches skip pattern)
	f, _ := cfs.Create("image.jpg")
	f.Write([]byte("fake image data"))
	f.Close()

	// This file WILL be compressed (doesn't match skip pattern)
	f, _ = cfs.Create("document.txt")
	f.Write([]byte("document content"))
	f.Close()

	fmt.Println("Files processed with skip patterns")
}

Output:

Files processed with skip patterns

ExampleSmartConfig demonstrates using SmartConfig with intelligent algorithm selection

package main

import (
	"fmt"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	// Create a memory filesystem for demo
	memfs := compressfs.NewMemFS()

	// Create filesystem with smart configuration
	// - Auto-selects algorithms based on file type
	// - LZ4 for logs (speed)
	// - Zstd for JSON/XML (balance)
	// - Snappy for temp files (very fast)
	fs, err := compressfs.NewWithSmartConfig(memfs)
	if err != nil {
		log.Fatal(err)
	}

	// Log files automatically use LZ4 (fast)
	logFile, _ := fs.Create("app.log")
	logFile.Write([]byte("2025-01-15 INFO: Application started\n"))
	logFile.Close()

	// JSON files automatically use Zstd level 6 (good compression)
	jsonFile, _ := fs.Create("config.json")
	jsonFile.Write([]byte(`{"setting": "value", "count": 42}`))
	jsonFile.Close()

	// Regular files use default Zstd level 3
	textFile, _ := fs.Create("readme.txt")
	textFile.Write([]byte("This is a readme file"))
	textFile.Close()

	fmt.Println("Files compressed with smart algorithm selection")
}

Output:

Files compressed with smart algorithm selection

package main

import (
	"fmt"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	base := compressfs.NewMemFS()

	cfs, err := compressfs.New(base, &compressfs.Config{
		Algorithm:         compressfs.AlgorithmGzip,
		PreserveExtension: true,
		StripExtension:    true,
	})
	if err != nil {
		log.Fatal(err)
	}

	// Write some files
	for i := 0; i < 3; i++ {
		f, _ := cfs.Create(fmt.Sprintf("file%d.txt", i))
		f.Write([]byte(fmt.Sprintf("Content for file %d", i)))
		f.Close()
	}

	// Check statistics
	stats := cfs.GetStats()
	fmt.Printf("Files compressed: %d\n", stats.FilesCompressed)
	fmt.Printf("Bytes written: %d\n", stats.BytesWritten)

}

Output:

Files compressed: 3
Bytes written: 54

package main

import (
	"fmt"
	"io"
	"log"

	"github.com/absfs/compressfs"
)

func main() {
	base := compressfs.NewMemFS()

	cfs, err := compressfs.New(base, &compressfs.Config{
		Algorithm:         compressfs.AlgorithmGzip,
		PreserveExtension: true, // file.txt -> file.txt.gz
		StripExtension:    true, // access via "file.txt"
	})
	if err != nil {
		log.Fatal(err)
	}

	// Write to "data.txt" - actually stored as "data.txt.gz"
	f, _ := cfs.Create("data.txt")
	f.Write([]byte("transparent compression"))
	f.Close()

	// Read from "data.txt" - automatically finds "data.txt.gz"
	f, _ = cfs.Open("data.txt")
	content, _ := io.ReadAll(f)
	f.Close()

	fmt.Println(string(content))
}

Output:

transparent compression

ExampleZstdDictionary demonstrates dictionary-based compression

package main

import (
	"fmt"

	"github.com/absfs/compressfs"
)

func main() {
	memfs := compressfs.NewMemFS()

	// In practice, train dictionary from sample data
	// For demo, use a simple dictionary
	dictionary := []byte("common repeated pattern")

	config := &compressfs.Config{
		Algorithm:         compressfs.AlgorithmZstd,
		Level:             3,
		ZstdDictionary:    dictionary,
		PreserveExtension: true,
		StripExtension:    true,
	}

	fs, _ := compressfs.New(memfs, config)

	// Files with similar patterns compress better with dictionary
	file, _ := fs.Create("data.txt")
	file.Write([]byte("common repeated pattern appears common repeated pattern"))
	file.Close()

	// Read back - dictionary is used automatically
	file, _ = fs.Open("data.txt")
	data := make([]byte, 1024)
	n, _ := file.Read(data)
	file.Close()

	fmt.Printf("Read %d bytes with dictionary compression\n", n)
}

Output:

Read 55 bytes with dictionary compression