feat: optimize path methods and test workflows

.github/workflows/codecov.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Install dependencies
         run: go mod tidy
       - name: Run tests with coverage
-        run: go test -coverprofile="coverage.out" $(go list ./... | grep -v /mocks | grep -v /facades | grep -v /contracts | grep -v /testing/mock)
+        run: go test -timeout 1h -coverprofile="coverage.out" $(go list ./... | grep -v /mocks | grep -v /facades | grep -v /contracts | grep -v /testing/mock)
       - name: Print coverage report
         run: go tool cover -func=coverage.out
       - name: Upload coverage report to Codecov

.github/workflows/lint.yml

@@ -15,18 +15,20 @@ jobs:
         with:
           go-version: 'stable'
           cache: false
-      - name: go mod pakcage cache
+      - name: Go mod cache
         uses: actions/cache@v4
         with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('go.mod') }}
+          path: |
+            ~/.cache/go-build
+            ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
       - name: Install dependencies
         run: go mod tidy
       - name: Lint
         uses: golangci/golangci-lint-action@v6
         with:
           skip-cache: true
-          skip-pkg-cache: true
-          skip-build-cache: true
           version: latest
           args: --timeout=30m ./...

.github/workflows/test.yml

@@ -5,41 +5,49 @@ on:
       - master
   pull_request:
 jobs:
-  test:
+  ubuntu:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: [ "1.21", "1.22" ]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go }}
-      - name: go mod pakcage cache
+      - name: Go mod cache
         uses: actions/cache@v4
         with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('go.mod') }}
+          path: |
+            ~/.cache/go-build
+            ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
       - name: Install dependencies
         run: go mod tidy
       - name: Run tests
-        run: go test ./...
+        run: go test -timeout 1h ./...
   windows:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: [ "1.21", "1.22" ]
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go }}
-      - name: go mod pakcage cache
+      - name: Go mod cache
         uses: actions/cache@v4
         with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('go.mod') }}
+          path: |
+            ~\AppData\Local\go-build
+            ~\go\pkg\mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
       - name: Install dependencies
         run: go mod tidy
       - name: Run tests
-        run: go test ./...
+        run: go test -timeout 1h ./...

contracts/foundation/application.go

