modules

type Browser ¶

type Browser interface {
	// Returns a pointer to an initialized browser config
	Config() *BrowserConfig
}

type BrowserConfig ¶

type BrowserConfig struct {
	Name string

	// Path to the browser base config directory
	BaseDir string

	// Absolute path to the browser's bookmark directory
	BkDir string

	// Name of bookmarks file
	BkFile string

	// In memory sqlite db (named `memcache`).
	// Used to keep a browser's state of bookmarks across jobs.
	BufferDB *database.DB

	// Fast query db using an RB-Tree hashmap.
	// It represents a URL index of the last running job
	URLIndex index.HashTree

	// Pointer to the root of the node tree
	// The node tree is built again for every Run job on a browser
	NodeTree *tree.Node

	// Watch for changes on the bookmark file
	UseFileWatcher bool

	// Hooks registered by the browser module identified by name
	UseHooks []string
	// contains filtered or unexported fields
}

BrowserConfig is the main browser configuration shared by all browser modules.

func (b BrowserConfig) BookmarkPath() (string, error)

func (b BrowserConfig) CallHooks(obj any) error

func (b *BrowserConfig) GetWatcher() *watch.WatchDescriptor

func (b BrowserConfig) RebuildIndex()

type BrowserModule ¶

type BrowserModule interface {
	Browser
	Module
}

browser modules need to implement Browser interface

func GetBrowserModules() []BrowserModule

type BrowserType ¶

type BrowserType uint8

type Context ¶

type Context struct {
	context.Context

	Cli *cli.Command
}

type Detected ¶

type Detected struct {
	Flavour string

	// Canonical path to the browser config directory
	BasePath string
}

type Detector ¶

type Detector interface {
	// List of detected browser instances
	Detect() ([]Detected, error)
}

Browsers must offer a way to detect if they are installed on the system and display path to their base directory. Note that if the browser module already implements profiles.ProfileManager, implementing this interface is redundant.

type DumbPreLoader ¶

type DumbPreLoader interface {
	PreLoad() ([]*gosuki.Bookmark, error)
}

This type of PreLoader simply returns a list of bookmarks and has no knwoledge of the loading and syncrhonization primitives. Mostly useful for simple modules (see `modules.BookmarksImporter`).

type ErrModDisabled ¶ added in v1.1.1

type ErrModDisabled struct {
	Reason string
	Err    error
}

func (e *ErrModDisabled) Error() string

type Initializer ¶

type Initializer interface {

	// Init() is the first method called after a browser instance is created
	// and registered.
	// A pointer to
	// Return ok, error
	Init(*Context) error
}

Initialize the module before any data loading or callbacks If a module wants to do any preparation and prepare custom state before Loader.Load() is called and before any Watchable.Run() or other callbacks are executed.

type Listener ¶ added in v1.1.0

type Listener struct {
	Ctx   context.Context
	Queue chan ModMsg
	MsgListener
}

Listener is a Work unit for modules that implement the MsgListener interface

func (lw Listener) Run(m manager.UnitManager)

type ModID ¶

type ModID string

type ModInfo ¶

type ModInfo struct {
	ID ModID // Id of this module

	// New returns a pointer to a new instance of a gosuki module.
	// Browser modules MUST implement this method.
	New func() Module
}

Information related to the browser module

type ModMsg ¶ added in v1.1.0

type ModMsg struct {
	Type    ModMsgType
	To      ModID
	Payload any
}

ModMsg is a message exchanged between modules

type ModMsgType ¶ added in v1.1.0

type ModMsgType int

type Module ¶

type Module interface {
	ModInfo() ModInfo
}

Every new module needs to register as a Module using this interface

func GetModules() []Module

type MsgListener ¶ added in v1.1.0

type MsgListener interface {
	MsgListen(context.Context, <-chan ModMsg)
}

MsgListener is a module that can listen to messages from other mods

type PreLoader ¶

type PreLoader interface {

	// PreLoad() will be called right after a browser is initialized
	PreLoad(*Context) error
}

PreLoader is an interface for modules which is run only once when the module starts. It should have the same effect as Watchable.Run(). Run() is automatically called for watched events, Load() is called once before starting to watch events.

PreLoader allows modules to do a first pass of bookmark loading logic before the watcher threads is spawned

type ProfileInitializer ¶

type ProfileInitializer interface {
	Init(*Context, *profiles.Profile) error
}

ProfileInitializer is similar to Initializer but is called with a profile. This is useful for modules that need to do some custom initialization for a specific profile.

type ProfilePrefs ¶

type ProfilePrefs struct {
	// Whether to watch all the profiles for multi-profile modules
	WatchAllProfiles bool `toml:"watch-all-profiles" mapstructure:"watch-all-profiles"`

	Profile string `toml:"profile" mapstructure:"profile"`
}

The profile preferences for modules with builtin profile management.

type Shutdowner ¶

type Shutdowner interface {
	watch.Shutdowner
}

Modules which implement this interface need to handle all shuttind down and cleanup logic in the defined methods. This is usually called at the end of the module instance lifetime