imagorpath

README

imagorpath

Parse and generate imagor endpoint using Go struct

import "github.com/cshum/imagor/imagorpath"

...

func Test(t *testing.T) {
	params := imagorpath.Params{
		Image:    "raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png",
		FitIn:    true,
		Width:    500,
		Height:   400,
		PaddingTop: 20,
		PaddingBottom: 20,
		Filters: imagorpath.Filters{
			{
				Name: "fill",
				Args: "white",
			},
		},
	}

	// generate signed imagor endpoint from Params struct with secret
	path := imagorpath.Generate(params, imagorpath.NewDefaultSigner("mysecret"))

	assert.Equal(t, path, "OyGJyvfYJw8xNkYDmXU-4NPA2U0=/fit-in/500x400/0x20/filters:fill(white)/raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png")

	assert.Equal(t,
		// parse Params struct from signed imagor endpoint
		imagorpath.Parse(path),

		// Params include endpoint attributes with path and signed hash
		imagorpath.Params{
			Path:     "fit-in/500x400/0x20/filters:fill(white)/raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png",
			Hash:     "OyGJyvfYJw8xNkYDmXU-4NPA2U0=",
			Image:    "raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png",
			FitIn:    true,
			Width:    500,
			Height:   400,
			PaddingTop: 20,
			PaddingBottom: 20,
			Filters: imagorpath.Filters{
				{
					Name: "fill",
					Args: "white",
				},
			},
		},
	)
}

Documentation

Index

• Constants
• Variables
• func Generate(p Params, signer Signer) string
• func GeneratePath(p Params) string
• func GenerateUnsafe(p Params) string
• func Normalize(image string, safeChars SafeChars) string
• type Filter
• type Filters
• type Params
  • func Apply(p Params, path string) Params
  • func Parse(path string) Params
• type ResultStorageHasher
• type ResultStorageHasherFunc
  • func (h ResultStorageHasherFunc) HashResult(p Params) string
• type SafeChars
  • func NewNoopSafeChars() SafeChars
  • func NewSafeChars(safechars string) SafeChars
• type Signer
  • func NewDefaultSigner(secret string) Signer
  • func NewHMACSigner(alg func() hash.Hash, truncate int, secret string) Signer
• type StorageHasher
• type StorageHasherFunc
  • func (h StorageHasherFunc) Hash(image string) string

Constants

const (
	// TrimByTopLeft trim by top-left keyword
	TrimByTopLeft = "top-left"
	// TrimByBottomRight trim by bottom-right keyword
	TrimByBottomRight = "bottom-right"
	// HAlignLeft horizontal align left keyword
	HAlignLeft = "left"
	// HAlignRight horizontal align right keyword
	HAlignRight = "right"
	// VAlignTop vertical align top keyword
	VAlignTop = "top"
	// VAlignBottom vertical align bottom keyword
	VAlignBottom = "bottom"
)

Variables

var DigestResultStorageHasher = ResultStorageHasherFunc(func(p Params) string {
	if p.Path == "" {
		p.Path = GeneratePath(p)
	}
	return hexDigestPath(p.Path)
})

DigestResultStorageHasher ResultStorageHasher using SHA digest

var DigestStorageHasher = StorageHasherFunc(hexDigestPath)

DigestStorageHasher StorageHasher using SHA digest

var SizeSuffixResultStorageHasher = ResultStorageHasherFunc(func(p Params) string {
	if p.Path == "" {
		p.Path = GeneratePath(p)
	}
	var digest = sha1.Sum([]byte(p.Path))
	var hash = "." + hex.EncodeToString(digest[:])[:20]
	if p.Width != 0 || p.Height != 0 {
		hash += "_" + strconv.Itoa(p.Width) + "x" + strconv.Itoa(p.Height)
	}
	var dotIdx = strings.LastIndex(p.Image, ".")
	var slashIdx = strings.LastIndex(p.Image, "/")
	if dotIdx > -1 && slashIdx < dotIdx {
		ext := p.Image[dotIdx:]
		if p.Meta {
			ext = ".json"
		} else {
			for _, filter := range p.Filters {
				if filter.Name == "format" {
					ext = "." + filter.Args
				}
			}
		}
		return p.Image[:dotIdx] + hash + ext
	}
	return p.Image + hash
})

SizeSuffixResultStorageHasher ResultStorageHasher using storage path with digest and size suffix

var SuffixResultStorageHasher = ResultStorageHasherFunc(func(p Params) string {
	if p.Path == "" {
		p.Path = GeneratePath(p)
	}
	var digest = sha1.Sum([]byte(p.Path))
	var hash = "." + hex.EncodeToString(digest[:])[:20]
	var dotIdx = strings.LastIndex(p.Image, ".")
	var slashIdx = strings.LastIndex(p.Image, "/")
	if dotIdx > -1 && slashIdx < dotIdx {
		ext := p.Image[dotIdx:]
		if p.Meta {
			ext = ".json"
		} else {
			for _, filter := range p.Filters {
				if filter.Name == "format" {
					ext = "." + filter.Args
				}
			}
		}
		return p.Image[:dotIdx] + hash + ext
	}
	return p.Image + hash
})

