feat: GO언어 바인딩 추가

.github/workflows/publish.yml

@@ -723,3 +723,65 @@ jobs:
         with:
           name: nuget-packages
           path: packages/dotnet/**/nupkg/*.nupkg
+
+  # go
+  go-test:
+    name: Go Test - ${{ matrix.platform }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Windows x64
+          - runner: windows-latest
+            target: x86_64-pc-windows-gnu
+            platform: windows-amd64
+          # Linux x64
+          - runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            platform: linux-amd64
+          # Linux ARM64
+          - runner: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+            platform: linux-arm64
+          # macOS ARM64
+          - runner: macos-14
+            target: aarch64-apple-darwin
+            platform: darwin-arm64
+          # macOS x64
+          - runner: macos-13
+            target: x86_64-apple-darwin
+            platform: darwin-amd64
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          target: ${{ matrix.target }}
+
+      - name: Install cross-compilation tools (Linux ARM64)
+        if: matrix.platform == 'linux-arm64'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+
+      - name: Build native library
+        run: cargo build --release --target ${{ matrix.target }} -p braillify-go
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+
+      - name: Copy native library
+        run: |
+          mkdir -p packages/go/libs/${{ matrix.platform }}
+          cp target/${{ matrix.target }}/release/libbraillify_go.a packages/go/libs/${{ matrix.platform }}/
+        shell: bash
+
+      - name: Test
+        run: go test -v ./...
+        working-directory: packages/go

packages/go/.gitignore

@@ -0,0 +1,4 @@
+*.test
+*.exe
+*.out
+libs/

packages/go/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "braillify-go"
+version = "2.0.0"
+edition = "2024"
+
+[lib]
+name = "braillify_go"
+crate-type = ["cdylib", "staticlib"]
+
+[dependencies]
+braillify = { path = "../../libs/braillify", default-features = false }

packages/go/braillify.go

@@ -0,0 +1,16 @@
+package braillify
+
+// Encode converts Korean text to braille byte representation.
+func Encode(text string) ([]byte, error) {
+	return cEncode(text)
+}
+
+// EncodeToUnicode converts Korean text to braille Unicode string.
+func EncodeToUnicode(text string) (string, error) {
+	return cEncodeToUnicode(text)
+}
+
+// EncodeToBrailleFont converts Korean text to braille font string.
+func EncodeToBrailleFont(text string) (string, error) {
+	return cEncodeToBrailleFont(text)
+}

packages/go/braillify_test.go

@@ -0,0 +1,51 @@
+package braillify
+
+import "testing"
+
+func TestEncodeToUnicode(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"안녕하세요", "⠣⠒⠉⠻⠚⠠⠝⠬"},
+		{"상상이상의", "⠇⠶⠇⠶⠕⠇⠶⠺"},
+		{"1,000", "⠼⠁⠂⠚⠚⠚"},
+		{"ATM", "⠠⠠⠁⠞⠍"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		result, err := EncodeToUnicode(tt.input)
+		if err != nil {
+			t.Errorf("EncodeToUnicode(%q): unexpected error: %v", tt.input, err)
+			continue
+		}
+		t.Logf("EncodeToUnicode(%q) = %q", tt.input, result)
+		if result != tt.expected {
+			t.Errorf("EncodeToUnicode(%q) = %q, want %q", tt.input, result, tt.expected)
+		}
+	}
+}
+
+func TestEncode(t *testing.T) {
+	result, err := Encode("안녕")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	t.Logf("Encode(%q) = %v", "안녕", result)
+	if len(result) == 0 {
+		t.Error("expected non-empty byte slice")
+	}
+}
+
+func TestEncodeToBrailleFont(t *testing.T) {
+	result, err := EncodeToBrailleFont("안녕하세요")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	expected := "⠣⠒⠉⠻⠚⠠⠝⠬"
+	t.Logf("EncodeToBrailleFont(%q) = %q", "안녕하세요", result)
+	if result != expected {
+		t.Errorf("EncodeToBrailleFont = %q, want %q", result, expected)
+	}
+}

packages/go/cgo.go

@@ -0,0 +1,85 @@
+package braillify
+
+/*
+#cgo darwin,amd64 LDFLAGS: -L${SRCDIR}/libs/darwin-amd64 -lbraillify_go -lm -lpthread
+#cgo darwin,arm64 LDFLAGS: -L${SRCDIR}/libs/darwin-arm64 -lbraillify_go -lm -lpthread
+#cgo linux,amd64 LDFLAGS: -L${SRCDIR}/libs/linux-amd64 -lbraillify_go -lm -lpthread -ldl
+#cgo linux,arm64 LDFLAGS: -L${SRCDIR}/libs/linux-arm64 -lbraillify_go -lm -lpthread -ldl
+#cgo windows,amd64 LDFLAGS: -L${SRCDIR}/libs/windows-amd64 -lbraillify_go -lntdll -lws2_32 -lbcrypt -ladvapi32 -luserenv
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stddef.h>
+
+extern uint8_t* braillify_encode(const char* text, size_t* out_len);
+extern char* braillify_encode_to_unicode(const char* text);
+extern char* braillify_encode_to_braille_font(const char* text);
+extern char* braillify_get_last_error();
+extern void braillify_free_string(char* ptr);
+extern void braillify_free_bytes(uint8_t* ptr, size_t len);
+*/
+import "C"
+
+import (
+	"errors"
+	"runtime"
+	"unsafe"
+)
+
+func cEncode(text string) ([]byte, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cText := C.CString(text)
+	defer C.free(unsafe.Pointer(cText))
+
+	var outLen C.size_t
+	result := C.braillify_encode(cText, &outLen)
+	if result == nil {
+		return nil, getLastError()
+	}
+	defer C.braillify_free_bytes(result, outLen)
+
+	return C.GoBytes(unsafe.Pointer(result), C.int(outLen)), nil
+}
+
+func cEncodeToUnicode(text string) (string, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cText := C.CString(text)
+	defer C.free(unsafe.Pointer(cText))
+
+	result := C.braillify_encode_to_unicode(cText)
+	if result == nil {
+		return "", getLastError()
+	}
+	defer C.braillify_free_string(result)
+
+	return C.GoString(result), nil
+}
+
+func cEncodeToBrailleFont(text string) (string, error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	cText := C.CString(text)
+	defer C.free(unsafe.Pointer(cText))
+
+	result := C.braillify_encode_to_braille_font(cText)
+	if result == nil {
+		return "", getLastError()
+	}
+	defer C.braillify_free_string(result)
+
+	return C.GoString(result), nil
+}
+
+func getLastError() error {
+	errPtr := C.braillify_get_last_error()
+	if errPtr == nil {
+		return errors.New("braillify: unknown error")
+	}
+	defer C.braillify_free_string(errPtr)
+	return errors.New(C.GoString(errPtr))
+}

packages/go/go.mod

@@ -0,0 +1,3 @@
+module github.com/dev-five-git/braillify/packages/go
+
+go 1.21