feature

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 29, 2023 License: Apache-2.0 Imports: 22 Imported by: 15

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Buildable 

type Buildable interface {
	Builder

	// MakeEnvKey returns name with EnvPrefix (SCREAMING_SNAKE formatted)
	MakeEnvKey(name string) (key string)

	// MakeEnvKeys returns name with EnvPrefix (SCREAMING_SNAKE formatted)
	MakeEnvKeys(names ...string) (key []string)
}

type Builder 

type Builder interface {
	SiteTag(key string) Builder
	SiteName(name string) Builder
	SiteTagLine(title string) Builder
	SiteLanguageMode(mode lang.Mode) Builder
	SiteCopyrightName(name string) Builder
	SiteCopyrightNotice(notice string) Builder
	SiteDefaultLanguage(tag language.Tag) Builder
	SiteSupportedLanguages(tags ...language.Tag) Builder
	SiteLanguageDisplayNames(names map[language.Tag]string) Builder

	AddLocalesLocalFS(path string) Builder
	AddLocalesEmbedFS(path string, efs embed.FS) Builder

	// Set a custom context key with value
	Set(key string, value interface{}) Builder

	// AddHtmlHeadTag adds a custom (singleton) HTML tag to the <head> section
	// of the page output, example meta tag:
	//   AddHtmlHeadTag("meta",map[string]string{"name":"og:thing","content":"stuff"})
	AddHtmlHeadTag(name string, attr map[string]string) Builder

	// AddDomains restricts inbound requests to only the domain names given
	AddDomains(domains ...string) Builder

	// AddFlags adds custom command line flags
	AddFlags(flags ...cli.Flag) Builder

	// AddCommands adds custom command line commands
	AddCommands(commands ...*cli.Command) Builder

	// AddConsole adds custom command line go-curses consoles (ctk.Window)
	AddConsole(c Console) Builder

	// AddFeature includes the given feature within the built Enjin
	AddFeature(f Feature) Builder

	// AddRouteProcessor adds the given route processor to the Enjin route
	// processing middleware
	AddRouteProcessor(route string, processor ReqProcessFn) Builder

	// AddOutputTranslator adds the given output filter (for the given mime type)
	AddOutputTranslator(mime string, filter TranslateOutputFn) Builder

	// AddModifyHeadersFn adds the given headers.ModifyHeadersFn function to the
	// default headers enjin middleware layer
	AddModifyHeadersFn(fn headers.ModifyHeadersFn) Builder

	AddNotifyHook(name string, hook NotifyHook) Builder

	// AddPageFromString is a convenience wrapper around AddPage
	AddPageFromString(path, raw string) Builder

	// SetStatusPage overrides specific HTTP error pages, ie: 404
	SetStatusPage(status int, path string) Builder

	// AddTheme includes the given theme within the built Enjin
	AddTheme(t *theme.Theme) Builder

	// SetTheme configures the default theme
	SetTheme(name string) Builder

	// AddThemes is a convenience wrapper include all themes in the given path
	AddThemes(path string) Builder

	// EmbedTheme is a wrapper around AddTheme for an embed.FS theme
	EmbedTheme(name, path string, tfs embed.FS) Builder

	// EmbedThemes is a wrapper to include all themes in the given embed.FS
	EmbedThemes(path string, fs embed.FS) Builder

	// HotReload enables or disables hot-reloading theme templates and content files
	HotReload(enabled bool) Builder

	// Build constructs an Enjin Runner from the Builder configuration
	Build() Runner
}

type CConsole 

type CConsole struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*CConsole) Build 

func (c *CConsole) Build(b Buildable) (err error)

func (*CConsole) Depends 

func (c *CConsole) Depends() (deps Tags)

func (*CConsole) Init 

func (c *CConsole) Init(this interface{})

func (*CConsole) Make 

func (c *CConsole) Make() Console

func (*CConsole) Self 

func (c *CConsole) Self() (self Console)

func (*CConsole) Tag 

func (c *CConsole) Tag() (tag Tag)

func (*CConsole) This 

func (c *CConsole) This() (this interface{})

type CEnjinBlock 

