2020-04-19 06:17:02 -05:00
i f e q ( $( USE_REPO_TEST_DIR ) , 1 )
# This rule replaces the whole Makefile when we're trying to use /tmp repository temporary files
location = $( CURDIR) /$( word $( words $( MAKEFILE_LIST) ) ,$( MAKEFILE_LIST) )
self := $( location)
% :
@tmpdir= ` mktemp --tmpdir -d` ; \
echo Using temporary directory $$ tmpdir for test repositories ; \
USE_REPO_TEST_DIR = $( MAKE) -f $( self) --no-print-directory REPO_TEST_DIR = $$ tmpdir/ $@ ; \
STATUS = $$ ? ; rm -r " $$ tmpdir " ; exit $$ STATUS
e l s e
# This is the "normal" part of the Makefile
2016-11-04 07:58:55 -05:00
DIST := dist
2020-02-18 22:10:25 -05:00
DIST_DIRS := $( DIST) /binaries $( DIST) /release
2016-11-10 11:24:48 -05:00
IMPORT := code.gitea.io/gitea
2017-06-15 08:51:23 -05:00
2017-08-15 19:46:41 -05:00
GO ?= go
2019-04-14 10:06:43 -05:00
SHASUM ?= shasum -a 256
2023-04-17 09:46:25 -05:00
HAS_GO := $( shell hash $( GO) > /dev/null 2>& 1 && echo yes)
2020-03-08 19:11:39 -05:00
COMMA := ,
2023-10-21 06:30:19 -05:00
DIFF ?= diff --unified
2020-02-01 21:43:35 -05:00
2024-09-06 06:54:14 -05:00
i f e q ( $( USE_GOTESTSUM ) , y e s )
GOTEST ?= gotestsum --
GOTESTCOMPILEDRUNPREFIX ?= gotestsum --raw-command -- go tool test2json -t
GOTESTCOMPILEDRUNSUFFIX ?= -test.v= test2json
e l s e
GOTEST ?= $( GO) test
GOTESTCOMPILEDRUNPREFIX ?=
GOTESTCOMPILEDRUNSUFFIX ?=
e n d i f
2023-08-20 17:27:46 -05:00
XGO_VERSION := go-1.21.x
2022-03-15 21:50:26 -05:00
2024-06-04 01:52:58 -05:00
AIR_PACKAGE ?= github.com/air-verse/air@v1 # renovate: datasource=go
2024-08-09 11:14:19 -05:00
EDITORCONFIG_CHECKER_PACKAGE ?= github.com/editorconfig-checker/editorconfig-checker/v3/cmd/editorconfig-checker@v3.0.3 # renovate: datasource=go
2024-08-16 19:02:59 -05:00
GOFUMPT_PACKAGE ?= mvdan.cc/gofumpt@v0.7.0 # renovate: datasource=go
2024-09-10 19:02:45 -05:00
GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/cmd/golangci-lint@v1.61.0 # renovate: datasource=go
2024-04-11 08:00:11 -05:00
GXZ_PACKAGE ?= github.com/ulikunitz/xz/cmd/gxz@v0.5.11 # renovate: datasource=go
2024-06-07 19:02:59 -05:00
MISSPELL_PACKAGE ?= github.com/golangci/misspell/cmd/misspell@v0.6.0 # renovate: datasource=go
2024-05-14 21:05:32 -05:00
SWAGGER_PACKAGE ?= github.com/go-swagger/go-swagger/cmd/swagger@v0.31.0 # renovate: datasource=go
2024-05-12 08:58:52 -05:00
XGO_PACKAGE ?= src.techknowlogick.com/xgo@latest
2024-04-11 08:00:11 -05:00
GO_LICENSES_PACKAGE ?= github.com/google/go-licenses@v1.6.0 # renovate: datasource=go
2024-04-13 00:00:52 -05:00
GOVULNCHECK_PACKAGE ?= golang.org/x/vuln/cmd/govulncheck@v1 # renovate: datasource=go
2024-10-10 01:03:14 -05:00
DEADCODE_PACKAGE ?= golang.org/x/tools/cmd/deadcode@v0.26.0 # renovate: datasource=go
2024-05-22 00:17:59 -05:00
GOMOCK_PACKAGE ?= go.uber.org/mock/mockgen@v0.4.0 # renovate: datasource=go
2024-09-05 19:02:39 -05:00
GOPLS_PACKAGE ?= golang.org/x/tools/gopls@v0.16.2 # renovate: datasource=go
2024-10-28 01:26:24 -05:00
RENOVATE_NPM_PACKAGE ?= renovate@38.133.0 # renovate: datasource=docker packageName=code.forgejo.org/forgejo-contrib/renovate
2020-03-20 09:29:31 -05:00
2023-04-17 09:46:25 -05:00
i f e q ( $( HAS_GO ) , y e s )
2020-06-05 18:57:25 -05:00
CGO_EXTRA_CFLAGS := -DSQLITE_MAX_VARIABLE_NUMBER= 32766
CGO_CFLAGS ?= $( shell $( GO) env CGO_CFLAGS) $( CGO_EXTRA_CFLAGS)
2020-02-01 21:43:35 -05:00
e n d i f
2017-06-15 08:51:23 -05:00
2023-10-06 15:39:21 -05:00
i f e q ( $( GOOS ) , w i n d o w s )
IS_WINDOWS := yes
e l s e i f e q ( $( patsubst Windows %,Windows ,$ ( OS ) ) , W i n d o w s )
ifeq ( $( GOOS) ,)
IS_WINDOWS := yes
endif
e n d i f
i f e q ( $( IS_WINDOWS ) , y e s )
2021-05-29 02:37:21 -05:00
GOFLAGS := -v -buildmode= exe
EXECUTABLE ?= gitea.exe
2017-06-15 08:51:23 -05:00
e l s e
2020-08-24 16:46:41 -05:00
GOFLAGS := -v
2019-04-29 13:08:21 -05:00
EXECUTABLE ?= gitea
2020-07-27 15:13:15 -05:00
e n d i f
i f e q ( $( shell sed --version 2>/dev /null | grep -q GNU && echo gnu ) , g n u )
SED_INPLACE := sed -i
e l s e
SED_INPLACE := sed -i ''
2017-06-15 08:51:23 -05:00
e n d i f
2017-04-05 03:10:32 -05:00
EXTRA_GOFLAGS ?=
2023-06-18 20:53:16 -05:00
MAKE_VERSION := $( shell " $( MAKE) " -v | cat | head -n 1)
2020-02-01 15:15:32 -05:00
MAKE_EVIDENCE_DIR := .make_evidence
2019-04-02 11:10:11 -05:00
2021-06-02 10:34:11 -05:00
i f e q ( $( RACE_ENABLED ) , t r u e )
GOFLAGS += -race
GOTESTFLAGS += -race
2020-01-29 10:43:07 -05:00
e n d i f
2020-02-22 04:15:11 -05:00
STORED_VERSION_FILE := VERSION
2023-03-23 10:18:24 -05:00
HUGO_VERSION ?= 0.111.3
2020-02-22 04:15:11 -05:00
2024-02-28 09:57:48 -05:00
GITEA_COMPATIBILITY ?= gitea-1.22.0
2023-06-20 00:37:32 -05:00
2023-06-14 06:32:20 -05:00
STORED_VERSION = $( shell cat $( STORED_VERSION_FILE) 2>/dev/null)
i f n e q ( $( STORED_VERSION ) , )
2024-02-11 09:36:58 -05:00
FORGEJO_VERSION ?= $( STORED_VERSION)
2018-07-11 22:32:01 -05:00
e l s e
2024-03-28 09:45:51 -05:00
ifneq ( $( GITEA_VERSION) ,)
FORGEJO_VERSION ?= $( GITEA_VERSION)
FORGEJO_VERSION_API ?= $( GITEA_VERSION) +${ GITEA_COMPATIBILITY }
else
# drop the "g" prefix prepended by git describe to the commit hash
FORGEJO_VERSION ?= $( shell git describe --exclude '*-test' --tags --always | sed 's/^v//' | sed 's/\-g/-/' ) +${ GITEA_COMPATIBILITY }
endif
2023-04-24 10:43:19 -05:00
e n d i f
2024-03-05 11:44:26 -05:00
FORGEJO_VERSION_MAJOR = $( shell echo $( FORGEJO_VERSION) | sed -e 's/\..*//' )
2024-03-20 11:32:06 -05:00
FORGEJO_VERSION_MINOR = $( shell echo $( FORGEJO_VERSION) | sed -E -e 's/^([0-9]+\.[0-9]+).*/\1/' )
2024-03-05 11:44:26 -05:00
show-version-full :
@echo ${ FORGEJO_VERSION }
show-version-major :
@echo ${ FORGEJO_VERSION_MAJOR }
2024-03-20 11:32:06 -05:00
show-version-minor :
@echo ${ FORGEJO_VERSION_MINOR }
2024-02-17 07:08:54 -05:00
RELEASE_VERSION ?= ${ FORGEJO_VERSION }
VERSION ?= ${ RELEASE_VERSION }
2023-04-24 10:43:19 -05:00
2024-03-28 09:45:51 -05:00
FORGEJO_VERSION_API ?= ${ FORGEJO_VERSION }
show-version-api :
@echo ${ FORGEJO_VERSION_API }
LDFLAGS := $( LDFLAGS) -X " main.ReleaseVersion= $( RELEASE_VERSION) " -X " main.MakeVersion= $( MAKE_VERSION) " -X " main.Version= $( FORGEJO_VERSION) " -X " main.Tags= $( TAGS) " -X " main.ForgejoVersion= $( FORGEJO_VERSION_API) "
2015-11-03 12:16:43 -05:00
2021-02-22 02:01:57 -05:00
LINUX_ARCHS ?= linux/amd64,linux/386,linux/arm-5,linux/arm-6,linux/arm64
2024-03-05 11:44:26 -05:00
i f e q ( $( HAS_GO ) , y e s )
2024-08-16 08:28:48 -05:00
GO_TEST_PACKAGES ?= $( filter-out $( shell $( GO) list code.gitea.io/gitea/models/migrations/...) $( shell $( GO) list code.gitea.io/gitea/models/forgejo_migrations/...) code.gitea.io/gitea/tests/integration/migration-test code.gitea.io/gitea/tests code.gitea.io/gitea/tests/integration code.gitea.io/gitea/tests/e2e,$( shell $( GO) list ./...) )
2024-03-05 11:44:26 -05:00
e n d i f
2024-06-18 07:31:15 -05:00
REMOTE_CACHER_MODULES ?= cache nosql session queue
GO_TEST_REMOTE_CACHER_PACKAGES ?= $( addprefix code.gitea.io/gitea/modules/,$( REMOTE_CACHER_MODULES) )
2019-12-04 22:41:38 -05:00
2021-04-01 19:11:04 -05:00
FOMANTIC_WORK_DIR := web_src/fomantic
2020-06-28 19:18:12 -05:00
2023-03-14 21:20:19 -05:00
WEBPACK_SOURCES := $( shell find web_src/js web_src/css -type f)
Add tailwindcss (#29357)
This will get tailwindcss working on a basic level. It provides only the
utility classes, e.g. no tailwind base which we don't need because we
have our own CSS reset. Without the base, we also do not have their CSS
variables so a small amount of features do not work and I removed the
generated classes for them.
***Note for future developers: This currently uses a `tw-` prefix, so we
use it like `tw-p-3`.***
<details>
<summary>Currently added CSS, all false-positives</summary>
```
.\!visible{
visibility: visible !important
}
.visible{
visibility: visible
}
.invisible{
visibility: hidden
}
.collapse{
visibility: collapse
}
.static{
position: static
}
.\!fixed{
position: fixed !important
}
.absolute{
position: absolute
}
.relative{
position: relative
}
.sticky{
position: sticky
}
.left-10{
left: 2.5rem
}
.isolate{
isolation: isolate
}
.float-right{
float: right
}
.float-left{
float: left
}
.mr-2{
margin-right: 0.5rem
}
.mr-3{
margin-right: 0.75rem
}
.\!block{
display: block !important
}
.block{
display: block
}
.inline-block{
display: inline-block
}
.inline{
display: inline
}
.flex{
display: flex
}
.inline-flex{
display: inline-flex
}
.\!table{
display: table !important
}
.inline-table{
display: inline-table
}
.table-caption{
display: table-caption
}
.table-cell{
display: table-cell
}
.table-column{
display: table-column
}
.table-column-group{
display: table-column-group
}
.table-footer-group{
display: table-footer-group
}
.table-header-group{
display: table-header-group
}
.table-row-group{
display: table-row-group
}
.table-row{
display: table-row
}
.flow-root{
display: flow-root
}
.inline-grid{
display: inline-grid
}
.contents{
display: contents
}
.list-item{
display: list-item
}
.\!hidden{
display: none !important
}
.hidden{
display: none
}
.flex-shrink{
flex-shrink: 1
}
.shrink{
flex-shrink: 1
}
.flex-grow{
flex-grow: 1
}
.grow{
flex-grow: 1
}
.border-collapse{
border-collapse: collapse
}
.select-all{
user-select: all
}
.resize{
resize: both
}
.flex-wrap{
flex-wrap: wrap
}
.overflow-visible{
overflow: visible
}
.rounded{
border-radius: 0.25rem
}
.border{
border-width: 1px
}
.text-justify{
text-align: justify
}
.uppercase{
text-transform: uppercase
}
.lowercase{
text-transform: lowercase
}
.capitalize{
text-transform: capitalize
}
.italic{
font-style: italic
}
.text-red{
color: var(--color-red)
}
.text-shadow{
color: var(--color-shadow)
}
.underline{
text-decoration-line: underline
}
.overline{
text-decoration-line: overline
}
.line-through{
text-decoration-line: line-through
}
.outline{
outline-style: solid
}
.ease-in{
transition-timing-function: cubic-bezier(0.4, 0, 1, 1)
}
.ease-in-out{
transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1)
}
.ease-out{
transition-timing-function: cubic-bezier(0, 0, 0.2, 1)
}
```
</details>
---------
Co-authored-by: Giteabot <teabot@gitea.io>
(cherry picked from commit f4b92578b4601bc6e9b631b9a5a5f3766c27b0cb)
2024-02-25 11:46:46 -05:00
WEBPACK_CONFIGS := webpack.config.js tailwind.config.js
2023-07-18 11:06:43 -05:00
WEBPACK_DEST := public/assets/js/index.js public/assets/css/index.css
2024-03-28 22:00:07 -05:00
WEBPACK_DEST_ENTRIES := public/assets/js public/assets/css public/assets/fonts
2020-03-03 14:51:11 -05:00
2019-12-04 22:41:38 -05:00
BINDATA_DEST := modules/public/bindata.go modules/options/bindata.go modules/templates/bindata.go
2020-01-26 20:05:38 -05:00
BINDATA_HASH := $( addsuffix .hash,$( BINDATA_DEST) )
2019-12-04 22:41:38 -05:00
2022-09-05 01:04:18 -05:00
GENERATED_GO_DEST := modules/charset/invisible_gen.go modules/charset/ambiguous_gen.go
2023-07-18 11:06:43 -05:00
SVG_DEST_DIR := public/assets/img/svg
2020-07-12 04:10:56 -05:00
2020-07-27 13:05:42 -05:00
AIR_TMP_DIR := .air
2022-09-03 17:20:46 -05:00
GO_LICENSE_TMP_DIR := .go-licenses
GO_LICENSE_FILE := assets/go-licenses.json
2020-03-08 19:11:39 -05:00
TAGS ?=
TAGS_SPLIT := $( subst $( COMMA) , ,$( TAGS) )
TAGS_EVIDENCE := $( MAKE_EVIDENCE_DIR) /tags
2020-12-17 09:00:47 -05:00
TEST_TAGS ?= sqlite sqlite_unlock_notify
2022-09-03 17:20:46 -05:00
TAR_EXCLUDES := .git data indexers queues log node_modules $( EXECUTABLE) $( FOMANTIC_WORK_DIR) /node_modules $( DIST) $( MAKE_EVIDENCE_DIR) $( AIR_TMP_DIR) $( GO_LICENSE_TMP_DIR)
2021-04-09 00:08:14 -05:00
Clean some legacy files and move some build files (#23699)
* Clean the "tools" directory. The "tools" directory contains only two
files, move them.
* The "external_renderer.go" works like "cat" command to echo Stdin to
Stdout , to help testing.
* The `// gobuild: external_renderer` is incorrect, there should be no
space: `//gobuild: external_renderer`
* The `fmt.Print(os.Args[1])` is not a well-defined behavior, and it's
never used.
* The "watch.sh" is for "make watch", it's somewhat related to "build"
* After this PR, there is no "tools" directory, the project root
directory looks slightly simpler than before.
* Remove the legacy "contrib/autoboot.sh", there is no
"gogs_supervisord.sh"
* Remove the legacy "contrib/mysql.sql", it's never mentioned anywhere.
* Remove the legacy "contrib/pr/checkout.go", it has been broken for
long time, and it introduces unnecessary dependencies of the main code
base.
2023-03-25 15:22:51 -05:00
GO_DIRS := build cmd models modules routers services tests
2023-03-14 21:20:19 -05:00
WEB_DIRS := web_src/js web_src/css
2020-12-17 09:00:47 -05:00
2024-10-23 00:07:18 -05:00
ESLINT_FILES := web_src/js tools *.js *.mjs tests/e2e/*.js tests/e2e/shared/*.js
2024-03-17 17:12:36 -05:00
STYLELINT_FILES := web_src/css web_src/js/components/*.vue
2024-04-18 13:54:40 -05:00
SPELLCHECK_FILES := $( GO_DIRS) $( WEB_DIRS) docs/content templates options/locale/locale_en-US.ini .github $( wildcard *.go *.js *.md *.yml *.yaml *.toml)
2024-02-08 22:59:39 -05:00
2020-03-08 19:11:39 -05:00
GO_SOURCES := $( wildcard *.go)
2023-05-06 23:41:33 -05:00
GO_SOURCES += $( shell find $( GO_DIRS) -type f -name "*.go" ! -path modules/options/bindata.go ! -path modules/public/bindata.go ! -path modules/templates/bindata.go)
2022-09-05 01:04:18 -05:00
GO_SOURCES += $( GENERATED_GO_DEST)
GO_SOURCES_NO_BINDATA := $( GO_SOURCES)
2020-03-08 19:11:39 -05:00
2024-03-05 11:44:26 -05:00
i f e q ( $( HAS_GO ) , y e s )
MIGRATION_PACKAGES := $( shell $( GO) list code.gitea.io/gitea/models/migrations/... code.gitea.io/gitea/models/forgejo_migrations/...)
e n d i f
2024-01-22 13:11:24 -05:00
2020-03-08 19:11:39 -05:00
i f e q ( $( filter $ ( TAGS_SPLIT ) ,bindata ) , b i n d a t a )
GO_SOURCES += $( BINDATA_DEST)
2022-09-05 01:04:18 -05:00
GENERATED_GO_DEST += $( BINDATA_DEST)
2020-03-08 19:11:39 -05:00
e n d i f
2022-09-02 14:18:23 -05:00
# Force installation of playwright dependencies by setting this flag
i f d e f D E P S _ P L A Y W R I G H T
PLAYWRIGHT_FLAGS += --with-deps
e n d i f
2023-02-07 05:23:49 -05:00
FORGEJO_API_SPEC := public/assets/forgejo/api.v1.yml
2018-07-27 19:19:01 -05:00
SWAGGER_SPEC := templates/swagger/v1_json.tmpl
2024-02-18 04:52:02 -05:00
SWAGGER_SPEC_S_TMPL := s| "basePath" : *"/api/v1" | "basePath" : "{{AppSubUrl \| JSEscape}}/api/v1" | g
SWAGGER_SPEC_S_JSON := s| "basePath" : *"{{AppSubUrl \| JSEscape}}/api/v1" | "basePath" : "/api/v1" | g
2020-10-13 23:06:00 -05:00
SWAGGER_EXCLUDE := code.gitea.io/sdk
2019-04-01 10:27:40 -05:00
SWAGGER_NEWLINE_COMMAND := -e '$$a\'
2023-01-09 16:28:04 -05:00
SWAGGER_SPEC_BRANDING := s| Gitea API| Forgejo API| g
2024-08-23 12:17:07 -05:00
SWAGGER_SPEC_LICENSE := s| "name" : "MIT" | "name" : "This file is distributed under the MIT license for the purpose of interoperability" |
2018-07-27 19:19:01 -05:00
2017-09-13 01:03:20 -05:00
TEST_MYSQL_HOST ?= mysql:3306
2024-07-15 10:32:36 -05:00
TEST_MYSQL_DBNAME ?= testgitea?multiStatements= true
2017-09-13 01:03:20 -05:00
TEST_MYSQL_USERNAME ?= root
TEST_MYSQL_PASSWORD ?=
TEST_PGSQL_HOST ?= pgsql:5432
TEST_PGSQL_DBNAME ?= testgitea
TEST_PGSQL_USERNAME ?= postgres
TEST_PGSQL_PASSWORD ?= postgres
2020-01-20 10:45:14 -05:00
TEST_PGSQL_SCHEMA ?= gtestschema
2017-09-13 01:03:20 -05:00
2016-11-04 07:58:55 -05:00
.PHONY : all
2016-11-18 03:57:30 -05:00
all : build
2016-08-30 16:06:05 -05:00
2020-01-05 12:40:02 -05:00
.PHONY : help
help :
@echo "Make Routines:"
2024-08-16 08:28:48 -05:00
@echo " - \"\" equivalent to \"build\""
2020-05-14 18:28:26 -05:00
@echo " - build build everything"
@echo " - frontend build frontend files"
@echo " - backend build backend files"
2020-09-04 19:55:06 -05:00
@echo " - watch watch everything and continuously rebuild"
2020-08-16 16:43:09 -05:00
@echo " - watch-frontend watch frontend files and continuously rebuild"
@echo " - watch-backend watch backend files and continuously rebuild"
2020-05-14 18:28:26 -05:00
@echo " - clean delete backend and integration files"
@echo " - clean-all delete backend, frontend and integration files"
2022-02-12 02:08:53 -05:00
@echo " - deps install dependencies"
@echo " - deps-frontend install frontend dependencies"
@echo " - deps-backend install backend dependencies"
2023-03-10 01:13:17 -05:00
@echo " - deps-tools install tool dependencies"
2023-06-14 13:17:58 -05:00
@echo " - deps-py install python dependencies"
2020-05-14 18:28:26 -05:00
@echo " - lint lint everything"
2023-04-22 13:53:00 -05:00
@echo " - lint-fix lint everything and fix issues"
2020-05-14 18:28:26 -05:00
@echo " - lint-frontend lint frontend files"
2023-04-22 13:53:00 -05:00
@echo " - lint-frontend-fix lint frontend files and fix issues"
2020-05-14 18:28:26 -05:00
@echo " - lint-backend lint backend files"
2023-04-22 13:53:00 -05:00
@echo " - lint-backend-fix lint backend files and fix issues"
2024-05-09 08:49:37 -05:00
@echo " - lint-codespell lint typos"
@echo " - lint-codespell-fix lint typos and fix them automatically"
@echo " - lint-codespell-fix-i lint typos and fix them interactively"
2023-04-22 13:53:00 -05:00
@echo " - lint-go lint go files"
@echo " - lint-go-fix lint go files and fix issues"
@echo " - lint-go-vet lint go files with vet"
2024-06-04 20:22:38 -05:00
@echo " - lint-go-gopls lint go files with gopls"
2023-04-22 13:53:00 -05:00
@echo " - lint-js lint js files"
@echo " - lint-js-fix lint js files and fix issues"
@echo " - lint-css lint css files"
@echo " - lint-css-fix lint css files and fix issues"
2023-04-09 13:05:12 -05:00
@echo " - lint-md lint markdown files"
2023-04-22 13:53:00 -05:00
@echo " - lint-swagger lint swagger files"
2023-06-14 13:17:58 -05:00
@echo " - lint-templates lint template files"
2024-06-18 05:42:28 -05:00
@echo " - lint-renovate lint renovate files"
2023-09-07 21:24:06 -05:00
@echo " - lint-yaml lint yaml files"
2024-02-08 22:59:39 -05:00
@echo " - lint-spell lint spelling"
@echo " - lint-spell-fix lint spelling and fix issues"
2020-08-17 11:58:07 -05:00
@echo " - checks run various consistency checks"
@echo " - checks-frontend check frontend files"
@echo " - checks-backend check backend files"
2021-04-08 05:41:57 -05:00
@echo " - test test everything"
2024-03-05 11:44:26 -05:00
@echo " - show-version-full show the same version as the API endpoint"
@echo " - show-version-major show major release number only"
2021-04-08 05:41:57 -05:00
@echo " - test-frontend test frontend files"
2024-06-24 00:12:55 -05:00
@echo " - test-frontend-coverage test frontend files and display code coverage"
2021-04-08 05:41:57 -05:00
@echo " - test-backend test backend files"
2024-06-18 07:31:15 -05:00
@echo " - test-remote-cacher test backend files that use a remote cache"
2024-04-09 09:49:05 -05:00
@echo " - test-e2e-sqlite[\#name.test.e2e] test end to end using playwright and sqlite"
2020-05-14 18:28:26 -05:00
@echo " - webpack build webpack files"
2020-07-12 04:10:56 -05:00
@echo " - svg build svg files"
2020-05-14 18:28:26 -05:00
@echo " - fomantic build fomantic files"
@echo " - generate run \"go generate\""
@echo " - fmt format the Go code"
2020-09-02 11:57:08 -05:00
@echo " - generate-license update license files"
@echo " - generate-gitignore update gitignore files"
2021-02-24 17:36:48 -05:00
@echo " - generate-manpage generate manpage"
2024-05-22 00:17:59 -05:00
@echo " - generate-gomock generate gomock files"
2023-02-07 05:23:49 -05:00
@echo " - generate-forgejo-api generate the forgejo API from spec"
@echo " - forgejo-api-validate check if the forgejo API matches the specs"
2020-05-14 18:28:26 -05:00
@echo " - generate-swagger generate the swagger spec from code comments"
@echo " - swagger-validate check if the swagger spec is valid"
2022-09-03 17:20:46 -05:00
@echo " - go-licenses regenerate go licenses"
2022-09-09 10:33:01 -05:00
@echo " - tidy run go mod tidy"
2024-08-16 08:28:48 -05:00
@echo " - test[\#TestSpecificName] run unit test"
2020-05-14 18:28:26 -05:00
@echo " - test-sqlite[\#TestSpecificName] run integration test for sqlite"
[CHORE] Support reproducible builds
This is a step towards making Forgejo's binaries (the one listed in the
release tab) reproducible.
In order to make the actual binary reproducible, we have to ensure that
the release workflow has the correct configuration to produce such
reproducible binaries. The release workflow currently uses the
Dockerfile to produce binaries, as this is one of the easiest ways to do
cross-compiling for Go binaries with CGO enabled (due to SQLite). In the
Dockerfile, two new arguments are being given to the build command.
`-trimpath` ensures that the workpath directory doesn't get included in
the binary; this means that file names (such as for panics) are
relative (to the workpath) and not absolute, which shouldn't impact
debugging. `-buildid=` is added to the linker flag; it sets the BuildID
of the Go linker to be empty; the `-buildid` hashes the input actions
and output content; these vary from build to build for unknown reasons,
but likely because of the involvement of temporary file names, this
doesn't have any effect on the behavior of the resulting binary.
The Makefile receives a new command, `reproduce-build#$VERSION` which
can be used by people to produce a reproducible Forgejo binary of a
particular release; it roughly does what the release workflow also does.
Build the Dockerfile and extract the Forgejo binary from it. This
doesn't allow to produce a reproducible version for every release, only
for those that include this patch, as it needs to call the makefile of
that version in order to make a reproducible binary.
There's one thing left to do: the Dockerfile pins the Go version to a
minor level and not to a patch level. This means that if a new Go patch
version is released, that will be used instead and will result in a
different binary that isn't bit to bit the same as the one that Forgejo
has released.
2024-08-15 13:53:47 -05:00
@echo " - reproduce-build\#version build a reproducible binary for the specified release version"
2020-01-05 12:40:02 -05:00
2024-08-16 08:04:25 -05:00
###
# Check system and environment requirements
###
2019-12-04 22:41:38 -05:00
.PHONY : go -check
go-check :
2022-07-14 03:58:14 -05:00
$( eval MIN_GO_VERSION_STR := $( shell grep -Eo '^go\s+[0-9]+\.[0-9]+' go.mod | cut -d' ' -f2) )
$( eval MIN_GO_VERSION := $( shell printf "%03d%03d" $( shell echo '$(MIN_GO_VERSION_STR)' | tr '.' ' ' ) ) )
$( eval GO_VERSION := $( shell printf "%03d%03d" $( shell $( GO) version | grep -Eo '[0-9]+\.[0-9]+' | tr '.' ' ' ) ; ) )
2020-03-20 09:29:31 -05:00
@if [ " $( GO_VERSION) " -lt " $( MIN_GO_VERSION) " ] ; then \
2024-08-16 08:04:25 -05:00
echo " Forgejo requires Go $( MIN_GO_VERSION_STR) or greater to build. You can get it at https://go.dev/dl/ " ; \
2019-12-04 22:41:38 -05:00
exit 1; \
fi
2020-01-13 19:06:54 -05:00
.PHONY : git -check
git-check :
@if git lfs >/dev/null 2>& 1 ; then : ; else \
2024-08-16 08:04:25 -05:00
echo "Forgejo requires git with lfs support to run tests." ; \
2020-01-13 19:06:54 -05:00
exit 1; \
fi
2019-12-04 22:41:38 -05:00
.PHONY : node -check
node-check :
2022-03-26 05:39:31 -05:00
$( eval MIN_NODE_VERSION_STR := $( shell grep -Eo '"node":.*[0-9.]+"' package.json | sed -n 's/.*[^0-9.]\([0-9.]*\)"/\1/p' ) )
$( eval MIN_NODE_VERSION := $( shell printf "%03d%03d%03d" $( shell echo '$(MIN_NODE_VERSION_STR)' | tr '.' ' ' ) ) )
2020-03-25 17:21:33 -05:00
$( eval NODE_VERSION := $( shell printf "%03d%03d%03d" $( shell node -v | cut -c2- | tr '.' ' ' ) ; ) )
2019-12-04 22:41:38 -05:00
$( eval NPM_MISSING := $( shell hash npm > /dev/null 2>& 1 || echo 1) )
2020-03-20 09:29:31 -05:00
@if [ " $( NODE_VERSION) " -lt " $( MIN_NODE_VERSION) " -o " $( NPM_MISSING) " = "1" ] ; then \
2024-08-16 08:04:25 -05:00
echo " Forgejo requires Node.js $( MIN_NODE_VERSION_STR) or greater and npm to build. You can get it at https://nodejs.org/en/download/ " ; \
2019-12-04 22:41:38 -05:00
exit 1; \
fi
2024-08-16 08:04:25 -05:00
###
# Basic maintenance, check and lint targets
###
2019-12-04 22:41:38 -05:00
.PHONY : clean -all
clean-all : clean
2021-05-08 04:57:48 -05:00
rm -rf $( WEBPACK_DEST_ENTRIES) node_modules
2019-12-04 22:41:38 -05:00
2016-11-04 07:58:55 -05:00
.PHONY : clean
clean :
2020-01-26 20:05:38 -05:00
rm -rf $( EXECUTABLE) $( DIST) $( BINDATA_DEST) $( BINDATA_HASH) \
2017-09-16 15:16:21 -05:00
integrations*.test \
2022-09-02 14:18:23 -05:00
e2e*.test \
2023-10-03 12:27:57 -05:00
tests/integration/gitea-integration-* \
tests/integration/indexers-* \
2024-04-04 11:02:24 -05:00
tests/mysql.ini tests/pgsql.ini man/ \
2023-10-03 12:27:57 -05:00
tests/e2e/gitea-e2e-*/ \
tests/e2e/indexers-*/ \
tests/e2e/reports/ tests/e2e/test-artifacts/ tests/e2e/test-snapshots/
2016-11-04 07:58:55 -05:00
.PHONY : fmt
2017-09-20 06:58:29 -05:00
fmt :
2024-04-13 12:32:15 -05:00
@GOFUMPT_PACKAGE= $( GOFUMPT_PACKAGE) $( GO) run build/code-batch-process.go gitea-fmt -w '{file-list}'
2022-08-31 10:58:54 -05:00
$( eval TEMPLATES := $( shell find templates -type f -name '*.tmpl' ) )
2023-04-24 01:48:43 -05:00
@# strip whitespace after '{{' or '(' and before '}}' or ')' unless there is only
@# whitespace before it
@$( SED_INPLACE) \
-e 's/{{[ ]\{1,\}/{{/g' -e '/^[ ]\{1,\}}}/! s/[ ]\{1,\}}}/}}/g' \
-e 's/([ ]\{1,\}/(/g' -e '/^[ ]\{1,\})/! s/[ ]\{1,\})/)/g' \
$( TEMPLATES)
2016-11-04 07:58:55 -05:00
2022-10-16 03:11:17 -05:00
.PHONY : fmt -check
fmt-check : fmt
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always $( GO_SOURCES) templates $( WEB_DIRS) \
|| ( code = $$ ?; echo "Please run 'make fmt' and commit the result" ; exit $$ { code} )
2022-10-16 03:11:17 -05:00
2020-02-11 14:42:03 -05:00
.PHONY : $( TAGS_EVIDENCE )
$(TAGS_EVIDENCE) :
@mkdir -p $( MAKE_EVIDENCE_DIR)
@echo " $( TAGS) " > $( TAGS_EVIDENCE)
i f n e q "$(TAGS)" "$(shell cat $(TAGS_EVIDENCE) 2>/dev/null)"
TAGS_PREREQ := $( TAGS_EVIDENCE)
e n d i f
2024-05-12 08:58:52 -05:00
OAPI_CODEGEN_PACKAGE ?= github.com/deepmap/oapi-codegen/cmd/oapi-codegen@v1.12.4
KIN_OPENAPI_CODEGEN_PACKAGE ?= github.com/getkin/kin-openapi/cmd/validate@v0.114.0
2023-02-07 05:23:49 -05:00
FORGEJO_API_SERVER = routers/api/forgejo/v1/generated.go
.PHONY : generate -forgejo -api
generate-forgejo-api : $( FORGEJO_API_SPEC )
$( GO) run $( OAPI_CODEGEN_PACKAGE) -package v1 -generate chi-server,types $< > $( FORGEJO_API_SERVER)
.PHONY : forgejo -api -check
forgejo-api-check : generate -forgejo -api
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always $( FORGEJO_API_SERVER) \
|| ( code = $$ ?; echo "Please run 'make generate-forgejo-api' and commit the result" ; exit $$ { code} )
2023-02-07 05:23:49 -05:00
.PHONY : forgejo -api -validate
forgejo-api-validate :
$( GO) run $( KIN_OPENAPI_CODEGEN_PACKAGE) $( FORGEJO_API_SPEC)
2017-06-15 08:51:23 -05:00
.PHONY : generate -swagger
2022-09-05 01:04:18 -05:00
generate-swagger : $( SWAGGER_SPEC )
$(SWAGGER_SPEC) : $( GO_SOURCES_NO_BINDATA )
2022-03-15 21:50:26 -05:00
$( GO) run $( SWAGGER_PACKAGE) generate spec -x " $( SWAGGER_EXCLUDE) " -o './$(SWAGGER_SPEC)'
2018-07-27 19:19:01 -05:00
$( SED_INPLACE) '$(SWAGGER_SPEC_S_TMPL)' './$(SWAGGER_SPEC)'
2019-04-01 10:27:40 -05:00
$( SED_INPLACE) $( SWAGGER_NEWLINE_COMMAND) './$(SWAGGER_SPEC)'
2023-01-09 16:28:04 -05:00
$( SED_INPLACE) '$(SWAGGER_SPEC_BRANDING)' './$(SWAGGER_SPEC)'
2024-08-23 12:17:07 -05:00
$( SED_INPLACE) '$(SWAGGER_SPEC_LICENSE)' './$(SWAGGER_SPEC)'
2017-07-11 21:28:57 -05:00
2018-04-20 04:13:50 -05:00
.PHONY : swagger -check
swagger-check : generate -swagger
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always '$(SWAGGER_SPEC)' \
|| ( code = $$ ?; echo "Please run 'make generate-swagger' and commit the result" ; exit $$ { code} )
2018-04-20 04:13:50 -05:00
2018-06-02 06:29:12 -05:00
.PHONY : swagger -validate
swagger-validate :
2018-07-27 19:19:01 -05:00
$( SED_INPLACE) '$(SWAGGER_SPEC_S_JSON)' './$(SWAGGER_SPEC)'
2022-03-15 21:50:26 -05:00
$( GO) run $( SWAGGER_PACKAGE) validate './$(SWAGGER_SPEC)'
2018-07-27 19:19:01 -05:00
$( SED_INPLACE) '$(SWAGGER_SPEC_S_TMPL)' './$(SWAGGER_SPEC)'
2018-06-02 06:29:12 -05:00
2020-08-16 16:43:09 -05:00
.PHONY : checks
checks : checks -frontend checks -backend
2020-03-29 06:56:58 -05:00
2020-08-16 16:43:09 -05:00
.PHONY : checks -frontend
2022-01-15 15:06:29 -05:00
checks-frontend : lockfile -check svg -check
2020-08-16 16:43:09 -05:00
.PHONY : checks -backend
2024-02-08 22:59:39 -05:00
checks-backend : tidy -check swagger -check fmt -check swagger -validate security -check
2020-08-16 16:43:09 -05:00
.PHONY : lint
2024-02-08 22:59:39 -05:00
lint : lint -frontend lint -backend lint -spell
2020-03-29 06:56:58 -05:00
2023-04-22 13:53:00 -05:00
.PHONY : lint -fix
2024-02-09 05:57:09 -05:00
lint-fix : lint -frontend -fix lint -backend -fix lint -spell -fix
2023-04-22 13:53:00 -05:00
2020-03-29 06:56:58 -05:00
.PHONY : lint -frontend
2023-06-29 09:37:41 -05:00
lint-frontend : lint -js lint -css
2023-04-22 13:53:00 -05:00
.PHONY : lint -frontend -fix
2023-06-29 09:37:41 -05:00
lint-frontend-fix : lint -js -fix lint -css -fix
2023-04-22 13:53:00 -05:00
.PHONY : lint -backend
2024-06-18 05:42:28 -05:00
lint-backend : lint -go lint -go -vet lint -editorconfig lint -renovate
2023-04-22 13:53:00 -05:00
.PHONY : lint -backend -fix
lint-backend-fix : lint -go -fix lint -go -vet lint -editorconfig
2024-05-09 08:49:37 -05:00
.PHONY : lint -codespell
lint-codespell :
codespell
.PHONY : lint -codespell -fix
lint-codespell-fix :
codespell -w
.PHONY : lint -codespell -fix -i
lint-codespell-fix-i :
codespell -w -i 3 -C 2
2023-04-22 13:53:00 -05:00
.PHONY : lint -js
lint-js : node_modules
2024-10-23 00:07:18 -05:00
npx eslint --color --max-warnings= 0 $( ESLINT_FILES)
2023-04-22 13:53:00 -05:00
.PHONY : lint -js -fix
lint-js-fix : node_modules
2024-10-23 00:07:18 -05:00
npx eslint --color --max-warnings= 0 $( ESLINT_FILES) --fix
2023-04-22 13:53:00 -05:00
.PHONY : lint -css
lint-css : node_modules
2024-03-17 17:12:36 -05:00
npx stylelint --color --max-warnings= 0 $( STYLELINT_FILES)
2023-04-22 13:53:00 -05:00
.PHONY : lint -css -fix
lint-css-fix : node_modules
2024-03-17 17:12:36 -05:00
npx stylelint --color --max-warnings= 0 $( STYLELINT_FILES) --fix
2023-04-22 13:53:00 -05:00
.PHONY : lint -swagger
lint-swagger : node_modules
2022-07-11 18:07:16 -05:00
npx spectral lint -q -F hint $( SWAGGER_SPEC)
2023-04-09 13:05:12 -05:00
2024-06-18 05:42:28 -05:00
.PHONY : lint -renovate
lint-renovate : node_modules
npx --yes --package $( RENOVATE_NPM_PACKAGE) -- renovate-config-validator --strict > .lint-renovate 2>& 1 || true
@if grep --quiet --extended-regexp -e '^( WARN:|ERROR:)' .lint-renovate ; then cat .lint-renovate ; rm .lint-renovate ; exit 1 ; fi
@rm .lint-renovate
2023-04-09 13:05:12 -05:00
.PHONY : lint -md
lint-md : node_modules
2022-07-27 20:22:47 -05:00
npx markdownlint docs *.md
2020-03-29 06:56:58 -05:00
2024-02-08 22:59:39 -05:00
.PHONY : lint -spell
2024-05-09 08:49:37 -05:00
lint-spell : lint -codespell
2024-02-08 22:59:39 -05:00
@go run $( MISSPELL_PACKAGE) -error $( SPELLCHECK_FILES)
.PHONY : lint -spell -fix
2024-05-09 08:49:37 -05:00
lint-spell-fix : lint -codespell -fix
2024-02-08 22:59:39 -05:00
@go run $( MISSPELL_PACKAGE) -w $( SPELLCHECK_FILES)
2024-06-08 15:02:25 -05:00
RUN_DEADCODE = $( GO) run $( DEADCODE_PACKAGE) -generated= false -f= '{{println .Path}}{{range .Funcs}}{{printf "\t%s\n" .Name}}{{end}}{{println}}' -test code.gitea.io/gitea
2023-04-22 13:53:00 -05:00
.PHONY : lint -go
lint-go :
2023-09-10 09:47:22 -05:00
$( GO) run $( GOLANGCI_LINT_PACKAGE) run $( GOLANGCI_LINT_ARGS)
2024-06-08 15:02:25 -05:00
$( RUN_DEADCODE) > .cur-deadcode-out
2024-03-14 05:38:58 -05:00
@$( DIFF) .deadcode-out .cur-deadcode-out \
|| ( code = $$ ?; echo "Please run 'make lint-go-fix' and commit the result" ; exit $$ { code} )
2023-04-22 13:53:00 -05:00
.PHONY : lint -go -fix
lint-go-fix :
2023-09-10 09:47:22 -05:00
$( GO) run $( GOLANGCI_LINT_PACKAGE) run $( GOLANGCI_LINT_ARGS) --fix
2024-06-08 15:02:25 -05:00
$( RUN_DEADCODE) > .deadcode-out
2023-04-22 13:53:00 -05:00
2023-05-11 20:21:28 -05:00
# workaround step for the lint-go-windows CI task because 'go run' can not
2023-04-22 13:53:00 -05:00
# have distinct GOOS/GOARCH for its build and run steps
.PHONY : lint -go -windows
lint-go-windows :
@GOOS= GOARCH = $( GO) install $( GOLANGCI_LINT_PACKAGE)
golangci-lint run
.PHONY : lint -go -vet
lint-go-vet :
@echo "Running go vet..."
2024-04-17 04:40:35 -05:00
@$( GO) vet ./...
2023-04-22 13:53:00 -05:00
2024-06-04 20:22:38 -05:00
.PHONY : lint -go -gopls
lint-go-gopls :
@echo "Running gopls check..."
@GO= $( GO) GOPLS_PACKAGE = $( GOPLS_PACKAGE) tools/lint-go-gopls.sh $( GO_SOURCES_NO_BINDATA)
2023-04-22 13:53:00 -05:00
.PHONY : lint -editorconfig
lint-editorconfig :
2023-12-19 09:35:38 -05:00
$( GO) run $( EDITORCONFIG_CHECKER_PACKAGE) templates .forgejo/workflows
2020-08-16 16:43:09 -05:00
2023-06-14 13:17:58 -05:00
.PHONY : lint -templates
2024-03-26 06:19:15 -05:00
lint-templates : .venv node_modules
@node tools/lint-templates-svg.js
2023-06-14 13:17:58 -05:00
@poetry run djlint $( shell find templates -type f -iname '*.tmpl' )
2023-09-07 21:24:06 -05:00
.PHONY : lint -yaml
lint-yaml : .venv
@poetry run yamllint .
2024-08-16 08:04:25 -05:00
.PHONY : security -check
security-check :
go run $( GOVULNCHECK_PACKAGE) ./...
###
# Development and testing targets
###
2020-09-04 19:55:06 -05:00
.PHONY : watch
watch :
2024-03-17 17:12:36 -05:00
@bash tools/watch.sh
2020-09-04 19:55:06 -05:00
2020-04-11 22:50:59 -05:00
.PHONY : watch -frontend
2020-10-27 18:44:06 -05:00
watch-frontend : node -check node_modules
2023-05-24 15:11:04 -05:00
@rm -rf $( WEBPACK_DEST_ENTRIES)
2020-12-27 09:24:27 -05:00
NODE_ENV = development npx webpack --watch --progress
2020-04-11 22:50:59 -05:00
2020-07-27 13:05:42 -05:00
.PHONY : watch -backend
watch-backend : go -check
2022-12-27 01:00:34 -05:00
GITEA_RUN_MODE = dev $( GO) run $( AIR_PACKAGE) -c .air.toml
2020-07-27 13:05:42 -05:00
2016-11-04 07:58:55 -05:00
.PHONY : test
2021-04-08 05:41:57 -05:00
test : test -frontend test -backend
.PHONY : test -backend
test-backend :
2021-07-17 12:09:56 -05:00
@echo " Running go test with $( GOTESTFLAGS) -tags ' $( TEST_TAGS) '... "
2024-09-06 06:54:14 -05:00
@$( GOTEST) $( GOTESTFLAGS) -tags= '$(TEST_TAGS)' $( GO_TEST_PACKAGES)
2017-05-24 11:13:18 -05:00
2024-06-18 07:31:15 -05:00
.PHONY : test -remote -cacher
test-remote-cacher :
@echo " Running go test with $( GOTESTFLAGS) -tags ' $( TEST_TAGS) '... "
2024-09-06 06:54:14 -05:00
@$( GOTEST) $( GOTESTFLAGS) -tags= '$(TEST_TAGS)' $( GO_TEST_REMOTE_CACHER_PACKAGES)
2024-06-18 07:31:15 -05:00
2021-04-08 05:41:57 -05:00
.PHONY : test -frontend
2021-05-14 01:28:51 -05:00
test-frontend : node_modules
2022-10-14 08:36:16 -05:00
npx vitest
2021-04-08 05:41:57 -05:00
2024-06-24 00:12:55 -05:00
.PHONY : test -frontend -coverage
test-frontend-coverage : node_modules
npx vitest --coverage --coverage.include 'web_src/**'
2020-03-06 01:47:40 -05:00
.PHONY : test -check
2020-01-26 15:07:12 -05:00
test-check :
2020-12-02 20:54:30 -05:00
@echo "Running test-check..." ;
2020-01-26 15:07:12 -05:00
@diff= $$ ( git status -s) ; \
if [ -n " $$ diff " ] ; then \
2021-04-08 05:41:57 -05:00
echo "make test-backend has changed files in the source tree:" ; \
2020-01-26 15:07:12 -05:00
echo " $$ {diff} " ; \
echo "You should change the tests to create these files in a temporary directory." ; \
echo "Do not simply add these files to .gitignore" ; \
exit 1; \
2020-11-29 16:39:36 -05:00
fi
2020-01-26 15:07:12 -05:00
2019-10-16 08:42:42 -05:00
.PHONY : test \#%
test\#% :
2020-12-17 09:00:47 -05:00
@echo " Running go test with -tags ' $( TEST_TAGS) '... "
2024-09-06 06:54:14 -05:00
@$( GOTEST) $( GOTESTFLAGS) -tags= '$(TEST_TAGS)' -run $( subst .,/,$* ) $( GO_TEST_PACKAGES)
2019-10-16 08:42:42 -05:00
2017-09-07 12:22:15 -05:00
.PHONY : coverage
2017-09-13 07:57:55 -05:00
coverage :
2021-08-31 21:43:29 -05:00
grep '^\(mode: .*\)\|\(.*:[0-9]\+\.[0-9]\+,[0-9]\+\.[0-9]\+ [0-9]\+ [0-9]\+\)$$' coverage.out > coverage-bodged.out
grep '^\(mode: .*\)\|\(.*:[0-9]\+\.[0-9]\+,[0-9]\+\.[0-9]\+ [0-9]\+ [0-9]\+\)$$' integration.coverage.out > integration.coverage-bodged.out
2022-08-12 15:13:31 -05:00
$( GO) run build/gocovmerge.go integration.coverage-bodged.out coverage-bodged.out > coverage.all
2017-06-15 04:38:33 -05:00
.PHONY : unit -test -coverage
unit-test-coverage :
2021-07-17 12:09:56 -05:00
@echo " Running unit-test-coverage $( GOTESTFLAGS) -tags ' $( TEST_TAGS) '... "
2024-09-06 06:54:14 -05:00
@$( GOTEST) $( GOTESTFLAGS) -timeout= 20m -tags= '$(TEST_TAGS)' -cover -coverprofile coverage.out $( GO_TEST_PACKAGES) && echo "\n==>\033[32m Ok\033[m\n" || exit 1
2015-11-08 14:31:49 -05:00
2022-05-24 19:19:13 -05:00
.PHONY : tidy
tidy :
$( eval MIN_GO_VERSION := $( shell grep -Eo '^go\s+[0-9]+\.[0-9.]+' go.mod | cut -d' ' -f2) )
$( GO) mod tidy -compat= $( MIN_GO_VERSION)
2022-10-10 13:45:02 -05:00
@$( MAKE) --no-print-directory $( GO_LICENSE_FILE)
2022-05-24 19:19:13 -05:00
2022-09-09 10:33:01 -05:00
vendor : go .mod go .sum
2022-05-24 19:19:13 -05:00
$( GO) mod vendor
2022-09-09 10:33:01 -05:00
@touch vendor
2017-05-02 08:22:21 -05:00
2022-09-01 20:58:09 -05:00
.PHONY : tidy -check
tidy-check : tidy
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always go.mod go.sum $( GO_LICENSE_FILE) \
|| ( code = $$ ?; echo "Please run 'make tidy' and commit the result" ; exit $$ { code} )
2017-04-24 09:31:46 -05:00
2022-09-03 17:20:46 -05:00
.PHONY : go -licenses
2022-09-09 10:33:01 -05:00
go-licenses : $( GO_LICENSE_FILE )
2022-09-03 17:20:46 -05:00
2022-09-09 10:33:01 -05:00
$(GO_LICENSE_FILE) : go .mod go .sum
2024-07-25 04:03:36 -05:00
-$( shell $( GO) env GOROOT) /bin/go run $( GO_LICENSES_PACKAGE) save . --force --ignore code.gitea.io/gitea --save_path= $( GO_LICENSE_TMP_DIR) 2>/dev/null
2022-09-07 16:35:54 -05:00
$( GO) run build/generate-go-licenses.go $( GO_LICENSE_TMP_DIR) $( GO_LICENSE_FILE)
@rm -rf $( GO_LICENSE_TMP_DIR)
2022-09-03 17:20:46 -05:00
2020-04-19 06:17:02 -05:00
generate-ini-sqlite :
sed -e 's|{{REPO_TEST_DIR}}|${REPO_TEST_DIR}|g' \
2022-09-02 14:18:23 -05:00
-e 's|{{TEST_LOGGER}}|$(or $(TEST_LOGGER),test$(COMMA)file)|g' \
-e 's|{{TEST_TYPE}}|$(or $(TEST_TYPE),integration)|g' \
tests/sqlite.ini.tmpl > tests/sqlite.ini
2020-04-19 06:17:02 -05:00
2017-04-25 02:24:51 -05:00
.PHONY : test -sqlite
2020-04-19 06:17:02 -05:00
test-sqlite : integrations .sqlite .test generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX)
2017-04-25 02:24:51 -05:00
2019-04-04 11:22:10 -05:00
.PHONY : test -sqlite \#%
2020-04-19 06:17:02 -05:00
test-sqlite\#% : integrations .sqlite .test generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run $( subst .,/,$* )
2019-04-04 11:22:10 -05:00
2019-01-28 11:18:52 -05:00
.PHONY : test -sqlite -migration
2022-11-02 03:54:36 -05:00
test-sqlite-migration : migrations .sqlite .test migrations .individual .sqlite .test
2022-02-13 16:19:12 -05:00
2019-09-25 07:13:18 -05:00
generate-ini-mysql :
2017-09-13 01:03:20 -05:00
sed -e 's|{{TEST_MYSQL_HOST}}|${TEST_MYSQL_HOST}|g' \
2017-09-13 07:57:55 -05:00
-e 's|{{TEST_MYSQL_DBNAME}}|${TEST_MYSQL_DBNAME}|g' \
-e 's|{{TEST_MYSQL_USERNAME}}|${TEST_MYSQL_USERNAME}|g' \
-e 's|{{TEST_MYSQL_PASSWORD}}|${TEST_MYSQL_PASSWORD}|g' \
2020-04-19 06:17:02 -05:00
-e 's|{{REPO_TEST_DIR}}|${REPO_TEST_DIR}|g' \
2022-09-02 14:18:23 -05:00
-e 's|{{TEST_LOGGER}}|$(or $(TEST_LOGGER),test$(COMMA)file)|g' \
-e 's|{{TEST_TYPE}}|$(or $(TEST_TYPE),integration)|g' \
tests/mysql.ini.tmpl > tests/mysql.ini
2019-09-25 07:13:18 -05:00
.PHONY : test -mysql
test-mysql : integrations .mysql .test generate -ini -mysql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.mysql.test $( GOTESTCOMPILEDRUNSUFFIX)
2019-09-25 07:13:18 -05:00
.PHONY : test -mysql \#%
test-mysql\#% : integrations .mysql .test generate -ini -mysql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.mysql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run $( subst .,/,$* )
2019-09-25 07:13:18 -05:00
.PHONY : test -mysql -migration
2022-11-02 03:54:36 -05:00
test-mysql-migration : migrations .mysql .test migrations .individual .mysql .test
2019-09-25 07:13:18 -05:00
generate-ini-pgsql :
2017-09-13 07:57:55 -05:00
sed -e 's|{{TEST_PGSQL_HOST}}|${TEST_PGSQL_HOST}|g' \
-e 's|{{TEST_PGSQL_DBNAME}}|${TEST_PGSQL_DBNAME}|g' \
-e 's|{{TEST_PGSQL_USERNAME}}|${TEST_PGSQL_USERNAME}|g' \
-e 's|{{TEST_PGSQL_PASSWORD}}|${TEST_PGSQL_PASSWORD}|g' \
2020-01-20 10:45:14 -05:00
-e 's|{{TEST_PGSQL_SCHEMA}}|${TEST_PGSQL_SCHEMA}|g' \
2020-04-19 06:17:02 -05:00
-e 's|{{REPO_TEST_DIR}}|${REPO_TEST_DIR}|g' \
2022-09-02 14:18:23 -05:00
-e 's|{{TEST_LOGGER}}|$(or $(TEST_LOGGER),test$(COMMA)file)|g' \
-e 's|{{TEST_TYPE}}|$(or $(TEST_TYPE),integration)|g' \
tests/pgsql.ini.tmpl > tests/pgsql.ini
2016-11-24 08:40:56 -05:00
2019-09-25 07:13:18 -05:00
.PHONY : test -pgsql
test-pgsql : integrations .pgsql .test generate -ini -pgsql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.pgsql.test $( GOTESTCOMPILEDRUNSUFFIX)
2019-01-28 11:18:52 -05:00
2019-09-25 07:13:18 -05:00
.PHONY : test -pgsql \#%
test-pgsql\#% : integrations .pgsql .test generate -ini -pgsql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTESTCOMPILEDRUNPREFIX) ./integrations.pgsql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run $( subst .,/,$* )
2019-03-17 14:17:18 -05:00
2019-09-25 07:13:18 -05:00
.PHONY : test -pgsql -migration
2022-11-02 03:54:36 -05:00
test-pgsql-migration : migrations .pgsql .test migrations .individual .pgsql .test
2019-03-17 14:17:18 -05:00
2022-09-02 14:18:23 -05:00
.PHONY : playwright
2024-02-21 22:19:13 -05:00
playwright : deps -frontend
2022-09-02 14:18:23 -05:00
npx playwright install $( PLAYWRIGHT_FLAGS)
.PHONY : test -e 2e %
test-e2e% : TEST_TYPE ?= e 2e
# Clear display env variable. Otherwise, chromium tests can fail.
DISPLAY =
.PHONY : test -e 2e
test-e2e : test -e 2e -sqlite
.PHONY : test -e 2e -sqlite
test-e2e-sqlite : playwright e 2e .sqlite .test generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e
2022-09-02 14:18:23 -05:00
.PHONY : test -e 2e -sqlite \#%
test-e2e-sqlite\#% : playwright e 2e .sqlite .test generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e/$*
2022-09-02 14:18:23 -05:00
2024-04-09 09:49:05 -05:00
.PHONY : test -e 2e -sqlite -firefox \#%
test-e2e-sqlite-firefox\#% : playwright e 2e .sqlite .test generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini PLAYWRIGHT_PROJECT = firefox $( GOTESTCOMPILEDRUNPREFIX) ./e2e.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e/$*
2024-04-09 09:49:05 -05:00
2022-09-02 14:18:23 -05:00
.PHONY : test -e 2e -mysql
test-e2e-mysql : playwright e 2e .mysql .test generate -ini -mysql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.mysql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e
2022-09-02 14:18:23 -05:00
.PHONY : test -e 2e -mysql \#%
test-e2e-mysql\#% : playwright e 2e .mysql .test generate -ini -mysql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.mysql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e/$*
2022-09-02 14:18:23 -05:00
.PHONY : test -e 2e -pgsql
test-e2e-pgsql : playwright e 2e .pgsql .test generate -ini -pgsql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.pgsql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e
2022-09-02 14:18:23 -05:00
.PHONY : test -e 2e -pgsql \#%
test-e2e-pgsql\#% : playwright e 2e .pgsql .test generate -ini -pgsql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTESTCOMPILEDRUNPREFIX) ./e2e.pgsql.test $( GOTESTCOMPILEDRUNSUFFIX) -test.run TestE2e/$*
2022-09-02 14:18:23 -05:00
2024-02-21 12:10:21 -05:00
.PHONY : test -e 2e -debugserver
test-e2e-debugserver : e 2e .sqlite .test generate -ini -sqlite
sed -i s/3003/3000/g tests/sqlite.ini
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini ./e2e.sqlite.test -test.run TestDebugserver -test.timeout 24h
2017-06-20 06:23:16 -05:00
.PHONY : bench -sqlite
2020-04-19 06:17:02 -05:00
bench-sqlite : integrations .sqlite .test generate -ini -sqlite
2022-09-02 14:18:23 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini ./integrations.sqlite.test -test.cpuprofile= cpu.out -test.run DontRunTests -test.bench .
2017-06-20 06:23:16 -05:00
.PHONY : bench -mysql
2019-09-25 07:13:18 -05:00
bench-mysql : integrations .mysql .test generate -ini -mysql
2022-09-02 14:18:23 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini ./integrations.mysql.test -test.cpuprofile= cpu.out -test.run DontRunTests -test.bench .
2017-06-20 06:23:16 -05:00
.PHONY : bench -pgsql
2019-09-25 07:13:18 -05:00
bench-pgsql : integrations .pgsql .test generate -ini -pgsql
2022-09-02 14:18:23 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini ./integrations.pgsql.test -test.cpuprofile= cpu.out -test.run DontRunTests -test.bench .
2017-06-20 06:23:16 -05:00
2017-06-15 04:38:33 -05:00
.PHONY : integration -test -coverage
2019-09-25 07:13:18 -05:00
integration-test-coverage : integrations .cover .test generate -ini -mysql
2022-09-02 14:18:23 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini ./integrations.cover.test -test.coverprofile= integration.coverage.out
2017-06-15 04:38:33 -05:00
2022-02-18 21:28:43 -05:00
.PHONY : integration -test -coverage -sqlite
integration-test-coverage-sqlite : integrations .cover .sqlite .test generate -ini -sqlite
2022-09-02 14:18:23 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini ./integrations.cover.sqlite.test -test.coverprofile= integration.coverage.out
2022-02-18 21:28:43 -05:00
2020-01-13 19:06:54 -05:00
integrations.mysql.test : git -check $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration -o integrations.mysql.test
2019-09-25 07:13:18 -05:00
2020-01-13 19:06:54 -05:00
integrations.pgsql.test : git -check $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration -o integrations.pgsql.test
2019-09-25 07:13:18 -05:00
2020-01-13 19:06:54 -05:00
integrations.sqlite.test : git -check $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration -o integrations.sqlite.test -tags '$(TEST_TAGS)'
2017-06-15 04:38:33 -05:00
2020-01-16 14:21:35 -05:00
integrations.cover.test : git -check $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration -coverpkg $( shell echo $( GO_TEST_PACKAGES) | tr ' ' ',' ) -o integrations.cover.test
2017-06-15 04:38:33 -05:00
2022-02-18 21:28:43 -05:00
integrations.cover.sqlite.test : git -check $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration -coverpkg $( shell echo $( GO_TEST_PACKAGES) | tr ' ' ',' ) -o integrations.cover.sqlite.test -tags '$(TEST_TAGS)'
2022-02-18 21:28:43 -05:00
2019-09-25 07:13:18 -05:00
.PHONY : migrations .mysql .test
2022-11-02 03:54:36 -05:00
migrations.mysql.test : $( GO_SOURCES ) generate -ini -mysql
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration/migration-test -o migrations.mysql.test
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTESTCOMPILEDRUNPREFIX) ./migrations.mysql.test $( GOTESTCOMPILEDRUNSUFFIX)
2019-09-25 07:13:18 -05:00
.PHONY : migrations .pgsql .test
2022-11-02 03:54:36 -05:00
migrations.pgsql.test : $( GO_SOURCES ) generate -ini -pgsql
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration/migration-test -o migrations.pgsql.test
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTESTCOMPILEDRUNPREFIX) ./migrations.pgsql.test $( GOTESTCOMPILEDRUNSUFFIX)
2019-09-25 07:13:18 -05:00
2019-01-28 11:18:52 -05:00
.PHONY : migrations .sqlite .test
2022-11-02 03:54:36 -05:00
migrations.sqlite.test : $( GO_SOURCES ) generate -ini -sqlite
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/integration/migration-test -o migrations.sqlite.test -tags '$(TEST_TAGS)'
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTESTCOMPILEDRUNPREFIX) ./migrations.sqlite.test $( GOTESTCOMPILEDRUNSUFFIX)
2019-01-28 11:18:52 -05:00
2021-03-24 13:27:22 -05:00
.PHONY : migrations .individual .mysql .test
migrations.individual.mysql.test : $( GO_SOURCES )
2024-01-22 13:11:24 -05:00
for pkg in $( MIGRATION_PACKAGES) ; do \
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/mysql.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' $$ pkg || exit 1; \
2022-11-02 03:54:36 -05:00
done
2021-03-24 13:27:22 -05:00
2023-10-03 12:27:57 -05:00
.PHONY : migrations .individual .sqlite .test \#%
2022-11-02 03:54:36 -05:00
migrations.individual.sqlite.test\#% : $( GO_SOURCES ) generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' code.gitea.io/gitea/models/migrations/$*
2021-03-24 13:27:22 -05:00
.PHONY : migrations .individual .pgsql .test
migrations.individual.pgsql.test : $( GO_SOURCES )
2024-01-22 13:11:24 -05:00
for pkg in $( MIGRATION_PACKAGES) ; do \
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' $$ pkg || exit 1; \
2022-11-02 03:54:36 -05:00
done
.PHONY : migrations .individual .pgsql .test \#%
migrations.individual.pgsql.test\#% : $( GO_SOURCES ) generate -ini -pgsql
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/pgsql.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' code.gitea.io/gitea/models/migrations/$*
2022-11-02 03:54:36 -05:00
2021-03-24 13:27:22 -05:00
.PHONY : migrations .individual .sqlite .test
2022-11-02 03:54:36 -05:00
migrations.individual.sqlite.test : $( GO_SOURCES ) generate -ini -sqlite
2024-01-22 13:11:24 -05:00
for pkg in $( MIGRATION_PACKAGES) ; do \
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' $$ pkg || exit 1; \
2022-11-02 03:54:36 -05:00
done
.PHONY : migrations .individual .sqlite .test \#%
migrations.individual.sqlite.test\#% : $( GO_SOURCES ) generate -ini -sqlite
2024-09-06 06:54:14 -05:00
GITEA_ROOT = " $( CURDIR) " GITEA_CONF = tests/sqlite.ini $( GOTEST) $( GOTESTFLAGS) -tags '$(TEST_TAGS)' code.gitea.io/gitea/models/migrations/$*
2021-03-24 13:27:22 -05:00
2022-09-02 14:18:23 -05:00
e2e.mysql.test : $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/e2e -o e2e.mysql.test
2022-09-02 14:18:23 -05:00
e2e.pgsql.test : $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/e2e -o e2e.pgsql.test
2022-09-02 14:18:23 -05:00
e2e.sqlite.test : $( GO_SOURCES )
2024-09-06 06:54:14 -05:00
$( GOTEST) $( GOTESTFLAGS) -c code.gitea.io/gitea/tests/e2e -o e2e.sqlite.test -tags '$(TEST_TAGS)'
2022-09-02 14:18:23 -05:00
2016-11-07 09:31:44 -05:00
.PHONY : check
2016-11-07 07:41:47 -05:00
check : test
2024-08-16 08:04:25 -05:00
###
# Production / build targets
###
2020-02-11 14:42:03 -05:00
.PHONY : install $( TAGS_PREREQ )
2016-11-24 08:38:37 -05:00
install : $( wildcard *.go )
2020-06-05 18:57:25 -05:00
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) install -v -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)'
2016-08-05 14:46:26 -05:00
2016-11-04 07:58:55 -05:00
.PHONY : build
2020-02-22 04:15:11 -05:00
build : frontend backend
.PHONY : frontend
2022-10-10 13:45:02 -05:00
frontend : $( WEBPACK_DEST )
2020-02-22 04:15:11 -05:00
.PHONY : backend
2022-09-05 01:04:18 -05:00
backend : go -check generate -backend $( EXECUTABLE )
2020-02-22 04:15:11 -05:00
2022-09-05 01:04:18 -05:00
# We generate the backend before the frontend in case we in future we want to generate things in the frontend from generated files in backend
2020-02-22 04:15:11 -05:00
.PHONY : generate
2022-10-10 13:45:02 -05:00
generate : generate -backend
2022-09-09 10:33:01 -05:00
2022-09-05 01:04:18 -05:00
.PHONY : generate -backend
generate-backend : $( TAGS_PREREQ ) generate -go
2022-09-09 10:33:01 -05:00
.PHONY : generate -go
2022-09-05 01:04:18 -05:00
generate-go : $( TAGS_PREREQ )
2020-12-02 20:54:30 -05:00
@echo "Running go generate..."
2024-04-28 22:45:53 -05:00
@CC= GOOS = GOARCH = CGO_ENABLED = 0 $( GO) generate -tags '$(TAGS)' ./...
2016-07-25 13:48:17 -05:00
2024-03-28 11:29:32 -05:00
.PHONY : merge -locales
merge-locales :
@echo "NOT NEEDED: THIS IS A NOOP AS OF Forgejo 7.0 BUT KEPT FOR BACKWARD COMPATIBILITY"
2020-02-11 14:42:03 -05:00
$(EXECUTABLE) : $( GO_SOURCES ) $( TAGS_PREREQ )
2022-01-14 18:16:05 -05:00
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) build $( GOFLAGS) $( EXTRA_GOFLAGS) -tags '$(TAGS)' -ldflags '-s -w $(LDFLAGS)' -o $@
2016-02-14 23:14:55 -05:00
2023-07-21 04:36:24 -05:00
forgejo : $( EXECUTABLE )
ln -f $( EXECUTABLE) forgejo
2023-06-14 06:32:20 -05:00
static-executable : $( GO_SOURCES ) $( TAGS_PREREQ )
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) build $( GOFLAGS) $( EXTRA_GOFLAGS) -tags 'netgo osusergo $(TAGS)' -ldflags '-s -w -linkmode external -extldflags "-static" $(LDFLAGS)' -o $( EXECUTABLE)
2016-11-04 07:58:55 -05:00
.PHONY : release
2023-08-22 01:20:19 -05:00
release : frontend generate release -linux release -copy release -compress vendor release -sources release -check
2016-12-04 17:48:36 -05:00
2023-06-14 06:32:20 -05:00
# just the sources, with all assets builtin and frontend resources generated
sources-tarbal : frontend generate vendor release -sources release -check
2020-02-18 22:10:25 -05:00
$(DIST_DIRS) :
mkdir -p $( DIST_DIRS)
2015-11-03 12:16:43 -05:00
2017-03-07 08:49:24 -05:00
.PHONY : release -windows
2020-02-18 22:10:25 -05:00
release-windows : | $( DIST_DIRS )
2023-01-16 08:29:10 -05:00
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) run $( XGO_PACKAGE) -go $( XGO_VERSION) -buildmode exe -dest $( DIST) /binaries -tags 'osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets 'windows/*' -out gitea-$( VERSION) .
2017-03-07 08:49:24 -05:00
.PHONY : release -linux
2020-02-18 22:10:25 -05:00
release-linux : | $( DIST_DIRS )
2022-11-19 05:41:18 -05:00
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) run $( XGO_PACKAGE) -go $( XGO_VERSION) -dest $( DIST) /binaries -tags 'netgo osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets '$(LINUX_ARCHS)' -out forgejo-$( VERSION) .
i f e q ( $( CI ) , t r u e )
cp /build/* $( DIST) /binaries
e n d i f
2017-03-07 08:49:24 -05:00
.PHONY : release -darwin
2020-02-18 22:10:25 -05:00
release-darwin : | $( DIST_DIRS )
2022-03-15 21:50:26 -05:00
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) run $( XGO_PACKAGE) -go $( XGO_VERSION) -dest $( DIST) /binaries -tags 'netgo osusergo $(TAGS)' -ldflags '$(LDFLAGS)' -targets 'darwin-10.12/amd64,darwin-10.12/arm64' -out gitea-$( VERSION) .
2015-11-03 12:16:43 -05:00
2023-01-10 17:21:24 -05:00
.PHONY : release -freebsd
release-freebsd : | $( DIST_DIRS )
CGO_CFLAGS = " $( CGO_CFLAGS) " $( GO) run $( XGO_PACKAGE) -go $( XGO_VERSION) -dest $( DIST) /binaries -tags 'netgo osusergo $(TAGS)' -ldflags '$(LDFLAGS)' -targets 'freebsd/amd64' -out gitea-$( VERSION) .
2016-11-04 07:58:55 -05:00
.PHONY : release -copy
2020-02-18 22:10:25 -05:00
release-copy : | $( DIST_DIRS )
2022-06-04 21:42:24 -05:00
cd $( DIST) ; for file in ` find . -type f -name "*" ` ; do cp $$ { file} ./release/; done ;
2015-12-01 16:18:30 -05:00
2016-11-04 07:58:55 -05:00
.PHONY : release -check
2020-02-18 22:10:25 -05:00
release-check : | $( DIST_DIRS )
2019-04-14 15:33:24 -05:00
cd $( DIST) /release/; for file in ` find . -type f -name "*" ` ; do echo " checksumming $$ {file} " && $( SHASUM) ` echo $$ { file} | sed 's/^..//' ` > $$ { file} .sha256; done ;
2015-12-01 16:18:30 -05:00
2018-05-21 13:50:39 -05:00
.PHONY : release -compress
2020-02-18 22:10:25 -05:00
release-compress : | $( DIST_DIRS )
2023-07-26 17:51:02 -05:00
cd $( DIST) /release/; for file in ` find . -type f -name "*" ` ; do echo " compressing $$ {file} " && $( GO) run $( GXZ_PACKAGE) -k -9 $$ { file} ; done ;
2018-05-21 13:50:39 -05:00
2020-02-16 12:53:02 -05:00
.PHONY : release -sources
2021-04-09 00:08:14 -05:00
release-sources : | $( DIST_DIRS )
2020-02-22 04:15:11 -05:00
echo $( VERSION) > $( STORED_VERSION_FILE)
2021-04-09 00:08:14 -05:00
# bsdtar needs a ^ to prevent matching subdirectories
$( eval EXCL := --exclude= $( shell tar --help | grep -q bsdtar && echo "^" ) ./)
2022-04-25 11:41:07 -05:00
# use transform to a add a release-folder prefix; in bsdtar the transform parameter equivalent is -s
2022-11-19 05:41:18 -05:00
$( eval TRANSFORM := $( shell tar --help | grep -q bsdtar && echo " -s '/^./forgejo-src- $( VERSION) /' " || echo " --transform 's|^./|forgejo-src- $( VERSION) /|' " ) )
tar $( addprefix $( EXCL) ,$( TAR_EXCLUDES) ) $( TRANSFORM) -czf $( DIST) /release/forgejo-src-$( VERSION) .tar.gz .
2020-02-22 04:15:11 -05:00
rm -f $( STORED_VERSION_FILE)
2020-02-16 12:53:02 -05:00
2020-07-13 21:09:39 -05:00
.PHONY : release -docs
release-docs : | $( DIST_DIRS ) docs
2023-07-25 23:53:13 -05:00
tar -czf $( DIST) /release/gitea-docs-$( VERSION) .tar.gz -C ./docs .
2020-07-13 21:09:39 -05:00
[CHORE] Support reproducible builds
This is a step towards making Forgejo's binaries (the one listed in the
release tab) reproducible.
In order to make the actual binary reproducible, we have to ensure that
the release workflow has the correct configuration to produce such
reproducible binaries. The release workflow currently uses the
Dockerfile to produce binaries, as this is one of the easiest ways to do
cross-compiling for Go binaries with CGO enabled (due to SQLite). In the
Dockerfile, two new arguments are being given to the build command.
`-trimpath` ensures that the workpath directory doesn't get included in
the binary; this means that file names (such as for panics) are
relative (to the workpath) and not absolute, which shouldn't impact
debugging. `-buildid=` is added to the linker flag; it sets the BuildID
of the Go linker to be empty; the `-buildid` hashes the input actions
and output content; these vary from build to build for unknown reasons,
but likely because of the involvement of temporary file names, this
doesn't have any effect on the behavior of the resulting binary.
The Makefile receives a new command, `reproduce-build#$VERSION` which
can be used by people to produce a reproducible Forgejo binary of a
particular release; it roughly does what the release workflow also does.
Build the Dockerfile and extract the Forgejo binary from it. This
doesn't allow to produce a reproducible version for every release, only
for those that include this patch, as it needs to call the makefile of
that version in order to make a reproducible binary.
There's one thing left to do: the Dockerfile pins the Go version to a
minor level and not to a patch level. This means that if a new Go patch
version is released, that will be used instead and will result in a
different binary that isn't bit to bit the same as the one that Forgejo
has released.
2024-08-15 13:53:47 -05:00
.PHONY : reproduce -build
reproduce-build :
# Start building the Dockerfile with the RELEASE_VERSION tag set. GOPROXY is set
# for convience, because the default of the Dockerfile is `direct` which can be
# quite slow.
@docker build --build-arg= " RELEASE_VERSION= $( RELEASE_VERSION) " --build-arg= " GOPROXY= $( shell $( GO) env GOPROXY) " --tag "forgejo-reproducibility" .
@id= $$ ( docker create forgejo-reproducibility) ; \
docker cp $$ id:/app/gitea/gitea ./forgejo; \
docker rm -v $$ id; \
docker image rm forgejo-reproducibility:latest
.PHONY : reproduce -build \#%
reproduce-build\#% :
@git switch -d " $* "
# All the current variables are based on information before the git checkout happened.
# Call the makefile again, so these variables are correct and can be used for building
# a reproducible binary. Always execute git switch -, to go back to the previous branch.
@make reproduce-build; \
( code = $$ ?; git switch -; exit $$ { code} )
2024-08-16 08:04:25 -05:00
###
# Dependency management
###
2022-02-12 02:08:53 -05:00
.PHONY : deps
2023-07-25 23:53:13 -05:00
deps : deps -frontend deps -backend deps -tools deps -py
2023-06-14 13:17:58 -05:00
.PHONY : deps -py
deps-py : .venv
2022-02-12 02:08:53 -05:00
.PHONY : deps -frontend
deps-frontend : node_modules
.PHONY : deps -backend
deps-backend :
$( GO) mod download
2023-03-10 01:13:17 -05:00
.PHONY : deps -tools
deps-tools :
2022-03-15 21:50:26 -05:00
$( GO) install $( AIR_PACKAGE)
$( GO) install $( EDITORCONFIG_CHECKER_PACKAGE)
$( GO) install $( GOFUMPT_PACKAGE)
$( GO) install $( GOLANGCI_LINT_PACKAGE)
2023-07-26 17:51:02 -05:00
$( GO) install $( GXZ_PACKAGE)
2022-03-15 21:50:26 -05:00
$( GO) install $( MISSPELL_PACKAGE)
$( GO) install $( SWAGGER_PACKAGE)
$( GO) install $( XGO_PACKAGE)
2022-09-03 17:20:46 -05:00
$( GO) install $( GO_LICENSES_PACKAGE)
2022-09-11 02:02:18 -05:00
$( GO) install $( GOVULNCHECK_PACKAGE)
refactor: redis queue backend test cleanup
Summary:
- Move existing test under a `testify` Suite as `baseRedisWithServerTestSuite`
- Those tests require real redis server.
- Add `go.uber.org/mock/mockgen@latest` as dependency
- as a tool (Makefile).
- in the `go.mod` file.
- Mock redis client lives under a `mock` directory under the queue module.
- That mock module has an extra hand-written mock in-memory redis-like struct.
- Add tests using the mock redis client.
- Changed the logic around queue provider creation.
- Now the `getNewQueue` returns a Queue provider directly, not an init
function to create it.
The whole Queue module is close to impossible to test properly because
everything is private, everything goes through a struct route. Because
of that, we can't test for example what keys are used for given queue.
To overcome this, as a first step I removed one step from that hard
route by allowing custom calls to create new queue provider. To achieve
this, I moved the creation logic into the `getNewQueue` (previously it
was `getNewQueueFn`). That changes nothing on that side, everything goes
as before, except the `newXXX` call happens directly in that function
and not outside that.
That made it possible to add extra provider specific parameters to those
function (`newXXX`). For example a client on redis. Calling it through
the `getNewQueue` function, it gets `nil`.
- If the provided client is not `nil`, it will use that instead of the
connection string.
- If it's `nil` (default behaviour), it creates a new redis client as it
did before, no changes to that.
The rest of the provider code is unchanged. All these changes were
required to make it possible to generate mock clients for providers and
use them.
For the tests, the existing two test cases are good with redis server,
and they need some extra helpers, for example to start a new redis
server if required, or waiting on a redis server to be ready to use.
These helpers are only required for test cases using real redis server.
For better isolation, moved existing test under a testify Suite, and
moved them into a new test file called `base_redis_with_server_test.go`
because, well they test the code with server. These tests do exactly the
same as before, calling the same sub-tests the same way as before, the
only change is the structure of the test (remove repetition, scope
server related helper functions).
Finally, we can create unit tests without redis server. The main focus of
this group of tests are higher level overview of operations. With the
mock redis client we can set up expectations about used queue names,
received values, return value to simulate faulty state.
These new unit test functions don't test all functionality, at least
it's not aimed for it now. It's more about the possibility of doing that
and add extra tests around parts we couldn't test before, for example
key.
What extra features can test the new unit test group:
- What is the received key for given queue? For example using `prefix`,
or if all the `SXxx` calls are expected to use `queue_unique` if
it's a unique queue.
- If it's not a unique queue, no `SXxx` functions are called, because
those sets are used only to check if a value is unique or not.
- `HasItem` return `false` always if it's a non-unique queue.
- All functions are called exactly `N` times, and we don't have any
unexpected calls to redis from the code.
Signed-off-by: Victoria Nadasdi <victoria@efertone.me>
2024-05-20 12:13:42 -05:00
$( GO) install $( GOMOCK_PACKAGE)
2024-06-04 20:22:38 -05:00
$( GO) install $( GOPLS_PACKAGE)
2022-02-12 02:08:53 -05:00
2019-12-04 22:41:38 -05:00
node_modules : package -lock .json
2020-11-29 18:16:04 -05:00
npm install --no-save
2020-01-28 02:30:39 -05:00
@touch node_modules
2019-06-18 21:59:47 -05:00
2023-06-14 13:17:58 -05:00
.venv : poetry .lock
2024-06-07 08:37:33 -05:00
poetry install
2023-06-14 13:17:58 -05:00
@touch .venv
2020-01-21 00:17:58 -05:00
.PHONY : fomantic
2021-04-09 00:08:14 -05:00
fomantic :
2021-04-01 19:11:04 -05:00
rm -rf $( FOMANTIC_WORK_DIR) /build
2021-04-09 00:08:14 -05:00
cd $( FOMANTIC_WORK_DIR) && npm install --no-save
cp -f $( FOMANTIC_WORK_DIR) /theme.config.less $( FOMANTIC_WORK_DIR) /node_modules/fomantic-ui/src/theme.config
cp -rf $( FOMANTIC_WORK_DIR) /_site $( FOMANTIC_WORK_DIR) /node_modules/fomantic-ui/src/
2024-03-04 15:24:12 -05:00
$( SED_INPLACE) -e 's/ overrideBrowserslist\r/ overrideBrowserslist: ["defaults"]\r/g' $( FOMANTIC_WORK_DIR) /node_modules/fomantic-ui/tasks/config/tasks.js
2021-04-09 00:08:14 -05:00
cd $( FOMANTIC_WORK_DIR) && npx gulp -f node_modules/fomantic-ui/gulpfile.js build
2023-02-27 09:43:04 -05:00
# fomantic uses "touchstart" as click event for some browsers, it's not ideal, so we force fomantic to always use "click" as click event
$( SED_INPLACE) -e 's/clickEvent[ \t]*=/clickEvent = "click", unstableClickEvent =/g' $( FOMANTIC_WORK_DIR) /build/semantic.js
2022-06-10 07:24:02 -05:00
$( SED_INPLACE) -e 's/\r//g' $( FOMANTIC_WORK_DIR) /build/semantic.css $( FOMANTIC_WORK_DIR) /build/semantic.js
2021-08-29 14:57:07 -05:00
rm -f $( FOMANTIC_WORK_DIR) /build/*.min.*
2020-01-21 00:17:58 -05:00
2020-01-28 02:30:39 -05:00
.PHONY : webpack
2020-02-22 04:15:11 -05:00
webpack : $( WEBPACK_DEST )
2019-12-04 22:41:38 -05:00
2021-04-09 00:08:14 -05:00
$(WEBPACK_DEST) : $( WEBPACK_SOURCES ) $( WEBPACK_CONFIGS ) package -lock .json
@$( MAKE) -s node-check node_modules
2024-04-27 02:21:07 -05:00
@rm -rf $( WEBPACK_DEST_ENTRIES)
@echo "Running webpack..."
@BROWSERSLIST_IGNORE_OLD_DATA= true npx webpack
2020-01-28 02:30:39 -05:00
@touch $( WEBPACK_DEST)
2019-05-16 00:57:47 -05:00
2020-07-12 04:10:56 -05:00
.PHONY : svg
svg : node -check | node_modules
rm -rf $( SVG_DEST_DIR)
2024-03-17 17:12:36 -05:00
node tools/generate-svg.js
2020-07-12 04:10:56 -05:00
.PHONY : svg -check
svg-check : svg
2020-07-24 11:41:30 -05:00
@git add $( SVG_DEST_DIR)
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always --cached $( SVG_DEST_DIR) \
|| ( code = $$ ?; echo "Please run 'make svg' and commit the result" ; exit $$ { code} )
2020-07-12 04:10:56 -05:00
2022-01-15 15:06:29 -05:00
.PHONY : lockfile -check
lockfile-check :
npm install --package-lock-only
2024-03-14 05:38:58 -05:00
@git diff --exit-code --color= always package-lock.json \
|| ( code = $$ ?; echo "Please run 'npm install --package-lock-only' and commit the result" ; exit $$ { code} )
2022-01-15 15:06:29 -05:00
2020-09-02 11:57:08 -05:00
.PHONY : generate -license
generate-license :
2022-07-03 22:33:55 -05:00
$( GO) run build/generate-licenses.go
2020-09-02 11:57:08 -05:00
.PHONY : generate -gitignore
generate-gitignore :
2022-07-03 22:33:55 -05:00
$( GO) run build/generate-gitignores.go
2020-09-02 11:57:08 -05:00
2024-05-22 00:17:59 -05:00
.PHONY : generate -gomock
generate-gomock :
2024-08-31 22:36:00 -05:00
$( GO) run $( GOMOCK_PACKAGE) -package mock -destination ./modules/queue/mock/redisuniversalclient.go code.gitea.io/gitea/modules/nosql RedisClient
2024-05-22 00:17:59 -05:00
2017-07-28 00:51:20 -05:00
.PHONY : generate -images
2021-04-15 06:02:34 -05:00
generate-images : | node_modules
2024-06-29 10:37:18 -05:00
npm install --no-save fabric@6 imagemin-zopfli@7
2024-03-17 17:12:36 -05:00
node tools/generate-images.js $( TAGS)
2019-03-25 16:23:17 -05:00
2021-02-24 17:36:48 -05:00
.PHONY : generate -manpage
generate-manpage :
@[ -f gitea ] || make backend
@mkdir -p man/man1/ man/man5
@./gitea docs --man > man/man1/gitea.1
@gzip -9 man/man1/gitea.1 && echo man/man1/gitea.1.gz created
Fix various typos (#20338)
* Fix various typos
Found via `codespell -q 3 -S ./options/locale,./options/license,./public/vendor -L actived,allways,attachements,ba,befores,commiter,pullrequest,pullrequests,readby,splitted,te,unknwon`
Co-authored-by: zeripath <art27@cantab.net>
2022-07-12 16:32:37 -05:00
@#TODO A small script that formats config-cheat-sheet.en-us.md nicely for use as a config man page
2021-02-24 17:36:48 -05:00
2020-04-19 06:17:02 -05:00
# This endif closes the if at the top of the file
2020-04-30 01:26:37 -05:00
e n d i f
2024-02-15 22:17:34 -05:00
# Disable parallel execution because it would break some targets that don't
# specify exact dependencies like 'backend' which does currently not depend
# on 'frontend' to enable Node.js-less builds from source tarballs.
.NOTPARALLEL :