combine tools into single binary

Author: randilfernando

.github/workflows/publish-version.yml

@@ -0,0 +1,53 @@
+name: Publish version
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  create_tag:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Step 1: Checkout the repository
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      # Step 2: Set up Git for tagging
+      - name: Set up Git for tagging
+        run: |
+          git config user.name "${{ github.actor }}"
+          git config user.email "${{ github.actor }}@users.noreply.github.com"
+
+      # Step 3: Get the latest tag and increment the minor version
+      - name: Get latest tag and increment
+        id: get_tag
+        run: |
+          # Fetch all tags
+          git fetch --tags
+
+          # Get the latest tag version
+          latest_tag=$(git describe --tags --abbrev=0 || echo "v0.0.0")
+          echo "Latest tag: $latest_tag"
+
+          # Extract the version numbers (major, minor, patch)
+          major=$(echo $latest_tag | cut -d. -f1 | cut -dv -f2)
+          minor=$(echo $latest_tag | cut -d. -f2)
+          patch=$(echo $latest_tag | cut -d. -f3)
+
+          # Increment the minor version and reset patch to 0
+          new_minor=$((minor + 1))
+          new_version="v${major}.${new_minor}.0"
+
+          # Write the new version to the GITHUB_OUTPUT file for later use
+          echo "tag=$new_version" >> $GITHUB_OUTPUT
+
+      # Step 4: Create and push the new tag
+      - name: Create new tag
+        run: |
+          new_tag="${{ steps.get_tag.outputs.tag }}"
+          git tag $new_tag
+          git push origin $new_tag

.gitignore

@@ -0,0 +1,25 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+
+.idea
+*.iml
+**/.DS_Store

core/generator.go

@@ -0,0 +1,9 @@
+package core
+
+import "github.com/fsnotify/fsnotify"
+
+type Generator interface {
+	Init() error
+	OnChange(appPath string, outputPath string, event fsnotify.Event) error
+	Generate(appPath string, outputPath string) error
+}

go.mod

@@ -0,0 +1,7 @@
+module github.com/cloudimpl/polycode
+
+go 1.24.5
+
+require github.com/fsnotify/fsnotify v1.7.0
+
+require golang.org/x/sys v0.20.0 // indirect

go.sum

@@ -0,0 +1,4 @@
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

go/generate.go

