roulette/types/types.go

/*
Copyright © 2024 Seednode <seednode@seedno.de>
*/

package types

import (
	"path/filepath"
	"slices"
	"strings"
)

var SupportedFormats = make(Types)

type Type interface {
	// Returns either "inline" or "embed", depending on whether the file
	// should be displayed inline (e.g. code) or embedded (e.g. images)
	Type() string

	// Returns a CSS string used to format the corresponding page
	Css() string

	// Returns an HTML <title> element for the specified file
	Title(rootUrl, fileUri, filePath, fileName, prefix, mime string) (string, error)

	// Returns an HTML <body> element used to display the specified file
	Body(rootUrl, fileUri, filePath, fileName, prefix, mime string) (string, error)

	// Returns a map of file extensions to MIME type strings.
	Extensions() map[string]string

	// Given a file extension, returns the corresponding media type,
	// if one exists. Otherwise, returns an empty string.
	MediaType(extension string) string

	// Optional function used to validate whether a given file matches this format.
	// If no validation checks are needed, this function should always return true.
	Validate(filePath string) bool
}

type Types map[string]Type

func (t Types) Add(format Type) {
	for k := range format.Extensions() {
		_, exists := t[k]
		if !exists {
			t[k] = format
		}
	}
}

func (t Types) FileType(path string) Type {
	fileType, exists := t[filepath.Ext(path)]
	if exists {
		return fileType
	}

	return nil
}

func (t Types) Register(format Type) {
	t.Add(format)
}

func (t Types) Validate(path string) bool {
	format, exists := t[filepath.Ext(path)]
	if !exists {
		return false
	}

	return format.Validate(path)
}

func (t Types) GetExtensions() string {
	var output strings.Builder

	extensions := make([]string, len(t))

	i := 0

	for k := range t {
		extensions[i] = k
		i++
	}

	slices.Sort(extensions)

	for _, v := range extensions {
		output.WriteString(v + "\n")
	}

	return output.String()
}

func (t Types) GetMediaTypes() string {
	var output strings.Builder

	var mediaTypes []string

	for _, j := range t {
		extensions := j.Extensions()

		for _, v := range extensions {
			if v != "" {
				mediaTypes = append(mediaTypes, v)
			}
		}
	}

	mediaTypes = removeDuplicateStr(mediaTypes)

	slices.Sort(mediaTypes)

	for _, v := range mediaTypes {
		output.WriteString(v + "\n")
	}

	return output.String()
}

func removeDuplicateStr(strSlice []string) []string {
	allKeys := make(map[string]bool)
	list := []string{}
	for _, item := range strSlice {
		if _, value := allKeys[item]; !value {
			allKeys[item] = true
			list = append(list, item)
		}
	}
	return list
}
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`/*`
Update release year 2024-01-14 12:39:14 -06:00			`Copyright © 2024 Seednode <seednode@seedno.de>`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`*/`

Rename formats package to types, replace Css string literal in type struct with func() string 2023-09-12 16:32:19 -05:00			`package types`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00
			`import (`
Added .swf support, fallback to filetype detection by extension if mime type detection fails 2023-09-12 13:06:45 -05:00			`"path/filepath"`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`"slices"`
			`"strings"`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`)`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`var SupportedFormats = make(Types)`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00
Gonna be honest, guys, I don't think I know what an interface is 2023-09-12 20:56:39 -05:00			`type Type interface {`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00			`// Returns either "inline" or "embed", depending on whether the file`
			`// should be displayed inline (e.g. code) or embedded (e.g. images)`
Add Type() method to types.Type, to allow displaying served file size for both embedded and inline files 2023-09-15 15:13:45 -05:00			`Type() string`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
			`// Returns a CSS string used to format the corresponding page`
Gonna be honest, guys, I don't think I know what an interface is 2023-09-12 20:56:39 -05:00			`Css() string`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
			`// Returns an HTML <title> element for the specified file`
Add log channel, add --exit-on-error option 2023-09-15 14:28:21 -05:00			`Title(rootUrl, fileUri, filePath, fileName, prefix, mime string) (string, error)`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
			`// Returns an HTML <body> element used to display the specified file`
