mirror of
https://github.com/kjanat/articulate-parser.git
synced 2026-10-13 00:15:28 +02:00
kjanat
adb60ca7e5
- Add logger to all exporters for consistent error handling - Add Course.Validate() method with ValidationError type - Create shared test fixtures in internal/testdata - Refactor config passing: NewArticulateParser now takes *config.Config - Add NewLoggerFromConfig() factory for logger creation - Add context cancellation with signal handling (SIGINT/SIGTERM) - Add godoc examples for loggers and exporters - Add HTML exporter error path tests - Add fuzz tests for parser and HTMLCleaner - Fix markdown output: trim whitespace, collapse blank lines - Remove test output files from repo
120 lines
3.6 KiB
Go
120 lines
3.6 KiB
Go
package exporters
|
|
|
|
import (
|
|
_ "embed"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"os"
|
|
|
|
"github.com/kjanat/articulate-parser/internal/interfaces"
|
|
"github.com/kjanat/articulate-parser/internal/models"
|
|
"github.com/kjanat/articulate-parser/internal/services"
|
|
)
|
|
|
|
//go:embed html_styles.css
|
|
var defaultCSS string
|
|
|
|
//go:embed html_template.gohtml
|
|
var htmlTemplate string
|
|
|
|
// HTMLExporter implements the Exporter interface for HTML format.
|
|
// It converts Articulate Rise course data into a structured HTML document using templates.
|
|
type HTMLExporter struct {
|
|
// htmlCleaner is used to convert HTML content to plain text when needed
|
|
htmlCleaner *services.HTMLCleaner
|
|
// tmpl holds the parsed HTML template
|
|
tmpl *template.Template
|
|
// logger is used for logging warnings and errors
|
|
logger interfaces.Logger
|
|
}
|
|
|
|
// NewHTMLExporter creates a new HTMLExporter instance.
|
|
// It takes an HTMLCleaner to handle HTML content conversion when plain text is needed
|
|
// and a logger for logging.
|
|
//
|
|
// Parameters:
|
|
// - htmlCleaner: Service for cleaning HTML content in course data
|
|
// - logger: Logger instance for warnings and errors
|
|
//
|
|
// Returns:
|
|
// - An implementation of the Exporter interface for HTML format
|
|
func NewHTMLExporter(htmlCleaner *services.HTMLCleaner, logger interfaces.Logger) interfaces.Exporter {
|
|
// Parse the template with custom functions
|
|
funcMap := template.FuncMap{
|
|
"safeHTML": func(s string) template.HTML {
|
|
return template.HTML(s) // #nosec G203 - HTML content is from trusted course data
|
|
},
|
|
"safeCSS": func(s string) template.CSS {
|
|
return template.CSS(s) // #nosec G203 - CSS content is from trusted embedded file
|
|
},
|
|
}
|
|
|
|
tmpl := template.Must(template.New("html").Funcs(funcMap).Parse(htmlTemplate))
|
|
|
|
return &HTMLExporter{
|
|
htmlCleaner: htmlCleaner,
|
|
tmpl: tmpl,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// Export exports a course to HTML format.
|
|
// It generates a structured HTML document from the course data
|
|
// and writes it to the specified output path.
|
|
//
|
|
// Parameters:
|
|
// - course: The course data model to export
|
|
// - outputPath: The file path where the HTML content will be written
|
|
//
|
|
// Returns:
|
|
// - An error if writing to the output file fails
|
|
func (e *HTMLExporter) Export(course *models.Course, outputPath string) error {
|
|
f, err := os.Create(outputPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create file: %w", err)
|
|
}
|
|
defer func() {
|
|
// Close errors are logged but not fatal since the content has already been written.
|
|
// The file must be closed to flush buffers, but a close error doesn't invalidate
|
|
// the data already written to disk.
|
|
if closeErr := f.Close(); closeErr != nil {
|
|
// Note: In production, this should log via a logger passed to the exporter.
|
|
// For now, we silently ignore close errors as they're non-fatal.
|
|
_ = closeErr
|
|
}
|
|
}()
|
|
|
|
return e.WriteHTML(f, course)
|
|
}
|
|
|
|
// WriteHTML writes the HTML content to an io.Writer.
|
|
// This allows for better testability and flexibility in output destinations.
|
|
//
|
|
// Parameters:
|
|
// - w: The writer to output HTML content to
|
|
// - course: The course data model to export
|
|
//
|
|
// Returns:
|
|
// - An error if writing fails
|
|
func (e *HTMLExporter) WriteHTML(w io.Writer, course *models.Course) error {
|
|
// Prepare template data
|
|
data := prepareTemplateData(course, e.htmlCleaner)
|
|
|
|
// Execute template
|
|
if err := e.tmpl.Execute(w, data); err != nil {
|
|
return fmt.Errorf("failed to execute template: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SupportedFormat returns the format name this exporter supports
|
|
// It indicates the file format that the HTMLExporter can generate.
|
|
//
|
|
// Returns:
|
|
// - A string representing the supported format ("html")
|
|
func (e *HTMLExporter) SupportedFormat() string {
|
|
return FormatHTML
|
|
}
|