Refactor/organize wails services (#19)

* refactor: Move Wails service bindings to internal/wails package

Moves all Wails service wrapper files from root directory to internal/wails/

for better organization and separation of concerns.

Changes:

- Moved: jwt_service.go, barcode_service.go, conversion_service.go,

         data_generator_service.go, codeformatter_service.go

- Updated package from 'main' to 'wails'

- Changed startup() to Startup() (exported method)

- Updated main.go and server.go imports

- Updated type references to use wails package

* fix: wrong be package, try to build proper binary for each platform

* fix: unit tests

* fix: unit tests path

Author: vuon9

.github/workflows/build.yml

@@ -67,19 +67,43 @@ jobs:
           fi
         shell: bash
 
-      # Upload build artifacts
+      # Package and upload build artifacts
+      - name: Package Artifacts
+        run: |
+          mkdir -p release
+          if [ "${{ matrix.os }}" = "macos-latest" ]; then
+            # macOS: create DMG using create-dmg
+            brew install create-dmg
+            create-dmg \
+              --volname "Dev-Toolbox" \
+              --window-pos 200 120 \
+              --window-size 800 400 \
+              --icon-size 100 \
+              --app-drop-link 600 185 \
+              "release/dev-toolbox-${{ matrix.build }}.dmg" \
+              "build/bin/dev-toolbox.app"
+          elif [ "${{ matrix.os }}" = "windows-latest" ]; then
+            # Windows: rename binary with .exe extension
+            mv build/bin/dev-toolbox build/bin/dev-toolbox.exe
+            cp build/bin/dev-toolbox.exe release/dev-toolbox-${{ matrix.build }}.exe
+          else
+            # Linux: create AppImage or tar.gz
+            tar -czf "release/dev-toolbox-${{ matrix.build }}.tar.gz" -C build/bin dev-toolbox
+          fi
+        shell: bash
+
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: Wails-Build-${{ matrix.os }}-${{ github.ref_name }}
-          path: build/bin/*
+          name: dev-toolbox-${{ matrix.build }}-${{ github.ref_name }}
+          path: release/*
 
       # Create Release and upload assets (only on tags)
       - name: Create Release
         if: startsWith(github.ref, 'refs/tags/v')
         uses: softprops/action-gh-release@v1
         with:
-          files: build/bin/*
+          files: release/*
           draft: false
           prerelease: false
           generate_release_notes: true

.github/workflows/tests.yml

@@ -51,10 +51,10 @@ jobs:
         run: go mod download
 
       - name: Run Go Tests
-        run: go test ./internal/converter/... -v -race
+        run: go test ./internal/... -v -race
 
       - name: Run Tests with Coverage
-        run: go test ./internal/converter/... -coverprofile=coverage.out
+        run: go test ./internal/... -coverprofile=coverage.out
 
       - name: Generate Coverage Report
         run: |

internal/codeformatter/service.go

@@ -269,55 +269,124 @@ func extractXMLAttributes(xmlStr, elementName, attrName string) (string, error)
 
 // formatXMLPretty formats XML with indentation
 func formatXMLPretty(xmlStr string) (string, error) {
-	var buf bytes.Buffer
-	encoder := json.NewEncoder(&buf)
-	encoder.SetIndent("", "  ")
+	// Use a simple but robust approach: tokenize and rebuild
+	type token struct {
+		typ   string // "decl", "open", "close", "selfclose", "text", "comment"
+		value string
+		name  string // for tags
+	}
+
+	var tokens []token
+	i := 0
+	for i < len(xmlStr) {
+		if xmlStr[i] == '<' {
+			// Find end of tag
+			end := i + 1
+			for end < len(xmlStr) && xmlStr[end] != '>' {
+				end++
+			}
+			if end >= len(xmlStr) {
+				break
+			}
+			tagContent := xmlStr[i+1 : end]
+			fullTag := xmlStr[i : end+1]
+
+			if strings.HasPrefix(tagContent, "?") {
+				tokens = append(tokens, token{typ: "decl", value: fullTag})
+			} else if strings.HasPrefix(tagContent, "!--") {
+				tokens = append(tokens, token{typ: "comment", value: fullTag})
+			} else if strings.HasPrefix(tagContent, "/") {
+				name := strings.TrimSpace(tagContent[1:])
+				tokens = append(tokens, token{typ: "close", value: fullTag, name: name})
+			} else if strings.HasSuffix(tagContent, "/") {
+				name := strings.TrimSpace(strings.TrimSuffix(tagContent, "/"))
+				if idx := strings.IndexAny(name, " \t"); idx != -1 {
+					name = name[:idx]
+				}
+				tokens = append(tokens, token{typ: "selfclose", value: fullTag, name: name})
+			} else {
+				name := strings.TrimSpace(tagContent)
+				if idx := strings.IndexAny(name, " \t"); idx != -1 {
+					name = name[:idx]
+				}
+				tokens = append(tokens, token{typ: "open", value: fullTag, name: name})
+			}
+			i = end + 1
+		} else {
+			// Text content
+			start := i
+			for i < len(xmlStr) && xmlStr[i] != '<' {
+				i++
+			}
+			text := strings.TrimSpace(xmlStr[start:i])
+			if text != "" {
+				tokens = append(tokens, token{typ: "text", value: text})
+			}
+		}
+	}
 
-	// Simple pretty printing - parse and re-serialize
-	// In production, use proper XML indentation
+	// Rebuild with proper indentation
 	var result strings.Builder
 	indent := 0
-	inTag := false
+	for j, tok := range tokens {
+		switch tok.typ {
+		case "decl":
+			result.WriteString(tok.value)
+			result.WriteByte('\n')
+		case "comment":
+			result.WriteString(strings.Repeat("  ", indent))
+			result.WriteString(tok.value)
+			result.WriteByte('\n')
+		case "open":
+			// Check if this is an inline element (text follows and then close)
+			isInline := false
+			if j+2 < len(tokens) && tokens[j+1].typ == "text" && tokens[j+2].typ == "close" && tokens[j+2].name == tok.name {
+				isInline = true
+			}
 
-	for i := 0; i < len(xmlStr); i++ {
-		ch := xmlStr[i]
+			if !isInline && result.Len() > 0 && !strings.HasSuffix(result.String(), "\n") {
+				result.WriteByte('\n')
+			}
+			if !isInline {
+				result.WriteString(strings.Repeat("  ", indent))
+			}
+			result.WriteString(tok.value)
+			if !isInline {
+				indent++
+			}
+		case "close":
+			// Check if previous was inline (open + text + close sequence)
+			wasInline := j >= 2 && tokens[j-2].typ == "open" && tokens[j-2].name == tok.name && tokens[j-1].typ == "text"
 
-		switch ch {
-		case '<':
-			if i+1 < len(xmlStr) && xmlStr[i+1] == '/' {
-				// Closing tag
+			if !wasInline {
 				indent--
-				if result.Len() > 0 && result.String()[result.Len()-1] == '\n' {
-					result.WriteString(strings.Repeat("  ", indent))
+				if indent < 0 {
+					indent = 0
+				}
+				if result.Len() > 0 && !strings.HasSuffix(result.String(), "\n") {
+					result.WriteByte('\n')
 				}
+				result.WriteString(strings.Repeat("  ", indent))
 			}
-			result.WriteByte(ch)
-			inTag = true
-		case '>':
-			result.WriteByte(ch)
-			inTag = false
-			if i+1 < len(xmlStr) && xmlStr[i+1] != '<' && xmlStr[i+1] != ' ' && xmlStr[i+1] != '\t' && xmlStr[i+1] != '\n' {
-				// Content follows
-			} else if i+1 < len(xmlStr) && xmlStr[i+1] == '<' && xmlStr[i+2] != '/' {
-				// Opening tag follows
-				indent++
+			result.WriteString(tok.value)
+			if j < len(tokens)-1 {
 				result.WriteByte('\n')
-				result.WriteString(strings.Repeat("  ", indent))
-			} else if i+1 < len(xmlStr) && xmlStr[i+1] == '<' && xmlStr[i+2] == '/' {
-				// Closing tag follows
+			}
+		case "selfclose":
+			if result.Len() > 0 && !strings.HasSuffix(result.String(), "\n") {
 				result.WriteByte('\n')
-				result.WriteString(strings.Repeat("  ", indent))
 			}
-		case '\n', '\t':
-			if !inTag {
-				// Skip whitespace outside tags
+			result.WriteString(strings.Repeat("  ", indent))
+			result.WriteString(tok.value)
+			if j < len(tokens)-1 {
+				result.WriteByte('\n')
 			}
-		default:
-			result.WriteByte(ch)
+		case "text":
+			result.WriteString(tok.value)
 		}
 	}
 
-	return result.String(), nil
+	return strings.TrimSpace(result.String()), nil
 }
 
 // minifyXML removes whitespace from XML