working

src/docker_compose/cfg/replace.py

@@ -1,87 +1,75 @@
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import ClassVar, Self, override, final
+from itertools import chain
+from typing import ClassVar, Self, final, override
 
 
-#
-# class String(Protocol):
-#     @override
-#     def __str__(self) -> str: ...
+def format_src(src: str) -> str:
+    return f"${{_{src.upper()}}}"
 
 
-# def replace(self, string: str) -> str:
-#     return string.replace(str(self), str(self))
-
-
-# @dataclass(frozen=True, slots=True)
-# class RecordCls[T_New: str | Callable[[None],str]]:
-#     old: ClassVar[str]
-#     new: T_New
-#
-#     def __call__(self, string: str) -> str:
-#         return string.replace(str(self.old), self.new if isinstance(self.new, str) else self.new())
 @final
 @dataclass(frozen=True, slots=True)
-class ReplaceStatic:
-    val: 'str| ReplaceStatic'
+class ReplaceUnique:
+    src: str
+    dest: str  # | Callable[[], str]
+
+    def __call__(self, string: str) -> str:
+        return string.replace(self.src, self.dest)
+
+    @classmethod
+    def auto_format(cls, src: str, dest: str):
+        return cls(format_src(src), dest)
+
+    # @override
+    # def __str__(self) -> str:
+    #     if not self.dest:
+    #         return ""
+    #     if isinstance(self.dest, str):
+    #         return self.dest
+    #     return self.dest()
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class ReplaceDynamic:
+    val: str
     fmt: str = field(init=False)
 
     def __post_init__(self):
-        setter = super(ReplaceStatic, self).__setattr__
-        setter('fmt', f"${{_{self.val.upper()}}}")
+        setter = super(ReplaceDynamic, self).__setattr__
+        setter("fmt", format_src(self.val))
 
     def __call__(self, string: str) -> str:
-        return string.replace(
-            self.fmt,
-            str(self)
-        )
-    def __str__(self) -> str:
-        return self.val if isinstance(self.val, str) else self.val.fmt
+        return string.replace(self.fmt, self.val)
 
-@dataclass(frozen=True, slots=True)
-class ReplaceDynamic:
-    src: ReplaceStatic
-    dest: str | Callable[[], str]
-
-    def __call__(self, string: str) -> str:
-        return string.replace(
-            self.src,
-            str(self),
-        )
-
-    @override
-    def __str__(self) -> str:
-        return self.dest if isinstance(self.dest, str) else self.dest()
-    #
-    # @staticmethod
-    # def get_format(val: str) -> str:
-    #     return f"${{_{val.upper()}}}"
-
-    @classmethod
-    def auto_format(cls, src: str, dest: str | Callable[[], str]) -> Self:
-        return cls(ReplaceStatic(src), dest)
-
-    @classmethod
-    def from_str(cls, string: str) -> Self:
-        return cls.auto_format(string, string)
-
-
-    # @property
-    # def stage_two(self) -> 'Record':
-    #     return Record.from_str(self.dest if isinstance(self.dest, str) else self.dest())
+    # def __str__(self) -> str:
+    #     return self.val if isinstance(self.val, str) else self.val.fmt
+    def build_placeholder(self, *args: "ReplaceDynamic"):
+        data = ((rep.val.upper(), rep.fmt) for rep in chain((self,), args))
+        src: tuple[str, ...]
+        dest: tuple[str, ...]
+        src, dest = zip(*data)
+        return ReplaceUnique("_".join(src), "_".join(dest))
 
 
 @dataclass(frozen=True, slots=True)
-class RecordCls(ReplaceDynamic):
-    # val: ClassVar[str]# = 'org'
-    rep: ClassVar[ReplaceStatic]  # = Record.get_format(val)
+class ReplaceStatic:
+    src: ClassVar[ReplaceDynamic]
+    dest: None | str | Callable[[], str]
+
+    def __call__(self, string: str) -> str:
+        return string.replace(self.src.fmt, str(self))
 
     @override
-    @classmethod
-    def from_str(cls, string: str) -> Self:
-        return cls(cls.rep, string)
+    def __str__(self) -> str:
+        if not self.dest:
+            return ""
+        if isinstance(self.dest, str):
+            return self.dest
+        return self.dest()
 
     @classmethod
-    def two_stage(cls, dest: str) -> tuple[Self, Self]:
-        dest_var = ReplaceStatic(dest)
-        return cls(cls.rep, dest_var.fmt), cls(dest_var, dest)
+    def two_stage(cls, dest: str) -> tuple[Self, ReplaceDynamic]:
+        dest_var = ReplaceDynamic(dest)
+        return cls(dest_var.fmt), dest_var