SuffixResultStorageHasher ResultStorageHasher using storage path with digest suffix

Functions

func Generate

func Generate(p Params, signer Signer) string

Generate imagor endpoint with signature by Params struct with signer

func GeneratePath

func GeneratePath(p Params) string

GeneratePath generate imagor path by Params struct

func GenerateUnsafe

func GenerateUnsafe(p Params) string

GenerateUnsafe generate unsafe imagor endpoint by Params struct

func Normalize

func Normalize(image string, safeChars SafeChars) string

Normalize imagor path to be file path friendly, optional escapeByte func for custom SafeChars

Types

type Filter

type Filter struct {
	Name string `json:"name,omitempty"`
	Args string `json:"args,omitempty"`
}

Filter imagor endpoint filter

type Filters

type Filters []Filter

Filters a slice of Filter

type Params

type Params struct {
	Params        bool    `json:"-"`
	Path          string  `json:"path,omitempty"`
	Image         string  `json:"image,omitempty"`
	Unsafe        bool    `json:"unsafe,omitempty"`
	Hash          string  `json:"hash,omitempty"`
	Meta          bool    `json:"meta,omitempty"`
	Trim          bool    `json:"trim,omitempty"`
	TrimBy        string  `json:"trim_by,omitempty"`
	TrimTolerance int     `json:"trim_tolerance,omitempty"`
	CropLeft      float64 `json:"crop_left,omitempty"`
	CropTop       float64 `json:"crop_top,omitempty"`
	CropRight     float64 `json:"crop_right,omitempty"`
	CropBottom    float64 `json:"crop_bottom,omitempty"`
	FitIn         bool    `json:"fit_in,omitempty"`
	Stretch       bool    `json:"stretch,omitempty"`
	Width         int     `json:"width,omitempty"`
	Height        int     `json:"height,omitempty"`
	PaddingLeft   int     `json:"padding_left,omitempty"`
	PaddingTop    int     `json:"padding_top,omitempty"`
	PaddingRight  int     `json:"padding_right,omitempty"`
	PaddingBottom int     `json:"padding_bottom,omitempty"`
	HFlip         bool    `json:"h_flip,omitempty"`
	VFlip         bool    `json:"v_flip,omitempty"`
	HAlign        string  `json:"h_align,omitempty"`
	VAlign        string  `json:"v_align,omitempty"`
	Smart         bool    `json:"smart,omitempty"`
	Filters       Filters `json:"filters,omitempty"`
	IsBase64      bool    `json:"is_base64,omitempty"`
}

Params image endpoint parameters

func Apply

func Apply(p Params, path string) Params

Apply Params struct from imagor endpoint URI on top of existing Params

func Parse

func Parse(path string) Params

Parse Params struct from imagor endpoint URI

type ResultStorageHasher

type ResultStorageHasher interface {
	HashResult(p Params) string
}

ResultStorageHasher define key for result storage

type ResultStorageHasherFunc

type ResultStorageHasherFunc func(p Params) string

ResultStorageHasherFunc ResultStorageHasher handler func

func (ResultStorageHasherFunc) HashResult

func (h ResultStorageHasherFunc) HashResult(p Params) string

HashResult implements ResultStorageHasher interface

type SafeChars

type SafeChars interface {
	// ShouldEscape indicates if char byte should be escaped
	ShouldEscape(c byte) bool
}

SafeChars safe chars for storage paths

func NewNoopSafeChars

func NewNoopSafeChars() SafeChars

NewNoopSafeChars create no-op SafeChars

func NewSafeChars

func NewSafeChars(safechars string) SafeChars

NewSafeChars create SafeChars from predefined set of string, or "--" for no-op

type Signer

type Signer interface {
	Sign(path string) string
}

Signer imagor URL signature signer

func NewDefaultSigner

func NewDefaultSigner(secret string) Signer

NewDefaultSigner default signer using SHA1 with secret

func NewHMACSigner

func NewHMACSigner(alg func() hash.Hash, truncate int, secret string) Signer

NewHMACSigner custom HMAC alg signer with secret and string length based truncate

type StorageHasher

type StorageHasher interface {
	Hash(image string) string
}

StorageHasher define image key for storage

type StorageHasherFunc

type StorageHasherFunc func(image string) string

StorageHasherFunc StorageHasher handler func

func (StorageHasherFunc) Hash

func (h StorageHasherFunc) Hash(image string) string

Hash implements StorageHasher interface