135 lines
3.3 KiB
Go
135 lines
3.3 KiB
Go
package nomino
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"crypto/sha1"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"hash"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/gosimple/slug"
|
|
)
|
|
|
|
// Generator is a function that returns the "random" portion of the returned filename.
|
|
// Technically, it doesn't necessarily need to be random, and could be based on time, or a counter,
|
|
// for example.
|
|
type Generator func(conf *Config) (string, error)
|
|
|
|
// WithGenerator sets the specified generator
|
|
func WithGenerator(g Generator) Option {
|
|
return func(c *Config) {
|
|
c.generator = g
|
|
}
|
|
}
|
|
|
|
// ErrMissingGenerators is returned by a multi-generator if no generators are supplied.
|
|
var ErrMissingGenerators = errors.New("no generators supplied")
|
|
|
|
func missingGen(*Config) (string, error) {
|
|
return "", ErrMissingGenerators
|
|
}
|
|
|
|
// MultiGeneratorInOrder allows the use of multiple generators. Each new invokation will use the next generator in turn.
|
|
// If none are passed, the generator will always return ErrMissingGenerators.
|
|
func MultiGeneratorInOrder(gens ...Generator) Generator {
|
|
if len(gens) == 0 {
|
|
return missingGen
|
|
}
|
|
|
|
if len(gens) == 1 {
|
|
return gens[0]
|
|
}
|
|
|
|
var idx int
|
|
return func(c *Config) (string, error) {
|
|
st, err := gens[idx](c)
|
|
idx = (idx + 1) % len(gens)
|
|
return st, err
|
|
}
|
|
}
|
|
|
|
func uuidGen(*Config) (string, error) {
|
|
u, err := uuid.NewRandom()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return u.String(), nil
|
|
}
|
|
|
|
// UUID generates a UUIDv4.
|
|
func UUID() Generator {
|
|
return uuidGen
|
|
}
|
|
|
|
// ErrMissingOriginal is the error returned by Slug if there is no filename
|
|
var ErrMissingOriginal = errors.New("missing original filename")
|
|
|
|
func getOriginal(c *Config) (string, error) {
|
|
if c.original == "" {
|
|
return "", ErrMissingOriginal
|
|
}
|
|
name := c.original
|
|
c.original = ""
|
|
return name, nil
|
|
}
|
|
|
|
// Slug generates a name from the original filename.
|
|
// When this is used, the original filename will be removed from the final filename.
|
|
func Slug() Generator {
|
|
return func(c *Config) (string, error) {
|
|
name, err := getOriginal(c)
|
|
return slug.Make(name), err
|
|
}
|
|
}
|
|
|
|
// SlugWithLang generates a name from the original filename, accounting for the given language.
|
|
// When this is used, the original filename will be removed from the final filename.
|
|
func SlugWithLang(lang string) Generator {
|
|
return func(c *Config) (string, error) {
|
|
name, err := getOriginal(c)
|
|
return slug.MakeLang(name, lang), err
|
|
}
|
|
}
|
|
|
|
// HashingFunc is a function that generates a hash.Hash
|
|
type HashingFunc func() hash.Hash
|
|
|
|
//go:generate stringer -type=HashType
|
|
|
|
// HashType represents a particular hashing algorithm
|
|
type HashType uint8
|
|
|
|
const (
|
|
MD5 HashType = iota + 1
|
|
SHA1
|
|
SHA256
|
|
)
|
|
|
|
// ErrInvalidHashType is returned by the Hash generator when an invalid HashType is passed
|
|
var ErrInvalidHashType = errors.New("invalid hash type")
|
|
|
|
var hashMap = map[HashType]HashingFunc{
|
|
MD5: md5.New,
|
|
SHA1: sha1.New,
|
|
SHA256: sha256.New,
|
|
}
|
|
|
|
// Hash generates a name from a hash of the filename.
|
|
// When this is used, the original filename will be removed from the final filename.
|
|
func Hash(t HashType) Generator {
|
|
f, ok := hashMap[t]
|
|
return func(c *Config) (string, error) {
|
|
if !ok {
|
|
return "", fmt.Errorf("%w: %s", ErrInvalidHashType, t)
|
|
}
|
|
name, err := getOriginal(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
hs := f()
|
|
hs.Write([]byte(name))
|
|
return fmt.Sprintf("%x", hs.Sum(nil)), nil
|
|
}
|
|
}
|