The latest version of the library changed the behaviour when it comes to how digits are treated (commit https://github.com/pearxteam/kasechange/commit/e8e3222745956738aa8c584d9fc199ea2b37cb77).

It used to be that something like "a_word1_with_number" == "a_word1_with_number".toSnakeCase() but it no longer holds true.

To allow clients to maintain that behaviour if they need to so that they can still update to later versions of the library (my project is one that needs this behaviour for various reasons but I also would like to use the latest version), I raised https://github.com/pearxteam/kasechange/pull/5

This PR maintains API compatibility as it introduces one parameter to the public API that has a default value so existing code should not be affected

Description

This PR enhances digit characters handling, and it handles digit characters same as uppercase characters. There are some samples:

before:
UInt32Value => U|Int32Value

after:
UInt32Value => U|Int|32|Value

This is related to the earlier enhancement I raised #3

In CaseFormat, I had intentionally made the config value publicly accessible but didn't explain my reasoning behind it (my apologies):

https://github.com/pearxteam/kasechange/blob/21ea6a12a0b7fc4b2aea66e9679d10c41cdb7716/src/commonMain/kotlin/net/pearx/kasechange/CaseFormat.kt#L13

Since the API is now extensible, clients might want to mix and match predefined formats with their own and the only way to do it in a concise manner would be something like this:

val formats = mapOf(
    "SCREAMING_SNAKE_CASE" to CaseFormat.UPPER_UNDERSCORE.config,
    "snake_case" to CaseFormat.LOWER_UNDERSCORE.config,
    "Pascal.Dot.Case" to CaseFormatterConfig(false, ".", wordCapitalize = true, firstWordCapitalize = true)
)

which can then be used like so:

val format : String = parseFormatFromConfigurationFile()
"Some words".toCase(formats["format"] ?: throw IllegalArgumentException("Unrecognised format"))

If the config is not exposed, the only way is to keep two constructs and depending on the value you might want to use, know which construct to pull the formatter from.

Any thoughts on this?

Hello,

I really like the library, found a good use for it recently on one of my projects.

I realised that I had need for what I'd call Pascal.Dot.Case though and realised the library was not extensible since it relies on the enums themselves performing the formatting.

I decided to raise a PR that, in my view, fixes the problem while maintaining API compatibility: https://github.com/pearxteam/kasechange/pull/2

Please have a look and tell me if you think it's worth merging or, if not, any changes you'd propose if you think it's worth creating an extensible API for the library.

I have a use case where I want to format a string away from camel_case etc. but not remove the casing of each word.

E.g. If someone wrote this_is_Kotlin, I can change it to this is Kotlin.

Current solution is "this_is_Kotlin".splitToWords().joinToString(" "), however not able to do it with the custom case formatter, or at least haven't figured out how.

Thanks for this library, works really well.

It would be cool if it could be used to return the casing of a string also.

"my_string".detectCase() // snake_case

If [WordSplitterConfig.handleCase] is set to true: if a lowercase character is followed by an uppercase character, a word boundary is considered to be prior to the uppercase character. If [WordSplitterConfig.handleCase] is set to true: if multiple uppercase characters are followed by a lowercase character, a word boundary is considered to be prior to the last uppercase character.

Prior to the last digit is an odd place to be considered a boundary. As such any digits which are followed by letters get chopped up.

| Input | Expected | Actual | |---|---|---| | option14b | option 14 b | option 1 4b | | 123abc | 123 abc | 12 3abc |

Numbers should be considered continuous