Makefile

TEST?=$$(go list ./... | grep -v 'vendor')
HOSTNAME=clickhouse.cloud
NAMESPACE=terraform
NAME=clickhouse
BINARY=terraform-provider-${NAME}
VERSION=0.1
OS_ARCH=darwin_arm64

# golangci-lint can only analyse Go versions <= the one it was built with, so
# both the linter build and the lint runs have to be pinned. Take the version
# from go.mod, the same source CI resolves its Go from, so a bump can't leave
# the two out of step. Exported file-wide on purpose: every target then builds
# on the version CI uses, and no new target can miss the pin.
#
# Prefer the toolchain directive when there is one, since that is what setup-go
# resolves to. `go mod edit -go=1.27` writes a two-part language version, which
# is not a valid toolchain name, so pad it.
GO_MOD_VERSION := $(shell awk '/^toolchain go/{v=substr($$2,3)} /^go /{if (!g) g=$$2} END{if (!v) v=g; if (v ~ /^[0-9]+\.[0-9]+$$/) v=v".0"; print v}' go.mod)
ifeq ($(GO_MOD_VERSION),)
$(error could not read the go version from go.mod)
endif
export GOTOOLCHAIN := go$(GO_MOD_VERSION)

default: install

build:
	go build -o ${BINARY}

release:
	GOOS=darwin GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_darwin_amd64
	GOOS=freebsd GOARCH=386 go build -o ./bin/${BINARY}_${VERSION}_freebsd_386
	GOOS=freebsd GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_freebsd_amd64
	GOOS=freebsd GOARCH=arm go build -o ./bin/${BINARY}_${VERSION}_freebsd_arm
	GOOS=linux GOARCH=386 go build -o ./bin/${BINARY}_${VERSION}_linux_386
	GOOS=linux GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_linux_amd64
	GOOS=linux GOARCH=arm go build -o ./bin/${BINARY}_${VERSION}_linux_arm
	GOOS=openbsd GOARCH=386 go build -o ./bin/${BINARY}_${VERSION}_openbsd_386
	GOOS=openbsd GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_openbsd_amd64
	GOOS=solaris GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_solaris_amd64
	GOOS=windows GOARCH=386 go build -o ./bin/${BINARY}_${VERSION}_windows_386
	GOOS=windows GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_windows_amd64

install: build
	mkdir -p ~/.terraform.d/plugins/${HOSTNAME}/${NAMESPACE}/${NAME}/${VERSION}/${OS_ARCH}
	mv ${BINARY} ~/.terraform.d/plugins/${HOSTNAME}/${NAMESPACE}/${NAME}/${VERSION}/${OS_ARCH}

test: 
	go test -i $(TEST) || exit 1                                                   
	echo $(TEST) | xargs -t -n4 go test $(TESTARGS) -timeout=30s -parallel=4                    

enable_git_hooks: ## Add githooks for code validation before commit, as symlink so they get updated automatically
	mkdir -p .git/hooks
	cd .git/hooks && ln -fs ../../.githooks/* .
	echo "Git hooks were updated from .githooks/ into .git/hooks/"

.PHONY: docs
docs: ensure-tfplugindocs
	$(TFPLUGINDOCS) generate --provider-name=clickhouse
	go run ./internal/tools/docsubcategory

.PHONY: docs-validate
docs-validate: ensure-tfplugindocs ## Validate generated docs and pin subcategories to the registry's group names
	$(TFPLUGINDOCS) validate --provider-name=clickhouse --allowed-resource-subcategories-file=allowed-subcategories.txt

fmt: ensure-golangci-lint
	go fmt ./...
	$(GOLANGCILINT) run --fix --allow-serial-runners

.PHONY: lint
lint: ensure-golangci-lint ## Run go vet and golangci-lint
	go vet ./...
	$(GOLANGCILINT) run

.PHONY: sec
sec: ensure-golangci-lint ## Run only the gosec security linter (honors .golangci.yml exclusions)
	$(GOLANGCILINT) run --enable-only gosec ./...

.PHONY: testacc
testacc: ## Run acceptance tests (creates real resources)
	TF_ACC=1 go test ./... -v -timeout=120m

.PHONY: cover-profile
cover-profile: ## Produce cover.out
	go test ./... -coverprofile=./cover.out -covermode=atomic -coverpkg=./... -timeout=120s

.PHONY: cover
cover: cover-profile ## Enforce coverage thresholds from .testcoverage.yml
	go tool go-test-coverage --config=./.testcoverage.yml

.PHONY: cover-html
cover-html: cover-profile ## Open an HTML coverage report
	go tool cover -html=cover.out -o=cover.html

.PHONY: docs-check
docs-check: docs ## Fail if generated docs are stale (mirrors docs.yaml)
	git diff --exit-code docs/ || (echo "docs are stale: run 'make docs' and commit" && exit 1)

.PHONY: goreleaser-check
goreleaser-check: ## Validate the goreleaser config and do a snapshot build
	# Always name the config. Bare `goreleaser check` warns and exits 0 when it
	# finds no config, so a moved or renamed file would pass CI and then release
	# against goreleaser's defaults.
	goreleaser check --config .goreleaser.yml
	goreleaser build --config .goreleaser.yml --snapshot --clean --single-target

.PHONY: adr
adr: ## Create an ADR: make adr title="..." statement="..."
	go tool adr-tool short-adr -p ./decisions -t "$(title)" -s "$(statement)"

mock:
	cd ./internal/api && minimock -i github.com/ClickHouse/terraform-provider-clickhouse/internal/api.Client -o client_mock.go -n ClientMock -p api && cd ../..

TFPLUGINDOCS = /tmp/tfplugindocs-patched
ensure-tfplugindocs: ## Download tfplugindocs locally if necessary.
	$(call get-tfplugindocs,$(TFPLUGINDOCS),github.com/whites11/terraform-plugin-docs)

GOLANGCILINT = $(shell go env GOPATH)/bin/golangci-lint
# Test if golangci-lint is available in the GOPATH, if not, set to local and download if needed
ifneq ($(shell test -f $(GOLANGCILINT) && echo -n yes),yes)
GOLANGCILINT = /tmp/golangci-lint
endif
ensure-golangci-lint: ## Download golangci-lint locally if necessary.
	$(call go-get-tool,$(GOLANGCILINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2)

# go-get-tool will 'go get' any package $2 and install it to $1.
define go-get-tool
@[ -f $(1) ] || { \
set -e ;\
TMP_DIR=$$(mktemp -d) ;\
cd $$TMP_DIR ;\
go mod init tmp ;\
gobin="$$(dirname $(1))" ;\
echo "Downloading $(2) into $$gobin" ;\
GOBIN=$$gobin go install $(2) ;\
rm -rf $$TMP_DIR ;\
}
endef

define get-tfplugindocs
@[ -f $(1) ] || { \
set -e ;\
TMP_DIR=$$(mktemp -d) ;\
cd $$TMP_DIR ;\
echo "Cloning https://$(2).git into $$TMP_DIR" ;\
git clone https://$(2).git tfplugindocs ;\
cd tfplugindocs ;\
echo "Building tfplugindocs into $(1)" ;\
go build -o $(1) cmd/tfplugindocs/main.go ;\
rm -rf $$TMP_DIR ;\
}
endef