String Utilities for Go
=======================
[![GoReportCard](https://goreportcard.com/badge/github.com/ozgio/strutil)](https://goreportcard.com/report/github.com/ozgio/strutil)
[![GoDocs](https://godoc.org/github.com/ozgio/strutil?status.svg)](https://godoc.org/github.com/ozgio/strutil)

"strutil" provides string functions for go applications.

For documentation with examples see [GoDoc](https://godoc.org/github.com/ozgio/strutil)

## Functions


### Align ([Docs](https://godoc.org/github.com/ozgio/strutil#Align))
Aligns the text to the specified side

```go
strutil.Align("lorem ipsum", strutil.Right, 20) //->"        lorem ipsum" 
```

### AlignCenter ([Docs](https://godoc.org/github.com/ozgio/strutil#AlignCenter))
Aligns the text to the center
```go
strutil.AlignCenter("lorem\nipsum", 10) //->"  lorem   \n  ipsum   " 
```

### AlignLeft ([Docs](https://godoc.org/github.com/ozgio/strutil#AlignLeft))
Aligns the text to the left
```go
strutil.AlignLeft("  lorem   \n  ipsum   ") //->"lorem   \nipsum   " 
```

### AlignRight ([Docs](https://godoc.org/github.com/ozgio/strutil#AlignRight))
Aligns the text to the right
```go
strutil.AlignRight("lorem\nipsum", 10) //-> "     lorem\n     ipsum" 
```

### CountWords ([Docs](https://godoc.org/github.com/ozgio/strutil#CountWords))
Counts the words
```go
strutil.CountWords("Lorem ipsum, dolor sit amet") //-> "5"
```

### DrawBox ([Docs](https://godoc.org/github.com/ozgio/strutil#DrawBox))
Draws a frame around the string with default character set
```go
strutil.DrawBox("Hello World", 20, strutil.Center)
//┌──────────────────┐
//│   Hello World    │
//└──────────────────┘
```

### DrawCustomBox ([Docs](https://godoc.org/github.com/ozgio/strutil#DrawCustomBox))
Draws a frame around the string with custom character set
```go
strutil.DrawCustomBox("Hello World", 20, strutil.Center, strutil.SimpleBox9Slice(), "\n")
//┌──────────────────┐
//│   Hello World    │
//└──────────────────┘
```

### ExpandTabs  ([Docs](https://godoc.org/github.com/ozgio/strutil#ExpandTabs))
Converts tabs to the spaces
```go
strutil.ExpandTabs("\tlorem\n\tipsum\n", 2) //-> "  lorem\n  ipsum\n"
```

### Indent ([Docs](https://godoc.org/github.com/ozgio/strutil#Indent))
Indents every line
```go
strutil.Indent("lorem\nipsum", "> ") //-> "> lorem\n> ipsum"
```

### IsASCII ([Docs](https://godoc.org/github.com/ozgio/strutil#IsASCII))
Checks if all the characters in string are in standard ASCII table
```go
strutil.IsASCII("lorem\nipsum") //-> true
```

### Len ([Docs](https://godoc.org/github.com/ozgio/strutil#Len))
Alias of utf8.RuneCountInString which returns the number of runes in string
```go
strutil.Len("böt") //-> "3"
```

### MapLines ([Docs](https://godoc.org/github.com/ozgio/strutil#MapLines))
Runs function fn on every line of the string
```go
strutil.MapLines("   lorem      \n    ipsum      ", strings.TrimSpace) //-> "lorem\nipsum"
```

### OSNewLine ([Docs](https://godoc.org/github.com/ozgio/strutil#OSNewLine))
OSNewLine returns operating systems default new line character
```go
strutil.OSNewLine() //-> "\n"
```

### Pad ([Docs](https://godoc.org/github.com/ozgio/strutil#Pad))
Left and right pads the string
```go
strutil.Pad("lorem", 11, "->", "<-") //-> "->->lorem<-<-"
```

### PadLeft ([Docs](https://godoc.org/github.com/ozgio/strutil#PadLeft))
Left pads the string
```go
strutil.PadLeft("lorem", 9, "->") //-> "->->lorem"
```

### PadRight ([Docs](https://godoc.org/github.com/ozgio/strutil#PadRight))
Right pads the string
```go
strutil.PadRight("lorem", 9, "<-") //-> "lorem<-<-"
```

### Random ([Docs](https://godoc.org/github.com/ozgio/strutil#Random))
Creates a random string from a character set
```go
strutil.Random("abcdefghi", 10) //-> "aciafbeafg"
```

### RemoveAccents ([Docs](https://godoc.org/github.com/ozgio/strutil#RemoveAccents))
Convert accented letters to ascii counterparts
```go
strutil.RemoveAccents("résumé") //-> "resume"
```

### ReplaceAllToOne ([Docs](https://godoc.org/github.com/ozgio/strutil#ReplaceAllToOne))
Replace all substrings in the text with the specified string
```go
strutil.ReplaceAllToOne("lorem ipsum", []string{"o","e","i","u"}, ".") //-> "l.r.m .ps.m"
```

### Reverse ([Docs](https://godoc.org/github.com/ozgio/strutil#Reverse))
Reverses the string
```go
strutil.Reverse("lorem") //-> "merol"
```

### Splice ([Docs](https://godoc.org/github.com/ozgio/strutil#Splice))
Replaces a part of the string 
```go
strutil.Splice("lorem", "-x-", 2, 3) //-> "lo-x-em"
```

### SplitAndMap ([Docs](https://godoc.org/github.com/ozgio/strutil#SplitAndMap))
Splits the string and runs the function fn on every part
```go
strutil.MapLines("lorem-ipsum-dolor", "-",  strutil.Reverse) //-> "merol\nmuspi\nrolod"
```

### Slugify ([Docs](https://godoc.org/github.com/ozgio/strutil#Slugify))
Converts the string to a slug 
```go
strutil.Slugify("Lorem ipsum, dolör") //-> "lorem-ipsum-dolor"
```

### SlugifySpecial ([Docs](https://godoc.org/github.com/ozgio/strutil#SlugifySpecial))
Converts the string to a slug with custom delimiter.
```go
strutil.SlugifySpecial("Lorem ipsum, dolör", "_") //-> "lorem_ipsum_dolor"
```

### SplitCamelCase  ([Docs](https://godoc.org/github.com/ozgio/strutil#SplitCamelCase))
Splits the words in a camelCase string
```go
strutil.SplitCamelCase("loremIpsum") //-> []string{"lorem", "Ipsum"}
```

### Substring ([Docs](https://godoc.org/github.com/ozgio/strutil#SafeSubstring))
Gets a part of the string without panics
```go
strutil.SafeSubstring("lorem", 0, 1) //-> "l"
```

### MustSubstring ([Docs](https://godoc.org/github.com/ozgio/strutil#Substring))
Gets a part of the string
```go
strutil.Substring("lorem", 0, 1) //-> "l"
```

### Summary ([Docs](https://godoc.org/github.com/ozgio/strutil#Summary))
Cuts the string to the specified length
```go
strutil.Summary("Lorem ipsum dolor sit amet",  10, "...") //-> "lorem ipsum..."
```

### Tile ([Docs](https://godoc.org/github.com/ozgio/strutil#Tile))
Repeats the pattern until the result reaches the 'length'
```go
strutil.Tile("-৹", 4) //-> "-৹-৹"
```

### ToSnakeCase  ([Docs](https://godoc.org/github.com/ozgio/strutil#ToSnakeCase))
Converts the string to snake_case 
```go
strutil.ToSnakeCase("Snake Case") //-> "snake_case"
```

### ToCamelCase  ([Docs](https://godoc.org/github.com/ozgio/strutil#ToCamelCase))
Converts the string to camelCase 
```go
strutil.ToCamelCase("Camel Case") //-> "camelCase"
```

### Words ([Docs](https://godoc.org/github.com/ozgio/strutil#Words))
Returns the words inside the text
```go
strutil.Words("Lorem ipsum, dolor sit amet") //-> []string{"Lorem", "ipsum", "dolor", "sit", "amet"}
```

### WordWrap ([Docs](https://godoc.org/github.com/ozgio/strutil#WordWrap))
Wraps the lines in the text  
```go
strutil.WordWrap("Lorem ipsum dolor sit amet", 15, false) //-> "Lorem ipsum\ndolor sit amet"
```


## Install

Prequsities:
- Go 1.10+

Install with
```sh
go get github.com/ozgio/strutil
```


strutil

cross-platform, cli app to perform various operations on string

![sttr](./media/banner.png)

# sttr

[Website](https://abhimanyu003.github.io/sttr/)
| [Install](https://github.com/abhimanyu003/sttr#battery-installation)
| [Getting Started](https://github.com/abhimanyu003/sttr#books-guide)
| [CLI Reference](https://abhimanyu003.github.io/sttr/cli/sttr/)
| [Source Code](https://github.com/abhimanyu003/sttr)

`sttr` is command line software that allows you to quickly run various transformation operations on the string.

```shell
// With input prompt
sttr

// Direct input
sttr md5 "Hello World"

// File input
sttr md5 file.text
sttr base64-encode image.jpg

// Reading from different processor like cat, curl, printf etc..
echo "Hello World" | sttr md5
cat file.txt | sttr md5

// Writing output to a file
sttr yaml-json file.yaml > file-output.json
```

# :movie_camera: Demo

![sttr demo](./media/demo.gif)

# :battery: Installation

#### Quick install

You can run the below `curl` to install it somewhere in your PATH for easy use. Ideally it will be installed at `./bin`
folder

```shell
curl -sfL https://raw.githubusercontent.com/abhimanyu003/sttr/main/install.sh | sh
```

#### Homebrew

If you are on macOS and using Homebrew, you can install `sttr` with the following:

```shell
brew install abhimanyu003/sttr/sttr
```

#### Snap

```shell
sudo snap install sttr
```

#### Arch Linux

```shell
yay -S sttr-bin
```

#### Docker

```shell
docker run -it --rm -e TERM=xterm-256color ghcr.io/abhimanyu003/sttr:latest 
```
> You can use docker image in your project from `ghcr.io/abhimanyu003/sttr:latest`


#### Winget

```shell
winget install -e --id abhimanyu003.sttr
```

#### Scoop

```shell
scoop bucket add sttr https://github.com/abhimanyu003/scoop-bucket.git
scoop install sttr
```

#### X-CMD

If you are a user of [x-cmd](https://x-cmd.com), you can run:

```shell
x install sttr
```

#### Webi

**macOS / Linux**

```shell
curl -sS https://webi.sh/sttr | sh
```

**Windows**

```shell
curl.exe https://webi.ms/sttr | powershell
```

See [here](https://webinstall.dev/sttr/)

#### Go

```shell
go install github.com/abhimanyu003/sttr@latest
```

#### Binary

**MacOS**
[Binary](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Darwin_all.tar.gz) ( Multi-Architecture )

**Linux (Binaries)**
[amd64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Linux_x86_64.tar.gz) | [arm64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Linux_arm64.tar.gz) | [i386](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Linux_i386.tar.gz)

**Windows (Exe)**
[amd64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Windows_x86_64.zip) | [arm64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Windows_arm64.zip) | [i386](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Windows_i386.zip)

**FreeBSD (Binaries)**
[amd64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Freebsd_x86_64.tar.gz) | [arm64](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Freebsd_arm64.tar.gz) | [i386](https://github.com/abhimanyu003/sttr/releases/latest/download/sttr_Freebsd_i386.tar.gz)

#### Manually

Download the pre-compiled binaries from the [Release!](https://github.com/abhimanyu003/sttr/releases) page and copy them
to the desired location.

# :books: Guide

* After installation simply run `sttr` command.

```shell
// For interactive menu
sttr
// Provide your input
// Press two enter to open operation menu
// Press `/` to filter various operations.
// Can also press UP-Down arrows select various operations.
```

* Working with help.

```shell
sttr -h

// Example
sttr zeropad -h
sttr md5 -h
```

* Working with files input.

```shell
sttr {command-name} {filename}

sttr base64-encode image.jpg
sttr md5 file.txt
sttr md-html Readme.md
```

* Writing output to file.

```shell
sttr yaml-json file.yaml > file-output.json
```

* Taking input from other command.

```shell
curl https://jsonplaceholder.typicode.com/users | sttr json-yaml
```

* Chaining the different processor.

```shell
sttr md5 hello | sttr base64-encode

echo "Hello World" | sttr base64-encode | sttr md5
```

# :boom: Supported Operations

#### Encode/Decode

- [x] **ascii85-encode** - Encode your text to Ascii85
- [x] **ascii85-decode** - Decode your Ascii85 text
- [x] **base32-decode** - Decode your Base32 text
- [x] **base32-encode** - Encode your text to Base32
- [x] **base64-decode** - Decode your Base64 text
- [x] **base64-encode** - Encode your text to Base64
- [x] **base85-encode** - Encode your text to Base85
- [x] **base85-decode** - Decode your Base85 text
- [x] **base64url-decode** - Decode your Base64 URL
- [x] **base64url-encode** - Encode your text to URL
- [x] **html-decode** - Unescape your HTML
- [x] **html-encode** - Escape your HTML
- [x] **rot13-encode** - Encode your text to ROT13
- [x] **url-decode** - Decode URL entities
- [x] **url-encode** - Encode URL entities
- [x] **morse-decode** - Decode your Morse code
- [x] **morse-encode** - Encode your text to Morse code

#### Hash

- [x] **bcrypt** - Get the bcrypt hash of your text
- [x] **md5** - Get the MD5 checksum of your text
- [x] **sha1** - Get the SHA1 checksum of your text
- [x] **sha256** - Get the SHA256 checksum of your text
- [x] **sha512** - Get the SHA512 checksum of your text
- [x] **xxh32** - Get the XXH32 checksum of your text
- [x] **xxh64** - Get the XXH64 checksum of your text
- [x] **xxh128** - Get the XXH128 checksum of your text

#### String

- [x] **camel** - Transform your text to camelCase
- [x] **kebab** - Transform your text to kebab-case
- [x] **lower** - Transform your text to lower case
- [x] **pascal** - Transform your text to PascalCase
- [x] **reverse** - Reverse Text ( txeT esreveR )
- [x] **slug** - Transform your text to slug-case
- [x] **snake** - Transform your text to snake_case
- [x] **title** - Transform your text to Title Case
- [x] **upper** - Transform your text to UPPER CASE

#### Lines

- [x] **count-lines** - Count the number of lines in your text
- [x] **reverse-lines** - Reverse lines
- [x] **shuffle-lines** - Shuffle lines randomly
- [x] **sort-lines** - Sort lines alphabetically
- [x] **unique-lines** - Get unique lines from list
- [x] **number-lines** -  Prepend consecutive number to each line

#### Spaces

- [x] **remove-spaces** - Remove all spaces + new lines
- [x] **remove-newlines** - Remove all new lines

#### Count

- [x] **count-chars** - Find the length of your text (including spaces)
- [x] **count-lines** - Count the number of lines in your text
- [x] **count-words** - Count the number of words in your text

#### RGB/Hex

- [x] **hex-rgb** - Convert a #hex-color code to RGB
- [x] **hex-encode** - Encode your text Hex
- [x] **hex-decode** - Convert Hexadecimal to String

#### JSON

- [x] **json** - Format your text as JSON
- [x] **json-escape** - JSON Escape
- [x] **json-unescape** - JSON Unescape
- [x] **json-yaml** - Convert JSON to YAML text
- [x] **json-msgpack** - Convert JSON to MSGPACK
- [x] **msgpack-json** - Convert MSGPACK to JSON

#### YAML

- [x] **yaml-json** - Convert YAML to JSON text

#### Markdown

- [x] **markdown-html** - Convert Markdown to HTML

#### Extract

- [x] **extract-emails** - Extract emails from given text
- [x] **extract-ip** - Extract IPv4 and IPv6 from your text
- [x] **extract-urls** - Extract URLs your text ( we don't do ping check )

#### Other

- [x] **escape-quotes** - escape single and double quotes from your text
- [x] **completion** - generate the autocompletion script for the specified shell
- [x] **interactive** - Use sttr in interactive mode
- [x] **version** - Print the version of sttr
- [x] **zeropad** - Pad a number with zeros
- [x] **and adding more...**

# Featured On

These are the few locations where `sttr` was highlighted, many thanks to all of you. 
Please feel free to add any blogs/videos you may have made that discuss `sttr` to the list.

* [YouTube: The Giants of Open Source - DevOps Paradox](https://youtu.be/4nFRKbY_HVE?t=2529?ref=abhimanyu003/sttr)
* [Terminal Trove - Tool of the Week](https://terminaltrove.com/sttr/?ref=abhimanyu003/sttr)
* [nixCraft](https://www.cyberciti.biz/open-source/sttr-awesome-linux-unix-command-tool-for-transformation-string/?ref=abhimanyu003/sttr)

# Contribution

This project welcomes your PR and issues. For example, refactoring, adding features, correcting English, etc.

A quick development guide can be found
on. [Developer-Guides](https://github.com/abhimanyu003/sttr/wiki/Developer-Guides) wiki page.

If you need any help, you can contact me on [Twitter](https://twitter.com/abhimanyu003).

Thanks to all the people who already contributed!

<a href="https://github.com/abhimanyu003/sttr/graphs/contributors">
  <img src="https://contributors-img.web.app/image?repo=abhimanyu003/sttr" />
</a>

# License

[MIT](./LICENSE)

sttr

Collection of useful string functions ported from other languages

# xstrings

[![Build Status](https://github.com/huandu/xstrings/workflows/Go/badge.svg)](https://github.com/huandu/xstrings/actions)
[![Go Doc](https://godoc.org/github.com/huandu/xstrings?status.svg)](https://pkg.go.dev/github.com/huandu/xstrings)
[![Go Report](https://goreportcard.com/badge/github.com/huandu/xstrings)](https://goreportcard.com/report/github.com/huandu/xstrings)
[![Coverage Status](https://coveralls.io/repos/github/huandu/xstrings/badge.svg?branch=master)](https://coveralls.io/github/huandu/xstrings?branch=master)

Go package [xstrings](https://godoc.org/github.com/huandu/xstrings) is a collection of string functions, which are widely used in other languages but absent in Go package [strings](http://golang.org/pkg/strings).

All functions are well tested and carefully tuned for performance.

## Propose a new function

Please review [contributing guideline](CONTRIBUTING.md) and [create new issue](https://github.com/huandu/xstrings/issues) to state why it should be included.

## Install

Use `go get` to install this library.

    go get github.com/huandu/xstrings

## API document

See [GoDoc](https://godoc.org/github.com/huandu/xstrings) for full document.

## Function list

Go functions have a unique naming style. One, who has experience in other language but new in Go, may have difficulties to find out right string function to use.

Here is a list of functions in [strings](http://golang.org/pkg/strings) and [xstrings](https://godoc.org/github.com/huandu/xstrings) with enough extra information about how to map these functions to their friends in other languages. Hope this list could be helpful for fresh gophers.

### Package `xstrings` functions

_Keep this table sorted by Function in ascending order._

| Function                                                                          | Friends                                                                         | #                                                   |
| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | --------------------------------------------------- |
| [Center](https://godoc.org/github.com/huandu/xstrings#Center)                     | `str.center` in Python; `String#center` in Ruby                                 | [#30](https://github.com/huandu/xstrings/issues/30) |
| [Count](https://godoc.org/github.com/huandu/xstrings#Count)                       | `String#count` in Ruby                                                          | [#16](https://github.com/huandu/xstrings/issues/16) |
| [Delete](https://godoc.org/github.com/huandu/xstrings#Delete)                     | `String#delete` in Ruby                                                         | [#17](https://github.com/huandu/xstrings/issues/17) |
| [ExpandTabs](https://godoc.org/github.com/huandu/xstrings#ExpandTabs)             | `str.expandtabs` in Python                                                      | [#27](https://github.com/huandu/xstrings/issues/27) |
| [FirstRuneToLower](https://godoc.org/github.com/huandu/xstrings#FirstRuneToLower) | `lcfirst` in PHP or Perl                                                         | [#15](https://github.com/huandu/xstrings/issues/15) |
| [FirstRuneToUpper](https://godoc.org/github.com/huandu/xstrings#FirstRuneToUpper) | `String#capitalize` in Ruby; `ucfirst` in PHP or Perl                            | [#15](https://github.com/huandu/xstrings/issues/15) |
| [Insert](https://godoc.org/github.com/huandu/xstrings#Insert)                     | `String#insert` in Ruby                                                         | [#18](https://github.com/huandu/xstrings/issues/18) |
| [LastPartition](https://godoc.org/github.com/huandu/xstrings#LastPartition)       | `str.rpartition` in Python; `String#rpartition` in Ruby                         | [#19](https://github.com/huandu/xstrings/issues/19) |
| [LeftJustify](https://godoc.org/github.com/huandu/xstrings#LeftJustify)           | `str.ljust` in Python; `String#ljust` in Ruby                                   | [#28](https://github.com/huandu/xstrings/issues/28) |
| [Len](https://godoc.org/github.com/huandu/xstrings#Len)                           | `mb_strlen` in PHP                                                              | [#23](https://github.com/huandu/xstrings/issues/23) |
| [Partition](https://godoc.org/github.com/huandu/xstrings#Partition)               | `str.partition` in Python; `String#partition` in Ruby                           | [#10](https://github.com/huandu/xstrings/issues/10) |
| [Reverse](https://godoc.org/github.com/huandu/xstrings#Reverse)                   | `String#reverse` in Ruby; `strrev` in PHP; `reverse` in Perl                    | [#7](https://github.com/huandu/xstrings/issues/7)   |
| [RightJustify](https://godoc.org/github.com/huandu/xstrings#RightJustify)         | `str.rjust` in Python; `String#rjust` in Ruby                                   | [#29](https://github.com/huandu/xstrings/issues/29) |
| [RuneWidth](https://godoc.org/github.com/huandu/xstrings#RuneWidth)               | -                                                                               | [#27](https://github.com/huandu/xstrings/issues/27) |
| [Scrub](https://godoc.org/github.com/huandu/xstrings#Scrub)                       | `String#scrub` in Ruby                                                          | [#20](https://github.com/huandu/xstrings/issues/20) |
| [Shuffle](https://godoc.org/github.com/huandu/xstrings#Shuffle)                     | `str_shuffle` in PHP                                                             | [#13](https://github.com/huandu/xstrings/issues/13) |
| [ShuffleSource](https://godoc.org/github.com/huandu/xstrings#ShuffleSource)         | `str_shuffle` in PHP                                                             | [#13](https://github.com/huandu/xstrings/issues/13) |
| [Slice](https://godoc.org/github.com/huandu/xstrings#Slice)                       | `mb_substr` in PHP                                                              | [#9](https://github.com/huandu/xstrings/issues/9)   |
| [Squeeze](https://godoc.org/github.com/huandu/xstrings#Squeeze)                   | `String#squeeze` in Ruby                                                        | [#11](https://github.com/huandu/xstrings/issues/11) |
| [Successor](https://godoc.org/github.com/huandu/xstrings#Successor)               | `String#succ` or `String#next` in Ruby                                          | [#22](https://github.com/huandu/xstrings/issues/22) |
| [SwapCase](https://godoc.org/github.com/huandu/xstrings#SwapCase)                 | `str.swapcase` in Python; `String#swapcase` in Ruby                             | [#12](https://github.com/huandu/xstrings/issues/12) |
| [ToCamelCase](https://godoc.org/github.com/huandu/xstrings#ToCamelCase)           | `String#camelize` in RoR                                                        | [#1](https://github.com/huandu/xstrings/issues/1)   |
| [ToKebab](https://godoc.org/github.com/huandu/xstrings#ToKebabCase)               | -                                                                               | [#41](https://github.com/huandu/xstrings/issues/41) |
| [ToPascalCase](https://godoc.org/github.com/huandu/xstrings#ToPascalCase)         | -                                                                               | [#1](https://github.com/huandu/xstrings/issues/1)   |
| [ToSnakeCase](https://godoc.org/github.com/huandu/xstrings#ToSnakeCase)           | `String#underscore` in RoR                                                      | [#1](https://github.com/huandu/xstrings/issues/1)   |
| [Translate](https://godoc.org/github.com/huandu/xstrings#Translate)               | `str.translate` in Python; `String#tr` in Ruby; `strtr` in PHP; `tr///` in Perl | [#21](https://github.com/huandu/xstrings/issues/21) |
| [Width](https://godoc.org/github.com/huandu/xstrings#Width)                       | `mb_strwidth` in PHP                                                            | [#26](https://github.com/huandu/xstrings/issues/26) |
| [WordCount](https://godoc.org/github.com/huandu/xstrings#WordCount)               | `str_word_count` in PHP                                                         | [#14](https://github.com/huandu/xstrings/issues/14) |
| [WordSplit](https://godoc.org/github.com/huandu/xstrings#WordSplit)               | -                                                                               | [#14](https://github.com/huandu/xstrings/issues/14) |

### Package `strings` functions

_Keep this table sorted by Function in ascending order._

| Function                                                        | Friends                                                                             |
| --------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [Contains](http://golang.org/pkg/strings/#Contains)             | `String#include?` in Ruby                                                           |
| [ContainsAny](http://golang.org/pkg/strings/#ContainsAny)       | -                                                                                   |
| [ContainsRune](http://golang.org/pkg/strings/#ContainsRune)     | -                                                                                   |
| [Count](http://golang.org/pkg/strings/#Count)                   | `str.count` in Python; `substr_count` in PHP                                        |
| [EqualFold](http://golang.org/pkg/strings/#EqualFold)           | `stricmp` in PHP; `String#casecmp` in Ruby                                          |
| [Fields](http://golang.org/pkg/strings/#Fields)                 | `str.split` in Python; `split` in Perl; `String#split` in Ruby                      |
| [FieldsFunc](http://golang.org/pkg/strings/#FieldsFunc)         | -                                                                                   |
| [HasPrefix](http://golang.org/pkg/strings/#HasPrefix)           | `str.startswith` in Python; `String#start_with?` in Ruby                            |
| [HasSuffix](http://golang.org/pkg/strings/#HasSuffix)           | `str.endswith` in Python; `String#end_with?` in Ruby                                |
| [Index](http://golang.org/pkg/strings/#Index)                   | `str.index` in Python; `String#index` in Ruby; `strpos` in PHP; `index` in Perl     |
| [IndexAny](http://golang.org/pkg/strings/#IndexAny)             | -                                                                                   |
| [IndexByte](http://golang.org/pkg/strings/#IndexByte)           | -                                                                                   |
| [IndexFunc](http://golang.org/pkg/strings/#IndexFunc)           | -                                                                                   |
| [IndexRune](http://golang.org/pkg/strings/#IndexRune)           | -                                                                                   |
| [Join](http://golang.org/pkg/strings/#Join)                     | `str.join` in Python; `Array#join` in Ruby; `implode` in PHP; `join` in Perl        |
| [LastIndex](http://golang.org/pkg/strings/#LastIndex)           | `str.rindex` in Python; `String#rindex`; `strrpos` in PHP; `rindex` in Perl         |
| [LastIndexAny](http://golang.org/pkg/strings/#LastIndexAny)     | -                                                                                   |
| [LastIndexFunc](http://golang.org/pkg/strings/#LastIndexFunc)   | -                                                                                   |
| [Map](http://golang.org/pkg/strings/#Map)                       | `String#each_codepoint` in Ruby                                                     |
| [Repeat](http://golang.org/pkg/strings/#Repeat)                 | operator `*` in Python and Ruby; `str_repeat` in PHP                                |
| [Replace](http://golang.org/pkg/strings/#Replace)               | `str.replace` in Python; `String#sub` in Ruby; `str_replace` in PHP                 |
| [Split](http://golang.org/pkg/strings/#Split)                   | `str.split` in Python; `String#split` in Ruby; `explode` in PHP; `split` in Perl    |
| [SplitAfter](http://golang.org/pkg/strings/#SplitAfter)         | -                                                                                   |
| [SplitAfterN](http://golang.org/pkg/strings/#SplitAfterN)       | -                                                                                   |
| [SplitN](http://golang.org/pkg/strings/#SplitN)                 | `str.split` in Python; `String#split` in Ruby; `explode` in PHP; `split` in Perl    |
| [Title](http://golang.org/pkg/strings/#Title)                   | `str.title` in Python                                                               |
| [ToLower](http://golang.org/pkg/strings/#ToLower)               | `str.lower` in Python; `String#downcase` in Ruby; `strtolower` in PHP; `lc` in Perl |
| [ToLowerSpecial](http://golang.org/pkg/strings/#ToLowerSpecial) | -                                                                                   |
| [ToTitle](http://golang.org/pkg/strings/#ToTitle)               | -                                                                                   |
| [ToTitleSpecial](http://golang.org/pkg/strings/#ToTitleSpecial) | -                                                                                   |
| [ToUpper](http://golang.org/pkg/strings/#ToUpper)               | `str.upper` in Python; `String#upcase` in Ruby; `strtoupper` in PHP; `uc` in Perl   |
| [ToUpperSpecial](http://golang.org/pkg/strings/#ToUpperSpecial) | -                                                                                   |
| [Trim](http://golang.org/pkg/strings/#Trim)                     | `str.strip` in Python; `String#strip` in Ruby; `trim` in PHP                        |
| [TrimFunc](http://golang.org/pkg/strings/#TrimFunc)             | -                                                                                   |
| [TrimLeft](http://golang.org/pkg/strings/#TrimLeft)             | `str.lstrip` in Python; `String#lstrip` in Ruby; `ltrim` in PHP                     |
| [TrimLeftFunc](http://golang.org/pkg/strings/#TrimLeftFunc)     | -                                                                                   |
| [TrimPrefix](http://golang.org/pkg/strings/#TrimPrefix)         | -                                                                                   |
| [TrimRight](http://golang.org/pkg/strings/#TrimRight)           | `str.rstrip` in Python; `String#rstrip` in Ruby; `rtrim` in PHP                     |
| [TrimRightFunc](http://golang.org/pkg/strings/#TrimRightFunc)   | -                                                                                   |
| [TrimSpace](http://golang.org/pkg/strings/#TrimSpace)           | `str.strip` in Python; `String#strip` in Ruby; `trim` in PHP                        |
| [TrimSuffix](http://golang.org/pkg/strings/#TrimSuffix)         | `String#chomp` in Ruby; `chomp` in Perl                                             |

## License

This library is licensed under MIT license. See LICENSE for details.


xstrings

Go implementation of Brace Expansion mechanism to generate arbitrary strings

![Happy Logo](assets/images/happy.svg)

# Happy Prototyping Framework and SDK

Happy SDK is an open-source Go framework designed to make building applications simple and fast. Its clear, modular structure and addon system promote code reuse, enabling anyone—coders or non-coders—to create prototypes or full projects efficiently. It integrates smoothly with projects using multiple programming languages, helping teams bring ideas to life with ease with built-in monorepo support.

:warning: *Until v1.0.0, API changes may break compatibility, so pin your Happy version and update cautiously.*  

**Update your project to latest**

```bash
go get -u github.com/happy-sdk/happy
```

![GitHub Release](https://img.shields.io/github/v/release/happy-sdk/happy) [![PkgGoDev](https://pkg.go.dev/badge/github.com/happy-sdk/happy)](https://pkg.go.dev/github.com/happy-sdk/happy) [![Coverage Status](https://coveralls.io/repos/github/happy-sdk/happy/badge.svg?branch=main)](https://coveralls.io/github/happy-sdk/happy?branch=main) ![GitHub License](https://img.shields.io/github/license/happy-sdk/happy)

## Creating application

Happy SDK is designed to simplify your development process without introducing any new or additional developer tools. Your applications built with Happy can be used, built, and tested with the standard Go build tools, such as 'go test', 'go build', and 'go run'. With Happy, you have complete control over your development environment, as it will not add any third-party dependencies to your project.

*Here's a minimal example of how you can use Happy:*

```go
// main.go
package main

import (
 "fmt"

 "github.com/happy-sdk/happy"
 "github.com/happy-sdk/happy/sdk/action"
 "github.com/happy-sdk/happy/sdk/session"
)

func main() {
 app := happy.New(nil)

 app.Do(func(sess *session.Context, args action.Args) error {
  sess.Log().Info("Hello, world! ")
  return nil
 })

 app.Run()
}
// go run . 
// OUT: 
// info  00:00:00.000 Hello, world!
```

*Here's a example enabling builtin global flags including (help,version:*

```go
// main.go
package main

import (
 "fmt"

 "github.com/happy-sdk/happy"
 "github.com/happy-sdk/happy/sdk/action"
 "github.com/happy-sdk/happy/sdk/session"
)

func main() {
 app := happy.New(&happy.Settings{
  // Engine: happy.EngineSettings{},

  CLI: happy.CliSettings{
   WithGlobalFlags: true,
  },

  // Profiles: happy.ProfileSettings{},
  // DateTime: happy.DateTimeSettings{},
  Instance: happy.InstanceSettings{},

  // We enable global flags which has --verbose flag to set info level
  // so we set default something higher than info
  Logging: happy.LoggingSettings{
   Level: logging.LevelSuccess,
  },

  // Services: happy.ServicesSettings{},
  // Stats:    happy.StatsSettings{},
  // Devel:    happy.DevelSettings{},
  // I18n:     happy.I18nSettings{},
 })

 app.Do(func(sess *session.Context, args action.Args) error {
  sess.Log().Info("Hello, world! ")
  return nil
 })

 app.Run()
}
// go run . -h
// OUT: 
//  Happy Prototype - v0.0.1-devel+git.<hash>.<timestamp>
//  Copyright © {year} Anonymous
//  License: NOASSERTION
//  
//  This application is built using the Happy-SDK to provide enhanced functionality and features.
//
//  yourcmd [flags]
//
// GLOBAL FLAGS:
//
//  --debug              enable debug log level - default: "false"
//  --help         -h    display help or help for the command. [...command --help] - default: "false"
//  --show-exec    -x    the -x flag prints all the cli commands as they are executed. - default: "false"
//  --system-debug       enable system debug log level (very verbose) - default: "false"
//  --verbose      -v    set log level info - default: "false"
//  --version            print application version - default: "false"
```

For more examples, take a look at the [examples](#examples) section and the examples in the `./examples/` directory.

## Examples

Below are a few small examples to help you get started quickly.  
You can run them directly from the repository root using `go run`.

- **Minimal application**

  ```bash
  go run ./examples/apps/minimal
  ```

- **Basic application with built-in CLI features**

  ```bash
  go run ./examples/apps/basic
  ```

- **Application using an addon**

  ```bash
  go run ./examples/apps/hello
  ```

- **Showcase application (multiple features together)**

  ```bash
  go run ./examples/apps/showcase
  ```

See the full source in the `./examples/` directory for more patterns.

### Application API

More details of api read happy Godoc  
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/happy-sdk/happy/sdk/app)](https://pkg.go.dev/github.com/happy-sdk/happy/sdk/app)

```go

...
app.AddInfo(/* add paragraph to app help */)
app.WithOptions(/* adds allowed runtime option */)
app.SetOptions(/* update default value for any application or addon option */) 
app.Setup(/* optional setup action called only first time app is used */)
app.WithAddon(/* adds addon to app */)
app.WithBrand(/* customize branding of the app */)
app.WithCommands(/* adds command(s) to app */)
app.WithFlags(/* adds flag(s) to app root command */)
app.WithLogger(/* uses provided logger */)
app.WithMigrations(/* use migration manager */)
app.WithServices(/* adds service(s) to app */)

...

...
// Application root command actions
app.BeforeAlways(/* called always before any command is invoked*/)
app.Before(/* called before root command is invoked*/)
app.Do(/* root command Do function */)
app.AfterSuccess(/* called when root cmd or sub command returns without errors */)
app.AfterFailure(/* called when root cmd or sub command returns with errors */)
app.AfterAlways(/* called always when root cmd or sub command returns */)
app.Tick(/* called in specific interfal while root command is blocking */)
app.Tock(/* called after every tick*/)
...
```

### Commands

`command.Command` provides a universal API for attaching sub-commands directly to the application or providing them from an Addon.  
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/happy-sdk/happy/sdk/cli/command)](https://pkg.go.dev/github.com/happy-sdk/happy/sdk/cli/command)

```go
import "github.com/happy-sdk/happy/sdk/cli/command"
...
cmd := command.New(command.Config{
  Name: "my-command"
})

cmd.Do(/* Main function for the command */)
// Optional:
cmd.Before(/* Called after app.Before and before cmd.Do */)
cmd.AfterSuccess(/* Called when cmd.Do returns without errors */)
cmd.AfterFailure(/* Called when cmd.Do returns with errors */)
cmd.AfterAlways(/* Called always when cmd.Do returns */)

cmd.Usage(/* add attitional usage lines to help menu */)
cmd.AddInfo(/* add long description paragraph for command */)
cmd.WithSubCommands(/* Add a sub-command to the command */)
cmd.WithFlags(/* add flag(s) to  command*/)
...
```

### Services

The `services.Service` API provides a flexible way to add runtime-controllable background services to your application.  
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/happy-sdk/happy/sdk/services)](https://pkg.go.dev/github.com/happy-sdk/happy/sdk/services)

```go
import (
  "github.com/happy-sdk/happy/sdk/services"
  "github.com/happy-sdk/happy/sdk/services/service"
)
...
svc := services.New(service.Config{
  Name: "my-service",
})

svc.OnRegister(/* Called when the app starts. */)
svc.OnStart(/* Called when the service is requested to start. */)
svc.OnStop(/* Called when the service is requested to stop. */)
svc.OnEvent(/* Called when a specific event is received. */)
svc.OnAnyEvent(/* Called when any event is received. */)
svc.Cron(/* Scheduled cron jobs to run when the service is running. */)
svc.Tick(/* Called every tick when the service is running. */)
svc.Tock(/* Called after every tick when the service is running. */)

app.WithServices(svc)
...
```

## Addons

Addons provide a simple way to bundle commands and services into a single Go package, allowing for easy sharing between projects.  
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/happy-sdk/happy/sdk/addon)](https://pkg.go.dev/github.com/happy-sdk/happy/sdk/addon)

```go
// main.go
package main

import (
  "github.com/happy-sdk/happy"
  "helloworld"
)

func main() {
  app := happy.New(&happy.Settings{})
  app.WithAddons(helloworld.Addon())
  app.Run()
}

```

```go
// helloworld/addon.go
package helloworld

import (
  "github.com/happy-sdk/happy/sdk/addon"
  "github.com/happy-sdk/happy/sdk/session"
  "github.com/happy-sdk/happy/sdk/custom"
)

type HelloWorldAPI struct {
  custom.API
}

func Addon() *happy.Addon {
  ad := addon.New("Hello World").
    WithOptions(
      addon.Option("my-opt", "default-val"),
    )


  // Optional: Register commands provided by the addon
  ad.ProvideCommands(/* provide command(s) */)

  // Optional: Register services provided by the addon
  ad.ProvideServices(/* provide service(s) */)

  // Optional: Make a custom API accessible across the application 
  ad.ProvideAPI(&HelloWorldAPI{}) 

  // Register all events that the addon may emit ()
  ad.WithEvents(/* events what addon emits */)

  // Optional callback to be called when the addon is registered
  ad.OnRegister(func(sess session.Register) error {
    sess.Log().Notice("hello-world addon registered")
    return nil
  })

  return ad
}
```

## Credits

[![GitHub contributors](https://img.shields.io/github/contributors/happy-sdk/happy?style=flat-square)](https://github.com/happy-sdk/happy/graphs/contributors)

<sub>**Happy banner design.**</sub>  
<sup>Happy banner was designed by Egon Elbre <a href="https://egonelbre.com/" target="_blank">egonelbre.com</a></sup>


bexp

# caps is a case conversion library for go

[![Go Reference](https://pkg.go.dev/badge/github.com/chanced/caps.svg)](https://pkg.go.dev/github.com/chanced/caps)
[![Latest Version](https://img.shields.io/github/v/tag/chanced/caps.svg?sort=semver&style=flat-square&label=version&color=blue)](https://img.shields.io/github/v/tag/chanced/caps.svg?sort=semver&style=flat-square&label=version&color=blue)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/chanced/caps.svg?style=flat-square&label=go)
[![GoReportCard](https://goreportcard.com/badge/github.com/chanced/caps?style=flat-square)](https://goreportcard.com/report/github.com/chanced/caps)
[![Codecov](https://img.shields.io/codecov/c/github/chanced/caps?style=flat-square&token=6601V8MSG3)](https://codecov.io/gh/chanced/caps)
![Build Status](https://img.shields.io/github/actions/workflow/status/chanced/caps/main.yaml?style=flat-square)

caps is a unicode aware, case conversion library for Go.



## Supported Case Conversions

The following case conversions are available:

-   Camel Case (e.g. CamelCase)
-   Lower Camel Case (e.g. lowerCamelCase)
-   Snake Case (e.g. snake_case)
-   Screaming Snake Case (e.g. SCREAMING_SNAKE_CASE)
-   Kebab Case (e.g. kebab-case)
-   Screaming Kebab Case(e.g. SCREAMING-KEBAB-CASE)
-   Dot Notation Case (e.g. dot.notation.case)
-   Screaming Dot Notation Case (e.g. DOT.NOTATION.CASE)
-   Title Case (e.g. Title Case)
-   Other deliminations

## Install

```
go get github.com/chanced/caps
```

## Example

```go
package main

import (
	"fmt"
	"github.com/chanced/caps"
)
func main() {
	fmt.Println(caps.ToCamel("http request"))
	// Output:
	// HTTPRequest
	fmt.Println(caps.ToLowerCamel("some_id"))
	// Output:
	// someID
	fmt.Println(caps.ToLowerCamel("SomeID", caps.WithReplaceStyleCamel()))
	// Output:
	// someId

	// Alternatively:
	capsJS := caps.New(caps.Config{
		AllowedSymbols: "$",
		ReplaceStyle:   caps.ReplaceStyleCamel,
	})
	fmt.Println(capsJS.ToCamel("SomeID"))
	// Output:
	// someId
}

```

[go playground link](https://go.dev/play/p/bJvbMAmtZzV)

## Word boundaries

Word boundaries are determined by the `caps.Converter`. The provided implementation, `caps.StdConverter`,
delegates the boundary detection to `caps.Tokenizer`. The provided implementation, `caps.StdTokenizer`,
uses the following rules:

-   The following characters are considered word breaks `" _.!?:;$-(){}[]#@&+~"` unless present in `AllowedSymbols`
-   Strings with all upper case characters are split by the above symbols or by
    numbers, unless the character is allowed in a number based on the following rules:
    -   'v' or 'V' followed by numbers
    -   '.' before/after a number and only once
    -   'e' or 'E' if in the fractional part of a number and only once
    -   '-', '+' if at the start and followed by either a number or '.' and a
        number or in the fractional part proceeded by 'e' or 'E'
    -   additional rules can be added through the number rules (e.g. `WithNumberRules`)
    -   NOTE: If '.', '+', '-' are not in the `AllowedSymbols` they are
        considered breaks even for numbers
-   When a string consists of both upper case and lower case letters, upper case
    letters are considered boundaries (e.g. `"ThisVar"` would be tokenized into `["This", "Var"]`)
-   When mixed with lower and upper case characters, sequences of upper case are
    broken up into token strings (e.g. `"SomeID"` would be tokenized into `["Some", "I", "D"]`).
-   Replacement rules are then evaluated based on the token strings, which may
    combine them based on the rules below.

## Replacements

`caps.StdConverter` also allows users to register `caps.Replacement`s for
initialism replacements. Each `Replacement` is indexed in a trie (see
[Index](https://github.com/chanced/caps/blob/main/index/index.go)).

-   Multi-rune token strings are searched independently unless followed by a number (e.g.
    `"ID"`, `"UTF8"`).
-   Sequences of single rune token (e.g.`["U", "U", "I", "D"]`) are
    evaluated as a potential `Replacement` until a non-match is
    found or the sequence is broken by a token string with more than one rune.

### Default replacements

```go
{"Acl", "ACL"}
{"Api", "API"}
{"Ascii", "ASCII"}
{"Cpu", "CPU"}
{"Css", "CSS"}
{"Dns", "DNS"}
{"Eof", "EOF"}
{"Guid", "GUID"}
{"Html", "HTML"}
{"Http", "HTTP"}
{"Https", "HTTPS"}
{"Id", "ID"}
{"Ip", "IP"}
{"Json", "JSON"}
{"Lhs", "LHS"}
{"Qps", "QPS"}
{"Ram", "RAM"}
{"Rhs", "RHS"}
{"Rpc", "RPC"}
{"Sla", "SLA"}
{"Smtp", "SMTP"}
{"Sql", "SQL"}
{"Ssh", "SSH"}
{"Tcp", "TCP"}
{"Tls", "TLS"}
{"Ttl", "TTL"}
{"Udp", "UDP"}
{"Ui", "UI"}
{"Uid", "UID"}
{"Uuid", "UUID"}
{"Uri", "URI"}
{"Url", "URL"}
{"Utf8", "UTF8"}
{"Vm", "VM"}
{"Xml", "XML"}
{"Xmpp", "XMPP"}
{"Xsrf", "XSRF"}
{"Xss", "XSS"}
```

If you would like to add or remove entries from that list, you have a few
options. See below.

## Customizing the `Converter`

### Using caps.Caps

This is likely your best option. You can create and utilize an instance of
`caps.Caps` which has all of the conversions as methods:

```go
package main

import (
	"fmt"

	"github.com/chanced/caps"
)

func main() {
	c := caps.New(caps.Config{
		Replacements: []caps.Replacement{
			{Camel: "Ex", Screaming: "EX"},
			// ... your replacements
		},
	})
	fmt.Println(c.ToCamel("some ex"))
	// Output:
	// SomeEX
}
```

[go playground link](https://go.dev/play/p/8G6Yl-9I030)

### Creating isolated `caps.StdConverter` instances

You can pass a new instance of `caps.StdConverter` with a new set of
`caps.Replacement`.

```go
    package main
    import (
        "fmt"
        "github.com/chanced/caps"
        "github.com/chanced/caps/token"
    )
    func main() {
        replacements := []caps.Replacement{
            {"Ex", "EX" },
            // ... your replacements
        }
        converter := caps.NewConverter(replacements, caps.DefaultTokenizer, token.DefaultCaser)
        fmt.Println(caps.ToCamel("ex id", caps.WithConverter(converter)))
        // note: ID was not in the replacement list above
        // Output:
        // "EXId"
       fmt.Println(caps.ToCamel("ex id"))
        // Output:
        // ExID
    }
```

[go playground link](https://go.dev/play/p/jlFAj3ujhTW)

### Modifying the `caps.DefaultConverter` global

You can update `caps.DefaultConverter`. You should set it before you make any
conversions. Otherwise, you'll need guard your usage of the library accordingly
(e.g. a mutex).

```go
package main

import (
	"fmt"

	"github.com/chanced/caps"
)

func main() {
	converter, _ := caps.DefaultConverter.(caps.StdConverter)
	converter.Set("Gcp", "GCP")
	fmt.Println(caps.ToCamel("some_gcp_var"))
	// Output:
	// SomeGCPVar
}

```

[go playground link](https://go.dev/play/p/GcEHFAR8zHK)

### Creating a custom `caps.Converter`

Finally, if you are so inclined, you can create your own `caps.Converter`. This
could be as simple as implementing the single `Convert` method, calling
`caps.DefaultConverter.Convert`, and then modifying the result.

```go
package main
import (
    "fmt"
    "github.com/chanced/caps"
)
type MyConverter struct{}
func (MyConverter) Convert(req caps.ConvertRequest) string {
    res := caps.DefaultConverter.Convert(req)
    if req.Style.IsLowerCamel() && req.ReplaceStyle.IsCamel() && res == "id" {
        return "_id"
    }
    return res
}
func main() {
    fmt.Println(caps.ToLowerCamel("ID", caps.WithReplaceStyleCamel(), caps.WithConverter(MyConverter{})))
    // Output:
    // _id
}
```

[go playground link](https://go.dev/play/p/kmtwZlP41S9)

## Support for special case unicode (e.g. Turkish, Azeri)

caps supports Turkish and Azeri through the `token.Caser` interface. It is
satisfied by `unicode.TurkishCase` and `unicode.AzeriCase`. `token.TurkishCaser`
and `token.AzeriCaser` are available as pointers to those variables (although
you can use the unicode variables directly).

For example, to use Turkish, you would need to instantiate a few variables:

```go
package main
import (
    "github.com/chanced/caps"
    "github.com/chanced/caps/token"

)
func main() {
    tokenizer := caps.NewTokenizer(caps.DEFAULT_DELIMITERS, token.TurkishCaser)
    // I suppose these would need to be specific to Turkish?
    // if not, you can just use caps.DefaultReplacements
    replacements := []caps.Replacement{
        { Camel: "Http", Screaming: "HTTP" }, // just an example
    }
    turkish := caps.NewConverter(replacements, tokenizer, token.TurkishCaser)

    // to use this as your default throughout your application
    // you can overwrite caps.DefaultConverter
    //
    // caps.DefaultConverter = turkish
    //
    // otherwise, you can pass in the converter to the config for each call:
    fmt.Println(caps.ToScreamingKebab("i ı", caps.WithConverter(turkish)))
    // Output:
    // İ-I
}
```

[go playground link](https://go.dev/play/p/aKfuU5eZJgp)

## text pkg

The `text` package contains two types:

-   `Text` which has all of the case conversions and relevant functions from strings as methods.
-   `Texts` which is a sortable slice of Text with a few helper methods

```go
package main

import (
	"fmt"
	"github.com/chanced/caps/text"
)

func main() {
	t := text.Text("Hello World")
	for _, p := range t.ToKebab().Split("-") {
		fmt.Println(p)
	}
	// Output:
	// hello
	// world
}
```

[go playground link](https://go.dev/play/p/MOYKz4ySpAv)

## Benchmarks

```
input: "Example Uuid."
```

```
goos: darwin
goarch: arm64
pkg: github.com/chanced/caps
```

Using a `caps.Caps` instance:

```
BenchmarkCapsToTitle
BenchmarkCapsToTitle-10                   	 2488982	       470.2 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToCamel
BenchmarkCapsToCamel-10                   	 2474846	       467.8 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToLowerCamel
BenchmarkCapsToLowerCamel-10              	 2650843	       451.0 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToSnake
BenchmarkCapsToSnake-10                   	 2619945	       456.9 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToScreamingSnake
BenchmarkCapsToScreamingSnake-10          	 2591302	       461.9 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToKebab
BenchmarkCapsToKebab-10                   	 2621020	       457.0 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToScreamingKebab
BenchmarkCapsToScreamingKebab-10          	 2593428	       466.3 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToDotNotation
BenchmarkCapsToDotNotation-10             	 2575178	       463.0 ns/op	     200 B/op	       8 allocs/op
BenchmarkCapsToScreamingDotNotation
BenchmarkCapsToScreamingDotNotation-10    	 2526782	       472.8 ns/op	     200 B/op	       8 allocs/op
```

Using top-level functions:

```
BenchmarkToTitle
BenchmarkToTitle-10                       	 2316468	       519.1 ns/op	     200 B/op	       8 allocs/op
BenchmarkToCamel
BenchmarkToCamel-10                       	 2327542	       516.8 ns/op	     200 B/op	       8 allocs/op
BenchmarkToLowerCamel
BenchmarkToLowerCamel-10                  	 2372518	       505.3 ns/op	     200 B/op	       8 allocs/op
BenchmarkToSnake
BenchmarkToSnake-10                       	 2337992	       511.8 ns/op	     200 B/op	       8 allocs/op
BenchmarkToScreamingSnake
BenchmarkToScreamingSnake-10              	 2313232	       518.8 ns/op	     200 B/op	       8 allocs/op
BenchmarkToKebab
BenchmarkToKebab-10                       	 2333046	       513.7 ns/op	     200 B/op	       8 allocs/op
BenchmarkToScreamingKebab
BenchmarkToScreamingKebab-10              	 2274729	       521.3 ns/op	     200 B/op	       8 allocs/op
BenchmarkToDotNotation
BenchmarkToDotNotation-10                 	 2319278	       511.0 ns/op	     200 B/op	       8 allocs/op
BenchmarkToScreamingDotNotation
BenchmarkToScreamingDotNotation-10        	 2310217	       518.5 ns/op	     200 B/op	       8 allocs/op
```

## License

MIT

caps

String manipulation library to convert string to camel case, snake case, kebab case / slugify etc

gobeam/Stringy

Pipeline-first string toolkit for composing transformations

[![CI](https://github.com/schigh/str/actions/workflows/ci.yml/badge.svg)](https://github.com/schigh/str/actions/workflows/ci.yml)
[![Go Reference](https://pkg.go.dev/badge/github.com/schigh/str.svg)](https://pkg.go.dev/github.com/schigh/str)
[![Go Report Card](https://goreportcard.com/badge/github.com/schigh/str)](https://goreportcard.com/report/github.com/schigh/str)
[![codecov](https://codecov.io/github/schigh/str/graph/badge.svg?token=vzYvIwXOLk)](https://codecov.io/github/schigh/str)

# str

Pipeline-first string toolkit for Go. Compose transformations, not calls.

```go
normalize := str.Pipe(
    str.TrimSpace,
    str.CollapseWhitespace,
    str.ToSnakeCase,
    str.Truncate(64, "..."),
)
slug := normalize("  HelloWorld  ") // "hello_world"
```

Every function is `func(string) string`. Compose them with `Pipe`. Zero dependencies.

## Install

```
go get github.com/schigh/str@latest
```

## Compose

**Pipe** composes multiple transformers into a single function, applied left to right.

```go
format := str.Pipe(str.TrimSpace, str.PadLeft("0", 8))
format("  42  ") // "00000042"
```

**PipeErr** composes fallible transformers. Short-circuits on the first error.

**PipeIf** applies a transformation only when a predicate is true. Otherwise passes through.

```go
isLong := func(s string) bool { return len([]rune(s)) > 100 }
clean := str.Pipe(
    str.TrimSpace,
    str.PipeIf(isLong, str.Truncate(100, "...")),
)
```

**PipeUnless** is the inverse: applies when the predicate is false.

**PipeMap** splits a string, transforms each part, and rejoins.

```go
trimLines := str.PipeMap(str.Lines, "\n", str.TrimSpace)
trimLines("  hello  \n  world  ") // "hello\nworld"
```

Built-in splitters: `Lines` (split on `\n`) and `Words` (split on whitespace).

## Transform

**ToSnakeCase** / **ToCamelCase** / **ToPascalCase** / **ToKebabCase** / **ToTitleCase** / **ToScreamingSnake**

```go
str.ToSnakeCase("HTMLParser")   // "html_parser"
str.ToCamelCase("hello_world")  // "helloWorld"
str.ToPascalCase("hello_world") // "HelloWorld"
str.ToKebabCase("HelloWorld")   // "hello-world"
str.ToTitleCase("hello_world")  // "Hello World"
str.ToScreamingSnake("hello")   // "HELLO"
```

Handles acronyms (ID, URL, HTTP, HTML, API, JSON, etc.), digit boundaries, and Unicode letters.

Every case function has a `*With` variant for custom acronyms:

```go
toSnake := str.ToSnakeCaseWith(str.WithAcronyms("DAO", "NFT", "DEFI"))
toSnake("DAOVoting") // "dao_voting"
```

**ToTitleCaseEnglish** skips articles, conjunctions, and prepositions mid-sentence:

```go
str.ToTitleCaseEnglish("a tale of two cities") // "A Tale of Two Cities"
```

**Reverse** reverses runes in a string.

```go
str.Reverse("hello") // "olleh"
```

**CollapseWhitespace** collapses all Unicode whitespace to a single space.

```go
str.CollapseWhitespace("hello   \t\n  world") // "hello world"
```

**SlugifyASCII** generates URL-safe ASCII slugs.

```go
str.SlugifyASCII("Hello, World!") // "hello-world"
```

**NaturalSortKey** returns a key that sorts naturally (numbers in numeric order).

```go
str.NaturalSortKey("file2")  // sorts before NaturalSortKey("file10")
```

## Format

**PadLeft** / **PadRight** pad to a target width (runes). Multi-char pads are truncated to hit exact width.

```go
str.PadLeft("0", 8)("1234")   // "00001234"
str.PadRight(".", 10)("hello") // "hello....."
```

**Truncate** truncates to a max length (runes) with an ellipsis. Length includes the ellipsis.

```go
str.Truncate(8, "...")("hello world") // "hello..."
```

**Substring** extracts a substring with negative indexing support.

```go
str.Substring(0, 3)("hello")  // "hel"
str.Substring(-3, 2)("abcde") // "cd"
```

**Wrap** wraps text at a given width with configurable behavior.

```go
str.Wrap(40)("long text...")                           // wraps before words (default)
str.Wrap(40, str.WrapAfterWord)("long text...")        // wraps after words
str.Wrap(76, str.WrapHardBreak)("base64encoded...")    // hard break at width
```

**Pluralize** selects singular or plural form based on count.

```go
str.Pluralize(1, "items")("item") // "item"
str.Pluralize(5, "items")("item") // "items"
```

## Generate

**RandomToken** generates cryptographically random strings using `crypto/rand`.

```go
str.RandomToken()                                                    // 20 alphanumeric chars
str.RandomToken(str.WithLength(32), str.WithCharset("0123456789"))   // 32 digits
str.RandomToken(str.WithPrefix("tok_"), str.WithLength(16))          // "tok_" + 16 random chars
```

## Search

**FuzzyMatch** scores haystack entries against a needle using JaroWinkler similarity. Returns matches with score >= 0.7, sorted by score descending. Case-insensitive.

```go
matches := str.FuzzyMatch("helo", []string{"hello", "help", "world"})
// matches[0].Value == "hello", matches[0].Score ≈ 0.93
```

**FuzzyMatchAll** returns all non-zero scores (no threshold).

## Measure

**Levenshtein** returns the edit distance between two strings.

```go
str.Levenshtein("kitten", "sitting") // 3
```

**JaroWinkler** returns a similarity score between 0.0 and 1.0.

```go
str.JaroWinkler("martha", "marhta") // ~0.96
```

## Pipeline Patterns

```go
// Normalize user input for storage
var normalizeInput = str.Pipe(
    str.TrimSpace,
    str.CollapseWhitespace,
)

// Generate URL slugs
var slugify = str.Pipe(
    str.TrimSpace,
    str.CollapseWhitespace,
    str.SlugifyASCII,
)

// Format log fields
var formatField = str.Pipe(
    str.TrimSpace,
    str.Truncate(50, "..."),
    str.PadRight(" ", 50),
)
```

## Roadmap

Future releases may add: transliteration, grapheme-aware reverse, Unicode-aware slugify, word/line diff, and template helpers.

## License

MIT


Case-insensitive implementation of the standard library's strings/bytes packages

strcase

String formatting like in Python or C# manner with the additional text formatting features

# Wissance/StringFormatter
[![Awesome Package](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
![GitHub go.mod Go version (subdirectory of monorepo)](https://img.shields.io/github/go-mod/go-version/wissance/stringFormatter?style=plastic) 
![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/wissance/stringFormatter?style=plastic) 
![GitHub issues](https://img.shields.io/github/issues/wissance/stringFormatter?style=plastic)
![GitHub Release Date](https://img.shields.io/github/release-date/wissance/stringFormatter) 
[![Wissance.StringFormatter CI](https://github.com/Wissance/stringFormatter/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/Wissance/stringFormatter/actions/workflows/ci.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/wissance/stringFormatter)](https://goreportcard.com/report/github.com/wissance/stringFormatter)
[![Coverage Status](https://coveralls.io/repos/github/Wissance/stringFormatter/badge.svg?branch=master)](https://coveralls.io/github/Wissance/stringFormatter?branch=master)

![String Formatter: a convenient string formatting tool](img/sf_logo_sm.png)

`StringFormatter` is a ***high-performance*** Go library for string (text) formatting. It offers a syntax *familiar* to `C#`, `Java` and `Python` developers (via template arguments - `{0}` (positional), `{name}` (named)), extensive argument formatting options (numbers, lists, code style), and a set of text utilities — all while being significantly fast as the standard `fmt` package and even more! Typical usage of `sf` are:
1. Create `e-mails`, `Messages` (`SMS`, `Telegram`, other `Notifications`) or other complicated text **based on templates**
2. Create a complicated log text with specific argument formatting
3. Use for **template-based src code generator**
4. Other text proccessing

Other important resources: 
* [Go Report Card A+](https://goreportcard.com/report/github.com/wissance/stringFormatter)
* [Coverage > 80%](https://coveralls.io/github/Wissance/stringFormatter)


## ✨ 1 Features

🔤 Flexible Syntax: Supports both indexed / positional (`{0}`) and named (`{user}`) *placeholders* in templates.

🎨 Advanced Formatting: Built-in directives for numbers (`HEX`, `BIN`), `floats`, `lists`, and code styles (camelCase, SNAKE_CASE).

🚀 Performance: Template formatting and slice conversion are even faster then `fmt`.

🛠 Utilities: Functions to convert `maps` and `slices` into strings with custom separators and formats.

:man_technologist: Safe : `StringFormatter` aka `sf` **is safe** (`SAST` and tests are running automatically on push) 

## 📦 2 Installation

```bash
go get github.com/Wissance/stringFormatter
```

## 🚀 3  Usage

### 3.1 Template Formatting

#### 3.1.1 By Argument Order (Format)
The Format function replaces `{n}` placeholders with the corresponding argument in the provided order.

```go
package main

import (
    "fmt"
    sf "github.com/Wissance/stringFormatter"
)

func main() {
    template := "Hello, {0}! Your balance is {1} USD."
    result := sf.Format(template, "Alex", 2500)
    fmt.Println(result)
    // Output: Hello, Alex! Your balance is 2500 USD.
}
```

#### 3.1.2 By Argument Name (FormatComplex)
The FormatComplex function uses a `map[string]any` to replace named placeholders like `{key}`.

```go
package main

import (
    "fmt"
    sf "github.com/Wissance/stringFormatter"
)

func main() {
    template := "User {user} (ID: {id}) logged into {app}."
    args := map[string]any{
        "user": "john_doe",
        "id":   12345,
        "app":  "dashboard",
    }
    result := sf.FormatComplex(template, args)
    fmt.Println(result)
    // Output: User john_doe (ID: 12345) logged into dashboard.
}
```

### 3.2 Advanced Argument Formatting
You can control how arguments are displayed by adding a colon (:) and a format specifier to the placeholder.

| Type | Specifier | Description | Example Template | Example Value | Output |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Numbers** | `:B` | Binary (without padding) | `"{0:B}"` | `15` | `1111` |
| | `:B8` | Binary with 8-digit padding | `"{0:B8}"` | `15` | `00001111` |
| | `:X` | Hexadecimal (lowercase) | `"{0:X}"` | `250` | `fa` |
| | `:X4` | Hexadecimal with 4-digit padding | `"{0:X4}"` | `250` | `00fa` |
| | `:o` | Octal | `"{0:o}"` | `11` | `14` |
| **Floating Point** | `:F` | Default float format | `"{0:F}"` | `10.4567890` | `10.456789` |
| | `:F2` | Float with 2 decimal places | `"{0:F2}"` | `10.4567890` | `10.46` |
| | `:F4` | Float with 4 decimal places | `"{0:F4}"` | `10.4567890` | `10.4568` |
| | `:F8` | Float with 8 decimal places | `"{0:F8}"` | `10.4567890` | `10.45678900` |
| | `:E2` | Scientific notation | `"{0:E2}"` | `191.0478` | `1.91e+02` |
| **Percentage** | `:P100` | Percentage (multiply by 100) | `"{0:P100}"` | `12` | `12%` |
| **Lists (Slices)** | `:L-` | Join with hyphen | `"{0:L-}"` | `[1 2 3]` | `1-2-3` |
| | `:L, ` | Join with comma and space | `"{0:L, }"` | `[1 2 3]` | `1, 2, 3` |
| **Code Styles** | `:c:snake` | Convert to snake_case | `"{0:c:snake}"` | `myFunc` | `my_func` |
| | `:c:Snake` | Convert to Snake_Case (PascalSnake) | `"{0:c:Snake}"` | `myFunc` | `My_Func` |
| | `:c:SNAKE` | Convert to SNAKE_CASE (upper) | `"{0:c:SNAKE}"` | `read-timeout` | `READ_TIMEOUT` |
| | `:c:camel` | Convert to camelCase | `"{0:c:camel}"` | `my_variable` | `myVariable` |
| | `:c:Camel` | Convert to CamelCase (PascalCase) | `"{0:c:Camel}"` | `my_variable` | `MyVariable` |
| | `:c:kebab` | Convert to kebab-case | `"{0:c:kebab}"` | `myVariable` | `my-variable` |
| | `:c:Kebab` | Convert to Kebab-Case (PascalKebab) | `"{0:c:Kebab}"` | `myVariable` | `My-Variable` |
| | `:c:KEBAB` | Convert to KEBAB-CASE (upper) | `"{0:c:KEBAB}"` | `myVariable` | `MY-VARIABLE` |

```go
package main

import (
    "fmt"
    sf "github.com/Wissance/stringFormatter"
)

func main() {
    template := "Status 0x{0:X4} (binary: {0:B8}), temp: {1:F1}°C, items: {2:L, }."
    result := sf.Format(template, 475, 23.876, []int{1, 2, 3})
    fmt.Println(result)
    // Output: Status 0x01DB (binary: 00011101), temp: 23.9°C, items: 1, 2, 3.
}
```

## 🛠 4 Text Utilities

### 4.1 Map to String (MapToString)
Converts a map with primitive keys to a formatted string.
```go
options := map[string]any{
    "host": "localhost",
    "port": 8080,
    "ssl":  true,
}

str := sf.MapToString(&options, "{key} = {value}", "\n")
// Possible output (key order is not guaranteed):
// host = localhost
// port = 8080
// ssl = true
```

### 4.2 Slice to String (SliceToString, SliceSameTypeToString)
Converts slices to a string using a specified separator.

```go
// For a slice of any type
mixedSlice := []any{100, "text", 3.14}
separator := " | "
result1 := sf.SliceToString(&mixedSlice, &separator)
// result1: "100 | text | 3.14"

// For a typed slice
numSlice := []int{10, 20, 30}
result2 := sf.SliceSameTypeToString(&numSlice, &separator)
// result2: "10 | 20 | 30"
```

## 📊 5 Benchmarks
The library is optimized for high-load scenarios. Key benchmarks show significant performance gains (performance could be differ due to 1. different CPU architectures 2. statistics):

Formatting (Format) vs fmt.Sprintf: 3-5x faster for complex templates.
Slices (SliceToString) vs manual fmt-based joining: from `2.5` faster up to 20 items.

Run the benchmarks yourself:
```bash
go test -bench=Format -benchmem -cpu 1
go test -bench=Fmt -benchmem -cpu 1
go test -bench=MapToStr -benchmem -cpu 1
```
Some benchmark screenshots:

1. `Format` and `FormatComplex`:
![Format](img/benchmarks2.png)

2. `MapToStr`:
![MapToStr benchmarks](img/map2str_benchmarks.png)

3. `SliceToStr`:
![SliceToStr benchmarks](img/slice2str_benchmarks.png)

## 📄 6 License
This project is licensed under the MIT License - see the LICENSE file for details.

## 🤝 7 Contributing
Contributions are welcome! If you find a bug or have a feature suggestion, please open an issue or submit a pull request.

**Contributors:**

<a href="https://github.com/Wissance/stringFormatter/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=Wissance/stringFormatter" />
</a>


The Best Go Libraries For Miscellaneous - Strings (9)