kcmvp / gob

Golang project boot

Golang Project Boot

Introduction

Although the Golang programming ecosystem is becoming more and more mature, these tools and frameworks exist independently to solve specific problems. Whenever a new Golang project is started, it requires a series of initialization; What’s worse is that whenever your switch the development environment, same process have to be repeated! This project is built to solve this problem by providing a tool named gbc*, which is similar to Maven or Gradle in the Java ecosystem together with a framework(glue) similar to SpringBoot. Please refer documents for details

Features

1. Everything is a plugin, you can use any tool you like as a plugin to customize your build process!
2. Model driver SQL database DAO(data access object).
3. IoC Container support via samber/do.
4. Code generation for most popular frameworks scaffolding.
5. Environment sensitive profile. application.yml for no-test environment and application-test.yml for test environment
6. Friendly help messages
7. More ....

What's a gob based project looks like?

Just likeSpringBoot, the most important part of a gob project is the configurations which define your project. There are two main configurations

1. gob.yaml : it acts as the same as settings.gradle.kts( Gradle) or pom.xml(Maven), you can define any thrid party tool as a plugin in this file.
2. application.yaml: it acts as the same application.yaml of SpringBoot

Quick Start

1. Install gbc with below command

    go install github.com/kcmvp/gob/cmd/gbc@latest

2. Initialize project with below command(in the project home directory)

  gbc init

Make some changes and commit code	execute gbc deps

How gbc works

gbc takes everything defined in the gob.yaml as plugin.

flowchart TD
        gbc --> gob.yaml 
        gob.yaml --> plugin1
        gob.yaml --> plugin2
        gob.yaml --> plugin3

You just need to tell gbc 3W(where,when and what)

1. Where : where to download the tool
2. When : when to execute to command
3. What : what to do with the tool

Commands

Build Commands

• gbc init
• gbc build
• gbc clean
• gbc test
• gbc lint
• gbc deps

Plugin Commands

• gbc plugin install
• gbc plugin list

Setup Commands

• gbc setup version

gbc init

gbc init

Initialize gbc for the project, it will do following initializations

1. generate file gob.yaml
2. generate file .golangci.yaml, which is the configuration for golangci-lint
3. setup git hooks if project in the source control. 4. commit-msg 5. pre-commit 6. pre-push

This command can be executed at any time.

Content of gob.yaml

exec:
    commit-msg-hook: ^#[0-9]+:\s*.{10,}$
    pre-commit-hook:
        - lint
        - test
    pre-push-hook:
        - test
plugins:
    golangci-lint:
        alias: lint #When : when issue `gbc lint`
        args: run ./... #What: execute `golangci-lint run ./...`
        url: github.com/golangci/golangci-lint/cmd/[email protected] #Where: where to download the plugin
    gotestsum:
        alias: test
        args: --format testname -- -coverprofile=target/cover.out ./...
        url: gotest.tools/[email protected]

in most cases you don't need to edit the configuration manually. you can achieve this by plugin commands

gbc build

gbc build

This command would build all the candidate binaries(main methods in main packages) to the target folder.

1. Final binary name is same as go source file name which contains main method
2. Would fail if there are same name go main surce file

gbc clean

gbc clean

This command would clean target folder

gbc test

gbc test

This command would run all tests for the project and generate coverage report at target/cover.html

gbc lint

gbc lint

Run golangci-lint against project based on the configuration, a report named target/lint.log will be generated if there are any violations

gbc deps

gbc deps

List project dependencies tree and indicate there are updates for a specific dependency

gbc plugin install

gbc plugin install github.com/golangci/golangci-lint/cmd/[email protected] lint run ./...

It is an advanced version of go install, which supports multi-version.(eg:golangci-lint-v1.55.2, golangci-lint-v1.55.1)

1. Install the versioned tool(just the same as go install)
2. Set up the tool as plugin in gob.yaml
3. You can update adjust the parameters of the plugin by editing gob.yaml

gob plugin list

gob plugin list

List all the installed plugins

gob setup version

gob setup version

This command will generate file version.go in infra folder, and project version informatill will be injected into buildVersion when build the project with command gob build

