1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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))
|
