Add directives for class, style, Alpine.js, HTMX

dominate/all.py

@@ -0,0 +1,3 @@
+from .document import document
+from .tags import *
+from .util import *

dominate/directives/alpine.py

@@ -0,0 +1,33 @@
+from .base import BaseAttributeDirective, BaseDominated
+from .mixins.modifier import BaseAttributeModifierMixin
+
+
+class AlpineDirective(BaseAttributeDirective):
+    prefix = 'x-'
+
+
+class AlpineModifier(BaseAttributeModifierMixin, AlpineDirective):
+    pass
+
+
+class AlpineDominated(BaseDominated):
+    default_directive = 'bind'
+
+    data = AlpineDirective()
+    init = AlpineDirective()
+    show = AlpineDirective()
+    bind = AlpineModifier()
+    on = AlpineModifier()
+    text = AlpineDirective()
+    html = AlpineDirective()
+    model = AlpineDirective()
+    modelable = AlpineDirective()
+    for_ = AlpineDirective()
+    transition = AlpineDirective()
+    effect = AlpineDirective()
+    ignore = AlpineDirective()
+    ref = AlpineDirective()
+    cloak = AlpineDirective()
+    teleport = AlpineDirective()
+    if_ = AlpineDirective()
+    id = AlpineDirective()

dominate/directives/attrs.py

@@ -0,0 +1,101 @@
+import cssutils
+
+from .base import BaseAttributeDirective
+from .mixins.delemeted_string import SpaceDelemetedStringListMixin
+from .mixins.modifier import BaseAttributeModifierMixin
+
+
+class KlassDirective(SpaceDelemetedStringListMixin, BaseAttributeDirective):
+    pass
+
+
+class StyleDirective(BaseAttributeDirective):
+
+    encoding='utf-8'
+    normalize = True
+
+    @property
+    def css(self):
+        return cssutils.parseStyle(self.current_attr() or '', self.encoding)
+
+    @css.setter
+    def css(self, css):
+        super().__call__(css.getCssText(' '))
+
+    def reset_style(self, **properties):
+        return self.make_style(False, **properties)
+
+    def make_style(self, __include_current=True, __replace=True, __is_pythonic_key=True, **properties):
+        css = self.css if __include_current else cssutils.css.CSSStyleDeclaration()
+
+        for name, value in properties.items():
+            value, priority = value if type(value) is tuple else (value, '')
+
+            if __is_pythonic_key:
+                name = name.replace('_', '-')
+
+            css.setProperty(name, value, priority, self.normalize, __replace)
+
+        return css.getCssText(' ')
+
+    def reset(self, **properties):
+        return super().__call__(
+            self.reset_style(**properties)
+        )
+
+    def add(self, __replace=True, **properties):
+        return super().__call__(
+            self.make_style(True, __replace, **properties)
+        )
+
+    def add_extra(self, **properties):
+        return self.add(False, **properties)
+
+    def __add__(self, other):
+        return self.make_style(True, True, **other)
+
+    def __setitem__(self, key, value):
+        return super().__call__(
+            self.make_style(True, True, False, **{key: value})
+        )
+
+    def __set__(self, instance, value):
+        if type(value) is dict:
+            self.copied_self(instance).__call__(**value)
+        elif type(value) is cssutils.css.CSSStyleDeclaration:
+            super(StyleDirective, self.copied_self(instance)).__call__(value.getCssText(' '))
+        else:
+            super(StyleDirective, self.copied_self(instance)).__call__(value)
+
+    def remove_properties(self, *properties):
+        css = self.css
+
+        for name in properties:
+            css.removeProperty(name, self.normalize)
+
+        return css.getCssText(' ')
+
+    def remove(self, *properties):
+        return super().__call__(self.remove_properties(*properties))
+
+    def __delitem__(self, key):
+        return self.remove(key)
+
+    def __sub__(self, other):
+        if type(other) is str:
+            return self.remove_properties(other)
+        else:
+            return self.remove_properties(*other)
+
+    def __call__(self, **properties):
+        super().__call__(self.reset_style(**properties))
+
+
+class DataDirective(BaseAttributeModifierMixin, BaseAttributeDirective):
+
+    separator = "-"
+
+
+class AriaDirective(BaseAttributeModifierMixin, BaseAttributeDirective):
+
+    separator = "-"

dominate/directives/base.py