@@ -0,0 +1,115 @@
+package _go
+
+import (
+	"fmt"
+	"github.com/fsnotify/fsnotify"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+// isGoImportsAvailable checks if the `goimports` command is available
+func isGoImportsAvailable() bool {
+	_, err := exec.LookPath("goimports")
+	return err == nil
+}
+
+// installGoImports installs the `goimports` tool using `go install`
+func installGoImports() error {
+	cmd := exec.Command("go", "install", "golang.org/x/tools/cmd/goimports@latest")
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func buildProject(appPath, outPath string) error {
+	absAppPath, err := filepath.Abs(appPath)
+	if err != nil {
+		fmt.Println("failed to resolve absolute app path:", err)
+		return err
+	}
+
+	// Step 1: go mod download
+	cmdDownload := exec.Command("go", "mod", "download")
+	cmdDownload.Dir = absAppPath
+	cmdDownload.Stdout = os.Stdout
+	cmdDownload.Stderr = os.Stderr
+	if err := cmdDownload.Run(); err != nil {
+		fmt.Println("failed to download modules:", err)
+		return err
+	}
+
+	// Step 2: GOOS=linux GOARCH=amd64 go build -o "$OUT_PATH" .
+	cmdBuild := exec.Command("go", "build", "-o", outPath, ".")
+	cmdBuild.Dir = absAppPath
+	cmdBuild.Env = append(os.Environ(),
+		"GOOS=linux",
+		"GOARCH=amd64",
+	)
+	cmdBuild.Stdout = os.Stdout
+	cmdBuild.Stderr = os.Stderr
+	if err := cmdBuild.Run(); err != nil {
+		fmt.Println("failed to build binary:", err)
+		return err
+	}
+
+	fmt.Println("build completed successfully:", outPath)
+	return nil
+}
+
+type Generator struct {
+}
+
+func (g *Generator) Init() error {
+	// Check if `goimports` is installed
+	if !isGoImportsAvailable() {
+		log.Println("goimports is not installed. Installing now...")
+
+		err := installGoImports()
+		if err != nil {
+			log.Printf("failed to install goimports: %s\nplease install it manually by running:\n\tgo install golang.org/x/tools/cmd/goimports@latest\n", err.Error())
+			return err
+		}
+
+		log.Println("goimports successfully installed.")
+	}
+
+	return nil
+}
+
+func (g *Generator) OnChange(appPath string, outputPath string, event fsnotify.Event) error {
+	if IsGoFile(event.Name) {
+		if err := CheckFileCompilable(event.Name); err == nil {
+			log.Printf("change detected in: %s, triggering generate\n", event.Name)
+			return g.Generate(appPath, outputPath)
+		} else {
+			log.Printf("file not compilable: %s, error: %s\n", event.Name, err.Error())
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (g *Generator) Generate(appPath string, outputPath string) error {
+	err := generateServices(appPath, true)
+	if err != nil {
+		fmt.Printf("error generating services, error: %s\n", err.Error())
+		return err
+	}
+
+	err = generateRuntime(appPath)
+	if err != nil {
+		fmt.Printf("error generating runtime, error: %s\n", err.Error())
+		return err
+	}
+
+	err = buildProject(appPath, outputPath)
+	if err != nil {
+		fmt.Printf("error building project, error: %s\n", err.Error())
+		return err
+	}
+
+	return nil
+}

go/runtime-gen.go

@@ -0,0 +1,83 @@
+package _go
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"text/template"
+)
+
+type RuntimeServiceInfo struct {
+	ServiceStructName string
+}
+
+type RuntimeInfo struct {
+	Services []RuntimeServiceInfo
+}
+
+const runtimeFileTemplate = `package _polycode
+
+import (
+	runtime "github.com/cloudimpl/polycode-runtime-go"
+)
+
+func init() {
+	var err error
+	{{range .Services}}err = runtime.RegisterService(&{{.ServiceStructName}}{})
+	if err != nil {
+		panic(err)
+	}
+	{{end}}
+}
+`
+
+func generateRuntime(appPath string) error {
+	servicesFolder := filepath.Join(appPath, "services")
+
+	if _, err := os.Stat(servicesFolder); os.IsNotExist(err) {
+		println("No services folder found")
+	} else {
+		entries, err := os.ReadDir(servicesFolder)
+		if err != nil {
+			fmt.Printf("Error reading directory: %v\n", err)
+			return err
+		}
+
+		var services []RuntimeServiceInfo
+		for i, entry := range entries {
+			fmt.Printf("Processing entry [%d/%d]\n", i+1, len(entries))
+			if entry.IsDir() {
+				serviceName := entry.Name()
+				serviceStructName := toPascalCase(serviceName)
+				services = append(services, RuntimeServiceInfo{
+					ServiceStructName: serviceStructName,
+				})
+			}
+		}
+
+		// Use template to generate the code
+		var buf bytes.Buffer
+		tmpl, err := template.New("runtime-file-template").Parse(runtimeFileTemplate)
+		if err != nil {
+			return err
+		}
+
+		runtimeInfo := RuntimeInfo{
+			Services: services,
+		}
+
+		err = tmpl.Execute(&buf, runtimeInfo)
+		if err != nil {
+			return err
+		}
+
+		err = os.WriteFile(appPath+"/.polycode/runtime.go", []byte(buf.String()), 0644)
+		if err != nil {
+			fmt.Printf("Error writing file: %v\n", err)
+			return err
+		}
+	}
+
+	return nil
+}