type CEnjinBlock struct {
	CEnjinFeature
}

type CEnjinFeature 

type CEnjinFeature struct {
	CFeature
}

func (*CEnjinFeature) NjnCheckClass 

func (f *CEnjinFeature) NjnCheckClass(tagClass NjnClass) (allow bool)

func (*CEnjinFeature) NjnCheckTag 

func (f *CEnjinFeature) NjnCheckTag(tagName string) (allow bool)

func (*CEnjinFeature) NjnClassAllowed 

func (f *CEnjinFeature) NjnClassAllowed() (allowed NjnClass, ok bool)

func (*CEnjinFeature) NjnTagsAllowed 

func (f *CEnjinFeature) NjnTagsAllowed() (allowed []string, ok bool)

func (*CEnjinFeature) NjnTagsDenied 

func (f *CEnjinFeature) NjnTagsDenied() (denied []string, ok bool)

type CEnjinField 

type CEnjinField struct {
	CEnjinFeature
}

type CFeature 

type CFeature struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func (*CFeature) Build 

func (f *CFeature) Build(b Buildable) (err error)

func (*CFeature) Context 

func (f *CFeature) Context() (ctx context.Context)

func (*CFeature) Depends 

func (f *CFeature) Depends() (deps Tags)

func (*CFeature) Init 

func (f *CFeature) Init(this interface{})

func (*CFeature) Make 

func (f *CFeature) Make() Feature

func (*CFeature) Self 

func (f *CFeature) Self() (self Feature)

func (*CFeature) Setup 

func (f *CFeature) Setup(enjin Internals)

func (*CFeature) Shutdown 

func (f *CFeature) Shutdown()

func (*CFeature) Startup 

func (f *CFeature) Startup(ctx *cli.Context) (err error)

func (*CFeature) Tag 

func (f *CFeature) Tag() (tag Tag)

func (*CFeature) This 

func (f *CFeature) This() (this interface{})

type CMiddleware 

type CMiddleware struct {
	CFeature
}

func (*CMiddleware) Apply 

func (f *CMiddleware) Apply(s System) (err error)

func (*CMiddleware) Middleware 

func (f *CMiddleware) Middleware(next http.Handler) (this http.Handler)

func (*CMiddleware) Serve 

func (f *CMiddleware) Serve(w http.ResponseWriter, r *http.Request) (err error)

func (*CMiddleware) ServePath 

func (f *CMiddleware) ServePath(path string, s System, w http.ResponseWriter, r *http.Request) (err error)

func (*CMiddleware) Use 

func (f *CMiddleware) Use(s System) MiddlewareFn

type CanSetupInternals 

type CanSetupInternals interface {
	Setup(enjin Internals)
}

type Console 

type Console interface {
	Tag() (tag Tag)
	Init(this interface{})
	This() (this interface{})
	Self() (self Console)
	Build(c Buildable) (err error)
	Depends() (deps Tags)
}

type ContentSecurityPolicyModifier 

type ContentSecurityPolicyModifier interface {
	ModifyContentSecurityPolicy(policy csp.Policy, r *http.Request) (modified csp.Policy)
}

type DataRestrictionHandler 

type DataRestrictionHandler interface {
	Feature

	RestrictServeData(data []byte, mime string, w http.ResponseWriter, r *http.Request) (out *http.Request, allow bool)
}

type Database 

type Database interface {
	Feature

	// ListDB returns a sorted list of connected db tags for use with DB and
	// MustDB
	ListDB() (tags []string)

	// DB returns the database connection or an error
	DB(tag string) (db interface{}, err error)

	// MustDB returns the database connection or panics on error
	MustDB(tag string) (db interface{})
}

type EnjinBlock 

type EnjinBlock interface {
	EnjinFeature

	NjnBlockType() (name string)

	ProcessBlock(re EnjinRenderer, blockType string, data map[string]interface{}) (html template.HTML, redirect string, err error)

	PrepareBlock(re EnjinRenderer, blockType string, data map[string]interface{}) (block map[string]interface{}, redirect string, err error)
	RenderPreparedBlock(re EnjinRenderer, block map[string]interface{}) (html template.HTML, err error)
}