Add log channel, add --exit-on-error option 2023-09-15 14:28:21 -05:00			`Body(rootUrl, fileUri, filePath, fileName, prefix, mime string) (string, error)`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
			`// Returns a map of file extensions to MIME type strings.`
Gonna be honest, guys, I don't think I know what an interface is 2023-09-12 20:56:39 -05:00			`Extensions() map[string]string`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
Updated transitive dependencies 2023-10-17 20:38:45 -05:00			`// Given a file extension, returns the corresponding media type,`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00			`// if one exists. Otherwise, returns an empty string.`
Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`MediaType(extension string) string`
Add new --fun flag, add comments to Type interface 2023-10-04 17:33:03 -05:00
			`// Optional function used to validate whether a given file matches this format.`
			`// If no validation checks are needed, this function should always return true.`
Gonna be honest, guys, I don't think I know what an interface is 2023-09-12 20:56:39 -05:00			`Validate(filePath string) bool`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`}`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`type Types map[string]Type`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00
Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`func (t Types) Add(format Type) {`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`for k := range format.Extensions() {`
Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`_, exists := t[k]`
Added .swf support, fallback to filetype detection by extension if mime type detection fails 2023-09-12 13:06:45 -05:00			`if !exists {`
Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`t[k] = format`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`}`
			`}`
			`}`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`func (t Types) FileType(path string) Type {`
			`fileType, exists := t[filepath.Ext(path)]`
Added .swf support, fallback to filetype detection by extension if mime type detection fails 2023-09-12 13:06:45 -05:00			`if exists {`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`return fileType`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`}`

Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`return nil`
Moved types to their own package (formats) 2023-09-11 11:25:39 -05:00			`}`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00
Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`func (t Types) Register(format Type) {`
Changed all variables to non-exported by default 2023-09-13 09:26:15 -05:00			`t.Add(format)`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`}`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`func (t Types) Validate(path string) bool {`
			`format, exists := t[filepath.Ext(path)]`
Fix validation of files when in cache/not cached mode 2023-09-14 19:10:55 -05:00			`if !exists {`
			`return false`
			`}`

			`return format.Validate(path)`
			`}`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`func (t Types) GetExtensions() string {`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`var output strings.Builder`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`extensions := make([]string, len(t))`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00
			`i := 0`

Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`for k := range t {`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`extensions[i] = k`
			`i++`
			`}`

			`slices.Sort(extensions)`

			`for _, v := range extensions {`
			`output.WriteString(v + "\n")`
			`}`

			`return output.String()`
			`}`

Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`func (t Types) GetMediaTypes() string {`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`var output strings.Builder`

Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`var mediaTypes []string`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00
Replace single-value registered format struct with the map value itself 2023-10-04 14:09:49 -05:00			`for _, j := range t {`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`extensions := j.Extensions()`
Remove --page-length and HTML index dump, fix media type identification 2024-01-15 08:51:41 -06:00
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`for _, v := range extensions {`
Remove --page-length and HTML index dump, fix media type identification 2024-01-15 08:51:41 -06:00			`if v != "" {`
			`mediaTypes = append(mediaTypes, v)`
			`}`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00			`}`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`}`

Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`mediaTypes = removeDuplicateStr(mediaTypes)`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00
Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`slices.Sort(mediaTypes)`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00
Rename mime types to media types, change endpoints accordingly 2023-10-09 09:47:17 -05:00			`for _, v := range mediaTypes {`
Total restructure, just look at the diffs at this point 2023-09-12 23:35:17 -05:00			`output.WriteString(v + "\n")`
			`}`

			`return output.String()`
			`}`
Add syntax highlighting for code 2023-09-14 17:37:22 -05:00
			`func removeDuplicateStr(strSlice []string) []string {`
			`allKeys := make(map[string]bool)`
			`list := []string{}`
			`for _, item := range strSlice {`
			`if _, value := allKeys[item]; !value {`
			`allKeys[item] = true`
			`list = append(list, item)`
			`}`
			`}`
			`return list`
			`}`