Updated actions, fix some lint issues and introduce translate package

.gitea/workflows/demo.yaml

@@ -1,19 +0,0 @@
-name: Gitea Actions Demo
-run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀
-on: [push]
-
-jobs:
-  Explore-Gitea-Actions:
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo "🎉 The job was automatically triggered by a ${{ gitea.event_name }} event."
-      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by Gitea!"
-      - run: echo "🔎 The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - run: echo "💡 The ${{ gitea.repository }} repository has been cloned to the runner."
-      - run: echo "🖥️ The workflow is now ready to test your code on the runner."
-      - name: List files in the repository
-        run: |
-          ls ${{ gitea.workspace }}
-      - run: echo "🍏 This job's status is ${{ job.status }}."

bin/pattern-lookup/generatetable.go

@@ -100,7 +100,7 @@ func allFans() []pattern.Fan {
 
 func AllFansToFile() {
 	allFans := allFans()
-	pattern.FansToFile(allFans, "test.json")
+	_ = pattern.FansToFile(allFans, "test.json")
 }
 
 func GenerateFan(fan pattern.Fan) {

pkg/pattern/pattern.go

@@ -1,13 +1,13 @@
 package pattern
 
-type pattern struct {
-}
+// type pattern struct {
+// }
 
-type shun struct {
-}
+// type shun struct {
+// }
 
-type ke struct {
-}
+// type ke struct {
+// }
 
-type jiang struct {
-}
+// type jiang struct {
+// }

pkg/tiles/tiles.go

@@ -8,12 +8,12 @@ import (
 	"sort"
 )
 
-var TileTypes = [34]string{
+var TileTypes []string = []string{
 	"1W", "2W", "3W", "4W", "5W", "6W", "7W", "8W", "9W",
 	"1T", "2T", "3T", "4T", "5T", "6T", "7T", "8T", "9T",
 	"1B", "2B", "3B", "4B", "5B", "6B", "7B", "8B", "9B",
 	"DO", "XI", "NA", "BE", "ZH", "FA", "BA"}
-var tileHuaTypes = [8]string{"ME", "LA", "ZU", "JU", "CH", "XA", "QI", "DN"}
+var TileHuaTypes []string = []string{"ME", "LA", "ZU", "JU", "CH", "XA", "QI", "DN"}
 
 // Given two tiles, return if first tile is smaller the second tile, functions used as comparator for ordering
 // Default order is: 万 < 条 < 饼 < 字（东西南北中发白）
@@ -184,7 +184,7 @@ func CheckXushuTile(tiles []string) ([][][]string, error) {
 }
 
 func TilesDividedToPatterns(tiles []string) error {
-	Sort(tiles)
+	_ = Sort(tiles)
 	var wan, tiao, bing, zi []string
 	for _, tile := range tiles {
 		switch tile[1] {
@@ -198,5 +198,9 @@ func TilesDividedToPatterns(tiles []string) error {
 			zi = append(zi, tile)
 		}
 	}
+	_, _ = CheckXushuTile(wan)
+	_, _ = CheckXushuTile(tiao)
+	_, _ = CheckXushuTile(bing)
+	log.Println(zi)
 	return nil
 }

pkg/tiles/tiles_opts.go

@@ -1,5 +1,5 @@
 package tiles
 
-type tileStruct struct {
-	
-}
+// type tileStruct struct {
+
+// }

pkg/tiles/tiles_test.go

@@ -84,6 +84,5 @@ func TestCheckXushuTile(t *testing.T) {
 				log.Fatalf("TestCheckXushuTile(%v) = %v want %v", tc.Args, result, tc.Want)
 			}
 		})
-
 	}
 }

pkg/tiles/translate.go

@@ -0,0 +1,77 @@
+package tiles
+
+import (
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+var jpnZiPaiTileTypes []string = []string{"DO", "NA", "XI", "BE", "BA", "FA", "ZH"}
+
+// Translate numberized Zi Pai to 2-letter format
+// rule can be "CHN" or "JPN"
+// If rule is "CHN", it should translate as DO XI NA BE ZH FA BA
+// If rule is  "JPN", it should translate as DO NA XI BE BA FA ZH
+func ziPaiShortSplit(num int, rule string) (string, error) {
+	if num < 1 || num > 7 {
+		return "", fmt.Errorf("invalid zipai index %d", num)
+	}
+	switch rule {
+	case "CHN":
+		return TileTypes[num-1+27], nil
+	case "JPN":
+		return jpnZiPaiTileTypes[num-1], nil
+	}
+	return "", fmt.Errorf("error calling ziPaiShortSplit()")
+}
+
+func shortToArray(tiles string) ([]string, error) {
+	var ret []string
+	var stack []string
+	var rule string
+
+	// Check if it's jpn format
+	tiles = strings.ToUpper(tiles)
+	if strings.Contains(tiles, "M") || strings.Contains(tiles, "S") || strings.Contains(tiles, "P") {
+		rule = "JPN"
+	} else {
+		rule = "CHN"
+	}
+
+	for _, char := range tiles {
+		if unicode.IsDigit(char) {
+			stack = append(stack, string(char))
+		} else {
+			switch string(char) {
+			case "W", "M":
+				for _, prefix := range stack {
+					ret = append(ret, prefix+"W")
+				}
+			case "T", "S":
+				for _, prefix := range stack {
+					ret = append(ret, prefix+"T")
+				}
+			case "B", "P":
+				for _, prefix := range stack {
+					ret = append(ret, prefix+"B")
+				}
+			case "Z":
+				for _, prefix := range stack {
+					num, _ := strconv.Atoi(prefix)
+					ziPaiStr, _ := ziPaiShortSplit(num, rule)
+					ret = append(ret, ziPaiStr)
+				}
+			}
+			stack = []string{}
+		}
+	}
+	// Check return value valid, if not return error
+	for _, t := range ret {
+		if !slices.Contains(TileTypes, t) {
+			return []string{}, fmt.Errorf("invalid tile string with %s", t)
+		}
+	}
+	return ret, nil
+}

pkg/tiles/translate_test.go

@@ -0,0 +1,32 @@
+package tiles
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"testing"
+)
+
+func TestShortToArray(t *testing.T) {
+	type testcase struct {
+		Name string
+		Arg  string
+		Want []string
+	}
+	testcases := []testcase{
+		{Name: "自创格式", Arg: "12W56T456B1234567Z", Want: []string{"1W", "2W", "5T", "6T", "4B", "5B", "6B", "DO", "XI", "NA", "BE", "ZH", "FA", "BA"}},
+		{Name: "日麻格式", Arg: "1134m4p24s123677z6m", Want: []string{"1W", "1W", "3W", "4W", "4B", "2T", "4T", "DO", "NA", "XI", "FA", "ZH", "ZH", "6W"}},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.Name, func(t *testing.T) {
+			result, err := shortToArray(tc.Arg)
+			if err != nil {
+				log.Fatalf("Failed in translating tiles %s , error: %s", tc.Arg, err)
+			}
+			fmt.Println(result)
+			if !reflect.DeepEqual(result, tc.Want) {
+				log.Fatalf("Failed in translating tiles %s , expectd: %v, got %v", tc.Arg, tc.Want, result)
+			}
+		})
+	}
+}