├── .gitignore ├── tests ├── config.nims ├── test_dot.nim ├── test_vm.nim ├── test_camel.nim ├── test_path.nim ├── test_cobol.nim ├── test_kebab.nim ├── test_pascal.nim ├── test_plain.nim ├── test_snake.nim ├── test_train.nim ├── test_pascal_snake.nim ├── test_screaming_snake.nim └── test_words.nim ├── src ├── anycase │ ├── dot.nim │ ├── path.nim │ ├── kebab.nim │ ├── plain.nim │ ├── snake.nim │ ├── cobol.nim │ ├── screaming_snake.nim │ ├── train.nim │ ├── pascal_snake.nim │ ├── pascal.nim │ ├── camel.nim │ └── words.nim └── anycase.nim ├── CHANGELOG.md ├── anycase.nimble ├── .github └── workflows │ └── main.yml ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /tests/config.nims: -------------------------------------------------------------------------------- 1 | switch("path", "$projectDir/../src") -------------------------------------------------------------------------------- /src/anycase/dot.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join 3 | 4 | proc dot*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, ".") 8 | -------------------------------------------------------------------------------- /src/anycase/path.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join 3 | 4 | proc path*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, "/") 8 | -------------------------------------------------------------------------------- /src/anycase/kebab.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join 3 | 4 | proc kebab*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, "-") 8 | -------------------------------------------------------------------------------- /src/anycase/plain.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join 3 | 4 | proc plain*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, " ") 8 | -------------------------------------------------------------------------------- /src/anycase/snake.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join 3 | 4 | proc snake*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, "_") 8 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # v0.1.0 2 | 3 | Base library implementation. 4 | 5 | Includes following cases: 6 | 7 | - `camel` 8 | - `kebab` 9 | - `pascal` 10 | - `path` 11 | - `snake` 12 | - `plain` 13 | 14 | -------------------------------------------------------------------------------- /src/anycase/cobol.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, toUpperAscii 3 | 4 | proc cobol*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, "-").toUpperAscii 8 | -------------------------------------------------------------------------------- /src/anycase/screaming_snake.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, toUpperAscii 3 | 4 | proc screamingSnake*(str: string): string = 5 | let parts = words(str) 6 | 7 | return join(parts, "_").toUpperAscii 8 | -------------------------------------------------------------------------------- /src/anycase/train.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, capitalizeAscii 3 | from sequtils import map 4 | 5 | proc train*(str: string): string = 6 | let parts = words(str) 7 | 8 | return join(map(parts, capitalizeAscii), "-") 9 | -------------------------------------------------------------------------------- /src/anycase/pascal_snake.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, capitalizeAscii 3 | from sequtils import map 4 | 5 | proc pascalSnake*(str: string): string = 6 | let parts = words(str) 7 | 8 | return join(map(parts, capitalizeAscii), "_") 9 | -------------------------------------------------------------------------------- /anycase.nimble: -------------------------------------------------------------------------------- 1 | # Package 2 | 3 | version = "0.2.1" 4 | author = "lamartire" 5 | description = "Convert strings to any case" 6 | license = "MIT" 7 | srcDir = "src" 8 | 9 | # Dependencies 10 | 11 | requires "nim >= 1.0.0" 12 | requires "regex >= 0.23.0" -------------------------------------------------------------------------------- /src/anycase/pascal.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, capitalizeAscii 3 | from sequtils import map 4 | 5 | proc pascal*(str: string): string = 6 | let parts = words(str) 7 | let capitalizedParts = map(parts, capitalizeAscii) 8 | 9 | return join(capitalizedParts) 10 | -------------------------------------------------------------------------------- /src/anycase/camel.nim: -------------------------------------------------------------------------------- 1 | import anycase/words 2 | from strutils import join, capitalizeAscii 3 | from sequtils import map, concat 4 | 5 | proc camel*(str: string): string = 6 | let parts = words(str) 7 | let capitalizedParts = map(parts[1..parts.len - 1], capitalizeAscii) 8 | 9 | return join(concat([parts[0..0], capitalizedParts])) 10 | -------------------------------------------------------------------------------- /src/anycase.nim: -------------------------------------------------------------------------------- 1 | import anycase/camel 2 | import anycase/cobol 3 | import anycase/dot 4 | import anycase/kebab 5 | import anycase/pascal 6 | import anycase/pascal_snake 7 | import anycase/path 8 | import anycase/plain 9 | import anycase/screaming_snake 10 | import anycase/snake 11 | import anycase/train 12 | 13 | export camel 14 | export cobol 15 | export dot 16 | export kebab 17 | export pascal 18 | export pascalSnake 19 | export path 20 | export plain 21 | export screamingSnake 22 | export snake 23 | export train 24 | -------------------------------------------------------------------------------- /src/anycase/words.nim: -------------------------------------------------------------------------------- 1 | from sugar import collect 2 | from regex import split, re2, findAll 3 | from strutils import toLowerAscii 4 | from sequtils import map, filterIt 5 | 6 | proc splitBySymbols(str: string): seq[string] = 7 | return split(str, re2"(-|_|\/|\.|\s)").filterIt(it != "") 8 | 9 | proc splitByUpperChars(str: string): seq[string] = 10 | return collect: 11 | for match in findAll(str, re2"(^[a-z0-9]+|[A-Z0-9][a-z0-9]*)"): 12 | str[match.boundaries] 13 | 14 | proc words*(str: string): seq[string] = 15 | var parts = splitBySymbols(str) 16 | 17 | if parts.len == 1: 18 | parts = splitByUpperChars(str) 19 | 20 | return map(parts, toLowerAscii) 21 | -------------------------------------------------------------------------------- /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | on: [push, pull_request] 2 | 3 | jobs: 4 | test: 5 | runs-on: ubuntu-latest 6 | steps: 7 | - uses: actions/checkout@v1 8 | - name: Cache choosenim 9 | id: cache-choosenim 10 | uses: actions/cache@v1 11 | with: 12 | path: ~/.choosenim 13 | key: ${{ runner.os }}-choosenim-1.0.2 14 | - name: Cache nimble 15 | id: cache-nimble 16 | uses: actions/cache@v1 17 | with: 18 | path: ~/.nimble 19 | key: ${{ runner.os }}-nimble-1.0.2 20 | - name: Install Nim 21 | if: steps.cache-choosenim.outputs.cache-hit != 'true' || steps.cache-nimble.outputs.cache-hit != 'true' 22 | run: | 23 | export CHOOSENIM_CHOOSE_VERSION="1.0.2" 24 | curl https://nim-lang.org/choosenim/init.sh -sSf > init.sh 25 | sh init.sh -y 26 | - name: Test 27 | run: | 28 | export PATH=$HOME/.nimble/bin:$PATH 29 | echo $PATH 30 | nimble test -c -y 31 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright 2019 Konstantin Epishev 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # anycase 2 | 3 | [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Flamartire%2Fanycase%2Fbadge&style=flat)](https://actions-badge.atrox.dev/lamartire/anycase/goto) 4 | ![MIT License](https://camo.githubusercontent.com/4481c7672053be9c676fbc983c040ca59fddfa19/68747470733a2f2f696d672e736869656c64732e696f2f6e706d2f6c2f6c6f6775782d70726f636573736f722e737667) 5 | 6 | > Convert strings to any case 7 | 8 | ## Usage 9 | 10 | ```nim 11 | import anycase 12 | 13 | camel("any case") # "anyCase" 14 | cobol("any case") # "ANY-CASE" 15 | dot("any case") # "any.case" 16 | kebab("any case") # "any-case" 17 | pascal("any case") # "AnyCase" 18 | pascalSnake("any case") # "Any_Case" 19 | path("any case") # "any/case" 20 | screamingSnake("any case") # "ANY_CASE" 21 | snake("any case") # "any_case" 22 | train("any case") # "Any-Case" 23 | plain("any-case") # "any case" 24 | ``` 25 | 26 | ## Supported cases 27 | 28 | - `camel` 29 | - `cobol` 30 | - `dot` 31 | - `kebab` 32 | - `pascal snake` 33 | - `pascal` 34 | - `path` 35 | - `screaming snake` 36 | - `snake` 37 | - `train` 38 | - `plain` 39 | 40 | If you don't see any case – feel free to open issue or pull request. 41 | -------------------------------------------------------------------------------- /tests/test_dot.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/dot 3 | 4 | suite "dot": 5 | test "plain -> dot": 6 | check dot("change my case") == "change.my.case" 7 | 8 | test "path -> dot": 9 | check dot("change/my/case") == "change.my.case" 10 | 11 | test "kebab -> dot": 12 | check dot("change-my-case") == "change.my.case" 13 | 14 | test "camel -> dot": 15 | check dot("changeMyCase") == "change.my.case" 16 | 17 | test "pascal -> dot": 18 | check dot("ChangeMyCase") == "change.my.case" 19 | 20 | test "snake -> dot": 21 | check dot("change_my_case") == "change.my.case" 22 | 23 | test "pascalSnake -> dot": 24 | check dot("Change_My_Case") == "change.my.case" 25 | 26 | test "screamingSnake -> dot": 27 | check dot("CHANGE_MY_CASE") == "change.my.case" 28 | 29 | test "cobol -> dot": 30 | check dot("CHANGE-MY-CASE") == "change.my.case" 31 | 32 | test "dot -> dot": 33 | check dot("change.my.case") == "change.my.case" 34 | 35 | test "train -> dot": 36 | check dot("Change-My-Case") == "change.my.case" 37 | 38 | test "doesn't cut numbers": 39 | check dot("change/my/case/2") == "change.my.case.2" 40 | 41 | test "single character tokens": 42 | check dot("c") == "c" 43 | check dot("C") == "c" 44 | check dot("CMC") == "c.m.c" 45 | -------------------------------------------------------------------------------- /tests/test_vm.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/camel 3 | 4 | suite "vm": 5 | test "plain -> camel": 6 | check compiles static camel("change my case") 7 | 8 | test "path -> camel": 9 | check compiles static camel("change/my/case") 10 | 11 | test "kebab -> camel": 12 | check compiles static camel("change-my-case") 13 | 14 | test "camel -> camel": 15 | check compiles static camel("changeMyCase") 16 | 17 | test "pascal -> camel": 18 | check compiles static camel("ChangeMyCase") 19 | 20 | test "snake -> camel": 21 | check compiles static camel("change_my_case") 22 | 23 | test "pascalSnake -> camel": 24 | check compiles static camel("Change_My_Case") 25 | 26 | test "screamingSnake -> camel": 27 | check compiles static camel("CHANGE_MY_CASE") 28 | 29 | test "cobol -> camel": 30 | check compiles static camel("CHANGE-MY-CASE") 31 | 32 | test "dot -> camel": 33 | check compiles static camel("change.my.case") 34 | 35 | test "train -> camel": 36 | check compiles static camel("Change-My-Case") 37 | 38 | test "doesn't cut numbers": 39 | check compiles static camel("changeMyCase2") 40 | 41 | test "single character tokens": 42 | check compiles static camel("c") 43 | check compiles static camel("C") 44 | check compiles static camel("CMC") 45 | -------------------------------------------------------------------------------- /tests/test_camel.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/camel 3 | 4 | suite "camel": 5 | test "plain -> camel": 6 | check camel("change my case") == "changeMyCase" 7 | 8 | test "path -> camel": 9 | check camel("change/my/case") == "changeMyCase" 10 | 11 | test "kebab -> camel": 12 | check camel("change-my-case") == "changeMyCase" 13 | 14 | test "camel -> camel": 15 | check camel("changeMyCase") == "changeMyCase" 16 | 17 | test "pascal -> camel": 18 | check camel("ChangeMyCase") == "changeMyCase" 19 | 20 | test "snake -> camel": 21 | check camel("change_my_case") == "changeMyCase" 22 | 23 | test "pascalSnake -> camel": 24 | check camel("Change_My_Case") == "changeMyCase" 25 | 26 | test "screamingSnake -> camel": 27 | check camel("CHANGE_MY_CASE") == "changeMyCase" 28 | 29 | test "cobol -> camel": 30 | check camel("CHANGE-MY-CASE") == "changeMyCase" 31 | 32 | test "dot -> camel": 33 | check camel("change.my.case") == "changeMyCase" 34 | 35 | test "train -> camel": 36 | check camel("Change-My-Case") == "changeMyCase" 37 | 38 | test "doesn't cut numbers": 39 | check camel("changeMyCase2") == "changeMyCase2" 40 | 41 | test "single character tokens": 42 | check camel("c") == "c" 43 | check camel("C") == "c" 44 | check camel("CMC") == "cMC" 45 | -------------------------------------------------------------------------------- /tests/test_path.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/path 3 | 4 | suite "path": 5 | test "plain -> path": 6 | check path("change my case") == "change/my/case" 7 | 8 | test "path -> path": 9 | check path("change/my/case") == "change/my/case" 10 | 11 | test "kebab -> path": 12 | check path("change-my-case") == "change/my/case" 13 | 14 | test "camel -> path": 15 | check path("changeMyCase") == "change/my/case" 16 | 17 | test "pascal -> path": 18 | check path("ChangeMyCase") == "change/my/case" 19 | 20 | test "snake -> path": 21 | check path("change_my_case") == "change/my/case" 22 | 23 | test "pascalSnake -> path": 24 | check path("Change_My_Case") == "change/my/case" 25 | 26 | test "screamingSnake -> path": 27 | check path("CHANGE_MY_CASE") == "change/my/case" 28 | 29 | test "cobol -> path": 30 | check path("CHANGE-MY-CASE") == "change/my/case" 31 | 32 | test "dot -> path": 33 | check path("change.my.case") == "change/my/case" 34 | 35 | test "train -> path": 36 | check path("Change-My-Case") == "change/my/case" 37 | 38 | test "doesn't cut numbers": 39 | check path("change/my/case/2") == "change/my/case/2" 40 | 41 | test "single character tokens": 42 | check path("c") == "c" 43 | check path("C") == "c" 44 | check path("CMC") == "c/m/c" 45 | -------------------------------------------------------------------------------- /tests/test_cobol.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/cobol 3 | 4 | suite "cobol": 5 | test "plain -> cobol": 6 | check cobol("change my case") == "CHANGE-MY-CASE" 7 | 8 | test "path -> cobol": 9 | check cobol("change/my/case") == "CHANGE-MY-CASE" 10 | 11 | test "kebab -> cobol": 12 | check cobol("change-my-case") == "CHANGE-MY-CASE" 13 | 14 | test "camel -> cobol": 15 | check cobol("changeMyCase") == "CHANGE-MY-CASE" 16 | 17 | test "pascal -> cobol": 18 | check cobol("ChangeMyCase") == "CHANGE-MY-CASE" 19 | 20 | test "snake -> cobol": 21 | check cobol("change_my_case") == "CHANGE-MY-CASE" 22 | 23 | test "pascalSnake -> cobol": 24 | check cobol("Change_My_Case") == "CHANGE-MY-CASE" 25 | 26 | test "screamingSnake -> cobol": 27 | check cobol("CHANGE_MY_CASE") == "CHANGE-MY-CASE" 28 | 29 | test "cobol -> cobol": 30 | check cobol("CHANGE-MY-CASE") == "CHANGE-MY-CASE" 31 | 32 | test "dot -> cobol": 33 | check cobol("change.my.case") == "CHANGE-MY-CASE" 34 | 35 | test "train -> cobol": 36 | check cobol("Change-My-Case") == "CHANGE-MY-CASE" 37 | 38 | test "doesn't cut numbers": 39 | check cobol("change_my_case_2") == "CHANGE-MY-CASE-2" 40 | 41 | test "single character tokens": 42 | check cobol("c") == "C" 43 | check cobol("C") == "C" 44 | check cobol("CMC") == "C-M-C" 45 | -------------------------------------------------------------------------------- /tests/test_kebab.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/kebab 3 | 4 | suite "kebab": 5 | test "plain -> kebab": 6 | check kebab("change my case") == "change-my-case" 7 | 8 | test "path -> kebab": 9 | check kebab("change/my/case") == "change-my-case" 10 | 11 | test "kebab -> kebab": 12 | check kebab("change-my-case") == "change-my-case" 13 | 14 | test "camel -> kebab": 15 | check kebab("changeMyCase") == "change-my-case" 16 | 17 | test "pascal -> kebab": 18 | check kebab("ChangeMyCase") == "change-my-case" 19 | 20 | test "snake -> kebab": 21 | check kebab("change_my_case") == "change-my-case" 22 | 23 | test "pascalSnake -> kebab": 24 | check kebab("Change_My_Case") == "change-my-case" 25 | 26 | test "screamingSnake -> kebab": 27 | check kebab("CHANGE_MY_CASE") == "change-my-case" 28 | 29 | test "cobol -> kebab": 30 | check kebab("CHANGE-MY-CASE") == "change-my-case" 31 | 32 | test "dot -> kebab": 33 | check kebab("change.my.case") == "change-my-case" 34 | 35 | test "train -> kebab": 36 | check kebab("Change-My-Case") == "change-my-case" 37 | 38 | test "doesn't cut numbers": 39 | check kebab("change-my-case-2") == "change-my-case-2" 40 | 41 | test "single character tokens": 42 | check kebab("c") == "c" 43 | check kebab("C") == "c" 44 | check kebab("CMC") == "c-m-c" 45 | -------------------------------------------------------------------------------- /tests/test_pascal.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/pascal 3 | 4 | suite "pascal": 5 | test "plain -> pascal": 6 | check pascal("change my case") == "ChangeMyCase" 7 | 8 | test "path -> pascal": 9 | check pascal("change/my/case") == "ChangeMyCase" 10 | 11 | test "kebab -> pascal": 12 | check pascal("change-my-case") == "ChangeMyCase" 13 | 14 | test "camel -> pascal": 15 | check pascal("changeMyCase") == "ChangeMyCase" 16 | 17 | test "pascal -> pascal": 18 | check pascal("ChangeMyCase") == "ChangeMyCase" 19 | 20 | test "snake -> pascal": 21 | check pascal("change_my_case") == "ChangeMyCase" 22 | 23 | test "pascalSnake -> pascal": 24 | check pascal("Change_My_Case") == "ChangeMyCase" 25 | 26 | test "screamingSnake -> pascal": 27 | check pascal("CHANGE_MY_CASE") == "ChangeMyCase" 28 | 29 | test "cobol -> pascal": 30 | check pascal("CHANGE-MY-CASE") == "ChangeMyCase" 31 | 32 | test "dot -> pascal": 33 | check pascal("change.my.case") == "ChangeMyCase" 34 | 35 | test "train -> pascal": 36 | check pascal("Change-My-Case") == "ChangeMyCase" 37 | 38 | test "doesn't cut numbers": 39 | check pascal("ChangeMyCase2") == "ChangeMyCase2" 40 | 41 | test "single character tokens": 42 | check pascal("c") == "C" 43 | check pascal("C") == "C" 44 | check pascal("CMC") == "CMC" 45 | -------------------------------------------------------------------------------- /tests/test_plain.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/plain 3 | 4 | suite "plain": 5 | test "plain -> plain": 6 | check plain("change my case") == "change my case" 7 | 8 | test "path -> plain": 9 | check plain("change/my/case") == "change my case" 10 | 11 | test "kebab -> plain": 12 | check plain("change-my-case") == "change my case" 13 | 14 | test "camel -> plain": 15 | check plain("changeMyCase") == "change my case" 16 | 17 | test "pascal -> plain": 18 | check plain("ChangeMyCase") == "change my case" 19 | 20 | test "snake -> plain": 21 | check plain("change_my_case") == "change my case" 22 | 23 | test "pascalSnake -> plain": 24 | check plain("Change_My_Case") == "change my case" 25 | 26 | test "screamingSnake -> plain": 27 | check plain("CHANGE_MY_CASE") == "change my case" 28 | 29 | test "cobol -> plain": 30 | check plain("CHANGE-MY-CASE") == "change my case" 31 | 32 | test "dot -> plain": 33 | check plain("change.my.case") == "change my case" 34 | 35 | test "train -> plain": 36 | check plain("Change-My-Case") == "change my case" 37 | 38 | test "doesn't cut numbers": 39 | check plain("change my case 2") == "change my case 2" 40 | 41 | test "single character tokens": 42 | check plain("c") == "c" 43 | check plain("C") == "c" 44 | check plain("CMC") == "c m c" 45 | -------------------------------------------------------------------------------- /tests/test_snake.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/snake 3 | 4 | suite "snake": 5 | test "plain -> snake": 6 | check snake("change my case") == "change_my_case" 7 | 8 | test "path -> snake": 9 | check snake("change/my/case") == "change_my_case" 10 | 11 | test "kebab -> snake": 12 | check snake("change-my-case") == "change_my_case" 13 | 14 | test "camel -> snake": 15 | check snake("changeMyCase") == "change_my_case" 16 | 17 | test "pascal -> snake": 18 | check snake("ChangeMyCase") == "change_my_case" 19 | 20 | test "snake -> snake": 21 | check snake("change_my_case") == "change_my_case" 22 | 23 | test "pascalSnake -> snake": 24 | check snake("Change_My_Case") == "change_my_case" 25 | 26 | test "screamingSnake -> snake": 27 | check snake("CHANGE_MY_CASE") == "change_my_case" 28 | 29 | test "cobol -> snake": 30 | check snake("CHANGE-MY-CASE") == "change_my_case" 31 | 32 | test "dot -> snake": 33 | check snake("change.my.case") == "change_my_case" 34 | 35 | test "train -> snake": 36 | check snake("Change-My-Case") == "change_my_case" 37 | 38 | test "doesn't cut numbers": 39 | check snake("change_my_case_2") == "change_my_case_2" 40 | 41 | test "single character tokens": 42 | check snake("c") == "c" 43 | check snake("C") == "c" 44 | check snake("CMC") == "c_m_c" 45 | -------------------------------------------------------------------------------- /tests/test_train.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/train 3 | 4 | suite "train": 5 | test "plain -> train": 6 | check train("change my case") == "Change-My-Case" 7 | 8 | test "path -> train": 9 | check train("change/my/case") == "Change-My-Case" 10 | 11 | test "kebab -> train": 12 | check train("change-my-case") == "Change-My-Case" 13 | 14 | test "camel -> train": 15 | check train("changeMyCase") == "Change-My-Case" 16 | 17 | test "pascal -> train": 18 | check train("ChangeMyCase") == "Change-My-Case" 19 | 20 | test "snake -> train": 21 | check train("change_my_case") == "Change-My-Case" 22 | 23 | test "pascalSnake -> train": 24 | check train("Change_My_Case") == "Change-My-Case" 25 | 26 | test "screamingSnake -> train": 27 | check train("CHANGE_MY_CASE") == "Change-My-Case" 28 | 29 | test "cobol -> train": 30 | check train("CHANGE-MY-CASE") == "Change-My-Case" 31 | 32 | test "dot -> train": 33 | check train("change.my.case") == "Change-My-Case" 34 | 35 | test "train -> train": 36 | check train("Change-My-Case") == "Change-My-Case" 37 | 38 | test "doesn't cut numbers": 39 | check train("change_my_case_2") == "Change-My-Case-2" 40 | 41 | test "single character tokens": 42 | check train("c") == "C" 43 | check train("C") == "C" 44 | check train("CMC") == "C-M-C" 45 | -------------------------------------------------------------------------------- /tests/test_pascal_snake.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/pascal_snake 3 | 4 | suite "pascalSnake": 5 | test "plain -> pascalSnake": 6 | check pascalSnake("change my case") == "Change_My_Case" 7 | 8 | test "path -> pascalSnake": 9 | check pascalSnake("change/my/case") == "Change_My_Case" 10 | 11 | test "kebab -> pascalSnake": 12 | check pascalSnake("change-my-case") == "Change_My_Case" 13 | 14 | test "camel -> pascalSnake": 15 | check pascalSnake("changeMyCase") == "Change_My_Case" 16 | 17 | test "pascal -> pascalSnake": 18 | check pascalSnake("ChangeMyCase") == "Change_My_Case" 19 | 20 | test "snake -> pascalSnake": 21 | check pascalSnake("change_my_case") == "Change_My_Case" 22 | 23 | test "pascalSnake -> pascalSnake": 24 | check pascalSnake("Change_My_Case") == "Change_My_Case" 25 | 26 | test "screamingSnake -> pascalSnake": 27 | check pascalSnake("CHANGE_MY_CASE") == "Change_My_Case" 28 | 29 | test "cobol -> pascalSnake": 30 | check pascalSnake("CHANGE-MY-CASE") == "Change_My_Case" 31 | 32 | test "dot -> pascalSnake": 33 | check pascalSnake("change.my.case") == "Change_My_Case" 34 | 35 | test "train -> pascalSnake": 36 | check pascalSnake("Change-My-Case") == "Change_My_Case" 37 | 38 | test "doesn't cut numbers": 39 | check pascalSnake("change_my_case_2") == "Change_My_Case_2" 40 | 41 | test "single character tokens": 42 | check pascalSnake("c") == "C" 43 | check pascalSnake("C") == "C" 44 | check pascalSnake("CMC") == "C_M_C" 45 | -------------------------------------------------------------------------------- /tests/test_screaming_snake.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/screaming_snake 3 | 4 | suite "screamingSnake": 5 | test "plain -> screamingSnake": 6 | check screamingSnake("change my case") == "CHANGE_MY_CASE" 7 | 8 | test "path -> screamingSnake": 9 | check screamingSnake("change/my/case") == "CHANGE_MY_CASE" 10 | 11 | test "kebab -> screamingSnake": 12 | check screamingSnake("change-my-case") == "CHANGE_MY_CASE" 13 | 14 | test "camel -> screamingSnake": 15 | check screamingSnake("changeMyCase") == "CHANGE_MY_CASE" 16 | 17 | test "pascal -> screamingSnake": 18 | check screamingSnake("ChangeMyCase") == "CHANGE_MY_CASE" 19 | 20 | test "snake -> screamingSnake": 21 | check screamingSnake("change_my_case") == "CHANGE_MY_CASE" 22 | 23 | test "pascalSnake -> screamingSnake": 24 | check screamingSnake("Change_My_Case") == "CHANGE_MY_CASE" 25 | 26 | test "screamingSnake -> screamingSnake": 27 | check screamingSnake("CHANGE_MY_CASE") == "CHANGE_MY_CASE" 28 | 29 | test "cobol -> screamingSnake": 30 | check screamingSnake("CHANGE-MY-CASE") == "CHANGE_MY_CASE" 31 | 32 | test "dot -> screamingSnake": 33 | check screamingSnake("change.my.case") == "CHANGE_MY_CASE" 34 | 35 | test "train -> screamingSnake": 36 | check screamingSnake("Change-My-Case") == "CHANGE_MY_CASE" 37 | 38 | test "doesn't cut numbers": 39 | check screamingSnake("change_my_case_2") == "CHANGE_MY_CASE_2" 40 | 41 | test "single character tokens": 42 | check screamingSnake("c") == "C" 43 | check screamingSnake("C") == "C" 44 | check screamingSnake("CMC") == "C_M_C" 45 | -------------------------------------------------------------------------------- /tests/test_words.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import anycase/words 3 | 4 | suite "words": 5 | test "plain -> words": 6 | check words("change my case") == @["change", "my", "case"] 7 | 8 | test "path -> words": 9 | check words("change/my/case") == @["change", "my", "case"] 10 | 11 | test "kebab -> words": 12 | check words("change-my-case") == @["change", "my", "case"] 13 | 14 | test "camel -> words": 15 | check words("changeMyCase") == @["change", "my", "case"] 16 | 17 | test "pascal -> words": 18 | check words("ChangeMyCase") == @["change", "my", "case"] 19 | 20 | test "snake -> words": 21 | check words("change_my_case") == @["change", "my", "case"] 22 | 23 | test "pascalSnake -> words": 24 | check words("Change_My_Case") == @["change", "my", "case"] 25 | 26 | test "screamingSnake -> words": 27 | check words("CHANGE_MY_CASE") == @["change", "my", "case"] 28 | 29 | test "cobol -> words": 30 | check words("CHANGE-MY-CASE") == @["change", "my", "case"] 31 | 32 | test "dot -> words": 33 | check words("change.my.case") == @["change", "my", "case"] 34 | 35 | test "train -> words": 36 | check words("Change-My-Case") == @["change", "my", "case"] 37 | 38 | test "doesn't cut numbers": 39 | check words("change my case 2") == @["change", "my", "case", "2"] 40 | check words("2 change my case") == @["2", "change", "my", "case"] 41 | 42 | test "skip empty tokens": 43 | check words(" change my case ") == @["change", "my", "case"] 44 | check words("change.-my _case") == @["change", "my", "case"] 45 | check words("change..my--case") == @["change", "my", "case"] 46 | check words("--change..my--case.") == @["change", "my", "case"] 47 | check words(" ChangeMyCase---") == @["change", "my", "case"] 48 | 49 | test "single character": 50 | check words("c") == @["c"] 51 | check words("C") == @["c"] 52 | 53 | test "two letter strings": 54 | check words("cm") == @["cm"] 55 | check words("Cm") == @["cm"] 56 | check words("cM") == @["c", "m"] 57 | check words("CM") == @["c", "m"] 58 | 59 | test "upper ending strings": 60 | check words("CM") == @["c", "m"] 61 | check words("ChangeM") == @["change", "m"] 62 | check words("changeM") == @["change", "m"] 63 | check words("changeMyC") == @["change", "my", "c"] 64 | check words("changeMyCASE") == @["change", "my", "c", "a", "s", "e"] 65 | --------------------------------------------------------------------------------