type EnjinFeature 

type EnjinFeature interface {
	Feature

	NjnClass() (tagClass NjnClass)
	NjnCheckTag(tagName string) (allow bool)
	NjnCheckClass(tagClass NjnClass) (allow bool)
	NjnTagsAllowed() (allowed []string, ok bool)
	NjnTagsDenied() (denied []string, ok bool)
	NjnClassAllowed() (allowed NjnClass, ok bool)
}

type EnjinField 

type EnjinField interface {
	EnjinFeature

	NjnFieldNames() (tagNames []string)

	PrepareNjnData(re EnjinRenderer, tagName string, field map[string]interface{}) (data map[string]interface{}, err error)
}

type EnjinRenderer 

type EnjinRenderer interface {
	RequestArgv() (reqArgv *argv.RequestArgv)
	RequestContext() (ctx context.Context)

	RenderNjnTemplate(tag string, data map[string]interface{}) (html template.HTML, err error)

	ProcessBlock(data map[string]interface{}) (html template.HTML, redirect string, err error)

	PrepareBlock(data map[string]interface{}) (block map[string]interface{}, redirect string, err error)
	RenderPreparedBlock(block map[string]interface{}) (html template.HTML, err error)

	PrepareGenericBlockData(contentData interface{}) (blockDataContent map[string]interface{}, err error)
	PrepareGenericBlock(typeName string, data map[string]interface{}) (preparedData map[string]interface{})

	GetData() (data interface{})
	GetBlockIndex() (index int)

	GetWithinAside() (within bool)
	SetWithinAside(within bool)

	GetCurrentDepth() (depth int)
	IncCurrentDepth() (depth int)
	DecCurrentDepth() (depth int)

	GetHeadingCount() (count int)
	SetHeadingCount(count int)
	IncHeadingCount()

	GetHeadingLevel() (level int)
	SetHeadingLevel(level int)
	IncHeadingLevel()
	DecHeadingLevel()

	AddFootnote(blockIndex int, field map[string]interface{}) (index int)
	PrepareFootnotes(blockIndex int) (footnotes []map[string]interface{}, err error)

	ParseTypeName(data map[string]interface{}) (name string, ok bool)
	ParseFieldAndTypeName(data interface{}) (field map[string]interface{}, name string, ok bool)

	PrepareStringTags(text string) (data []interface{}, err error)
	WalkStringTags(doc *html.Node) (prepared []interface{})

	PrepareBlockHeader(content map[string]interface{}) (combined []interface{}, ok bool)
	PrepareBlockFooter(content map[string]interface{}) (combined []interface{}, ok bool)

	ParseBlockHeadingLevel(count, current int, blockData map[string]interface{}) (level, headingReset, headingLevel int)
	RenderBlockHeader(content map[string]interface{}) (html template.HTML, ok bool)
	RenderBlockFooter(content map[string]interface{}) (html template.HTML, ok bool)

	PrepareInlineFieldText(field map[string]interface{}) (combined []interface{}, err error)
	PrepareInlineFieldList(list []interface{}) (combined []interface{}, err error)
	PrepareInlineFields(fields []interface{}) (combined []interface{}, err error)
	PrepareInlineField(field map[string]interface{}) (prepared map[string]interface{}, err error)

	PrepareContainerFieldText(field map[string]interface{}) (fields []interface{}, err error)
	PrepareContainerFieldList(list []interface{}) (fields []interface{}, err error)
	PrepareContainerFields(fields []interface{}) (combined []map[string]interface{}, err error)
	PrepareContainerField(field map[string]interface{}) (prepared map[string]interface{}, err error)

	RenderInlineField(field map[string]interface{}) (combined []template.HTML, err error)
	RenderInlineFields(fields []interface{}) (combined []template.HTML, err error)
	RenderInlineFieldList(list []interface{}) (html template.HTML, err error)
	RenderInlineFieldText(field map[string]interface{}) (text template.HTML, err error)

	RenderContainerField(field map[string]interface{}) (combined []template.HTML, err error)
	RenderContainerFields(fields []interface{}) (combined []template.HTML, err error)
	RenderContainerFieldList(list []interface{}) (html template.HTML, err error)
	RenderContainerFieldText(field map[string]interface{}) (text template.HTML, err error)
}

