tailwind

func tailwindCommand(minify, useConfig bool) *exec.Cmd

{
	switch {
	case minify && useConfig:
		return exec.Command("tailwindcss", "-i", "-", "--minify", "--config", "tailwind.config.js")
	case minify:
		return exec.Command("tailwindcss", "-i", "-", "--minify")
	case useConfig:
		return exec.Command("tailwindcss", "-i", "-", "--config", "tailwind.config.js")
	default:
		return exec.Command("tailwindcss", "-i", "-")
	}
}

func writeProjectFile(root *os.Root, filePath string, content []byte) error

{
	directory := filepath.Dir(filePath)
	if directory != "." {
		if err := root.MkdirAll(directory, 0o755); err != nil {
			return err
		}
	}
	if err := root.Remove(filePath); err != nil && !errors.Is(err, os.ErrNotExist) {
		return err
	}
	file, err := root.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
	if err != nil {
		return err
	}
	_, writeErr := file.Write(content)
	closeErr := file.Close()
	return errors.Join(writeErr, closeErr)
}

func validateProjectFile(filePath string, mustExist bool) (string, error)

{
	if filePath == "" || filepath.IsAbs(filePath) || strings.HasPrefix(filePath, "-") {
		return "", fmt.Errorf("path %q must be a project-relative file", filePath)
	}
	cleaned := filepath.Clean(filePath)
	if cleaned == "." || cleaned == ".." || strings.HasPrefix(cleaned, ".."+string(filepath.Separator)) {
		return "", fmt.Errorf("path %q escapes the project", filePath)
	}

	projectRoot, err := filepath.Abs(".")
	if err != nil {
		return "", err
	}
	resolvedRoot, err := filepath.EvalSymlinks(projectRoot)
	if err != nil {
		return "", err
	}
	candidate := filepath.Join(resolvedRoot, cleaned)
	checkPath := candidate
	if !mustExist {
		for {
			if _, statErr := os.Lstat(checkPath); statErr == nil {
				break
			} else if !os.IsNotExist(statErr) {
				return "", statErr
			}
			checkPath = filepath.Dir(candidate)
			if checkPath == resolvedRoot {
				break
			}
			candidate = checkPath
		}
	}
	resolved, err := filepath.EvalSymlinks(checkPath)
	if err != nil {
		return "", err
	}
	relative, err := filepath.Rel(resolvedRoot, resolved)
	if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
		return "", fmt.Errorf("path %q resolves outside the project", filePath)
	}
	return cleaned, nil
}

func validateExtraArgs(args []string) (bool, error)

{
	if len(args) == 0 {
		return false, nil
	}
	if len(args) != 2 || args[0] != "--config" && args[0] != "-c" {
		return false, fmt.Errorf("tailwind args only support the project-root tailwind.config.js")
	}
	configPath, err := validateProjectFile(args[1], true)
	if err != nil {
		return false, fmt.Errorf("invalid tailwind config: %w", err)
	}
	if configPath != "tailwind.config.js" {
		return false, fmt.Errorf("tailwind config must be tailwind.config.js in the project root")
	}
	return true, nil
}

func TestShouldRebuild(t *testing.T)

{
	p := &plugin{output: "tailwind.css"}

	if !p.ShouldRebuild("style.css") {
		t.Fatalf("expected css change to trigger rebuild")
	}
	if p.ShouldRebuild("tailwind.css") {
		t.Fatalf("output file should not trigger rebuild")
	}
	if !p.ShouldRebuild("index.html") || !p.ShouldRebuild("tmpl.rtml") {
		t.Fatalf("html/rtml should trigger rebuild")
	}
	if !p.ShouldRebuild("main.go") {
		t.Fatalf("go files should trigger rebuild")
	}
	if p.ShouldRebuild("image.png") {
		t.Fatalf("unrelated files should not trigger rebuild")
	}
}

func TestValidateProjectFile(t *testing.T)

{
	root := t.TempDir()
	oldWorkingDirectory, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Chdir(root); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() {
		if err := os.Chdir(oldWorkingDirectory); err != nil {
			t.Errorf("restore working directory: %v", err)
		}
	})
	if err := os.WriteFile("input.css", []byte("body {}"), 0o600); err != nil {
		t.Fatal(err)
	}

	if _, err := validateProjectFile("input.css", true); err != nil {
		t.Fatalf("expected project file to be valid: %v", err)
	}
	if _, err := validateProjectFile("dist/css/app.css", false); err != nil {
		t.Fatalf("expected nested output to be valid: %v", err)
	}
	for _, filePath := range []string{"../input.css", "/tmp/input.css", "-o"} {
		if _, err := validateProjectFile(filePath, false); err == nil {
			t.Errorf("expected %q to be rejected", filePath)
		}
	}

	outside := t.TempDir()
	if err := os.Symlink(outside, filepath.Join(root, "outside")); err != nil {
		t.Fatal(err)
	}
	if _, err := validateProjectFile("outside/output.css", false); err == nil {
		t.Fatal("expected symlink escape to be rejected")
	}
}

func TestValidateExtraArgs(t *testing.T)

{
	root := t.TempDir()
	oldWorkingDirectory, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Chdir(root); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() {
		if err := os.Chdir(oldWorkingDirectory); err != nil {
			t.Errorf("restore working directory: %v", err)
		}
	})
	if err := os.WriteFile("tailwind.config.js", nil, 0o600); err != nil {
		t.Fatal(err)
	}

	useConfig, err := validateExtraArgs([]string{"--config", "tailwind.config.js"})
	if err != nil {
		t.Fatalf("expected config argument to be valid: %v", err)
	}
	if !useConfig {
		t.Fatal("expected config to be enabled")
	}
	for _, args := range [][]string{{"--watch"}, {"--config"}, {"--config", "../config.js"}, {"--config", "config/tailwind.config.js"}} {
		if _, err := validateExtraArgs(args); err == nil {
			t.Errorf("expected %v to be rejected", args)
		}
	}
}

func TestTailwindCommandUsesFixedArguments(t *testing.T)

{
	tests := []struct {
		name      string
		minify    bool
		useConfig bool
		want      []string
	}{
		{name: "default", want: []string{"tailwindcss", "-i", "-"}},
		{name: "minified", minify: true, want: []string{"tailwindcss", "-i", "-", "--minify"}},
		{name: "configured", useConfig: true, want: []string{"tailwindcss", "-i", "-", "--config", "tailwind.config.js"}},
		{
			name:      "configured and minified",
			minify:    true,
			useConfig: true,
			want:      []string{"tailwindcss", "-i", "-", "--minify", "--config", "tailwind.config.js"},
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			command := tailwindCommand(test.minify, test.useConfig)
			if len(command.Args) != len(test.want) {
				t.Fatalf("args %v, want %v", command.Args, test.want)
			}
			for index := range test.want {
				if command.Args[index] != test.want[index] {
					t.Fatalf("args %v, want %v", command.Args, test.want)
				}
			}
		})
	}
}