Rewrite as go-randomstring (v1.0.0)

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Vet & Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+
+      - name: Verify formatting
+        run: test -z "$(gofmt -l .)"
+
+      - name: Vet
+        run: go vet ./...
+
+      - name: Test
+        run: go test ./...

.gitignore

@@ -13,3 +13,9 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# IDE
+.idea/
+
+# Claude Code local settings
+.claude/settings.local.json

README.md

@@ -1,37 +1,125 @@
-# go-string-randomizer
+# go-randomstring
 
-Go-string-randomizer is a simple but powerfull random strings generator for GO. 
-You can use it to generate random ids, passwords, etc.
+> Fast, flexible random string generation for Go — ids, tokens, and passwords in one small, dependency-free package.
 
-The package also includes a usefull collection of chars that can be used as argument LettersUniverse.
+[![Go Reference](https://pkg.go.dev/badge/github.com/gbbocchini/go-randomstring.svg)](https://pkg.go.dev/github.com/gbbocchini/go-randomstring)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gbbocchini/go-randomstring)](https://goreportcard.com/report/github.com/gbbocchini/go-randomstring)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔤 **Flexible character sets** — seven built-in universes, or bring your own (Unicode included).
+- 🔒 **Crypto-secure mode** — draw from `crypto/rand` for passwords and security tokens.
+- 🔁 **Unique batches** — generate thousands of guaranteed-distinct strings in one call.
+- 🎲 **Deterministic output** — pin a `Seed` for reproducible results in tests.
+- 🚀 **Fast** — an ASCII fast path with zero dependencies beyond the standard library.
 
 ## Installation
 
 ```bash
-go get github.com/gbbocchini/go-string-randomizer
+go get github.com/gbbocchini/go-randomstring
+```
+
+## Quick start
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/gbbocchini/go-randomstring"
+)
+
+func main() {
+	r := randomstring.Randomizer{
+		Universe: randomstring.LowerUpperDigits,
+		Length:   13,
+	}
+	id, err := r.GenerateOne()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(id)
+}
 ```
 
 ## Usage
 
+### Basic generation
+
+```go
+r := randomstring.Randomizer{
+	Universe: randomstring.LowerLetters,
+	Length:   8,
+}
+id, err := r.GenerateOne()
+```
+
+### Unique batches
+
+Set `Unique` to guarantee every string in a batch is distinct:
+
 ```go
-import "github.com/gbbocchini/go-string-randomizer"
+r := randomstring.Randomizer{
+	Universe: randomstring.LowerUpperDigits,
+	Length:   8,
+	Unique:   true,
+}
+ids, err := r.Generate(10_000) // 10,000 distinct ids
+```
+
+### Crypto-secure passwords
 
-randomizer := StringRandomizer{
-    LettersUniverse: LOWER_UPPER_LETTERS_NUMS,
-    GeneratedMaxLen: 13,
-    NoCollisions:    true,
-    RandSeed:        123,
+```go
+r := randomstring.Randomizer{
+	Universe: randomstring.LowerUpperDigitsSymbols,
+	Length:   32,
+	Secure:   true,
 }
+password, err := r.GenerateOne()
+```
 
-one := randomizer.GenerateOne()
+### Deterministic output (great for tests)
 
-bulk := randomizer.GenerateBulk(1000000)
+```go
+r := randomstring.Randomizer{
+	Universe: randomstring.LowerUpperDigits,
+	Length:   13,
+	Seed:     1,
+}
+id, _ := r.GenerateOne() // always "9g14r5YgIsx9v"
 ```
 
+### Custom universe
+
+```go
+r := randomstring.Randomizer{
+	Universe: "ABC123", // only these characters
+	Length:   6,
+}
+```
+
+### Built-in character sets
+
+| Constant | Contents |
+| --- | --- |
+| `LowerLetters` | `a-z` |
+| `UpperLetters` | `A-Z` |
+| `Digits` | `0-9` |
+| `Symbols` | `!@#$%&*()-_+={};:.,` |
+| `LowerUpperLetters` | `a-z` + `A-Z` |
+| `LowerUpperDigits` | `a-z` + `A-Z` + `0-9` |
+| `LowerUpperDigitsSymbols` | `a-z` + `A-Z` + `0-9` + symbols |
+
+## Documentation
+
+Full API reference is available on [pkg.go.dev](https://pkg.go.dev/github.com/gbbocchini/go-randomstring).
+
 ## Contributing
-Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
 
-Please make sure to update tests as appropriate.
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change, and update tests as appropriate.
 
 ## License
-[MIT](https://choosealicense.com/licenses/mit/)
+
+[MIT](LICENSE) © Gabriel Bocchini

charsets.go

@@ -0,0 +1,24 @@
+package randomstring
+
+// LowerLetters contains the lowercase ASCII letters a-z.
+const LowerLetters = "abcdefghijklmnopqrstuvwxyz"
+
+// UpperLetters contains the uppercase ASCII letters A-Z.
+const UpperLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+// Digits contains the decimal digits 0-9.
+const Digits = "0123456789"
+
+// Symbols contains a set of common punctuation and symbol characters.
+const Symbols = "!@#$%&*()-_+={};:.,"
+
+// LowerUpperLetters contains all lowercase and uppercase ASCII letters.
+const LowerUpperLetters = LowerLetters + UpperLetters
+
+// LowerUpperDigits contains all lowercase and uppercase ASCII letters plus
+// digits.
+const LowerUpperDigits = LowerLetters + UpperLetters + Digits
+
+// LowerUpperDigitsSymbols contains all lowercase and uppercase ASCII letters,
+// digits, and symbols.
+const LowerUpperDigitsSymbols = LowerUpperDigits + Symbols

doc.go

@@ -0,0 +1,17 @@
+// Package randomstring generates random strings for use as identifiers,
+// tokens, passwords, and anywhere else you need short, configurable random
+// text.
+//
+// The core type is Randomizer, configured through exported struct fields:
+//
+//	r := randomstring.Randomizer{
+//		Universe: randomstring.LowerUpperDigits,
+//		Length:   13,
+//		Unique:   true,
+//	}
+//	id, err := r.GenerateOne()
+//
+// The package also provides ready-made character sets (LowerLetters,
+// UpperLetters, Digits, Symbols, and their common combinations) that can be
+// passed as a Randomizer's Universe.
+package randomstring

example_test.go

@@ -0,0 +1,49 @@
+package randomstring_test
+
+import (
+	"fmt"
+
+	"github.com/gbbocchini/go-randomstring"
+)
+
+func ExampleRandomizer_GenerateOne() {
+	r := randomstring.Randomizer{
+		Universe: randomstring.LowerUpperDigits,
+		Length:   13,
+		Seed:     1,
+	}
+	id, err := r.GenerateOne()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(id)
+	// Output: 9g14r5YgIsx9v
+}
+
+func ExampleRandomizer_Generate() {
+	r := randomstring.Randomizer{
+		Universe: randomstring.LowerUpperDigits,
+		Length:   8,
+		Unique:   true,
+	}
+	ids, err := r.Generate(1000)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(len(ids))
+	// Output: 1000
+}
+
+func ExampleRandomizer_GenerateOne_secure() {
+	r := randomstring.Randomizer{
+		Universe: randomstring.LowerUpperDigitsSymbols,
+		Length:   32,
+		Secure:   true,
+	}
+	token, err := r.GenerateOne()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(len(token))
+	// Output: 32
+}

go.mod

@@ -1,3 +1,3 @@
-module github.com/gbbocchini/go-string-randomizer
+module github.com/gbbocchini/go-randomstring
 
-go 1.18
+go 1.23