@@ -13,21 +13,21 @@ type Application interface {
 	// Commands register the given commands with the console application.
 	Commands([]console.Command)
 	// Path gets the path respective to "app" directory.
-	Path(path string) string
+	Path(path ...string) string
 	// BasePath get the base path of the Goravel installation.
-	BasePath(path string) string
+	BasePath(path ...string) string
 	// ConfigPath get the path to the configuration files.
-	ConfigPath(path string) string
+	ConfigPath(path ...string) string
 	// DatabasePath get the path to the database directory.
-	DatabasePath(path string) string
+	DatabasePath(path ...string) string
 	// StoragePath get the path to the storage directory.
-	StoragePath(path string) string
+	StoragePath(path ...string) string
 	// LangPath get the path to the language files.
-	LangPath(path string) string
+	LangPath(path ...string) string
 	// PublicPath get the path to the public directory.
-	PublicPath(path string) string
+	PublicPath(path ...string) string
 	// ExecutablePath get the path to the executable of the running Goravel application.
-	ExecutablePath() (string, error)
+	ExecutablePath(path ...string) string
 	// Publishes register the given paths to be published by the "vendor:publish" command.
 	Publishes(packageName string, paths map[string]string, groups ...string)
 	// CurrentLocale get the current application locale.

foundation/application.go

@@ -24,6 +24,7 @@ var _ = flag.String("env", ".env", "custom .env path")
 
 func init() {
 	setEnv()
+	setRootPath()
 
 	app := &Application{
 		Container:     NewContainer(),
@@ -58,48 +59,49 @@ func (app *Application) Boot() {
 	})
 	app.bootArtisan()
 	app.setTimezone()
-	setRootPath()
 }
 
 func (app *Application) Commands(commands []consolecontract.Command) {
 	app.registerCommands(commands)
 }
 
-func (app *Application) Path(path string) string {
-	return filepath.Join("app", path)
+func (app *Application) Path(path ...string) string {
+	path = append([]string{"app"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) BasePath(path string) string {
-	return filepath.Join("", path)
+func (app *Application) BasePath(path ...string) string {
+	return filepath.Join(path...)
 }
 
-func (app *Application) ConfigPath(path string) string {
-	return filepath.Join("config", path)
+func (app *Application) ConfigPath(path ...string) string {
+	path = append([]string{"config"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) DatabasePath(path string) string {
-	return filepath.Join("database", path)
+func (app *Application) DatabasePath(path ...string) string {
+	path = append([]string{"database"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) StoragePath(path string) string {
-	return filepath.Join("storage", path)
+func (app *Application) StoragePath(path ...string) string {
+	path = append([]string{"storage"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) LangPath(path string) string {
-	return filepath.Join("lang", path)
+func (app *Application) LangPath(path ...string) string {
+	path = append([]string{"lang"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) PublicPath(path string) string {
-	return filepath.Join("public", path)
+func (app *Application) PublicPath(path ...string) string {
+	path = append([]string{"public"}, path...)
+	return filepath.Join(path...)
 }
 
-func (app *Application) ExecutablePath() (string, error) {
-	executable, err := os.Executable()
-	if err != nil {
-		return "", err
-	}
-
-	return filepath.Dir(executable), nil
+func (app *Application) ExecutablePath(path ...string) string {
+	path = append([]string{support.RootPath}, path...)
+	return filepath.Join(path...)
 }
 
 func (app *Application) Publishes(packageName string, paths map[string]string, groups ...string) {
@@ -260,15 +262,7 @@ func setEnv() {
 }
 
 func setRootPath() {
-	rootPath := getCurrentAbsolutePath()
-
-	// Hack the air path
-	airPath := "/storage/temp"
-	if strings.HasSuffix(rootPath, airPath) {
-		rootPath = strings.ReplaceAll(rootPath, airPath, "")
-	}
-
-	support.RootPath = rootPath
+	support.RootPath = getCurrentAbsolutePath()
 }
 
 func getEnvPath() string {

foundation/application_test.go

@@ -2,6 +2,7 @@ package foundation
 
 import (
 	"log"
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -83,14 +84,24 @@ func (s *ApplicationTestSuite) TestStoragePath() {
 	s.Equal(filepath.Join("storage", "goravel.go"), s.app.StoragePath("goravel.go"))
 }
 
+func (s *ApplicationTestSuite) TestLangPath() {
+	s.Equal(filepath.Join("lang", "goravel.go"), s.app.LangPath("goravel.go"))
+}
+
 func (s *ApplicationTestSuite) TestPublicPath() {
 	s.Equal(filepath.Join("public", "goravel.go"), s.app.PublicPath("goravel.go"))
 }
 
 func (s *ApplicationTestSuite) TestExecutablePath() {
-	executable, err := s.app.ExecutablePath()
+	path, err := os.Getwd()
 	s.NoError(err)
+
+	executable := s.app.ExecutablePath()
 	s.NotEmpty(executable)
+	executable2 := s.app.ExecutablePath("test")
+	s.Equal(filepath.Join(path, "test"), executable2)
+	executable3 := s.app.ExecutablePath("test", "test2/test3")
+	s.Equal(filepath.Join(path, "test", "test2/test3"), executable3)
 }
 
 func (s *ApplicationTestSuite) TestPublishes() {

foundation/path.go

@@ -4,39 +4,48 @@
 	"log"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 )
 
 func getCurrentAbsolutePath() string {
-	dir := getCurrentAbsolutePathByExecutable()
-	tmpDir, _ := filepath.EvalSymlinks(os.TempDir())
-	if strings.Contains(dir, tmpDir) {
-		return getCurrentAbsolutePathByCaller()
+	executable, err := os.Executable()
+	if err != nil {
+		log.Fatal(err)
+	}
+	res, _ := filepath.EvalSymlinks(filepath.Dir(executable))
+
+	if isTesting() || isAir() || isDirectlyRun() {
+		res, _ = os.Getwd()
 	}
 
-	return dir
+	return res
 }
 
-func getCurrentAbsolutePathByExecutable() string {
-	exePath, err := os.Executable()
-	if err != nil {
-		log.Fatal(err)
+// isTesting checks if the application is running in testing mode.
+func isTesting() bool {
+	for _, arg := range os.Args {
+		if strings.Contains(arg, "-test.") {
+			return true
+		}
 	}
-	res, _ := filepath.EvalSymlinks(filepath.Dir(exePath))
 
-	return res
+	return false
 }
 
-func getCurrentAbsolutePathByCaller() string {
-	var abPath string
-	for i := 0; i < 15; i++ {
-		_, filename, _, ok := runtime.Caller(i)
-		if ok && strings.HasSuffix(filename, "main.go") {
-			abPath = filepath.Dir(filename)
-			break
+// isAir checks if the application is running using Air.
+func isAir() bool {
+	for _, arg := range os.Args {
+		if strings.Contains(arg, "/storage/temp") {
+			return true
 		}
 	}
 
-	return abPath
+	return false
+}
+
+// isDirectlyRun checks if the application is running using go run.
+func isDirectlyRun() bool {
+	executable, _ := os.Executable()
+	return strings.Contains(filepath.Base(executable), os.TempDir()) ||
+		(strings.Contains(executable, "/var/folders") && strings.Contains(executable, "/T/go-build")) // macOS
 }