feat: Add randomstring library with basic functionality

This commit adds the randomstring library, which provides functionality for generating random strings based on specific characteristics. The library allows for generating strings with alphanumeric characters, letters only, digits only, special characters, or a custom character set. It also provides options to disable uppercase, lowercase, or numeric characters, and supports using a custom character set.

The library is added to the project to provide a convenient way to generate random strings for various purposes, such as generating passwords, tokens, or unique identifiers.

The license file and readme file are also added to provide information about the library and its usage. The license chosen for the library is the MIT License, which grants permission to use, copy, modify, merge, publish, distribute, sublicense, and/or sell the software.

Contributions to the library are welcome, and contributors are encouraged to open issues or pick up existing ones before making their contributions and submitting pull requests.

This commit addresses the need for a random string generation library and provides a starting point for using and contributing to the library.

test(randomstring): add unit tests for GenerateStringFromCharset and GenerateString functions
The new file `randomstring_test.go` contains unit tests for the `GenerateStringFromCharset` and `GenerateString` functions in the `randomstring` package. The tests cover various scenarios, including different charsets, lengths, and options. The purpose of these tests is to ensure the correctness and reliability of the `GenerateStringFromCharset` and `GenerateString` functions.

Author: necmettindev

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Necmettin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,84 @@
+# RandomString Generator
+
+This library assists in generating random strings based on specific characteristics. You can create random strings consisting of alphanumeric characters, letters only, digits only, special characters, or even a custom character set.
+
+## Features
+
+- Generate strings with alphanumeric, letters only, digits only, or special characters.
+- Ability to disable uppercase, lowercase, or numeric characters.
+- Option to use a custom character set.
+
+## Installation
+
+\```bash
+go get -u github.com/necmettindev/randomstring
+\```
+
+## Usage
+
+Below are different scenarios demonstrating how to use the `randomstring` package:
+
+### Basic Usage
+
+Generate a string of length 10 using the default alphanumeric characters:
+
+\```go
+package main
+
+import (
+"fmt"
+"github.com/necmettindev/randomstring"
+)
+
+func main() {
+result, \_ := randomstring.GenerateString(randomstring.GenerationOptions{Length: 10})
+fmt.Println(result)
+}
+\```
+
+### Disabling Features
+
+For instance, to generate a string containing letters only:
+
+\```go
+opts := randomstring.GenerationOptions{
+Length: 10,
+DisableNumeric: true,
+}
+result, \_ := randomstring.GenerateString(opts)
+fmt.Println(result)
+\```
+
+### Using Special Characters
+
+Generate a string with enabled special characters:
+
+\```go
+opts := randomstring.GenerationOptions{
+Length: 15,
+EnableSpecialCharacter: true,
+}
+result, \_ := randomstring.GenerateString(opts)
+fmt.Println(result)
+\```
+
+### Using a Custom Character Set
+
+Generate a string with your own custom character set:
+
+\```go
+opts := randomstring.GenerationOptions{
+Length: 12,
+CustomCharset: "abcXYZ789",
+}
+result, \_ := randomstring.GenerateString(opts)
+fmt.Println(result) // Produces a string consisting only of 'a', 'b', 'c', 'X', 'Y', 'Z', '7', '8', '9'.
+\```
+
+## Contributing
+
+If you wish to contribute to this project, please first open an issue or pick up an existing one. Then make your contribution and submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

go.mod

@@ -0,0 +1,3 @@
+module github.com/necmettindev/randomstring
+
+go 1.21.0

randomstring.go

@@ -0,0 +1,86 @@
+package randomstring
+
+import (
+	"crypto/rand"
+	"errors"
+	"math/big"
+	"strings"
+)
+
+type Charset string
+
+const (
+	Alphanumeric      = Charset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+	Lowercase         = Charset("abcdefghijklmnopqrstuvwxyz")
+	Uppercase         = Charset("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	Numeric           = Charset("0123456789")
+	SpecialCharacters = Charset("!@#$%^&*()-_=+[]{}|;:'<>,.?/~")
+)
+
+var (
+	GenerateString = generateString
+)
+
+type GenerationOptions struct {
+	Length                 int
+	DisableNumeric         bool
+	DisableLowercase       bool
+	DisableUppercase       bool
+	EnableSpecialCharacter bool
+	CustomCharset          Charset // Yeni eklenen alan: kullanıcı tanımlı karakter seti
+}
+
+func generateStringFromCharset(charset Charset, length int) (string, error) {
+	if len(charset) == 0 || length <= 0 {
+		return "", errors.New("invalid charset or length")
+	}
+
+	result := make([]byte, length)
+	charsetLen := big.NewInt(int64(len(charset)))
+	for i := 0; i < length; i++ {
+		randomIndex, err := rand.Int(rand.Reader, charsetLen)
+		if err != nil {
+			return "", err
+		}
+		result[i] = charset[randomIndex.Int64()]
+	}
+
+	return string(result), nil
+}
+func modifyCharset(opts GenerationOptions, charsetMappings map[string]Charset, charset Charset) Charset {
+	if opts.DisableNumeric {
+		charset = Charset(strings.ReplaceAll(string(charset), string(charsetMappings["numeric"]), ""))
+	}
+	if opts.DisableLowercase {
+		charset = Charset(strings.ReplaceAll(string(charset), string(charsetMappings["lowercase"]), ""))
+	}
+	if opts.DisableUppercase {
+		charset = Charset(strings.ReplaceAll(string(charset), string(charsetMappings["uppercase"]), ""))
+	}
+	if opts.EnableSpecialCharacter {
+		charset += charsetMappings["specialCharater"]
+	}
+	return charset
+}
+
+func generateString(opts GenerationOptions) (string, error) {
+	charsetMappings := map[string]Charset{
+		"numeric":         Numeric,
+		"lowercase":       Lowercase,
+		"uppercase":       Uppercase,
+		"specialCharater": SpecialCharacters,
+	}
+
+	charset := Alphanumeric
+	if opts.CustomCharset != "" {
+		charset = opts.CustomCharset
+	} else {
+		charset = modifyCharset(opts, charsetMappings, charset)
+	}
+
+	if len(charset) == 0 {
+		return "", errors.New("resulting charset is empty. adjust your options")
+	}
+
+	return generateStringFromCharset(charset, opts.Length)
+}

randomstring_test.go

@@ -0,0 +1,55 @@
+package randomstring
+
+import (
+	"testing"
+)
+
+func TestGenerateStringFromCharset(t *testing.T) {
+	tests := []struct {
+		charset Charset
+		length  int
+		err     bool
+	}{
+		{Alphanumeric, 10, false},
+		{Lowercase, 5, false},
+		{Uppercase, 5, false},
+		{Numeric, 5, false},
+		{SpecialCharacters, 5, false},
+		{Charset(""), 5, true},
+		{Alphanumeric, -5, true},
+	}
+
+	for _, tt := range tests {
+		result, err := generateStringFromCharset(tt.charset, tt.length)
+		if (err != nil) != tt.err {
+			t.Errorf("for charset %v and length %d, expected error: %v, got: %v", tt.charset, tt.length, tt.err, (err != nil))
+		}
+		if !tt.err && len(result) != tt.length {
+			t.Errorf("expected length %d, got %d", tt.length, len(result))
+		}
+	}
+}
+
+func TestGenerateString(t *testing.T) {
+	tests := []struct {
+		opts GenerationOptions
+		err  bool
+	}{
+		{GenerationOptions{Length: 10}, false},
+		{GenerationOptions{Length: 10, DisableNumeric: true, DisableLowercase: true, DisableUppercase: true}, true},
+		{GenerationOptions{Length: 10, DisableNumeric: true}, false},
+		{GenerationOptions{Length: 10, EnableSpecialCharacter: true}, false},
+		{GenerationOptions{Length: 10, CustomCharset: "abc123"}, false},
+		{GenerationOptions{Length: 0}, true},
+	}
+
+	for _, tt := range tests {
+		result, err := GenerateString(tt.opts)
+		if (err != nil) != tt.err {
+			t.Errorf("for options %+v, expected error: %v, got: %v", tt.opts, tt.err, (err != nil))
+		}
+		if !tt.err && len(result) != tt.opts.Length {
+			t.Errorf("expected length %d, got %d", tt.opts.Length, len(result))
+		}
+	}
+}