type EnjinRunner 

type EnjinRunner interface {
	Runner

	StartupString() (info string)

	Shutdown()

	Notify(tag string)
	NotifyF(tag, format string, argv ...interface{})
}

type EnjinSystem 

type EnjinSystem interface {
	InlineFields() (field map[string]EnjinField)
	ContainerFields() (field map[string]EnjinField)
	InlineBlocks() (field map[string]EnjinBlock)
	ContainerBlocks() (field map[string]EnjinBlock)
	StringTags() (names []string)
	FindField(tagClass NjnClass, fieldType string) (field EnjinField, ok bool)
	FindBlock(tagClass NjnClass, blockType string) (block EnjinBlock, ok bool)
}

type Feature 

type Feature interface {
	Init(this interface{})
	Tag() (tag Tag)
	Self() (f Feature)
	Depends() (deps Tags)
	Context() (ctx context.Context)
	Build(c Buildable) (err error)
	Setup(enjin Internals)
	Startup(ctx *cli.Context) (err error)
	Shutdown()
}

type HeadersModifier 

type HeadersModifier interface {
	ModifyHeaders(w http.ResponseWriter, r *http.Request)
}

type Internals 

type Internals interface {
	Service
	site.Enjin

	Self() (self interface{})

	Features() (features []Feature)
	Pages() (pages map[string]*page.Page)
	Theme() (theme string)
	Theming() (theming map[string]*theme.Theme)
	Headers() (headers []headers.ModifyHeadersFn)
	Domains() (domains []string)
	Consoles() (consoles map[Tag]Console)
	Processors() (processors map[string]ReqProcessFn)
	Translators() (translators map[string]TranslateOutputFn)
	Transformers() (transformers map[string]TransformOutputFn)
	Slugsums() (enabled bool)

	DB(tag string) (db interface{}, err error)
	MustDB(tag string) (db interface{})
	SpecificDB(fTag Tag, tag string) (db interface{}, err error)
	MustSpecificDB(fTag Tag, tag string) (db interface{})
}

type MakeConsole 

type MakeConsole interface {
	Make() Console
}

type MakeFeature 

type MakeFeature interface {
	Make() Feature
}
type MenuProvider interface {
	Feature

	GetMenus(tag language.Tag) (found map[string]menu.Menu)
}

type Middleware 

type Middleware interface {
	Feature

	Apply(s System) (err error)
	Use(s System) MiddlewareFn
	Middleware(next http.Handler) http.Handler
	Serve(w http.ResponseWriter, r *http.Request) (err error)
	ServePath(path string, s System, w http.ResponseWriter, r *http.Request) (err error)
}

type MiddlewareFn 

type MiddlewareFn = func(next http.Handler) (this http.Handler)

type NjnClass 

type NjnClass uint
const (
	InlineNjnClass NjnClass = iota
	ContainerNjnClass
	AnyNjnClass
)

func (NjnClass) String 

func (nc NjnClass) String() string

type NotifyHook 

type NotifyHook = func(format string, argv ...interface{})

type OutputTransformer 

type OutputTransformer interface {
	CanTransform(mime string, r *http.Request) (ok bool)
	TransformOutput(mime string, input []byte) (output []byte)
}

type OutputTranslator 

type OutputTranslator interface {
	CanTranslate(mime string) (ok bool)
	TranslateOutput(s Service, input []byte, inputMime string) (output []byte, mime string, err error)
}

type PageContextFilterFn 

type PageContextFilterFn = func(ctx context.Context, r *http.Request) (out context.Context)

type PageContextModifier 

type PageContextModifier interface {
	Feature

	FilterPageContext(themeCtx, pageCtx context.Context, r *http.Request) (themeOut context.Context)
}

type PageProvider 

type PageProvider interface {
	Feature

	FindRedirection(url string) (p *page.Page)
	FindTranslations(url string) (pages []*page.Page)
	FindPage(tag language.Tag, url string) (p *page.Page)
	LookupPrefixed(prefix string) (pages []*page.Page)
}