@@ -0,0 +1,87 @@
+from .mixins.descriptor import DescriptorMixin
+from .mixins.delemeted_string import DelemetedSubstringMixin
+
+
+class BaseDominated(DescriptorMixin):
+
+    default_directive = None
+
+    def __getitem__(self, key):
+        if self.default_directive:
+            return getattr(self, self.default_directive)[key]
+        else:
+            raise NotImplementedError(f"`{self.__class__.__name__}` does not support a default directive.")
+
+    def __setitem__(self, key, value):
+        if self.default_directive:
+            return getattr(self, self.default_directive)[key](value)
+        else:
+            raise NotImplementedError(f"`{self.__class__.__name__}` does not support a default directive.")
+
+    def __call__(self, value):
+        if self.default_directive:
+            return getattr(self, self.default_directive)(value)
+        else:
+            raise NotImplementedError(f"`{self.__class__.__name__}` does not support a default directive.")
+
+
+class BaseDirective(DescriptorMixin):
+
+    def prepend(self, string):
+        return self.__call__(
+            self.__radd__(string)
+        )
+
+    def append(self, string):
+        return self.__call__(
+            self.__add__(string)
+        )
+
+    def delete(self, raise_if_not_found=False):
+        try:
+            del self.get_dom_tag().attributes[self.full_directive()]
+        except:
+            if raise_if_not_found:
+                raise
+
+    def __add__(self, other):
+        return str(self) + other
+
+    def __radd__(self, other):
+        return other + str(self)
+
+    def __str__(self):
+        return self.current_attr() or ''
+
+    def __bool__(self):
+        return bool(str(self))
+
+
+class BaseAttributeDirective(BaseDirective):
+
+    prefix = ''
+
+    @property
+    def directive(self):
+        return self.fixed_name
+
+    def full_directive(self):
+        return f"{self.prefix}{self.directive}"
+
+    def make_attr(self, value):
+        return {
+            self.full_directive(): value
+        }
+
+    def current_attr(self):
+        return self.get_dom_tag().attributes.get(self.full_directive(), None)
+
+    def __call__(self, value):
+        attributes = self.make_attr(value)
+        for a, v in attributes.items():
+            self.get_dom_tag().set_attribute(a, v, clean_pair=True)
+        return self.instance
+
+
+class BaseDelemetedSubstringDirective(DelemetedSubstringMixin, BaseDirective):
+    pass

dominate/directives/htmx.py

@@ -0,0 +1,77 @@
+from .base import BaseAttributeDirective, BaseDelemetedSubstringDirective, BaseDominated
+from .mixins.delemeted_string import CommaDelemetedStringListMixin, DelemetedStringDirectiveMixin, SpaceDelemetedStringListMixin
+from .mixins.modifier import BaseAttributeModifierMixin
+
+
+class HtmxAttributeDirective(BaseAttributeDirective):
+    prefix = 'hx-'
+
+
+class HtmxAttributeModifier(BaseAttributeModifierMixin, HtmxAttributeDirective):
+    pass
+
+
+class HtmxSpaceListAttributeDirective(SpaceDelemetedStringListMixin, HtmxAttributeDirective):
+    pass
+
+
+class HtmxCommaListAttributeDirective(CommaDelemetedStringListMixin, HtmxAttributeDirective):
+    pass
+
+
+class HtmxColonAttributeDirective(DelemetedStringDirectiveMixin, HtmxAttributeDirective):
+    JOIN_DELIMETER = SPLIT_DELIMETER = ':'
+
+
+class HtmxSubstring(BaseDelemetedSubstringDirective):
+    pass
+
+
+class HtmxCommaListSubstring(CommaDelemetedStringListMixin, HtmxSubstring):
+    pass
+
+
+class HtmxSyncDirective(HtmxColonAttributeDirective):
+    selectors = HtmxCommaListSubstring()
+    strategy = HtmxSubstring()
+
+
+class HtmxDominated(BaseDominated):
+    default_directive = 'on'
+
+    get = HtmxAttributeDirective()
+    post = HtmxAttributeDirective()
+    on = HtmxAttributeModifier()
+    push_url = HtmxAttributeDirective()
+    select = HtmxCommaListAttributeDirective()
+    select_oob = HtmxCommaListAttributeDirective()
+    swap = HtmxSpaceListAttributeDirective()
+    swap_oob = HtmxAttributeDirective()
+    target = HtmxAttributeDirective()
+    trigger = HtmxCommaListAttributeDirective()
+    vals = HtmxAttributeDirective()
+
+    boost = HtmxAttributeDirective()
+    confirm = HtmxAttributeDirective()
+    delete = HtmxAttributeDirective()
+    disable = HtmxAttributeDirective()
+    disabled_elt = HtmxCommaListAttributeDirective()
+    disinherit = HtmxSpaceListAttributeDirective()
+    encoding = HtmxAttributeDirective()
+    ext = HtmxCommaListAttributeDirective()
+    headers = HtmxAttributeDirective()
+    history = HtmxAttributeDirective()
+    history_elt = HtmxAttributeDirective()
+    include = HtmxCommaListAttributeDirective()
+    indicator = HtmxCommaListAttributeDirective()
+    inherit = HtmxSpaceListAttributeDirective()
+    params = HtmxCommaListAttributeDirective()
+    patch = HtmxAttributeDirective()
+    preserve = HtmxAttributeDirective()
+    prompt = HtmxAttributeDirective()
+    put = HtmxAttributeDirective()
+    replace_url = HtmxAttributeDirective()
+    request = HtmxAttributeDirective()
+    sync = HtmxSyncDirective()
+    validate = HtmxAttributeDirective()
+    vars = HtmxAttributeDirective()

dominate/directives/hyperscript.py

@@ -0,0 +1,11 @@
+from .base import BaseAttributeDirective, BaseDominated
+
+
+class HyperscriptDirective(BaseAttributeDirective):
+    pass
+
+
+class HyperscriptDominated(BaseDominated):
+    default_directive = 'script'
+
+    script = HyperscriptDirective()