// buildVersion don't change this
var buildVersion string

FAQ

• When install a plugin, how to find out the url?

  gob plugin install work the same way as go install, it take the same url as go install.

• How to upgrade a plugin ?

  Just simply edit gob.yaml file and update the version you want.

  plugins:
    golangci-lint:
    alias: lint
    args: run ./...
    url: github.com/golangci/golangci-lint/cmd/[email protected]

`

gob's Issues

gob/report: generate dashboard report for the project

• coverage report
• dependency report
• lint report

Support 'latest' tag when run 'gob plugin'

When run gob install without version, it should always install the latest version of the tool

setup/github-workflow: github workflow setup

generate test coverage report

Set version information for a binary build

• set version information for binary build when run 'gob build' (#31)
• add version command for gob

remove dependency github.com/go-git/go-git/v5

As go get depends on git, so we can use os's git to do the necessary checking

awesome list

improve unit test coverage for awesome list requirements

Multiple thread for plugin download

upgrade dependency version

• github.com/jedib0t/go-pretty/[email protected] (v6.5.4)
• github.com/samber/[email protected] (v1.39.0)
• github.com/spf13/[email protected] (v1.18.2)
• github.com/tidwall/[email protected] (v1.17.1)

better information print: dont print time prefix when runs into command validation error

refactor: improve test coverage

progress bar support

progress bar support for long-running task

optimize: install plugins on demand

right now gob would always check all the plugins for every run. this can be optimized to only install the demanded plugin. it will save a lot of time especially in ci environment

should run 'go build ./...' first before run 'gob build'

setup command

runs into error

sample code runs into error
operation not supported by device

oldState, err := term.MakeRaw(int(os.Stdin.Fd()))

test: add test for hook

dep/list: list the dependencies of the project

• list all the dependencies of the projects
• indicate if there are new release or not for each dependency
• #33

dynamic support support all flags of buildclean & test

support alll the flags of the plugins and flags

gob/dep lays

gob should print out modified files by lint during git hooks

• pre-commit
• pre-push

refactor plugin command

• One command to cover all the case
• There are two args:
  • install
  • list

optimize command gob/plugin:install

• first parameter is the url of the tool
• second parameter is the alias of the command
• third command is the tool command

runs into error when init empty project

setup/docker: generate docker compoe file for the project

support oapi-codegen

https://github.com/deepmap/

Add a command list the dependency or plugin

• add a sub command to build to check there are updates or not for all the dependencies in go.mod
• add a sub command to plugin to check there are update or not for all the plugins that list in plugins sections

set environment per exec.Command instead of global

right now GOPATH this environment is set global, when run test with github-workflow. some of the test would fail sporadically

initialization document

gob plugin support

The idea of gob plugin is that there are many useful tools in golang ecosystem. Different tools aim different convenience for development. so it's better to supply mechanism. As a developer you can add whatever tools you like. As a plugin system it must be have following features:

• vension wise in project level
• configurable execution order

make package coverage report at the end of the report

always install the latest version of the plugin when no version specified

git hook

into error in docker environment Error reading output: read /dev/ptmx: input/output error

runs into error when execue command in the docker, the root cause is that access /dev/ptmx need special privilege.
actions/container-action#2

Configurable git hook

Implement build command

• build all the binarys of the project
• setup the dependency of the build serials command: clean -> test -> lint -> build

setup/version: auto inject version information into binary during building

ignore hook when delete a remote branch by executing `git push origin --delete `

setup/openapi: add open api support to the project

• https://github.com/topics/openapi3?l=go
• https://github.com/topics/swagger?l=go
• https://github.com/deepmap/

remove temporary files

dep/layer: show project package dependency diagram

• external package dependency diagram
• internal package dependency diagram

setup/layout: generate onion architecture for the project

Integrate gonew

https://go.dev/blog/gonew

target/test.log: file already closed

when test failed system would run into this error
Error: failed to test the project Error writing to file: write /target/test.log: file already closed

gob init generate an empty .golangci.yaml file

dep/tree: list the dependency tree of the project

• with with version information

install wrong binary name

add unit test for coverage report

add unit test for internal/plugin

refactor: design contract