Added github integration

buffteks/lib/python3.11/site-packages/strenum/_name_mangler.py

@@ -0,0 +1,127 @@
+# pylint: disable=no-name-in-module
+import re
+from zlib import crc32
+
+
+class _NameMangler:
+    _regex = re.compile(r"([A-Z]?[a-z]+)|([A-Z]+(?![a-z]))")
+
+    def words(self, name):
+        """
+        Split a string into words. Should correctly handle splitting:
+            camelCase
+            PascalCase
+            kebab-case
+            snake_case
+            MACRO_CASE
+            camel_Snake_Case
+            Pascal_Snake_Case
+            COBOL-CASE
+            Http-Header-Case
+
+        It _does not_ handle splitting spongebob case.
+        """
+        yield from (m.group(0) for m in self._regex.finditer(name))
+
+    def camel(self, name):
+        """
+        Convert a name to camelCase
+        """
+
+        def cased_words(word_iter):
+            yield next(word_iter, "").lower()
+            yield from (w.title() for w in word_iter)
+
+        return "".join(cased_words(self.words(name)))
+
+    def pascal(self, name):
+        """
+        Convert a name to PascalCase
+        """
+
+        return "".join(w.title() for w in self.words(name))
+
+    def kebab(self, name):
+        """
+        Convert a name to kebab-case
+        """
+
+        return "-".join(w.lower() for w in self.words(name))
+
+    def snake(self, name):
+        """
+        Convert a name to snake_case
+        """
+
+        return "_".join(w.lower() for w in self.words(name))
+
+    def macro(self, name):
+        """
+        Convert a name to MACRO_CASE
+        """
+
+        return "_".join(w.upper() for w in self.words(name))
+
+    # The following are inspired by examples in the Wikipedia
+    # [Naming convention](https://en.wikipedia.org/wiki/Naming_convention_(programming))
+    # article
+
+    def camel_snake(self, name):
+        """
+        Convert a name to camel_Snake_Case
+        """
+
+        def cased_words(word_iter):
+            yield next(word_iter, "").lower()
+            yield from (w.title() for w in word_iter)
+
+        return "_".join(cased_words(self.words(name)))
+
+    def pascal_snake(self, name):
+        """
+        Convert a name to Pascal_Snake_Case
+        """
+
+        return "_".join(w.title() for w in self.words(name))
+
+    def spongebob(self, name):
+        """
+        Convert a name to SpOngEBOb_CASe
+
+        The PRNG we use is seeded with the word to be scrambled. This produces
+        stable output so the same input will always produce in the same output.
+        It's not `truly` random, but your tests will thank me.
+        """
+
+        def prng(seed_word):
+            state = 1 << 31 | crc32(seed_word.encode("utf-8")) | 1
+
+            def step(state):
+                state = state >> 1 | (state & 0x01 ^ ((state & 0x02) >> 1)) << 31
+                bit = state & 0x1
+                return bit, state
+
+            for _ in range(100):
+                _, state = step(state)
+            while True:
+                bit, state = step(state)
+                yield str.upper if bit else str.lower
+
+        def scramble(word):
+            return "".join(f(ch) for ch, f in zip(word, prng(word)))
+
+        return "_".join(scramble(w) for w in self.words(name))
+
+    def cobol(self, name):
+        """
+        Convert a name to COBOL-CASE
+        """
+
+        return "-".join(w.upper() for w in self.words(name))
+
+    def http_header(self, name):
+        """
+        Convert a name to Http-Header-Case
+        """
+
+        return "-".join(w.title() for w in self.words(name))