Refactor xor package (#264)

* refactor the code

* update xor_cipher_test

Author: task4233

ciphers/xor/xorCipher.go

@@ -1,44 +1,34 @@
-package main
+// Package xor is an encryption algorithm that operates the exclusive disjunction(XOR)
+// ref: https://en.wikipedia.org/wiki/XOR_cipher
+package xor
 
-import "fmt"
-
-func encrypt(key int, plaintext []int) (ciphertext []int) {
-	for _, char := range plaintext {
-		ciphertext = append(ciphertext, xor(char, key))
-	}
-	return
-}
-func xor(char int, key int) int {
-	return (char ^ key)
+// Xor is struct for xor package
+type Xor struct {
 }
 
-func decrypt(key int, ciphertext []int) (plaintext []int) {
-	for _, char := range ciphertext {
-		plaintext = append(plaintext, xor(char, key))
-	}
-	return
+// NewXor returns a pointer to object of Xor.
+func NewXor() *Xor {
+	return &Xor{}
 }
 
-func decodeToString(slice []int) (str string) {
-	for _, v := range slice {
-		str += string(v)
+// Encrypt encrypts with Xor encryption after converting each character to byte
+// The returned value might not be readable because there is no guarantee
+// which is within the ASCII range
+// If using other type such as string, []int, or some other types,
+// add the statements for converting the type to []byte.
+func (x Xor) Encrypt(key byte, plaintext []byte) []byte {
+	cipherText := []byte{}
+	for _, ch := range plaintext {
+		cipherText = append(cipherText, key^ch)
 	}
-	return
+	return cipherText
 }
-func toASCII(slice []rune) []int {
-	var converted []int
-	for _, v := range slice {
-		converted = append(converted, int(v))
+
+// Decrypt decrypts with Xor encryption
+func (x Xor) Decrypt(key byte, cipherText []byte) []byte {
+	plainText := []byte{}
+	for _, ch := range cipherText {
+		plainText = append(plainText, key^ch)
 	}
-	return converted
-}
-func main() {
-	str := "hello world"
-	key := 97
-	temp := []rune(str)
-	message := toASCII(temp)
-	encrypted := encrypt(key, message)
-	decrypted := decrypt(key, encrypted)
-	plaintext := decodeToString(decrypted)
-	fmt.Println(plaintext)
+	return plainText
 }

ciphers/xor/xor_cipher_test.go

@@ -1,10 +1,30 @@
-package main
+package xor_test
 
 import (
+	"TheAlgorithms/Go/ciphers/xor"
+	"fmt"
 	"reflect"
 	"testing"
 )
 
+func ExampleNewXor() {
+	const (
+		seed = "Hello World"
+		key  = 97
+	)
+
+	x := xor.NewXor()
+	encrypted := x.Encrypt(byte(key), []byte(seed))
+	fmt.Printf("Encrypt=> key: %d, seed: %s, encryptedText: %v\n", key, seed, encrypted)
+
+	decrypted := x.Decrypt(byte(key), encrypted)
+	fmt.Printf("Decrypt=> key: %d, encryptedText: %v, DecryptedText: %s\n", key, encrypted, string(decrypted))
+
+	// Output:
+	// Encrypt=> key: 97, seed: Hello World, encryptedText: [41 4 13 13 14 65 54 14 19 13 5]
+	// Decrypt=> key: 97, encryptedText: [41 4 13 13 14 65 54 14 19 13 5], DecryptedText: Hello World
+}
+
 var xorTestData = []struct {
 	description string
 	input       string
@@ -61,16 +81,15 @@ var xorTestData = []struct {
 	},
 }
 
+var x *xor.Xor = xor.NewXor()
+
 func TestXorCipherEncrypt(t *testing.T) {
 	for _, test := range xorTestData {
 		t.Run(test.description, func(t *testing.T) {
-
-			message := toASCII([]rune(test.input))
-			encrypted := encrypt(test.key, message)
-
-			if actual := decodeToString(encrypted); !reflect.DeepEqual(actual, test.encrypted) {
+			encrypted := x.Encrypt(byte(test.key), []byte(test.input))
+			if !reflect.DeepEqual(string(encrypted), test.encrypted) {
 				t.Logf("FAIL: %s", test.description)
-				t.Fatalf("Expecting %s, actual %s", test.encrypted, actual)
+				t.Fatalf("Expecting %s, actual %s", test.encrypted, string(encrypted))
 			}
 		})
 	}
@@ -79,13 +98,11 @@ func TestXorCipherEncrypt(t *testing.T) {
 func TestXorCipherDecrypt(t *testing.T) {
 	for _, test := range xorTestData {
 		t.Run(test.description, func(t *testing.T) {
+			decrypted := x.Decrypt(byte(test.key), []byte(test.encrypted))
 
-			message := toASCII([]rune(test.encrypted))
-			decrypted := decrypt(test.key, message)
-
-			if actual := decodeToString(decrypted); !reflect.DeepEqual(actual, test.input) {
+			if !reflect.DeepEqual(string(decrypted), test.input) {
 				t.Logf("FAIL: %s", test.description)
-				t.Fatalf("Expecting %s, actual %s", test.input, actual)
+				t.Fatalf("Expecting %s, actual %s", test.input, string(decrypted))
 			}
 		})
 	}