119 lines
4.4 KiB
Python
119 lines
4.4 KiB
Python
from inifile import IniFile
|
|
from lektor.utils import slugify
|
|
from .util import split_strip
|
|
|
|
from typing import Set, Dict, Optional, Union, Any, List
|
|
|
|
AnyConfig = Union['Config', IniFile, Dict]
|
|
|
|
|
|
class Config:
|
|
'''
|
|
Holds information for GroupByWatcher and GroupBySource.
|
|
This object is accessible in your template file ({{this.config}}).
|
|
|
|
Available attributes:
|
|
key, root, slug, template, enabled, dependencies, fields, key_map
|
|
'''
|
|
|
|
def __init__(
|
|
self,
|
|
key: str, *,
|
|
root: Optional[str] = None, # default: "/"
|
|
slug: Optional[str] = None, # default: "{attr}/{group}/index.html"
|
|
template: Optional[str] = None, # default: "groupby-{attr}.html"
|
|
) -> None:
|
|
self.key = key
|
|
self.root = (root or '/').rstrip('/') or '/'
|
|
self.slug = slug or (key + '/{key}/') # key = GroupBySource.key
|
|
self.template = template or f'groupby-{self.key}.html'
|
|
# editable after init
|
|
self.enabled = True
|
|
self.dependencies = set() # type: Set[str]
|
|
self.fields = {} # type: Dict[str, Any]
|
|
self.key_map = {} # type: Dict[str, str]
|
|
self.pagination = {} # type: Dict[str, Any]
|
|
self.order_by = None # type: Optional[List[str]]
|
|
|
|
def slugify(self, k: str) -> str:
|
|
''' key_map replace and slugify. '''
|
|
return slugify(self.key_map.get(k, k)) # type: ignore[no-any-return]
|
|
|
|
def set_fields(self, fields: Optional[Dict[str, Any]]) -> None:
|
|
'''
|
|
The fields dict is a mapping of attrib = Expression values.
|
|
Each dict key will be added to the GroupBySource virtual object.
|
|
Each dict value is passed through jinja context first.
|
|
'''
|
|
self.fields = fields or {}
|
|
|
|
def set_key_map(self, key_map: Optional[Dict[str, str]]) -> None:
|
|
''' This mapping replaces group keys before slugify. '''
|
|
self.key_map = key_map or {}
|
|
|
|
def set_pagination(
|
|
self,
|
|
enabled: Optional[bool] = None,
|
|
per_page: Optional[int] = None,
|
|
url_suffix: Optional[str] = None,
|
|
items: Optional[str] = None,
|
|
) -> None:
|
|
''' Used for pagination. '''
|
|
self.pagination = dict(
|
|
enabled=enabled,
|
|
per_page=per_page,
|
|
url_suffix=url_suffix,
|
|
items=items,
|
|
)
|
|
|
|
def set_order_by(self, order_by: Optional[str]) -> None:
|
|
''' If specified, children will be sorted according to keys. '''
|
|
self.order_by = split_strip(order_by or '', ',') or None
|
|
|
|
def __repr__(self) -> str:
|
|
txt = '<GroupByConfig'
|
|
for x in ['key', 'root', 'slug', 'template', 'enabled']:
|
|
txt += ' {}="{}"'.format(x, getattr(self, x))
|
|
txt += f' fields="{", ".join(self.fields)}"'
|
|
if self.order_by:
|
|
txt += ' order_by="{}"'.format(' ,'.join(self.order_by))
|
|
return txt + '>'
|
|
|
|
@staticmethod
|
|
def from_dict(key: str, cfg: Dict[str, str]) -> 'Config':
|
|
''' Set config fields manually. Allowed: key, root, slug, template. '''
|
|
return Config(
|
|
key=key,
|
|
root=cfg.get('root'),
|
|
slug=cfg.get('slug'),
|
|
template=cfg.get('template'),
|
|
)
|
|
|
|
@staticmethod
|
|
def from_ini(key: str, ini: IniFile) -> 'Config':
|
|
''' Read and parse ini file. Also adds dependency tracking. '''
|
|
cfg = ini.section_as_dict(key) # type: Dict[str, str]
|
|
conf = Config.from_dict(key, cfg)
|
|
conf.enabled = ini.get_bool(key + '.enabled', True)
|
|
conf.dependencies.add(ini.filename)
|
|
conf.set_fields(ini.section_as_dict(key + '.fields'))
|
|
conf.set_key_map(ini.section_as_dict(key + '.key_map'))
|
|
conf.set_pagination(
|
|
enabled=ini.get_bool(key + '.pagination.enabled', None),
|
|
per_page=ini.get_int(key + '.pagination.per_page', None),
|
|
url_suffix=ini.get(key + '.pagination.url_suffix'),
|
|
items=ini.get(key + '.pagination.items'),
|
|
)
|
|
conf.set_order_by(ini.get(key + '.children.order_by', None))
|
|
return conf
|
|
|
|
@staticmethod
|
|
def from_any(key: str, config: AnyConfig) -> 'Config':
|
|
assert isinstance(config, (Config, IniFile, Dict))
|
|
if isinstance(config, Config):
|
|
return config
|
|
elif isinstance(config, IniFile):
|
|
return Config.from_ini(key, config)
|
|
elif isinstance(config, Dict):
|
|
return Config.from_dict(key, config)
|