Simplify function names

README.md

@@ -1,8 +1,11 @@
 ![persian-faker](https://socialify.git.ci/sepisoltani/persian-faker/image?description=1&font=Inter&forks=1&issues=1&language=1&name=1&owner=1&pattern=Circuit%20Board&pulls=1&stargazers=1&theme=Light)
+
 # Persian Faker
+
 [![codecov](https://codecov.io/gh/sepisoltani/persian-faker/graph/badge.svg?token=H0C0NFE9PM)](https://codecov.io/gh/sepisoltani/persian-faker)
 
-The `persian-faker` is a specialized Go package designed to generate realistic Persian fake data, ideal for populating test data or simulating user data in applications that require Persian locale-specific data.
+The `persian-faker` is a specialized Go package designed to generate realistic Persian fake data, ideal for populating
+test data or simulating user data in applications that require Persian locale-specific data.
 
 ## Installation
 
@@ -13,90 +16,116 @@ go get github.com/sepisoltani/persian-faker
 ```
 
 ## Quick Start
+
 Here's how you can start using the persian-faker to generate various types of fake data:
 
 ### Importing the Package
+
 ```go
 import persianfaker "github.com/sepisoltani/persian-faker"
 ```
 
 ### Creating a Data Generator
 
 ```go
-var generator = persianfaker.NewDataGenerator()
+var generator = persianfaker.New()
 ```
 
 ### Name Provider
+
 * Generate a random Persian first name:
+
 ```go
-var firstName = generator.Name.GenerateFirstName()
+var firstName = generator.Name.FirstName()
 ```
+
 * Generate a random Persian last name:
+
 ```go
-var firstName = generator.Name.GenerateLastName()
+var lastName = generator.Name.LastName()
 ```
+
 * Generate a random Persian full name:
+
 ```go
-var firstName = generator.Name.GenerateFullName()
+var fullName = generator.Name.FullName()
 ```
 
 ### Phone Number Provider
+
 * Generate a random Persian mobile number:
+
 ```go
-var mobileNumber = generator.PhoneNumber.GeneratePersianMobileNumber()
+var phoneNumber = generator.PhoneNumber.PhoneNumber()
 ```
 
 ### Location Provider
+
 * Generate a random province:
+
 ```go
-var province = generator.Location.GenerateProvince()
+var province = generator.Location.Province()
 ```
 
 * Generate a random city:
+
 ```go
-var province = generator.Location.GenerateCity()
+var city = generator.Location.City()
 ```
 
 * Generate a random country:
+
 ```go
-var province = generator.Location.GenerateCountry()
+var country = generator.Location.Country()
 ```
 
 * Generate a random address:
+
 ```go
-var address = generator.Location.GeneratePersianAddress()
+var address = generator.Location.Address()
 ```
 
 ### Bank Provider
+
 * Generate a random Persian bank name:
+
 ```go
-var bankName = generator.Bank.GenerateBankName()
+var bankName = generator.Bank.BankName()
 ```
 
 * Generate a random Persian bank IBAN:
+
 ```go
-var iban = generator.Bank.GenerateBankIBAN()
+var iban = generator.Bank.IBAN()
 ```
 
 * Generate a random bank card number:
+
 ```go
-var cardNumber = generator.Bank.GenerateBankCardNumber()
+var cardNumber = generator.Bank.CardNumber()
 ```
 
 ### Digit Provider
+
 * Generate a Persian digit:
+
 ```go
-var digit = generator.Digit.GeneratePersianDigit()
+var digit = generator.Digit.Digit()
 ```
 
 ### Bill Provider
+
 * Generate a random bill type:
+
 ```go
-var billType = generator.Bill.GenerateBillType()
+var billType = generator.Bill.BillType()
 ```
 
 ## Contributing
-We welcome contributions to improve the package. If you have suggestions or improvements, please fork the repository and submit a pull request.
+
+We welcome contributions to improve the package. If you have suggestions or improvements, please fork the repository and
+submit a pull request.
 
 ## License
+
 This project is licensed under the MIT License. See the LICENSE file for more information.

generator.go

@@ -19,7 +19,7 @@ type DataGenerator struct {
 	Name        *name.Name
 }
 
-func NewDataGenerator() *DataGenerator {
+func New() *DataGenerator {
 	return &DataGenerator{
 		Bank:        &bank.Bank{},
 		Bill:        &bill.Bill{},

generator_test.go

@@ -0,0 +1,58 @@
+package persianfaker
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/sepisoltani/persian-faker/providers/bank"
+	"github.com/sepisoltani/persian-faker/providers/bill"
+	"github.com/sepisoltani/persian-faker/providers/digit"
+	"github.com/sepisoltani/persian-faker/providers/location"
+	"github.com/sepisoltani/persian-faker/providers/name"
+	"github.com/sepisoltani/persian-faker/providers/phonenumber"
+)
+
+// TestNewDataGenerator tests the New function for proper initialization of DataGenerator.
+func TestNewDataGenerator(t *testing.T) {
+	dg := New()
+
+	// Test if all the struct fields are initialized and not nil
+	if dg.Bank == nil {
+		t.Error("Expected Bank to be initialized, got nil")
+	}
+	if dg.Bill == nil {
+		t.Error("Expected Bill to be initialized, got nil")
+	}
+	if dg.Digit == nil {
+		t.Error("Expected Digit to be initialized, got nil")
+	}
+	if dg.PhoneNumber == nil {
+		t.Error("Expected PhoneNumber to be initialized, got nil")
+	}
+	if dg.Location == nil {
+		t.Error("Expected Location to be initialized, got nil")
+	}
+	if dg.Name == nil {
+		t.Error("Expected Name to be initialized, got nil")
+	}
+
+	// Test if the types of all fields are correctly set
+	if reflect.TypeOf(dg.Bank).Elem() != reflect.TypeOf(bank.Bank{}) {
+		t.Errorf("Expected Bank type to be *bank.Bank, got %T", dg.Bank)
+	}
+	if reflect.TypeOf(dg.Bill).Elem() != reflect.TypeOf(bill.Bill{}) {
+		t.Errorf("Expected Bill type to be *bill.Bill, got %T", dg.Bill)
+	}
+	if reflect.TypeOf(dg.Digit).Elem() != reflect.TypeOf(digit.Digit{}) {
+		t.Errorf("Expected Digit type to be *digit.Digit, got %T", dg.Digit)
+	}
+	if reflect.TypeOf(dg.PhoneNumber).Elem() != reflect.TypeOf(phonenumber.PhoneNumber{}) {
+		t.Errorf("Expected PhoneNumber type to be *phonenumber.PhoneNumber, got %T", dg.PhoneNumber)
+	}
+	if reflect.TypeOf(dg.Location).Elem() != reflect.TypeOf(location.Location{}) {
+		t.Errorf("Expected Location type to be *location.Location, got %T", dg.Location)
+	}
+	if reflect.TypeOf(dg.Name).Elem() != reflect.TypeOf(name.Name{}) {
+		t.Errorf("Expected Name type to be *name.Name, got %T", dg.Name)
+	}
+}

providers/bank/bank.go

@@ -10,8 +10,8 @@ var rng = rand.New(rand.NewSource(time.Now().UnixNano()))
 
 type Bank struct{}
 
-// GenerateBankIBAN generates a random Persian bank IBAN number.
-func (Bank) GenerateBankIBAN() string {
+// IBAN generates a random Persian bank IBAN number.
+func (Bank) IBAN() string {
 	sheba := "IR"
 	for i := 0; i < 24; i++ {
 		digit := rng.Intn(10)
@@ -20,8 +20,8 @@ func (Bank) GenerateBankIBAN() string {
 	return sheba
 }
 
-// GenerateBankCardNumber generates a bank card number.
-func (Bank) GenerateBankCardNumber() string {
+// CardNumber generates a bank card number.
+func (Bank) CardNumber() string {
 	cardNumber := "6037"
 	for i := 0; i < 12; i++ {
 		digit := rng.Intn(10)
@@ -30,8 +30,8 @@ func (Bank) GenerateBankCardNumber() string {
 	return cardNumber
 }
 
-// GenerateBankName returns a random Persian bank name from a predefined list.
-func (Bank) GenerateBankName() string {
+// BankName returns a random Persian bank name from a predefined list.
+func (Bank) BankName() string {
 	bankNames := []string{
 		"بانک ملی ایران", "بانک سپه", "بانک تجارت", "بانک ملت",
 		"بانک صادرات ایران", "بانک کشاورزی", "بانک مسکن", "بانک صنعت و معدن",

providers/bank/bank_test.go

@@ -5,26 +5,26 @@ import (
 	"testing"
 )
 
-// TestGenerateBankIBAN ensures that the IBAN generated is in the correct format.
-func TestGenerateBankIBAN(t *testing.T) {
+// TestIBAN ensures that the IBAN generated is in the correct format.
+func TestIBAN(t *testing.T) {
 	bank := &Bank{}
-	sheba := bank.GenerateBankIBAN()
+	iban := bank.IBAN()
 	expectedPattern := `^IR[0-9]{24}$`
 
 	re := regexp.MustCompile(expectedPattern)
-	if !re.MatchString(sheba) {
-		t.Errorf("Generated IBAN is invalid. Got: %s, Expected pattern: %s", sheba, expectedPattern)
+	if !re.MatchString(iban) {
+		t.Errorf("Generated IBAN is invalid. Got: %s, Expected pattern: %s", iban, expectedPattern)
 	}
 
-	if len(sheba) != 26 {
-		t.Errorf("Generated IBAN length is incorrect. Expected 26, got: %d", len(sheba))
+	if len(iban) != 26 {
+		t.Errorf("Generated IBAN length is incorrect. Expected 26, got: %d", len(iban))
 	}
 }
 
-// TestGenerateBankCardNumber ensures that the bank card number generated is in the correct format.
-func TestGenerateBankCardNumber(t *testing.T) {
+// TestCardNumber ensures that the bank card number generated is in the correct format.
+func TestCardNumber(t *testing.T) {
 	bank := &Bank{}
-	cardNumber := bank.GenerateBankCardNumber()
+	cardNumber := bank.CardNumber()
 	expectedPattern := `^6037[0-9]{12}$`
 
 	re := regexp.MustCompile(expectedPattern)
@@ -37,10 +37,10 @@ func TestGenerateBankCardNumber(t *testing.T) {
 	}
 }
 
-// TestGenerateBankName checks if the returned bank name is from the list of defined bank names.
-func TestGenerateBankName(t *testing.T) {
+// TestBankName checks if the returned bank name is from the list of defined bank names.
+func TestBankName(t *testing.T) {
 	bank := &Bank{}
-	bankName := bank.GenerateBankName() // Use the GenerateBankName method
+	bankName := bank.BankName() // Use the GenerateBankName method
 	validBankNames := map[string]bool{
 		"بانک ملی ایران":            true,
 		"بانک سپه":                  true,

providers/bill/bill.go

@@ -24,8 +24,8 @@ var billTypes = map[int]string{
 	11: "تلویزیون",
 }
 
-// GenerateBillType returns a random bill type from the map.
-func (Bill) GenerateBillType() string {
+// BillType returns a random bill type from the map.
+func (Bill) BillType() string {
 
 	keys := make([]int, 0, len(billTypes))
 	for k := range billTypes {

providers/bill/bill_test.go

@@ -4,10 +4,10 @@ import (
 	"testing"
 )
 
-// TestGenerateBillType checks if the returned bill type is in the billTypes map.
-func TestGenerateBillType(t *testing.T) {
+// TestBillType checks if the returned bill type is in the billTypes map.
+func TestBillType(t *testing.T) {
 	bill := &Bill{}
-	result := bill.GenerateBillType()
+	result := bill.BillType()
 	found := false
 
 	for _, v := range billTypes {
@@ -17,6 +17,6 @@ func TestGenerateBillType(t *testing.T) {
 		}
 	}
 	if !found {
-		t.Errorf("GenerateBillType returned an invalid bill type: %s", result)
+		t.Errorf("BillType returned an invalid bill type: %s", result)
 	}
 }

providers/digit/digit.go

@@ -13,7 +13,7 @@ var faNums = []string{"۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹"
 type Digit struct {
 }
 
-// GeneratePersianDigit returns a random Persian digit.
-func (Digit) GeneratePersianDigit() string {
+// Digit returns a random Persian digit.
+func (Digit) Digit() string {
 	return faNums[rng.Intn(len(faNums))]
 }

providers/digit/digit_test.go

@@ -4,10 +4,10 @@ import (
 	"testing"
 )
 
-// TestGeneratePersianDigit checks if the digit returned by GeneratePersianDigit is one of the valid Persian digits.
-func TestGeneratePersianDigit(t *testing.T) {
+// TestDigit checks if the digit returned by Digit is one of the valid Persian digits.
+func TestDigit(t *testing.T) {
 	d := &Digit{}
-	digit := d.GeneratePersianDigit()
+	digit := d.Digit()
 	found := false
 	for _, d := range faNums {
 		if d == digit {
@@ -16,6 +16,6 @@ func TestGeneratePersianDigit(t *testing.T) {
 		}
 	}
 	if !found {
-		t.Errorf("GeneratePersianDigit returned an invalid digit: %s", digit)
+		t.Errorf("Digit returned an invalid digit: %s", digit)
 	}
 }

providers/location/address.go

@@ -33,8 +33,8 @@ func randomElement(items []string) string {
 	return items[rand.Intn(len(items))]
 }
 
-// GeneratePersianAddress generates a random Persian address.
-func (Location) GeneratePersianAddress() string {
+// Address generates a random Persian address.
+func (Location) Address() string {
 	// Construct the address from the parts
 	return fmt.Sprintf("%s %s %s %s %s %s %s",
 		cityPrefix,

providers/location/address_test.go

@@ -6,10 +6,10 @@ import (
 	"testing"
 )
 
-// TestGeneratePersianAddress verifies that the format of the generated address is correct.
-func TestGeneratePersianAddress(t *testing.T) {
+// TestAddress verifies that the format of the generated address is correct.
+func TestAddress(t *testing.T) {
 	location := &Location{}
-	address := location.GeneratePersianAddress()
+	address := location.Address()
 	// Split the address into components based on spaces
 	parts := strings.Fields(address)