type PageRestrictionHandler 

type PageRestrictionHandler interface {
	Feature

	RestrictServePage(ctx context.Context, w http.ResponseWriter, r *http.Request) (co context.Context, ro *http.Request, allow bool)
}

type PageTypeProcessor 

type PageTypeProcessor interface {
	Feature

	ProcessRequestPageType(r *http.Request, p *page.Page) (pg *page.Page, redirect string, processed bool, err error)
}

type PermissionsPolicyModifier 

type PermissionsPolicyModifier interface {
	ModifyPermissionsPolicy(policy permissions.Policy, r *http.Request) (modified permissions.Policy)
}

type Processor 

type Processor interface {
	Process(s Service, next http.Handler, w http.ResponseWriter, r *http.Request)
}

type ReqProcessFn 

type ReqProcessFn = func(s Service, w http.ResponseWriter, r *http.Request) (ok bool)

type RequestFilter 

type RequestFilter interface {
	FilterRequest(r *http.Request) (err error)
}

type RequestFilterFn 

type RequestFilterFn = func(r *http.Request) (err error)

type RequestModifier 

type RequestModifier interface {
	ModifyRequest(w http.ResponseWriter, r *http.Request)
}

type RequestRewriter 

type RequestRewriter interface {
	RewriteRequest(w http.ResponseWriter, r *http.Request) (modified *http.Request)
}

type RootInternals 

type RootInternals interface {
	Internals

	SetupRootEnjin(ctx *cli.Context) (err error)
}

type Runner 

type Runner interface {
	String() string
	Run(argv []string) (err error)
}

type Service 

type Service interface {
	Prefix() (prefix string)
	Context() (ctx context.Context)
	GetTheme() (t *theme.Theme, err error)
	ThemeNames() (names []string)
	ServerName() (name string)
	ServiceInfo() (listen string, port int)

	ContentSecurityPolicy() (handler *csp.PolicyHandler)
	PermissionsPolicy() (handler *permissions.PolicyHandler)

	ServeRedirect(destination string, w http.ResponseWriter, r *http.Request)

	Serve204(w http.ResponseWriter, r *http.Request)
	Serve401(w http.ResponseWriter, r *http.Request)
	ServeBasic401(w http.ResponseWriter, r *http.Request)
	Serve403(w http.ResponseWriter, r *http.Request)
	Serve404(w http.ResponseWriter, r *http.Request)
	Serve405(w http.ResponseWriter, r *http.Request)
	Serve500(w http.ResponseWriter, r *http.Request)

	ServeNotFound(w http.ResponseWriter, r *http.Request)
	ServeInternalServerError(w http.ResponseWriter, r *http.Request)

	ServeStatusPage(status int, w http.ResponseWriter, r *http.Request)
	ServePage(p *page.Page, w http.ResponseWriter, r *http.Request) (err error)
	ServePath(urlPath string, w http.ResponseWriter, r *http.Request) (err error)
	ServeData(data []byte, mime string, w http.ResponseWriter, r *http.Request)

	MatchQL(query string) (pages []*page.Page)
	MatchStubsQL(query string) (stubs []*pagecache.Stub)
	SelectQL(query string) (selected map[string]interface{})
	FindPage(tag language.Tag, url string) (p *page.Page)

	Notify(tag string)
	NotifyF(tag, format string, argv ...interface{})
}

type System 

type System interface {
	Service

	Router() (router *chi.Mux)
}

type Tag 

type Tag string
const NotImplemented Tag = "NotImplemented"

func (Tag) String 

func (t Tag) String() string

type Tags 

type Tags []Tag

func (Tags) Append 

func (t Tags) Append(tag Tag) Tags

func (Tags) Has 

func (t Tags) Has(tag Tag) bool

func (Tags) Len 

func (t Tags) Len() int

type TransformOutputFn 

type TransformOutputFn = func(input []byte) (output []byte)

type TranslateOutputFn 

type TranslateOutputFn = func(input []byte) (output []byte, mime string)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.