KaseFormat

Multiplatform kotlin string case conversion and detection library.

(Inspired by Guava's CaseFormat)

Setup

Declare repository

Include the following in your respositories block within the build.gradle.kts:

repositories {
    maven("https://dl.bintray.com/dotcipher/maven")
}

Or in groovy syntax for a build.gradle:

repositories {
    maven {
        url 'https://dl.bintray.com/dotcipher/maven'
    }   
}

Include dependency

Include the following in your dependencies block (replacing <version> with the latest release above:

dependencies {
        // JVM implementation
        implementation("io.dotcipher.kase:kase-format-jvm:<version>")

        // Native / JS implementations coming soon
}

Usage

KaseFormat is the main entrypoint for library usage, and it's defined as an enum of the following formats:

LOWER_HYPHEN (ie. hello-world)
CAPITAL_HYPHEN (ie. Hello-World)
UPPER_HYPHEN (ie. HELLO-WORLD)
LOWER_UNDERSCORE (ie. hello_world)
CAPITAL_UNDERSCORE (ie. Hello_World)
UPPER_UNDERSCORE (ie. HELLO_WORLD)
LOWER_CAMEL (ie. helloWorld)
CAPITAL_CAMEL (ie. HelloWorld)

Conversion

The most efficient way to convert is if the source format is known before conversion. For example, if the intent is to convert from LOWER_UNDERSCORE (ie. hello_world) to CAPITAL_CAMEL (ie. HelloWorld) then you could use the following syntax:

val str = "hello_world"
val output = KaseFormat.LOWER_UNDERSCORE.convert(KaseFormat.CAPITAL_CAMEL, str)
// output == "HelloWorld"

If the source format isn't known before conversion, then a KaseConverter needs to be created targeting the destination format. The KaseConverter can be reused and is thread-safe. For example if the intent is to convert into the LOWER_HYPHEN format from any unknown format then you can use the following syntax:

val strings = listOf("string_one", "STRING-TWO", "stringThree", "StringFour")
val converter = KaseFormat.LOWER_HYPHEN.converter()

val firstOutput = converter.convert(strings[0])
// firstOutput == "string-one"

val listOutput = converter.convert(strings.sublist(1, strings.size))
// listOutput == listOf("string-two", "string-three", "string-four")

Detection

Detection of what format a string might be (by best guess), can be accomplished using the following syntax:

val str = "someString"
val format = KaseFormat.determine(str)
// format == LOWER_CAMEL

Comments

Switch to MP lib pattern

Since this repo is MP by default, it's probably best to use the new MP publishing mechanisms introduced recently: https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#publishing-a-multiplatform-library
enhancement good first issue

opened by dotCipher 0
Include option to treat digits as boundaries

The consumer of the lib might want to treat digits as boundaries when converting between cases. The library should provide a flag or mechanism for handling that
enhancement good first issue

opened by dotCipher 0

Releases(0.1.0)

0.1.0(Nov 1, 2019)

First published release with basic functionality
Source code(tar.gz)
Source code(zip)
0.0.0(Sep 3, 2019)

Initial release
Source code(tar.gz)
Source code(zip)