memegen.stores.template

Complexity

Total Complexity

11

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	TemplateStore.__init__()	0	8	3
A	TemplateStore.filter()	0	5	2
A	TemplateModel.domain()	0	9	1
A	UpperString.to_data()	0	5	1
A	TemplateModel.__init__()	0	7	1
A	TemplateStore.read()	0	7	3

import os

import yorm
from yorm.types import String, List, SortedList

from ..domain import Template


class UpperString(String):

    @classmethod
    def to_data(cls, obj):
        value = super().to_data(obj)
        value = value.upper()
        return value


@yorm.attr(name=String)
@yorm.attr(link=String)
@yorm.attr(default=List.of_type(UpperString))
@yorm.attr(aliases=SortedList.of_type(String))
@yorm.sync("{self.root}/{self.key}/config.yml")
class TemplateModel:
    """Persistence model for templates."""

    def __init__(self, key, root):
        self.key = key
        self.root = root
        self.name = ""
        self.default = []
        self.link = ""
        self.aliases = []

    @property
    def domain(self):
        return Template(
            key=self.key,
            name=self.name,
            lines=self.default,
            aliases=self.aliases,
            link=self.link,
            root=self.root,
        )


class TemplateStore:

    def __init__(self, root):
        self.root = root
        self._items = {}
        for key in os.listdir(self.root):
            if key[0] not in ('.', '_'):
                model = TemplateModel(key, self.root)
                yorm.save(model)
                self._items[key] = model

    def read(self, key):
        try:
            model = self._items[key]
        except KeyError:
            return None
        else:
            return model.domain

    def filter(self, **_):
        templates = []
        for model in self._items.values():
            templates.append(model.domain)
        return templates