Convert between string cases with built-in case inference.
Project description
Convert Case
Convert between string cases with built-in case inference.
Status
Source | Shields |
---|---|
Project | |
Health | |
Publishers | |
Repository | |
Activity |
Installing
Install the package from pypi:
pip install convert-case
To experiment with the source code locally, clone the repository:
git clone https://github.com/joellefkowitz/convert-case
To install linters, formatters and test runners:
pip install .[all]
npm install
Usage
from convert_case import camel_case
camel_case('camel case') # Inferred: lower -> camel
'camelCase'
camel_case('Camel Case') # Inferred: title -> camel
'camelCase'
camel_case('CamelCase') # Inferred: pascal -> camel
'camelCase'
Exports
def pascal_case(string: str) -> str:
...
def is_pascal_case(string: str) -> bool:
...
def camel_case(string: str) -> str:
...
def is_camel_case(string: str) -> bool:
...
def kebab_case(string: str) -> str:
...
def is_kebab_case(string: str) -> bool:
...
def sentence_case(string: str) -> str:
...
def is_sentence_case(string: str) -> bool:
...
def snake_case(string: str) -> str:
...
def is_snake_case(string: str) -> bool:
...
def title_case(string: str) -> str:
...
def is_title_case(string: str) -> bool:
...
def upper_case(string: str) -> str:
...
def is_upper_case(string: str) -> bool:
...
Definitions
LOWER = re.compile(r"^[a-z0-9\s]*$")
UPPER = re.compile(r"^[A-Z0-9\s]*$")
TITLE = re.compile(r"^(([A-Z0-9][a-z0-9]*)(\s[A-Z0-9][a-z0-9]*)*)?$")
SENTENCE = re.compile(r"^(([A-Z0-9][a-z0-9]*)(\s[a-z0-9]*)*)?$")
CAMEL = re.compile(r"^([a-z0-9][a-zA-Z0-9]*)?$")
PASCAL = re.compile(r"^([A-Z0-9]|([A-Z0-9][a-z0-9]+)*)?$")
SNAKE = re.compile(r"^([a-z0-9]+(_[a-z0-9]+)*)?$")
KEBAB = re.compile(r"^([a-z0-9]+(-[a-z0-9]+)*)?$")
Tests
To run unit tests:
grunt test
Test cases
test | lower | upper | sentence | title | camel | snake | kebab | pascal |
---|---|---|---|---|---|---|---|---|
a | a | A | A | A | a | a | a | A |
A | a | A | A | A | a | a | a | A |
abc | abc | ABC | Abc | Abc | abc | abc | abc | Abc |
ab cd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
Ab cd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
Ab Cd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
ab_cd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
ab-cd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
abCd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
ABCD | abcd | ABCD | Abcd | Abcd | abcd | abcd | abcd | Abcd |
AbCd | ab cd | AB CD | Ab cd | Ab Cd | abCd | ab_cd | ab-cd | AbCd |
ab cd ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
AbCdEf | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
ab-cd-ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
Ab cd ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
Numbers
Numbers are treated as letters with no specific case.
test | lower | upper | sentence | title | camel | snake | kebab | pascal |
---|---|---|---|---|---|---|---|---|
1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
1bc | 1bc | 1BC | 1bc | 1bc | 1bc | 1bc | 1bc | 1bc |
a1c | a1c | A1C | A1c | A1c | a1c | a1c | a1c | A1c |
ab1 | ab1 | AB1 | Ab1 | Ab1 | ab1 | ab1 | ab1 | Ab1 |
a1 c | a1 c | A1 C | A1 c | A1 C | a1C | a1_c | a1-c | A1C |
a1-c | a1 c | A1 C | A1 c | A1 C | a1C | a1_c | a1-c | A1C |
Advanced
A goal of this converter is that it is deterministic. If we consider the following examples we can see that this is not simple to achieve. How should we interpret the string 'ABC', is it in upper case or pascal case?
test | upper | pascal |
---|---|---|
abc | ABC | Abc |
a b c | A B C | ABC |
Our options are:
-
To consider strings with consecutive capitals like 'ABC' not to be pascal case. If in this case 'a b c' is parsed to 'Abc' it would clash with parsing 'abc' into pascal case.
-
To store some state that remembers the string's case before parsing. This would introduce too much complexity.
-
To prioritize parsing the string as one case unless told otherwise. We choose to pick upper case as the inferred case. The caveat here is that we will no longer be performing 'round trip' conversion.
Round trip conversion:
kebab_case('a b c')
'a-b-c'
lower_case('a-b-c')
'a b c'
Not round trip conversion:
pascal_case('a b c')
'ABC'
lower_case('ABC')
'abc'
Documentation
This repository's documentation is hosted on readthedocs.
Tooling
To run linters:
grunt lint
To run formatters:
grunt format
Continuous integration
This repository uses github actions to lint and test each commit. Formatting tasks and writing/generating documentation must be done before committing new code.
Versioning
This repository adheres to semantic versioning standards. For more information on semantic versioning visit SemVer.
Bump2version is used to version and tag changes. For example:
bump2version patch
Changelog
Please read this repository's changelog for details on changes that have been made.
Contributing
Please read this repository's guidelines on contributing for details on the process for submitting pull requests. Moreover, our code of conduct declares our collaboration standards.
Contributors
- joellefkowitz - Initial work - joellefkowitz
Remarks
Lots of love to the open source community!
Project details
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for convert_case-1.2.3-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | ec8884050ca548e990666f82cba7ae2edfaa3c85dbead3042c2fd663b292373a |
|
MD5 | 84082886dced2273612b07233cd9aa70 |
|
BLAKE2b-256 | f32e500ff29726ef207fdf6b625e62caf3839662c5d845897efc93bdf019192a |