remove uint repeat conversion (#2096)

Co-authored-by: houseme <housemecn@gmail.com>

.github/ISSUE_TEMPLATE.MD

@@ -1,12 +1,11 @@
 <!-- Please answer these questions before submitting your issue. Thanks! -->
 
-<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！ -->
-<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！ -->
-<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！ -->
+<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！否则issue可能会被延期处理！ -->
+<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！否则issue可能会被延期处理！ -->
+<!-- 为高效处理您的疑问，如果觉得是BUG类问题，请您务必提供可复现该问题的最小可运行代码！否则issue可能会被延期处理！ -->
 <!-- 重要的事情说三遍！ -->
 
 ### 1. What version of `Go` and system type/arch are you using?
-
 <!-- 
 Please paste the output of command `go version` from your terminal.
 What expect to see is like: `go 1.12, linux/amd64`
@@ -14,7 +13,6 @@ What expect to see is like: `go 1.12, linux/amd64`
 
 
 ### 2. What version of `GoFrame` are you using?
-
 <!-- You can find the GF version from your `go.mod`, or from the `version.go` in `GF` -->
 
 
@@ -23,7 +21,6 @@ What expect to see is like: `go 1.12, linux/amd64`
 
 
 ### 4. What did you do?
-
 <!--
 If possible, provide a copy of shortest codes for reproducing the error.
 A complete runnable program is best.

.github/workflows/cli.yml

@@ -0,0 +1,65 @@
+name: GoFrame CLI Build Release
+
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+env:
+  TZ: Asia/Shanghai
+
+
+jobs:
+  build:
+    name: Build And Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Github Code
+        uses: actions/checkout@v2
+      
+      - name: Set Up Golang Environment
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+      
+      - name: Build CLI Binary
+        run: |
+          echo "Building linux amd64 binary..."
+          cd cmd/gf
+          GOOS=linux GOARCH=amd64 go build main.go
+          chmod +x main
+          ./main install -y
+
+      - name: Build CLI Binary For All Platform
+        run: |
+          cd cmd/gf
+          gf build main.go -n gf -a all -s all
+
+      - name: Move Files Before Release
+        run: |
+          cd cmd/gf/temp
+          for OS in *;do for FILE in $OS/*;\
+          do if [[ ${OS} =~ 'windows' ]];\
+          then mv $FILE gf_$OS.exe && rm -rf $OS;\
+          else mv $FILE gf_$OS && rm -rf $OS;\
+          fi;done;done
+
+      - name: Create Github Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name:     ${{ github.ref }}
+          release_name: GoFrame Release ${{ github.ref }}
+          draft:        false
+          prerelease:   false
+      
+      - name: Upload Release Asset
+        id:   upload-release-asset
+        uses: alexellis/upload-assets@0.2.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          asset_paths: '["cmd/gf/temp/gf_*"]'

.github/workflows/docker/docker-compose.yml

@@ -0,0 +1,95 @@
+version: "2"
+
+services:
+  redis-master:
+    container_name: redis-master
+    image: "loads/redis:7.0"
+    environment:
+      - REDIS_REPLICATION_MODE=master
+      - REDIS_PASSWORD=111111
+    ports:
+      - 6380:6379
+
+  redis-slave1:
+    container_name: redis-slave1
+    image: "loads/redis:7.0"
+    environment:
+      - REDIS_REPLICATION_MODE=slave
+      - REDIS_MASTER_HOST=redis-master
+      - REDIS_MASTER_PASSWORD=111111
+      - REDIS_PASSWORD=111111
+    ports:
+      - 6381:6379
+    depends_on:
+      - redis-master
+    links:
+      - redis-master
+
+  redis-slave2:
+    container_name: redis-slave2
+    image: "loads/redis:7.0"
+    environment:
+      - REDIS_REPLICATION_MODE=slave
+      - REDIS_MASTER_HOST=redis-master
+      - REDIS_MASTER_PASSWORD=111111
+      - REDIS_PASSWORD=111111
+    ports:
+      - 6382:6379
+    depends_on:
+      - redis-master
+    links:
+      - redis-master
+
+  redis-sentinel-1:
+    container_name: redis-sentinel-1
+    image: "loads/redis-sentinel:7.0"
+    environment:
+      - REDIS_MASTER_HOST=redis-master
+      - REDIS_MASTER_PORT_NUMBER=6379
+      - REDIS_MASTER_PASSWORD=111111
+    depends_on:
+      - redis-master
+      - redis-slave1
+      - redis-slave2
+    ports:
+      - 26379:26379
+    links:
+      - redis-master
+      - redis-slave1
+      - redis-slave2
+
+  redis-sentinel-2:
+    container_name: redis-sentinel-2
+    image: "loads/redis-sentinel:7.0"
+    environment:
+      - REDIS_MASTER_HOST=redis-master
+      - REDIS_MASTER_PORT_NUMBER=6379
+      - REDIS_MASTER_PASSWORD=111111
+    depends_on:
+      - redis-master
+      - redis-slave1
+      - redis-slave2
+    links:
+      - redis-master
+      - redis-slave1
+      - redis-slave2
+    ports:
+      - 26380:26379
+
+  redis-sentinel-3:
+    container_name: redis-sentinel-3
+    image: "loads/redis-sentinel:7.0"
+    environment:
+      - REDIS_MASTER_HOST=redis-master
+      - REDIS_MASTER_PORT_NUMBER=6379
+      - REDIS_MASTER_PASSWORD=111111
+    depends_on:
+      - redis-master
+      - redis-slave1
+      - redis-slave2
+    ports:
+      - 26381:26379
+    links:
+      - redis-master
+      - redis-slave1
+      - redis-slave2

.github/workflows/gf.yml

@@ -0,0 +1,196 @@
+name: GoFrame Main CI
+
+
+on:
+  push:
+    branches:
+    - master
+    - develop
+    - personal/**
+    - feature/**
+    - enhance/**
+    - fix/**
+
+  pull_request:
+    branches:
+    - master
+    - develop
+    - personal/**
+    - feature/**
+    - enhance/**
+    - fix/**
+
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+  group: '${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+env:
+  TZ: "Asia/Shanghai"
+
+
+jobs:
+  code-test:
+    runs-on: ubuntu-latest
+
+    # Service containers to run with `code-test`
+    services:
+      # Redis backend server.
+      redis:
+        image  : loads/redis:latest
+        options: >-
+          --health-cmd      "redis-cli ping"
+          --health-interval 10s
+          --health-timeout  5s
+          --health-retries  5
+        ports:
+          # Maps tcp port 6379 on service container to the host
+          - 6379:6379
+
+      # MySQL backend server.
+      mysql:
+        image: loads/mysql:5.7
+        env:
+          MYSQL_DATABASE     : test
+          MYSQL_ROOT_PASSWORD: 12345678
+        ports:
+          # Maps tcp port 3306 on service container to the host
+          - 3306:3306
+
+      # PostgreSQL backend server.
+      postgres:
+        image: loads/postgres:13
+        env:
+          POSTGRES_PASSWORD: 12345678
+          POSTGRES_USER:     postgres
+          POSTGRES_DB:       test
+          TZ:                Asia/Shanghai
+        ports:
+          - 5432:5432
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+      # MSSQL backend server.
+      mssql:
+        image: loads/mssqldocker:latest
+        env:
+          ACCEPT_EULA:    Y
+          SA_PASSWORD:    LoremIpsum86
+          MSSQL_DB:       test
+          MSSQL_USER:     root
+          MSSQL_PASSWORD: LoremIpsum86
+        ports:
+          - 1433:1433
+        options: >-
+          --health-cmd="/opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P LoremIpsum86 -l 30 -Q \"SELECT 1\" || exit 1"
+          --health-start-period 10s
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+
+      # ClickHouse backend server.
+      clickhouse-server:
+        image: loads/clickhouse-server:latest
+        ports:
+          - 9000:9000
+          - 8123:8123
+          - 9001:9001
+
+      polaris:
+        image: polarismesh/polaris-server-standalone:latest
+        ports:
+          - 8090:8090
+          - 8091:8091
+
+      #oracle 11g server
+      oracle-server:
+        image: loads/oracle-xe-11g-r2:latest
+        env:
+          ORACLE_ALLOW_REMOTE: true
+          ORACLE_SID: XE
+          ORACLE_DB_USER_NAME: system
+          ORACLE_DB_PASSWORD: oracle
+        ports:
+          - 1521:1521
+
+
+    strategy:
+      matrix:
+        go-version: [ "1.15", "1.16", "1.17", "1.18" ]
+        goarch: [ "386", "amd64" ]
+
+    steps:
+    - name: Setup Timezone
+      uses: szenius/set-timezone@v1.0
+      with:
+        timezoneLinux: "Asia/Shanghai"
+
+    - name: Checkout Repository
+      uses: actions/checkout@v2
+
+    - name: Setup Golang ${{ matrix.go-version }}
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go-version }}
+
+    - name: Setup Golang caches
+      uses: actions/cache@v3
+      with:
+        # In order:
+        # * Module download cache
+        # * Build cache (Linux)
+        # * Build cache (Mac)
+        # * Build cache (Windows)
+        path: |
+          ~/go/pkg/mod
+          ~/.cache/go-build
+          ~/Library/Caches/go-build
+          ~\AppData\Local\go-build
+        key: ${{ runner.os }}-go-${{ matrix.go-version }}-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-${{ matrix.go-version }}-
+
+    - name: Start containers
+      run: docker-compose -f ".github/workflows/docker/docker-compose.yml" up -d --build
+
+    - name: Before Script
+      run: |
+        find . -name "*.go" | xargs gofmt -w
+        git diff --name-only --exit-code || if [ $? != 0 ]; then echo "Notice: gofmt check failed,please gofmt before pr." && exit 1; fi
+        echo "gofmt check pass."
+        sudo echo "127.0.0.1   local" | sudo tee -a /etc/hosts
+
+    - name: Build & Test
+      run: |
+        GOARCH=${{ matrix.goarch }}
+        for file in `find . -name go.mod`; do
+            dirpath=$(dirname $file)
+
+            if [ "oracle" = $(basename $dirpath) ]; then
+                if ! go version|grep -q "1.17"; then
+                  continue 1
+                fi
+            fi
+
+            cd $dirpath
+            go mod tidy
+            go build ./...
+            go test ./... -race -coverprofile=coverage.out -covermode=atomic -coverpkg=./...,github.com/gogf/gf/... || exit 1
+            if grep -q "/gogf/gf/.*/v2" go.mod; then
+                sed -i "s/gogf\/gf\(\/.*\)\/v2/gogf\/gf\/v2\1/g" coverage.out
+            fi
+            cd -
+        done
+
+    - name: Stop containers
+      run: docker-compose -f ".github/workflows/docker/docker-compose.yml" down
+
+    - name: Report Coverage
+      uses: codecov/codecov-action@v2
+      with:
+        flags: go-${{ matrix.go-version }}-${{ matrix.goarch }}
+

.github/workflows/go.yml

@@ -1,74 +0,0 @@
-name: GoFrame CI
-
-on:
-  push:
-    branches:
-      - master
-      - develop
-  pull_request:
-    branches: [master, develop]
-env:
-  GF_DEBUG: 0
-
-jobs:
-  code-test:
-    runs-on: ubuntu-latest
-    # Service containers to run with `code-test`
-    services:
-      redis:
-        image  : redis
-        options: >-
-          --health-cmd      "redis-cli ping"
-          --health-interval 10s
-          --health-timeout  5s
-          --health-retries  5
-        ports:
-          # Maps tcp port 6379 on service container to the host
-          - 6379:6379
-      mysql:
-        image: mysql:5.7
-        env:
-          MYSQL_DATABASE     : test
-          MYSQL_ROOT_PASSWORD: 12345678
-        ports:
-          # Maps tcp port 3306 on service container to the host
-          - 3306:3306
-
-    # strategy set
-    strategy:
-      matrix:
-        go: ["1.15", "1.16", "1.17"]
-
-    steps:
-    - name: Set Up Timezone
-      uses: szenius/set-timezone@v1.0
-      with:
-        timezoneLinux: "Asia/Shanghai"
-
-    - name: Checkout Repositary
-      uses: actions/checkout@v2
-
-    - name: Set Up Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: ${{ matrix.go }}
-
-    - name: Before Script
-      run: |
-        date
-        find . -name "*.go" | xargs gofmt -w
-        git diff --name-only --exit-code || if [ $? != 0 ];then echo "Notice: gofmt check failed,please gofmt before pr." && exit 1; fi
-        echo "gofmt check pass."
-        sudo echo "127.0.0.1   local" | sudo tee -a /etc/hosts
-
-    - name: Run i386 Arch Test
-      run: GOARCH=386 go test -v ./... || exit 1
-
-    - name: Run amd64 Arch Test
-      run: GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
-
-    - name: Report Coverage
-      uses: codecov/codecov-action@v2
-      with:
-        flags: go-${{ matrix.go }}
-

.github/workflows/issue-check-inactive.yml

@@ -0,0 +1,28 @@
+# 规则描述：每天0点(GMT+8)执行一次，将最近7天没有活跃且非BUG的ISSUE设置标签:inactive
+name: Issue Check Inactive
+
+on:
+  schedule:
+    - cron: "0 3 * * *"
+
+env: # 设置环境变量
+  TZ: Asia/Shanghai #时区（设置时区可使页面中的`最近更新时间`使用时区时间）
+
+permissions:
+  contents: read
+
+jobs:
+  issue-check-inactive:
+    permissions:
+      issues: write  # for actions-cool/issues-helper to update issues
+     # pull-requests: write  # for actions-cool/issues-helper to update PRs
+    runs-on: ubuntu-latest
+    steps:
+      - name: check-inactive
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: 'check-inactive'
+          inactive-label: 'inactive'
+          inactive-day: 7
+          issue-state: open
+          exclude-labels: 'bug'

.github/workflows/issue-close-inactive.yml

@@ -0,0 +1,22 @@
+# 规则描述：每天0点(GMT+8)执行一次，将最近30天没有活跃且非BUG的ISSUE关闭
+name: Issue Close Inactive
+
+on:
+  schedule:
+    - cron: "0 3 * * *"
+
+env: # 设置环境变量
+  TZ: Asia/Shanghai #时区（设置时区可使页面中的`最近更新时间`使用时区时间）
+
+jobs:
+  close-issues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: need close
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "close-issues"
+#          token: ${{ secrets.GF_TOKEN }}
+          labels: 'inactive'
+          inactive-day: 30
+          exclude-labels: 'bug'

.github/workflows/issue-labeled.yml

@@ -0,0 +1,25 @@
+## 规则描述：当issue被标记为help wanted 时，增加评论
+
+name: Issue Labeled
+
+on:
+  issues:
+    types: [labeled]
+
+env: # 设置环境变量
+  TZ: Asia/Shanghai # 时区（设置时区可使页面中的`最近更新时间`使用时区时间）
+
+jobs:
+  reply-labeled:
+    runs-on: ubuntu-latest
+    steps:
+      - name: contribution welcome
+        if: github.event.label.name == 'help wanted'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment, remove-labels"
+#          token: ${{ secrets.GF_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            Hello @${{ github.event.issue.user.login }}. We like your proposal/feedback and would appreciate a contribution via a Pull Request by you or another community member. We thank you in advance for your contribution and are looking forward to reviewing it!
+            你好 @${{ github.event.issue.user.login }}。我们喜欢您的提案/反馈，并希望您或其他社区成员通过拉取请求做出贡献。我们提前感谢您的贡献，并期待对其进行审查。

.github/workflows/issue-remove-inactive.yml

@@ -0,0 +1,29 @@
+# 规则描述：在issue没有活跃且尚未被关闭期间，若issue作者更新或评论该ISSUE，则移除其inactive标签
+name: Issue Remove Inactive
+
+on:
+  issues:
+    types: [edited]
+  issue_comment:
+    types: [created, edited]
+
+env: # 设置环境变量
+  TZ: Asia/Shanghai #时区（设置时区可使页面中的`最近更新时间`使用时区时间）
+
+permissions:
+  contents: read
+
+jobs:
+  issue-remove-inactive:
+    permissions:
+      issues: write  # for actions-cool/issues-helper to update issues
+     # pull-requests: write  # for actions-cool/issues-helper to update PRs
+    runs-on: ubuntu-latest
+    steps:
+      - name: remove inactive
+        if: github.event.issue.state == 'open' && github.actor == github.event.issue.user.login
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: 'remove-labels'
+          issue-number: ${{ github.event.issue.number }}
+          labels: 'inactive'

.github/workflows/issue-remove-need-more-details.yml

@@ -0,0 +1,29 @@
+# 规则描述：将需要提供更多细节且暂未关闭的issue，在issue作者评论后，移除 need more details 标签
+name: Issue Remove Need More Details
+
+on:
+  issues:
+    types: [edited]
+  issue_comment:
+    types: [created, edited]
+
+env: # 设置环境变量
+  TZ: Asia/Shanghai #时区（设置时区可使页面中的`最近更新时间`使用时区时间）
+
+permissions:
+  contents: read
+
+jobs:
+  issue-remove-need-more-details:
+    permissions:
+      issues: write  # for actions-cool/issues-helper to update issues
+     # pull-requests: write  # for actions-cool/issues-helper to update PRs
+    runs-on: ubuntu-latest
+    steps:
+      - name: remove need more details
+        if: github.event.issue.state == 'open' && github.actor == github.event.issue.user.login
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: 'remove-labels'
+          issue-number: ${{ github.event.issue.number }}
+          labels: 'need more details'

.github/workflows/tag.yml

@@ -0,0 +1,30 @@
+name: GoFrame AutoCreating SubMod Tags
+
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+env:
+  TZ: Asia/Shanghai
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+jobs:
+  build:
+    name: Auto Creating Tags
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Github Code
+        uses: actions/checkout@v2
+
+      - name: Auto Creating Tags
+        run: |
+          git config --global user.email "tagrobot@goframe.org"
+          git config --global user.name  "TagRobot"
+          for file in `find contrib -name go.mod`; do
+              tag=$(dirname $file)/$GITHUB_REF_NAME
+              git tag $tag
+              git push origin $tag
+          done

.gitignore

@@ -13,7 +13,7 @@ pkg/
 bin/
 cbuild
 **/.DS_Store
-.vscode/
 .test/
-main
-gf
+cmd/gf/main
+cmd/gf/gf
+go.work

Makefile

@@ -0,0 +1,13 @@
+
+
+.PHONY: tidy
+tidy:
+	$(eval files=$(shell find . -name go.mod))
+	@set -e; \
+	for file in ${files}; do \
+		goModPath=$$(dirname $$file); \
+		cd $$goModPath; \
+		go mod tidy; \
+		cd -; \
+	done
+

README.MD

@@ -1,24 +1,42 @@
 # GoFrame
+<div align=center>
+<img src="https://goframe.org/statics/image/gf-head-large.png" width="100"/>
 
 [![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf)
-[![GoFrame CI](https://github.com/gogf/gf/actions/workflows/go.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/go.yml)
+[![GoFrame CI](https://github.com/gogf/gf/actions/workflows/gf.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/gf.yml)
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
 [![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
-
+</div>
 
 `GoFrame` is a modular, powerful, high-performance and enterprise-class application development framework of Golang. 
 
-> If you're a newbie to `Go`, you may consider `GoFrame` easy and great as `Laravel` in `PHP`, `SpringBoot` in `Java` or `Django` in `Python`.
+# Features
+- modular, loosely coupled design
+- rich components, out-of-the-box
+- automatic codes generating for efficiency
+- simple and easy to use, detailed documentation
+- interface designed components, with high scalability
+- fully supported tracing and error stack feature
+- specially developed and powerful ORM component
+- robust engineering design specifications
+- convenient development CLI tool provide
+- OpenTelemetry observability features support
+- OpenAPIV3 documentation generating, automatically
+- much, much more...ready to explore?
 
 # Installation
-```
+Enter your repo. directory and execute following command:
+
+## primary module
+```bash
 go get -u -v github.com/gogf/gf/v2
 ```
-suggested using `go.mod`:
-```
-require github.com/gogf/gf/v2 latest
+
+## cli tool
+```bash
+go install github.com/gogf/gf/cmd/gf/v2
 ```
 
 # Limitation
@@ -31,24 +49,10 @@ golang version >= 1.15
 <img src="https://goframe.org/download/attachments/1114119/arch.png"/>
 </div>
 
-# Packages
-1. **Primary Package**
-
-    The `gf` repository maintains some basic and most commonly used packages, keeping it as lightweight and simple as possible. 
-
-1. **Community Package**
-
-    The community packages are contributed and maintained by community members, which are hosted in `gogf` organization. Some of the community packages are separated from the `gf` repository, which are not of common usage or are with heavy dependencies. 
-
-# Performance
-
-The `Web` component performance of `GoFrame`, please refer to third-party project: https://github.com/the-benchmarker/web-frameworks
-
-
 
 # Documentation
 
-* 中文官网: [https://goframe.org](https://goframe.org/display/gf)
+* Chinese Official Site(中文官网): [https://goframe.org](https://goframe.org/display/gf)
 * GoDoc API: [https://pkg.go.dev/github.com/gogf/gf](https://pkg.go.dev/github.com/gogf/gf)
 
 

cmd/gf/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 john@goframe.org https://goframe.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmd/gf/Makefile

@@ -0,0 +1,18 @@
+
+pack: pack.template-single pack.template-mono
+
+pack.template-single:
+	@rm -fr temp
+	@mkdir temp || exit 0
+	@cd temp && git clone https://github.com/gogf/template-single
+	@rm -fr temp/template-single/.git
+	@cd temp && gf pack template-single ../internal/packed/template-single.go -n=packed -y
+	@rm -fr temp
+
+pack.template-mono:
+	@rm -fr temp
+	@mkdir temp || exit 0
+	@cd temp && git clone https://github.com/gogf/template-mono
+	@rm -fr temp/template-mono/.git
+	@cd temp && gf pack template-mono ../internal/packed/template-mono.go -n=packed -y
+	@rm -fr temp

cmd/gf/README.MD

@@ -0,0 +1,69 @@
+# gf
+
+`gf` is a powerful CLI tool for building [GoFrame](https://goframe.org) application with convenience.
+
+
+## 1. Install
+
+## 1) PreCompiled Binary
+You can also install `gf` tool using pre-built binaries: https://github.com/gogf/gf/releases
+
+1. `Mac` & `Linux`
+    ```shell
+    wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_$(go env GOOS)_$(go env GOARCH) && chmod +x gf && ./gf install -y && rm ./gf
+    ```
+   > If you're using `zsh`, you might need rename your alias by command `alias gf=gf` to resolve the conflicts between `gf` and `git fetch`.
+
+2. `Windows`
+
+   Manually download, execute it and then follow the instruction.
+
+3. Database `sqlite` and `oracle` are not support in `gf gen` command in default as it needs `cgo` and `gcc`, you can manually make some changes to the source codes and do the building.
+
+## 2) Manually Install
+
+ ```shell
+git clone https://github.com/gogf/gf && cd gf/cmd/gf && go install
+ ```
+
+
+## 2. Commands
+```html
+$ gf
+USAGE
+    gf COMMAND [OPTION]
+
+COMMAND
+   env        show current Golang environment variables
+   run        running go codes with hot-compiled-like feature
+   gen        automatically generate go files for dao/do/entity/pb/pbentity
+   tpl        template parsing and building commands
+   init       create and initialize an empty GoFrame project
+   pack       packing any file/directory to a resource file, or a go file
+   build      cross-building go project for lots of platforms
+   docker     build docker image for current GoFrame project
+   install    install gf binary to system (might need root/admin permission)
+   version    show version information of current binary
+
+OPTION
+   -y, --yes       all yes for all command without prompt ask
+   -v, --version   show version information of current binary
+   -d, --debug     show internal detailed debugging information
+   -h, --help      more information about this command
+
+ADDITIONAL
+    Use "gf COMMAND -h" for details about a command.
+```
+
+## 3. FAQ
+
+### 1). Command `gf run` returns `pipe: too many open files`
+
+Please use `ulimit -n 65535` to enlarge your system configuration for max open files for current terminal shell session, and then `gf run`.
+
+
+
+
+
+
+

cmd/gf/go.mod

@@ -0,0 +1,21 @@
+module github.com/gogf/gf/cmd/gf/v2
+
+go 1.15
+
+require (
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.1.0
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.1.0
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.1.0
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.1.0
+	github.com/gogf/gf/v2 v2.1.0
+	github.com/olekukonko/tablewriter v0.0.5
+	golang.org/x/tools v0.1.11
+)
+
+replace (
+	github.com/gogf/gf/contrib/drivers/mssql/v2 => ../../contrib/drivers/mssql/
+	github.com/gogf/gf/contrib/drivers/mysql/v2 => ../../contrib/drivers/mysql/
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 => ../../contrib/drivers/pgsql/
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 => ../../contrib/drivers/sqlite/
+	github.com/gogf/gf/v2 => ../../
+)

cmd/gf/go.sum

@@ -0,0 +1,226 @@
+github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
+github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/mxj/v2 v2.5.5 h1:oT81vUeEiQQ/DcHbzSytRngP6Ky9O+L+0Bw0zSJag9E=
+github.com/clbanning/mxj/v2 v2.5.5/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/denisenkom/go-mssqldb v0.11.0 h1:9rHa233rhdOyrz2GcP9NM+gi2psgJZ4GWDpL/7ND8HI=
+github.com/denisenkom/go-mssqldb v0.11.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
+github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
+github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/glebarez/go-sqlite v1.17.3 h1:Rji9ROVSTTfjuWD6j5B+8DtkNvPILoUC3xRhkQzGxvk=
+github.com/glebarez/go-sqlite v1.17.3/go.mod h1:Hg+PQuhUy98XCxWEJEaWob8x7lhJzhNYF1nZbUiRGIY=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
+github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
+github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
+github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.0.1 h1:0fThFwLbW7P/kOiTBs03FsJSV9RM2M/Q/MOnCQxKMo0=
+github.com/grokify/html-strip-tags-go v0.0.1/go.mod h1:2Su6romC5/1VXOQMaWL2yb618ARB8iVo6/DR99A6d78=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
+github.com/lib/pq v1.10.4 h1:SO9z7FRPzA03QhHKJrH5BXA6HU1rS4V2nIVrrNC1iYk=
+github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo=
+github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
+github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
+github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-sqlite3 v1.14.12/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/ginkgo/v2 v2.0.0 h1:CcuG/HvWNkkaqCUpJifQY8z7qEMBJya6aLPx6ftGyjQ=
+github.com/onsi/ginkgo/v2 v2.0.0/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
+github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.opentelemetry.io/otel v1.7.0 h1:Z2lA3Tdch0iDcrhJXDIlC94XE+bxok1F9B+4Lz/lGsM=
+go.opentelemetry.io/otel v1.7.0/go.mod h1:5BdUoMIz5WEs0vt0CUEMtSSaTSHBBVwrhnz7+nrD5xk=
+go.opentelemetry.io/otel/sdk v1.7.0 h1:4OmStpcKVOfvDOgCt7UriAPtKolwIhxpnSNI/yK+1B0=
+go.opentelemetry.io/otel/sdk v1.7.0/go.mod h1:uTEOTwaqIVuTGiJN7ii13Ibp75wJmYUDe374q6cZwUU=
+go.opentelemetry.io/otel/trace v1.7.0 h1:O37Iogk1lEkMRXewVtZ1BBTVn5JEp8GrJvP92bJqC6o=
+go.opentelemetry.io/otel/trace v1.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2 h1:CIJ76btIcR3eFI5EgSo6k1qKw9KJexJuRLI9G7Hp5wE=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220405052023-b1e9470b6e64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0=
+golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y=
+golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
+golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
+golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
+modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI=
+modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc=
+modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw=
+modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ=
+modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ=
+modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ=
+modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM=
+modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA=
+modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A=
+modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU=
+modernc.org/libc v1.16.7/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU=
+modernc.org/libc v1.16.8 h1:Ux98PaOMvolgoFX/YwusFOHBnanXdGRmWgI8ciI2z4o=
+modernc.org/libc v1.16.8/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU=
+modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/mathutil v1.4.1 h1:ij3fYGe8zBF4Vu+g0oT7mB06r8sqGWKuJu1yXeR4by8=
+modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/memory v1.1.1 h1:bDOL0DIDLQv7bWhP3gMvIrnoFw+Eo6F7a2QK9HPDiFU=
+modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw=
+modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
+modernc.org/sqlite v1.17.3 h1:iE+coC5g17LtByDYDWKpR6m2Z9022YrSh3bumwOnIrI=
+modernc.org/sqlite v1.17.3/go.mod h1:10hPVYar9C0kfXuTWGz8s0XtB8uAGymUy51ZzStYe3k=
+modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw=
+modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw=
+modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
+modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8=

cmd/gf/internal/cmd/cmd.go

@@ -0,0 +1,64 @@
+package cmd
+
+import (
+	"context"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/service"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	GF = cGF{}
+)
+
+type cGF struct {
+	g.Meta `name:"gf" ad:"{cGFAd}"`
+}
+
+const (
+	cGFAd = `
+ADDITIONAL
+    Use "gf COMMAND -h" for details about a command.
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cGFAd`: cGFAd,
+	})
+}
+
+type cGFInput struct {
+	g.Meta  `name:"gf"`
+	Yes     bool `short:"y" name:"yes"     brief:"all yes for all command without prompt ask"   orphan:"true"`
+	Version bool `short:"v" name:"version" brief:"show version information of current binary"   orphan:"true"`
+	Debug   bool `short:"d" name:"debug"   brief:"show internal detailed debugging information" orphan:"true"`
+}
+type cGFOutput struct{}
+
+func (c cGF) Index(ctx context.Context, in cGFInput) (out *cGFOutput, err error) {
+	// Version.
+	if in.Version {
+		_, err = Version.Index(ctx, cVersionInput{})
+		return
+	}
+	// No argument or option, do installation checks.
+	if !service.Install.IsInstalled() {
+		mlog.Print("hi, it seams it's the first time you installing gf cli.")
+		s := gcmd.Scanf("do you want to install gf binary to your system? [y/n]: ")
+		if strings.EqualFold(s, "y") {
+			if err = service.Install.Run(ctx); err != nil {
+				return
+			}
+			gcmd.Scan("press `Enter` to exit...")
+			return
+		}
+	}
+	// Print help content.
+	gcmd.CommandFromCtx(ctx).Print()
+	return
+}

cmd/gf/internal/cmd/cmd_build.go

@@ -0,0 +1,323 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"regexp"
+	"runtime"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/encoding/gbase64"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/genv"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Build = cBuild{
+		nodeNameInConfigFile: "gfcli.build",
+		packedGoFileName:     "internal/packed/build_pack_data.go",
+	}
+)
+
+type cBuild struct {
+	g.Meta               `name:"build" brief:"{cBuildBrief}" dc:"{cBuildDc}" eg:"{cBuildEg}" ad:"{cBuildAd}"`
+	nodeNameInConfigFile string // nodeNameInConfigFile is the node name for compiler configurations in configuration file.
+	packedGoFileName     string // packedGoFileName specifies the file name for packing common folders into one single go file.
+}
+
+const (
+	cBuildBrief = `cross-building go project for lots of platforms`
+	cBuildEg    = `
+gf build main.go
+gf build main.go --pack public,template
+gf build main.go --cgo
+gf build main.go -m none 
+gf build main.go -n my-app -a all -s all
+gf build main.go -n my-app -a amd64,386 -s linux -p .
+gf build main.go -n my-app -v 1.0 -a amd64,386 -s linux,windows,darwin -p ./docker/bin
+`
+	cBuildDc = `
+The "build" command is most commonly used command, which is designed as a powerful wrapper for 
+"go build" command for convenience cross-compiling usage. 
+It provides much more features for building binary:
+1. Cross-Compiling for many platforms and architectures.
+2. Configuration file support for compiling.
+3. Build-In Variables.
+`
+	cBuildAd = `
+PLATFORMS
+    darwin    amd64,arm64
+    freebsd   386,amd64,arm
+    linux     386,amd64,arm,arm64,ppc64,ppc64le,mips,mipsle,mips64,mips64le
+    netbsd    386,amd64,arm
+    openbsd   386,amd64,arm
+    windows   386,amd64
+`
+	// https://golang.google.cn/doc/install/source
+	cBuildPlatforms = `
+darwin    amd64
+darwin    arm64
+ios       amd64
+ios       arm64
+freebsd   386
+freebsd   amd64
+freebsd   arm
+linux     386
+linux     amd64
+linux     arm
+linux     arm64
+linux     ppc64
+linux     ppc64le
+linux     mips
+linux     mipsle
+linux     mips64
+linux     mips64le
+netbsd    386
+netbsd    amd64
+netbsd    arm
+openbsd   386
+openbsd   amd64
+openbsd   arm
+windows   386
+windows   amd64
+android   arm
+dragonfly amd64
+plan9     386
+plan9     amd64
+solaris   amd64
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cBuildBrief`: cBuildBrief,
+		`cBuildDc`:    cBuildDc,
+		`cBuildEg`:    cBuildEg,
+		`cBuildAd`:    cBuildAd,
+	})
+}
+
+type cBuildInput struct {
+	g.Meta        `name:"build" config:"gfcli.build"`
+	File          string `name:"FILE" arg:"true"    brief:"building file path"`
+	Name          string `short:"n"  name:"name"    brief:"output binary name"`
+	Version       string `short:"v"  name:"version" brief:"output binary version"`
+	Arch          string `short:"a"  name:"arch"    brief:"output binary architecture, multiple arch separated with ','"`
+	System        string `short:"s"  name:"system"  brief:"output binary system, multiple os separated with ','"`
+	Output        string `short:"o"  name:"output"  brief:"output binary path, used when building single binary file"`
+	Path          string `short:"p"  name:"path"    brief:"output binary directory path, default is './temp'" d:"./temp"`
+	Extra         string `short:"e"  name:"extra"   brief:"extra custom \"go build\" options"`
+	Mod           string `short:"m"  name:"mod"     brief:"like \"-mod\" option of \"go build\", use \"-m none\" to disable go module"`
+	Cgo           bool   `short:"c"  name:"cgo"     brief:"enable or disable cgo feature, it's disabled in default" orphan:"true"`
+	VarMap        g.Map  `short:"r"  name:"varMap"  brief:"custom built embedded variable into binary"`
+	PackSrc       string `short:"ps" name:"packSrc" brief:"pack one or more folders into one go file before building"`
+	PackDst       string `short:"pd" name:"packDst" brief:"temporary go file path for pack, this go file will be automatically removed after built" d:"internal/packed/build_pack_data.go"`
+	ExitWhenError bool   `short:"ew" name:"exitWhenError" brief:"exit building when any error occurs, default is false" orphan:"true"`
+}
+type cBuildOutput struct{}
+
+func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, err error) {
+	mlog.SetHeaderPrint(true)
+
+	mlog.Debugf(`build input: %+v`, in)
+	// Necessary check.
+	if gproc.SearchBinary("go") == "" {
+		mlog.Fatalf(`command "go" not found in your environment, please install golang first to proceed this command`)
+	}
+
+	var (
+		parser = gcmd.ParserFromCtx(ctx)
+		file   = parser.GetArg(2).String()
+	)
+	if len(file) < 1 {
+		// Check and use the main.go file.
+		if gfile.Exists("main.go") {
+			file = "main.go"
+		} else {
+			mlog.Fatal("build file path cannot be empty")
+		}
+	}
+	if in.Name == "" {
+		in.Name = gfile.Name(file)
+	}
+	if len(in.Name) < 1 || in.Name == "*" {
+		mlog.Fatal("name cannot be empty")
+	}
+	if in.Mod != "" && in.Mod != "none" {
+		mlog.Debugf(`mod is %s`, in.Mod)
+		if in.Extra == "" {
+			in.Extra = fmt.Sprintf(`-mod=%s`, in.Mod)
+		} else {
+			in.Extra = fmt.Sprintf(`-mod=%s %s`, in.Mod, in.Extra)
+		}
+	}
+	if in.Extra != "" {
+		in.Extra += " "
+	}
+	var (
+		customSystems = gstr.SplitAndTrim(in.System, ",")
+		customArches  = gstr.SplitAndTrim(in.Arch, ",")
+	)
+	if len(in.Version) > 0 {
+		in.Path += "/" + in.Version
+	}
+	// System and arch checks.
+	var (
+		spaceRegex  = regexp.MustCompile(`\s+`)
+		platformMap = make(map[string]map[string]bool)
+	)
+	for _, line := range strings.Split(strings.TrimSpace(cBuildPlatforms), "\n") {
+		line = gstr.Trim(line)
+		line = spaceRegex.ReplaceAllString(line, " ")
+		var (
+			array  = strings.Split(line, " ")
+			system = strings.TrimSpace(array[0])
+			arch   = strings.TrimSpace(array[1])
+		)
+		if platformMap[system] == nil {
+			platformMap[system] = make(map[string]bool)
+		}
+		platformMap[system][arch] = true
+	}
+	// Auto packing.
+	if in.PackSrc != "" {
+		if in.PackDst == "" {
+			mlog.Fatal(`parameter "packDst" should not be empty when "packSrc" is used`)
+		}
+		if gfile.Exists(in.PackDst) && !gfile.IsFile(in.PackDst) {
+			mlog.Fatalf(`parameter "packDst" path "%s" should be type of file not directory`, in.PackDst)
+		}
+		if !gfile.Exists(in.PackDst) {
+			// Remove the go file that is automatically packed resource.
+			defer func() {
+				_ = gfile.Remove(in.PackDst)
+				mlog.Printf(`remove the automatically generated resource go file: %s`, in.PackDst)
+			}()
+		}
+		packCmd := fmt.Sprintf(`gf pack %s %s`, in.PackSrc, in.PackDst)
+		mlog.Print(packCmd)
+		gproc.MustShellRun(ctx, packCmd)
+	}
+
+	// Injected information by building flags.
+	ldFlags := fmt.Sprintf(
+		`-X 'github.com/gogf/gf/v2/os/gbuild.builtInVarStr=%v'`,
+		c.getBuildInVarStr(ctx, in),
+	)
+
+	// start building
+	mlog.Print("start building...")
+	if in.Cgo {
+		genv.MustSet("CGO_ENABLED", "1")
+	} else {
+		genv.MustSet("CGO_ENABLED", "0")
+	}
+	var (
+		cmd = ""
+		ext = ""
+	)
+	for system, item := range platformMap {
+		cmd = ""
+		ext = ""
+		if len(customSystems) > 0 && customSystems[0] != "all" && !gstr.InArray(customSystems, system) {
+			continue
+		}
+		for arch, _ := range item {
+			if len(customArches) > 0 && customArches[0] != "all" && !gstr.InArray(customArches, arch) {
+				continue
+			}
+			if len(customSystems) == 0 && len(customArches) == 0 {
+				if runtime.GOOS == "windows" {
+					ext = ".exe"
+				}
+				// Single binary building, output the binary to current working folder.
+				output := ""
+				if len(in.Output) > 0 {
+					output = "-o " + in.Output + ext
+				} else {
+					output = "-o " + in.Name + ext
+				}
+				cmd = fmt.Sprintf(`go build %s -ldflags "%s" %s %s`, output, ldFlags, in.Extra, file)
+			} else {
+				// Cross-building, output the compiled binary to specified path.
+				if system == "windows" {
+					ext = ".exe"
+				}
+				genv.MustSet("GOOS", system)
+				genv.MustSet("GOARCH", arch)
+				cmd = fmt.Sprintf(
+					`go build -o %s/%s/%s%s -ldflags "%s" %s%s`,
+					in.Path, system+"_"+arch, in.Name, ext, ldFlags, in.Extra, file,
+				)
+			}
+			mlog.Debug(cmd)
+			// It's not necessary printing the complete command string.
+			cmdShow, _ := gregex.ReplaceString(`\s+(-ldflags ".+?")\s+`, " ", cmd)
+			mlog.Print(cmdShow)
+			if result, err := gproc.ShellExec(ctx, cmd); err != nil {
+				mlog.Printf(
+					"failed to build, os:%s, arch:%s, error:\n%s\n\n%s\n",
+					system, arch, gstr.Trim(result),
+					`you may use command option "--debug" to enable debug info and check the details`,
+				)
+				if in.ExitWhenError {
+					os.Exit(1)
+				}
+			} else {
+				mlog.Debug(gstr.Trim(result))
+			}
+			// single binary building.
+			if len(customSystems) == 0 && len(customArches) == 0 {
+				goto buildDone
+			}
+		}
+	}
+
+buildDone:
+	mlog.Print("done!")
+	return
+}
+
+// getBuildInVarMapJson retrieves and returns the custom build-in variables in configuration
+// file as json.
+func (c cBuild) getBuildInVarStr(ctx context.Context, in cBuildInput) string {
+	buildInVarMap := in.VarMap
+	if buildInVarMap == nil {
+		buildInVarMap = make(g.Map)
+	}
+	buildInVarMap["builtGit"] = c.getGitCommit(ctx)
+	buildInVarMap["builtTime"] = gtime.Now().String()
+	b, err := json.Marshal(buildInVarMap)
+	if err != nil {
+		mlog.Fatal(err)
+	}
+	return gbase64.EncodeToString(b)
+}
+
+// getGitCommit retrieves and returns the latest git commit hash string if present.
+func (c cBuild) getGitCommit(ctx context.Context) string {
+	if gproc.SearchBinary("git") == "" {
+		return ""
+	}
+	var (
+		cmd  = `git log -1 --format="%cd %H" --date=format:"%Y-%m-%d %H:%M:%S"`
+		s, _ = gproc.ShellExec(ctx, cmd)
+	)
+	mlog.Debug(cmd)
+	if s != "" {
+		if !gstr.Contains(s, "fatal") {
+			return gstr.Trim(s)
+		}
+	}
+	return ""
+}

cmd/gf/internal/cmd/cmd_docker.go

@@ -0,0 +1,161 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"runtime"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Docker = cDocker{}
+)
+
+type cDocker struct {
+	g.Meta `name:"docker" usage:"{cDockerUsage}" brief:"{cDockerBrief}" eg:"{cDockerEg}" dc:"{cDockerDc}"`
+}
+
+const (
+	cDockerUsage = `gf docker [MAIN] [OPTION]`
+	cDockerBrief = `build docker image for current GoFrame project`
+	cDockerEg    = `
+gf docker 
+gf docker -t hub.docker.com/john/image:tag
+gf docker -p -t hub.docker.com/john/image:tag
+gf docker main.go
+gf docker main.go -t hub.docker.com/john/image:tag
+gf docker main.go -t hub.docker.com/john/image:tag
+gf docker main.go -p -t hub.docker.com/john/image:tag
+`
+	cDockerDc = `
+The "docker" command builds the GF project to a docker images.
+It runs "gf build" firstly to compile the project to binary file.
+It then runs "docker build" command automatically to generate the docker image.
+You should have docker installed, and there must be a Dockerfile in the root of the project.
+`
+	cDockerMainBrief        = `main file path for "gf build", it's "main.go" in default. empty string for no binary build`
+	cDockerBuildBrief       = `binary build options before docker image build, it's "-a amd64 -s linux" in default`
+	cDockerFileBrief        = `file path of the Dockerfile. it's "manifest/docker/Dockerfile" in default`
+	cDockerShellBrief       = `path of the shell file which is executed before docker build`
+	cDockerPushBrief        = `auto push the docker image to docker registry if "-t" option passed`
+	cDockerTagNameBrief     = `tag name for this docker, pattern like "image:tag". this option is required with TagPrefixes`
+	cDockerTagPrefixesBrief = `tag prefixes for this docker, which are used for docker push. this option is required with TagName`
+	cDockerExtraBrief       = `extra build options passed to "docker image"`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cDockerUsage`:            cDockerUsage,
+		`cDockerBrief`:            cDockerBrief,
+		`cDockerEg`:               cDockerEg,
+		`cDockerDc`:               cDockerDc,
+		`cDockerMainBrief`:        cDockerMainBrief,
+		`cDockerFileBrief`:        cDockerFileBrief,
+		`cDockerShellBrief`:       cDockerShellBrief,
+		`cDockerBuildBrief`:       cDockerBuildBrief,
+		`cDockerPushBrief`:        cDockerPushBrief,
+		`cDockerTagNameBrief`:     cDockerTagNameBrief,
+		`cDockerTagPrefixesBrief`: cDockerTagPrefixesBrief,
+		`cDockerExtraBrief`:       cDockerExtraBrief,
+	})
+}
+
+type cDockerInput struct {
+	g.Meta      `name:"docker" config:"gfcli.docker"`
+	Main        string   `name:"MAIN" arg:"true" brief:"{cDockerMainBrief}"  d:"main.go"`
+	File        string   `name:"file"        short:"f"  brief:"{cDockerFileBrief}"  d:"manifest/docker/Dockerfile"`
+	Shell       string   `name:"shell"       short:"s"  brief:"{cDockerShellBrief}" d:"manifest/docker/docker.sh"`
+	Build       string   `name:"build"       short:"b"  brief:"{cDockerBuildBrief}" d:"-a amd64 -s linux"`
+	TagName     string   `name:"tagName"     short:"tn" brief:"{cDockerTagNameBrief}"     v:"required-with:TagPrefixes"`
+	TagPrefixes []string `name:"tagPrefixes" short:"tp" brief:"{cDockerTagPrefixesBrief}" v:"required-with:TagName"`
+	Push        bool     `name:"push"        short:"p"  brief:"{cDockerPushBrief}" orphan:"true"`
+	Extra       string   `name:"extra"       short:"e"  brief:"{cDockerExtraBrief}"`
+}
+type cDockerOutput struct{}
+
+func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput, err error) {
+	// Necessary check.
+	if gproc.SearchBinary("docker") == "" {
+		mlog.Fatalf(`command "docker" not found in your environment, please install docker first to proceed this command`)
+	}
+
+	// Binary build.
+	in.Build += " --exit"
+	if in.Main != "" {
+		if err = gproc.ShellRun(ctx, fmt.Sprintf(`gf build %s %s`, in.Main, in.Build)); err != nil {
+			return
+		}
+	}
+
+	// Shell executing.
+	if in.Shell != "" && gfile.Exists(in.Shell) {
+		if err = c.exeDockerShell(ctx, in.Shell); err != nil {
+			return
+		}
+	}
+	// Docker build.
+	var (
+		dockerBuildOptions string
+		dockerTags         []string
+		dockerTagBase      string
+	)
+	if len(in.TagPrefixes) > 0 {
+		for _, tagPrefix := range in.TagPrefixes {
+			tagPrefix = gstr.TrimRight(tagPrefix, "/")
+			dockerTags = append(dockerTags, fmt.Sprintf(`%s/%s`, tagPrefix, in.TagName))
+		}
+	}
+	if len(dockerTags) == 0 {
+		dockerTags = []string{""}
+	}
+	for i, dockerTag := range dockerTags {
+		if i > 0 {
+			err = gproc.ShellRun(ctx, fmt.Sprintf(`docker tag %s %s`, dockerTagBase, dockerTag))
+			if err != nil {
+				return
+			}
+			continue
+		}
+		dockerTagBase = dockerTag
+		dockerBuildOptions = ""
+		if dockerTag != "" {
+			dockerBuildOptions = fmt.Sprintf(`-t %s`, dockerTag)
+		}
+		if in.Extra != "" {
+			dockerBuildOptions = fmt.Sprintf(`%s %s`, dockerBuildOptions, in.Extra)
+		}
+		err = gproc.ShellRun(ctx, fmt.Sprintf(`docker build -f %s . %s`, in.File, dockerBuildOptions))
+		if err != nil {
+			return
+		}
+	}
+
+	// Docker push.
+	if !in.Push {
+		return
+	}
+	for _, dockerTag := range dockerTags {
+		if dockerTag == "" {
+			continue
+		}
+		err = gproc.ShellRun(ctx, fmt.Sprintf(`docker push %s`, dockerTag))
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (c cDocker) exeDockerShell(ctx context.Context, shellFilePath string) error {
+	if gfile.ExtName(shellFilePath) == "sh" && runtime.GOOS == "windows" {
+		mlog.Debugf(`ignore shell file "%s", as it cannot be run on windows system`, shellFilePath)
+		return nil
+	}
+	return gproc.ShellRun(ctx, gfile.GetContents(shellFilePath))
+}

cmd/gf/internal/cmd/cmd_env.go

@@ -0,0 +1,61 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/olekukonko/tablewriter"
+)
+
+var (
+	Env = cEnv{}
+)
+
+type cEnv struct {
+	g.Meta `name:"env" brief:"show current Golang environment variables"`
+}
+
+type cEnvInput struct {
+	g.Meta `name:"env"`
+}
+type cEnvOutput struct{}
+
+func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err error) {
+	result, err := gproc.ShellExec(ctx, "go env")
+	if err != nil {
+		mlog.Fatal(err)
+	}
+	if result == "" {
+		mlog.Fatal(`retrieving Golang environment variables failed, did you install Golang?`)
+	}
+	var (
+		lines  = gstr.Split(result, "\n")
+		buffer = bytes.NewBuffer(nil)
+	)
+	array := make([][]string, 0)
+	for _, line := range lines {
+		line = gstr.Trim(line)
+		if line == "" {
+			continue
+		}
+		if gstr.Pos(line, "set ") == 0 {
+			line = line[4:]
+		}
+		match, _ := gregex.MatchString(`(.+?)=(.*)`, line)
+		if len(match) < 3 {
+			mlog.Fatalf(`invalid Golang environment variable: "%s"`, line)
+		}
+		array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetColumnAlignment([]int{tablewriter.ALIGN_LEFT, tablewriter.ALIGN_LEFT})
+	tw.AppendBulk(array)
+	tw.Render()
+	mlog.Print(buffer.String())
+	return
+}

cmd/gf/internal/cmd/cmd_gen.go

@@ -0,0 +1,34 @@
+package cmd
+
+import (
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Gen = cGen{}
+)
+
+type cGen struct {
+	g.Meta `name:"gen" brief:"{cGenBrief}" dc:"{cGenDc}"`
+	cGenDao
+	cGenPb
+	cGenPbEntity
+	cGenService
+}
+
+const (
+	cGenBrief = `automatically generate go files for dao/do/entity/pb/pbentity`
+	cGenDc    = `
+The "gen" command is designed for multiple generating purposes. 
+It's currently supporting generating go files for ORM models, protobuf and protobuf entity files.
+Please use "gf gen dao -h" for specified type help.
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cGenBrief`: cGenBrief,
+		`cGenDc`:    cGenDc,
+	})
+}

cmd/gf/internal/cmd/cmd_gen_dao.go

@@ -0,0 +1,15 @@
+package cmd
+
+import (
+	_ "github.com/gogf/gf/contrib/drivers/mssql/v2"
+	_ "github.com/gogf/gf/contrib/drivers/mysql/v2"
+	_ "github.com/gogf/gf/contrib/drivers/pgsql/v2"
+	_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
+	//_ "github.com/gogf/gf/contrib/drivers/oracle/v2"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/gendao"
+)
+
+type (
+	cGenDao = gendao.CGenDao
+)

cmd/gf/internal/cmd/cmd_gen_pb.go

@@ -0,0 +1,79 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/genv"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+)
+
+type (
+	cGenPb      struct{}
+	cGenPbInput struct {
+		g.Meta `name:"pb" brief:"parse proto files and generate protobuf go files"`
+	}
+	cGenPbOutput struct{}
+)
+
+func (c cGenPb) Pb(ctx context.Context, in cGenPbInput) (out *cGenPbOutput, err error) {
+	// Necessary check.
+	if gproc.SearchBinary("protoc") == "" {
+		mlog.Fatalf(`command "protoc" not found in your environment, please install protoc first to proceed this command`)
+	}
+
+	// protocol fold checks.
+	protoFolder := "protocol"
+	if !gfile.Exists(protoFolder) {
+		mlog.Fatalf(`proto files folder "%s" does not exist`, protoFolder)
+	}
+	// folder scanning.
+	files, err := gfile.ScanDirFile(protoFolder, "*.proto", true)
+	if err != nil {
+		mlog.Fatal(err)
+	}
+	if len(files) == 0 {
+		mlog.Fatalf(`no proto files found in folder "%s"`, protoFolder)
+	}
+	dirSet := gset.NewStrSet()
+	for _, file := range files {
+		dirSet.Add(gfile.Dir(file))
+	}
+	var (
+		servicePath = gfile.RealPath(".")
+		goPathSrc   = gfile.RealPath(gfile.Join(genv.Get("GOPATH").String(), "src"))
+	)
+	dirSet.Iterator(func(protoDirPath string) bool {
+		parsingCommand := fmt.Sprintf(
+			"protoc --gofast_out=plugins=grpc:. %s/*.proto -I%s",
+			protoDirPath,
+			servicePath,
+		)
+		if goPathSrc != "" {
+			parsingCommand += " -I" + goPathSrc
+		}
+		mlog.Print(parsingCommand)
+		if output, err := gproc.ShellExec(ctx, parsingCommand); err != nil {
+			mlog.Print(output)
+			mlog.Fatal(err)
+		}
+		return true
+	})
+	// Custom replacement.
+	//pbFolder := "protobuf"
+	//_, _ = gfile.ScanDirFileFunc(pbFolder, "*.go", true, func(path string) string {
+	//	content := gfile.GetContents(path)
+	//	content = gstr.ReplaceByArray(content, g.SliceStr{
+	//		`gtime "gtime"`, `gtime "github.com/gogf/gf/v2/os/gtime"`,
+	//	})
+	//	_ = gfile.PutContents(path, content)
+	//	utils.GoFmt(path)
+	//	return path
+	//})
+	mlog.Print("done!")
+	return
+}

cmd/gf/internal/cmd/cmd_gen_pbentity.go

@@ -0,0 +1,410 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gtag"
+	"github.com/olekukonko/tablewriter"
+)
+
+type (
+	cGenPbEntity      struct{}
+	cGenPbEntityInput struct {
+		g.Meta       `name:"pbentity" config:"{cGenPbEntityConfig}" brief:"{cGenPbEntityBrief}" eg:"{cGenPbEntityEg}" ad:"{cGenPbEntityAd}"`
+		Path         string `name:"path"         short:"p" brief:"{cGenPbEntityBriefPath}"`
+		Package      string `name:"package"      short:"k" brief:"{cGenPbEntityBriefPackage}"`
+		Link         string `name:"link"         short:"l" brief:"{cGenPbEntityBriefLink}"`
+		Tables       string `name:"tables"       short:"t" brief:"{cGenPbEntityBriefTables}"`
+		Prefix       string `name:"prefix"       short:"f" brief:"{cGenPbEntityBriefPrefix}"`
+		RemovePrefix string `name:"removePrefix" short:"r" brief:"{cGenPbEntityBriefRemovePrefix}"`
+		NameCase     string `name:"nameCase"     short:"n" brief:"{cGenPbEntityBriefNameCase}" d:"Camel"`
+		JsonCase     string `name:"jsonCase"     short:"j" brief:"{cGenPbEntityBriefJsonCase}" d:"CamelLower"`
+		Option       string `name:"option"       short:"o" brief:"{cGenPbEntityBriefOption}"`
+	}
+	cGenPbEntityOutput struct{}
+
+	cGenPbEntityInternalInput struct {
+		cGenPbEntityInput
+		TableName    string // TableName specifies the table name of the table.
+		NewTableName string // NewTableName specifies the prefix-stripped name of the table.
+	}
+)
+
+const (
+	cGenPbEntityConfig = `gfcli.gen.pbentity`
+	cGenPbEntityBrief  = `generate entity message files in protobuf3 format`
+	cGenPbEntityEg     = `
+gf gen pbentity
+gf gen pbentity -l "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+gf gen pbentity -p ./protocol/demos/entity -t user,user_detail,user_login
+gf gen pbentity -r user_
+`
+
+	cGenPbEntityAd = `
+CONFIGURATION SUPPORT
+    Options are also supported by configuration file.
+    It's suggested using configuration file instead of command line arguments making producing. 
+    The configuration node name is "gf.gen.pbentity", which also supports multiple databases, for example(config.yaml):
+    gfcli:
+      gen:
+      - pbentity:
+            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+            path:    "protocol/demos/entity"
+            tables:  "order,products"
+            package: "demos"
+      - pbentity:
+            link:    "mysql:root:12345678@tcp(127.0.0.1:3306)/primary"
+            path:    "protocol/demos/entity"
+            prefix:  "primary_"
+            tables:  "user, userDetail"
+            package: "demos"
+            option:  |
+			  option go_package    = "protobuf/demos";
+			  option java_package  = "protobuf/demos";
+			  option php_namespace = "protobuf/demos";
+`
+	cGenPbEntityBriefPath         = `directory path for generated files`
+	cGenPbEntityBriefPackage      = `package name for all entity proto files`
+	cGenPbEntityBriefLink         = `database configuration, the same as the ORM configuration of GoFrame`
+	cGenPbEntityBriefTables       = `generate models only for given tables, multiple table names separated with ','`
+	cGenPbEntityBriefPrefix       = `add specified prefix for all entity names and entity proto files`
+	cGenPbEntityBriefRemovePrefix = `remove specified prefix of the table, multiple prefix separated with ','`
+	cGenPbEntityBriefOption       = `extra protobuf options`
+	cGenPbEntityBriefGroup        = `
+specifying the configuration group name of database for generated ORM instance,
+it's not necessary and the default value is "default"
+`
+
+	cGenPbEntityBriefNameCase = `
+case for message attribute names, default is "Camel":
+| Case            | Example            |
+|---------------- |--------------------|
+| Camel           | AnyKindOfString    | 
+| CamelLower      | anyKindOfString    | default
+| Snake           | any_kind_of_string |
+| SnakeScreaming  | ANY_KIND_OF_STRING |
+| SnakeFirstUpper | rgb_code_md5       |
+| Kebab           | any-kind-of-string |
+| KebabScreaming  | ANY-KIND-OF-STRING |
+`
+
+	cGenPbEntityBriefJsonCase = `
+case for message json tag, cases are the same as "nameCase", default "CamelLower".
+set it to "none" to ignore json tag generating.
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cGenPbEntityConfig`:            cGenPbEntityConfig,
+		`cGenPbEntityBrief`:             cGenPbEntityBrief,
+		`cGenPbEntityEg`:                cGenPbEntityEg,
+		`cGenPbEntityAd`:                cGenPbEntityAd,
+		`cGenPbEntityBriefPath`:         cGenPbEntityBriefPath,
+		`cGenPbEntityBriefPackage`:      cGenPbEntityBriefPackage,
+		`cGenPbEntityBriefLink`:         cGenPbEntityBriefLink,
+		`cGenPbEntityBriefTables`:       cGenPbEntityBriefTables,
+		`cGenPbEntityBriefPrefix`:       cGenPbEntityBriefPrefix,
+		`cGenPbEntityBriefRemovePrefix`: cGenPbEntityBriefRemovePrefix,
+		`cGenPbEntityBriefGroup`:        cGenPbEntityBriefGroup,
+		`cGenPbEntityBriefNameCase`:     cGenPbEntityBriefNameCase,
+		`cGenPbEntityBriefJsonCase`:     cGenPbEntityBriefJsonCase,
+		`cGenPbEntityBriefOption`:       cGenPbEntityBriefOption,
+	})
+}
+
+func (c cGenPbEntity) PbEntity(ctx context.Context, in cGenPbEntityInput) (out *cGenPbEntityOutput, err error) {
+	var (
+		config = g.Cfg()
+	)
+	if config.Available(ctx) {
+		v := config.MustGet(ctx, cGenPbEntityConfig)
+		if v.IsSlice() {
+			for i := 0; i < len(v.Interfaces()); i++ {
+				doGenPbEntityForArray(ctx, i, in)
+			}
+		} else {
+			doGenPbEntityForArray(ctx, -1, in)
+		}
+	} else {
+		doGenPbEntityForArray(ctx, -1, in)
+	}
+	mlog.Print("done!")
+	return
+}
+
+func doGenPbEntityForArray(ctx context.Context, index int, in cGenPbEntityInput) {
+	var (
+		err error
+		db  gdb.DB
+	)
+	if index >= 0 {
+		err = g.Cfg().MustGet(
+			ctx,
+			fmt.Sprintf(`%s.%d`, cGenPbEntityConfig, index),
+		).Scan(&in)
+		if err != nil {
+			mlog.Fatalf(`invalid configuration of "%s": %+v`, cGenPbEntityConfig, err)
+		}
+	}
+	if in.Package == "" {
+		mlog.Fatal("package name should not be empty")
+	}
+	removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
+	// It uses user passed database configuration.
+	if in.Link != "" {
+		var (
+			tempGroup = gtime.TimestampNanoStr()
+			match, _  = gregex.MatchString(`([a-z]+):(.+)`, in.Link)
+		)
+		if len(match) == 3 {
+			gdb.AddConfigNode(tempGroup, gdb.ConfigNode{
+				Type: gstr.Trim(match[1]),
+				Link: gstr.Trim(match[2]),
+			})
+			db, _ = gdb.Instance(tempGroup)
+		}
+	} else {
+		db = g.DB()
+	}
+	if db == nil {
+		mlog.Fatal("database initialization failed")
+	}
+
+	tableNames := ([]string)(nil)
+	if in.Tables != "" {
+		tableNames = gstr.SplitAndTrim(in.Tables, ",")
+	} else {
+		tableNames, err = db.Tables(context.TODO())
+		if err != nil {
+			mlog.Fatalf("fetching tables failed: \n %v", err)
+		}
+	}
+
+	for _, tableName := range tableNames {
+		newTableName := tableName
+		for _, v := range removePrefixArray {
+			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
+		}
+		generatePbEntityContentFile(ctx, db, cGenPbEntityInternalInput{
+			cGenPbEntityInput: in,
+			TableName:         tableName,
+			NewTableName:      newTableName,
+		})
+	}
+}
+
+// generatePbEntityContentFile generates the protobuf files for given table.
+func generatePbEntityContentFile(ctx context.Context, db gdb.DB, in cGenPbEntityInternalInput) {
+	fieldMap, err := db.TableFields(ctx, in.TableName)
+	if err != nil {
+		mlog.Fatalf("fetching tables fields failed for table '%s':\n%v", in.TableName, err)
+	}
+	// Change the `newTableName` if `Prefix` is given.
+	newTableName := "Entity_" + in.Prefix + in.NewTableName
+	var (
+		tableNameCamelCase  = gstr.CaseCamel(newTableName)
+		tableNameSnakeCase  = gstr.CaseSnake(newTableName)
+		entityMessageDefine = generateEntityMessageDefinition(tableNameCamelCase, fieldMap, in)
+		fileName            = gstr.Trim(tableNameSnakeCase, "-_.")
+		path                = gfile.Join(in.Path, fileName+".proto")
+	)
+	entityContent := gstr.ReplaceByMap(getTplPbEntityContent(""), g.MapStrStr{
+		"{PackageName}":   in.Package,
+		"{OptionContent}": in.Option,
+		"{EntityMessage}": entityMessageDefine,
+	})
+	if err := gfile.PutContents(path, strings.TrimSpace(entityContent)); err != nil {
+		mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+	} else {
+		mlog.Print("generated:", path)
+	}
+}
+
+// generateEntityMessageDefinition generates and returns the message definition for specified table.
+func generateEntityMessageDefinition(entityName string, fieldMap map[string]*gdb.TableField, in cGenPbEntityInternalInput) string {
+	var (
+		buffer = bytes.NewBuffer(nil)
+		array  = make([][]string, len(fieldMap))
+		names  = sortFieldKeyForPbEntity(fieldMap)
+	)
+	for index, name := range names {
+		array[index] = generateMessageFieldForPbEntity(index+1, fieldMap[name], in)
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
+	stContent := buffer.String()
+	// Let's do this hack of table writer for indent!
+	stContent = gstr.Replace(stContent, "  #", "")
+	buffer.Reset()
+	buffer.WriteString(fmt.Sprintf("message %s {\n", entityName))
+	buffer.WriteString(stContent)
+	buffer.WriteString("}")
+	return buffer.String()
+}
+
+// generateMessageFieldForPbEntity generates and returns the message definition for specified field.
+func generateMessageFieldForPbEntity(index int, field *gdb.TableField, in cGenPbEntityInternalInput) []string {
+	var (
+		typeName   string
+		comment    string
+		jsonTagStr string
+	)
+	t, _ := gregex.ReplaceString(`\(.+\)`, "", field.Type)
+	t = gstr.Split(gstr.Trim(t), " ")[0]
+	t = gstr.ToLower(t)
+	switch t {
+	case "binary", "varbinary", "blob", "tinyblob", "mediumblob", "longblob":
+		typeName = "bytes"
+
+	case "bit", "int", "tinyint", "small_int", "smallint", "medium_int", "mediumint", "serial":
+		if gstr.ContainsI(field.Type, "unsigned") {
+			typeName = "uint32"
+		} else {
+			typeName = "int32"
+		}
+
+	case "int8", "big_int", "bigint", "bigserial":
+		if gstr.ContainsI(field.Type, "unsigned") {
+			typeName = "uint64"
+		} else {
+			typeName = "int64"
+		}
+
+	case "real":
+		typeName = "float"
+
+	case "float", "double", "decimal", "smallmoney":
+		typeName = "double"
+
+	case "bool":
+		typeName = "bool"
+
+	case "datetime", "timestamp", "date", "time":
+		typeName = "int64"
+
+	default:
+		// Auto detecting type.
+		switch {
+		case strings.Contains(t, "int"):
+			typeName = "int"
+		case strings.Contains(t, "text") || strings.Contains(t, "char"):
+			typeName = "string"
+		case strings.Contains(t, "float") || strings.Contains(t, "double"):
+			typeName = "double"
+		case strings.Contains(t, "bool"):
+			typeName = "bool"
+		case strings.Contains(t, "binary") || strings.Contains(t, "blob"):
+			typeName = "bytes"
+		case strings.Contains(t, "date") || strings.Contains(t, "time"):
+			typeName = "int64"
+		default:
+			typeName = "string"
+		}
+	}
+	comment = gstr.ReplaceByArray(field.Comment, g.SliceStr{
+		"\n", " ",
+		"\r", " ",
+	})
+	comment = gstr.Trim(comment)
+	comment = gstr.Replace(comment, `\n`, " ")
+	comment, _ = gregex.ReplaceString(`\s{2,}`, ` `, comment)
+	if jsonTagName := formatCase(field.Name, in.JsonCase); jsonTagName != "" {
+		jsonTagStr = fmt.Sprintf(`[(gogoproto.jsontag) = "%s"]`, jsonTagName)
+		// beautiful indent.
+		if index < 10 {
+			// 3 spaces
+			jsonTagStr = "   " + jsonTagStr
+		} else if index < 100 {
+			// 2 spaces
+			jsonTagStr = "  " + jsonTagStr
+		} else {
+			// 1 spaces
+			jsonTagStr = " " + jsonTagStr
+		}
+	}
+	return []string{
+		"    #" + typeName,
+		" #" + formatCase(field.Name, in.NameCase),
+		" #= " + gconv.String(index) + jsonTagStr + ";",
+		" #" + fmt.Sprintf(`// %s`, comment),
+	}
+}
+
+func getTplPbEntityContent(tplEntityPath string) string {
+	if tplEntityPath != "" {
+		return gfile.GetContents(tplEntityPath)
+	}
+	return consts.TemplatePbEntityMessageContent
+}
+
+// formatCase call gstr.Case* function to convert the s to specified case.
+func formatCase(str, caseStr string) string {
+	switch gstr.ToLower(caseStr) {
+	case gstr.ToLower("Camel"):
+		return gstr.CaseCamel(str)
+
+	case gstr.ToLower("CamelLower"):
+		return gstr.CaseCamelLower(str)
+
+	case gstr.ToLower("Kebab"):
+		return gstr.CaseKebab(str)
+
+	case gstr.ToLower("KebabScreaming"):
+		return gstr.CaseKebabScreaming(str)
+
+	case gstr.ToLower("Snake"):
+		return gstr.CaseSnake(str)
+
+	case gstr.ToLower("SnakeFirstUpper"):
+		return gstr.CaseSnakeFirstUpper(str)
+
+	case gstr.ToLower("SnakeScreaming"):
+		return gstr.CaseSnakeScreaming(str)
+
+	case "none":
+		return ""
+	}
+	return str
+}
+
+func sortFieldKeyForPbEntity(fieldMap map[string]*gdb.TableField) []string {
+	names := make(map[int]string)
+	for _, field := range fieldMap {
+		names[field.Index] = field.Name
+	}
+	var (
+		result = make([]string, len(names))
+		i      = 0
+		j      = 0
+	)
+	for {
+		if len(names) == 0 {
+			break
+		}
+		if val, ok := names[i]; ok {
+			result[j] = val
+			j++
+			delete(names, i)
+		}
+		i++
+	}
+	return result
+}

cmd/gf/internal/cmd/cmd_gen_service.go

@@ -0,0 +1,441 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"go/parser"
+	"go/token"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+const (
+	cGenServiceConfig = `gfcli.gen.service`
+	cGenServiceUsage  = `gf gen service [OPTION]`
+	cGenServiceBrief  = `parse struct and associated functions from packages to generate service go file`
+	cGenServiceEg     = `
+gf gen service
+gf gen service -f Snake
+`
+	cGenServiceBriefSrcFolder    = `source folder path to be parsed. default: internal/logic`
+	cGenServiceBriefDstFolder    = `destination folder path storing automatically generated go files. default: internal/service`
+	cGenServiceBriefFileNameCase = `
+destination file name storing automatically generated go files, cases are as follows:
+| Case            | Example            |
+|---------------- |--------------------|
+| Lower           | anykindofstring    |
+| Camel           | AnyKindOfString    |
+| CamelLower      | anyKindOfString    |
+| Snake           | any_kind_of_string | default
+| SnakeScreaming  | ANY_KIND_OF_STRING |
+| SnakeFirstUpper | rgb_code_md5       |
+| Kebab           | any-kind-of-string |
+| KebabScreaming  | ANY-KIND-OF-STRING |
+`
+	cGenServiceBriefWatchFile    = `used in file watcher, it generates service go files only if given file is under srcFolder`
+	cGenServiceBriefStPattern    = `regular expression matching struct name for generating service. default: s([A-Z]\\\\w+)`
+	cGenServiceBriefPackages     = `produce go files only for given source packages`
+	cGenServiceBriefImportPrefix = `custom import prefix to calculate import path for generated importing go file of logic`
+	cGenServiceBriefOverWrite    = `overwrite service go files that already exist in generating folder. default: true`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cGenServiceConfig`:            cGenServiceConfig,
+		`cGenServiceUsage`:             cGenServiceUsage,
+		`cGenServiceBrief`:             cGenServiceBrief,
+		`cGenServiceEg`:                cGenServiceEg,
+		`cGenServiceBriefSrcFolder`:    cGenServiceBriefSrcFolder,
+		`cGenServiceBriefDstFolder`:    cGenServiceBriefDstFolder,
+		`cGenServiceBriefFileNameCase`: cGenServiceBriefFileNameCase,
+		`cGenServiceBriefWatchFile`:    cGenServiceBriefWatchFile,
+		`cGenServiceBriefStPattern`:    cGenServiceBriefStPattern,
+		`cGenServiceBriefPackages`:     cGenServiceBriefPackages,
+		`cGenServiceBriefImportPrefix`: cGenServiceBriefImportPrefix,
+		`cGenServiceBriefOverWrite`:    cGenServiceBriefOverWrite,
+	})
+}
+
+type (
+	cGenService      struct{}
+	cGenServiceInput struct {
+		g.Meta          `name:"service" config:"{cGenServiceConfig}" usage:"{cGenServiceUsage}" brief:"{cGenServiceBrief}" eg:"{cGenServiceEg}"`
+		SrcFolder       string   `short:"s" name:"srcFolder" brief:"{cGenServiceBriefSrcFolder}" d:"internal/logic"`
+		DstFolder       string   `short:"d" name:"dstFolder" brief:"{cGenServiceBriefDstFolder}" d:"internal/service"`
+		DstFileNameCase string   `short:"f" name:"dstFileNameCase" brief:"{cGenServiceBriefFileNameCase}" d:"Snake"`
+		WatchFile       string   `short:"w" name:"watchFile" brief:"{cGenServiceBriefWatchFile}"`
+		StPattern       string   `short:"a" name:"stPattern" brief:"{cGenServiceBriefStPattern}" d:"s([A-Z]\\w+)"`
+		Packages        []string `short:"p" name:"packages" brief:"{cGenServiceBriefPackages}"`
+		ImportPrefix    string   `short:"i" name:"importPrefix" brief:"{cGenServiceBriefImportPrefix}"`
+		OverWrite       bool     `short:"o" name:"overwrite" brief:"{cGenServiceBriefOverWrite}" d:"true" orphan:"true"`
+	}
+	cGenServiceOutput struct{}
+)
+
+const (
+	genServiceFileLockSeconds = 10
+)
+
+func (c cGenService) Service(ctx context.Context, in cGenServiceInput) (out *cGenServiceOutput, err error) {
+	// File lock to avoid multiple processes.
+	var (
+		flockFilePath = gfile.Temp("gf.cli.gen.service.lock")
+		flockContent  = gfile.GetContents(flockFilePath)
+	)
+	if flockContent != "" {
+		if gtime.Timestamp()-gconv.Int64(flockContent) < genServiceFileLockSeconds {
+			// If another "gen service" process is running, it just exits.
+			mlog.Debug(`another "gen service" process is running, exit`)
+			return
+		}
+	}
+	defer gfile.Remove(flockFilePath)
+	_ = gfile.PutContents(flockFilePath, gtime.TimestampStr())
+
+	in.SrcFolder = gstr.TrimRight(in.SrcFolder, `\/`)
+	in.SrcFolder = gstr.Replace(in.SrcFolder, "\\", "/")
+	in.WatchFile = gstr.TrimRight(in.WatchFile, `\/`)
+	in.WatchFile = gstr.Replace(in.WatchFile, "\\", "/")
+
+	// Watch file handling.
+	if in.WatchFile != "" {
+		// It works only if given WatchFile is in SrcFolder.
+		var (
+			watchFileDir = gfile.Dir(in.WatchFile)
+			srcFolderDir = gfile.Dir(watchFileDir)
+		)
+		mlog.Debug("watchFileDir:", watchFileDir)
+		mlog.Debug("logicFolderDir:", srcFolderDir)
+		if !gstr.HasSuffix(gstr.Replace(srcFolderDir, `\`, `/`), in.SrcFolder) {
+			mlog.Printf(`ignore watch file "%s", not in source path "%s"`, in.WatchFile, in.SrcFolder)
+			return
+		}
+		var newWorkingDir = gfile.Dir(gfile.Dir(srcFolderDir))
+		if err = gfile.Chdir(newWorkingDir); err != nil {
+			mlog.Fatalf(`%+v`, err)
+		}
+		mlog.Debug("Chdir:", newWorkingDir)
+		_ = gfile.Remove(flockFilePath)
+		var command = fmt.Sprintf(
+			`%s gen service -packages=%s`,
+			gfile.SelfName(), gfile.Basename(watchFileDir),
+		)
+		err = gproc.ShellRun(ctx, command)
+		return
+	}
+
+	if !gfile.Exists(in.SrcFolder) {
+		mlog.Fatalf(`source folder path "%s" does not exist`, in.SrcFolder)
+	}
+
+	if in.ImportPrefix == "" {
+		if !gfile.Exists("go.mod") {
+			mlog.Fatal("ImportPrefix is empty and go.mod does not exist in current working directory")
+		}
+		var (
+			goModContent = gfile.GetContents("go.mod")
+			match, _     = gregex.MatchString(`^module\s+(.+)\s*`, goModContent)
+		)
+		if len(match) > 1 {
+			in.ImportPrefix = fmt.Sprintf(`%s/%s`, gstr.Trim(match[1]), gstr.Replace(in.SrcFolder, `\`, `/`))
+		}
+	}
+
+	var (
+		isDirty               bool
+		files                 []string
+		fileContent           string
+		initImportSrcPackages []string
+		inputPackages         = in.Packages
+		dstPackageName        = gstr.ToLower(gfile.Basename(in.DstFolder))
+	)
+	srcFolders, err := gfile.ScanDir(in.SrcFolder, "*", false)
+	if err != nil {
+		return nil, err
+	}
+	for _, srcFolder := range srcFolders {
+		if !gfile.IsDir(srcFolder) {
+			continue
+		}
+		if files, err = gfile.ScanDir(srcFolder, "*.go", false); err != nil {
+			return nil, err
+		}
+		if len(files) == 0 {
+			continue
+		}
+		var (
+			// StructName => FunctionDefinitions
+			srcPkgInterfaceMap  = make(map[string]*garray.StrArray)
+			srcImportedPackages = garray.NewSortedStrArray().SetUnique(true)
+			ok                  bool
+		)
+		for _, file := range files {
+			fileContent = gfile.GetContents(file)
+			// Calculate imported packages of source go files.
+			err = c.calculateImportedPackages(fileContent, srcImportedPackages)
+			if err != nil {
+				return nil, err
+			}
+			// Calculate functions and interfaces for service generating.
+			err = c.calculateInterfaceFunctions(in, fileContent, srcPkgInterfaceMap, dstPackageName)
+			if err != nil {
+				return nil, err
+			}
+		}
+		initImportSrcPackages = append(
+			initImportSrcPackages,
+			fmt.Sprintf(`%s/%s`, in.ImportPrefix, gfile.Basename(srcFolder)),
+		)
+		// Ignore source packages if input packages given.
+		if len(inputPackages) > 0 && !gstr.InArray(inputPackages, gfile.Basename(srcFolder)) {
+			mlog.Debugf(
+				`ignore source package "%s" as it is not in desired packages: %+v`,
+				gfile.Basename(srcFolder), inputPackages,
+			)
+			continue
+		}
+		// Generating go files for service.
+		if ok, err = c.generateServiceFiles(in, srcPkgInterfaceMap, srcImportedPackages.Slice(), dstPackageName); err != nil {
+			return
+		}
+		if ok {
+			isDirty = true
+		}
+	}
+
+	if isDirty {
+		// Generate initialization go file.
+		if len(initImportSrcPackages) > 0 {
+			if err = c.generateInitializationFile(in, initImportSrcPackages); err != nil {
+				return
+			}
+		}
+
+		// Replace v1 to v2 for GoFrame.
+		if err = c.replaceGeneratedServiceContentGFV2(in); err != nil {
+			return nil, err
+		}
+		mlog.Printf(`gofmt go files in "%s"`, in.DstFolder)
+		utils.GoFmt(in.DstFolder)
+	}
+
+	mlog.Print(`done!`)
+	return
+}
+
+func (c cGenService) calculateImportedPackages(fileContent string, srcImportedPackages *garray.SortedStrArray) (err error) {
+	f, err := parser.ParseFile(token.NewFileSet(), "", fileContent, parser.ImportsOnly)
+	if err != nil {
+		return err
+	}
+	for _, s := range f.Imports {
+		if s.Path != nil {
+			if s.Name != nil {
+				// has alias and is not `_`
+				if pkgAlias := s.Name.String(); pkgAlias != "_" {
+					srcImportedPackages.Add(pkgAlias + " " + s.Path.Value)
+				}
+			} else {
+				// no alias
+				srcImportedPackages.Add(s.Path.Value)
+			}
+		}
+	}
+	return nil
+}
+
+func (c cGenService) calculateInterfaceFunctions(
+	in cGenServiceInput, fileContent string, srcPkgInterfaceMap map[string]*garray.StrArray, dstPackageName string,
+) (err error) {
+	var (
+		ok                       bool
+		matches                  [][]string
+		srcPkgInterfaceFuncArray *garray.StrArray
+	)
+	matches, err = gregex.MatchAllString(`func \((.+?)\) ([\s\S]+?) {`, fileContent)
+	if err != nil {
+		return err
+	}
+	for _, match := range matches {
+		var (
+			structName    string
+			structMatch   []string
+			funcReceiver  = gstr.Trim(match[1])
+			receiverArray = gstr.SplitAndTrim(funcReceiver, " ")
+			functionHead  = gstr.Trim(gstr.Replace(match[2], "\n", ""))
+		)
+		if len(receiverArray) > 1 {
+			structName = receiverArray[1]
+		} else {
+			structName = receiverArray[0]
+		}
+		structName = gstr.Trim(structName, "*")
+
+		// Xxx(\n    ctx context.Context, req *v1.XxxReq,\n) -> Xxx(ctx context.Context, req *v1.XxxReq)
+		functionHead = gstr.Replace(functionHead, `,)`, `)`)
+		functionHead, _ = gregex.ReplaceString(`\(\s+`, `(`, functionHead)
+		functionHead, _ = gregex.ReplaceString(`\s{2,}`, ` `, functionHead)
+		if !gstr.IsLetterUpper(functionHead[0]) {
+			continue
+		}
+		if structMatch, err = gregex.MatchString(in.StPattern, structName); err != nil {
+			return err
+		}
+		if len(structMatch) < 1 {
+			continue
+		}
+		structName = gstr.CaseCamel(structMatch[1])
+		if srcPkgInterfaceFuncArray, ok = srcPkgInterfaceMap[structName]; !ok {
+			srcPkgInterfaceMap[structName] = garray.NewStrArray()
+			srcPkgInterfaceFuncArray = srcPkgInterfaceMap[structName]
+		}
+		// Remove package name calls of `dstPackageName` in produced codes.
+		functionHead, _ = gregex.ReplaceString(fmt.Sprintf(`\*{0,1}%s\.`, dstPackageName), ``, functionHead)
+		srcPkgInterfaceFuncArray.Append(functionHead)
+	}
+	return nil
+}
+
+func (c cGenService) generateServiceFiles(
+	in cGenServiceInput,
+	srcPkgInterfaceMap map[string]*garray.StrArray,
+	srcImportedPackages []string,
+	dstPackageName string,
+) (ok bool, err error) {
+	srcImportedPackagesContent := fmt.Sprintf(
+		"import (\n%s\n)", gstr.Join(srcImportedPackages, "\n"),
+	)
+	for structName, funcArray := range srcPkgInterfaceMap {
+		var (
+			filePath         = gfile.Join(in.DstFolder, c.getDstFileNameCase(structName, in.DstFileNameCase)+".go")
+			generatedContent = gstr.ReplaceByMap(consts.TemplateGenServiceContent, g.MapStrStr{
+				"{Imports}":        srcImportedPackagesContent,
+				"{StructName}":     structName,
+				"{PackageName}":    dstPackageName,
+				"{FuncDefinition}": funcArray.Join("\n\t"),
+			})
+		)
+		if gfile.Exists(filePath) {
+			if !in.OverWrite {
+				mlog.Printf(`not overwrite, ignore generating service go file: %s`, filePath)
+				continue
+			}
+			if !utils.IsFileDoNotEdit(filePath) {
+				mlog.Printf(`ignore file as it is manually maintained: %s`, filePath)
+				continue
+			}
+			if !c.isToGenerateServiceGoFile(filePath, funcArray) {
+				mlog.Printf(`not dirty, ignore generating service go file: %s`, filePath)
+				continue
+			}
+		}
+		ok = true
+		mlog.Printf(`generating service go file: %s`, filePath)
+		if err = gfile.PutContents(filePath, generatedContent); err != nil {
+			return ok, err
+		}
+	}
+	return ok, nil
+}
+
+// isToGenerateServiceGoFile checks and returns whether the service content dirty.
+func (c cGenService) isToGenerateServiceGoFile(filePath string, funcArray *garray.StrArray) bool {
+	var (
+		fileContent        = gfile.GetContents(filePath)
+		generatedFuncArray = garray.NewSortedStrArrayFrom(funcArray.Slice())
+		contentFuncArray   = garray.NewSortedStrArray()
+	)
+	if fileContent == "" {
+		return true
+	}
+	match, _ := gregex.MatchString(`interface\s+{([\s\S]+?)}`, fileContent)
+	if len(match) != 2 {
+		return false
+	}
+	contentFuncArray.Append(gstr.SplitAndTrim(match[1], "\n")...)
+	if generatedFuncArray.Len() != contentFuncArray.Len() {
+		return true
+	}
+	for i := 0; i < generatedFuncArray.Len(); i++ {
+		if generatedFuncArray.At(i) != contentFuncArray.At(i) {
+			mlog.Debugf(`dirty, %s != %s`, generatedFuncArray.At(i), contentFuncArray.At(i))
+			return true
+		}
+	}
+	return false
+}
+
+func (c cGenService) generateInitializationFile(in cGenServiceInput, importSrcPackages []string) (err error) {
+	var (
+		srcPackageName   = gstr.ToLower(gfile.Basename(in.SrcFolder))
+		srcFilePath      = gfile.Join(in.SrcFolder, srcPackageName+".go")
+		srcImports       string
+		generatedContent string
+	)
+	if !utils.IsFileDoNotEdit(srcFilePath) {
+		mlog.Debugf(`ignore file as it is manually maintained: %s`, srcFilePath)
+		return nil
+	}
+	for _, importSrcPackage := range importSrcPackages {
+		srcImports += fmt.Sprintf(`%s_ "%s"%s`, "\t", importSrcPackage, "\n")
+	}
+	generatedContent = gstr.ReplaceByMap(consts.TemplateGenServiceLogicContent, g.MapStrStr{
+		"{PackageName}": srcPackageName,
+		"{Imports}":     srcImports,
+	})
+	mlog.Printf(`generating init go file: %s`, srcFilePath)
+	if err = gfile.PutContents(srcFilePath, generatedContent); err != nil {
+		return err
+	}
+	utils.GoFmt(srcFilePath)
+	return nil
+}
+
+func (c cGenService) replaceGeneratedServiceContentGFV2(in cGenServiceInput) (err error) {
+	return gfile.ReplaceDirFunc(func(path, content string) string {
+		if gstr.Contains(content, `"github.com/gogf/gf`) && !gstr.Contains(content, `"github.com/gogf/gf/v2`) {
+			content = gstr.Replace(content, `"github.com/gogf/gf"`, `"github.com/gogf/gf/v2"`)
+			content = gstr.Replace(content, `"github.com/gogf/gf/`, `"github.com/gogf/gf/v2/`)
+			return content
+		}
+		return content
+	}, in.DstFolder, "*.go", false)
+}
+
+// getDstFileNameCase call gstr.Case* function to convert the s to specified case.
+func (c cGenService) getDstFileNameCase(str, caseStr string) string {
+	switch gstr.ToLower(caseStr) {
+	case gstr.ToLower("Lower"):
+		return gstr.ToLower(str)
+
+	case gstr.ToLower("Camel"):
+		return gstr.CaseCamel(str)
+
+	case gstr.ToLower("CamelLower"):
+		return gstr.CaseCamelLower(str)
+
+	case gstr.ToLower("Kebab"):
+		return gstr.CaseKebab(str)
+
+	case gstr.ToLower("KebabScreaming"):
+		return gstr.CaseKebabScreaming(str)
+
+	case gstr.ToLower("SnakeFirstUpper"):
+		return gstr.CaseSnakeFirstUpper(str)
+
+	case gstr.ToLower("SnakeScreaming"):
+		return gstr.CaseSnakeScreaming(str)
+	}
+	return gstr.CaseSnake(str)
+}

cmd/gf/internal/cmd/cmd_init.go

@@ -0,0 +1,124 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/os/gres"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Init = cInit{}
+)
+
+type cInit struct {
+	g.Meta `name:"init" brief:"{cInitBrief}" eg:"{cInitEg}"`
+}
+
+const (
+	cInitRepoPrefix = `github.com/gogf/`
+	cInitMonoRepo   = `template-mono`
+	cInitSingleRepo = `template-single`
+	cInitBrief      = `create and initialize an empty GoFrame project`
+	cInitEg         = `
+gf init my-project
+gf init my-mono-repo -m
+`
+	cInitNameBrief = `
+name for the project. It will create a folder with NAME in current directory.
+The NAME will also be the module name for the project.
+`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cInitBrief`:     cInitBrief,
+		`cInitEg`:        cInitEg,
+		`cInitNameBrief`: cInitNameBrief,
+	})
+}
+
+type cInitInput struct {
+	g.Meta `name:"init"`
+	Name   string `name:"NAME" arg:"true" v:"required" brief:"{cInitNameBrief}"`
+	Mono   bool   `name:"mono"   short:"m" brief:"initialize a mono-repo instead a single-repo" orphan:"true"`
+	Update bool   `name:"update" short:"u" brief:"update to the latest goframe version" orphan:"true"`
+}
+type cInitOutput struct{}
+
+func (c cInit) Index(ctx context.Context, in cInitInput) (out *cInitOutput, err error) {
+	if !gfile.IsEmpty(in.Name) && !allyes.Check() {
+		s := gcmd.Scanf(`the folder "%s" is not empty, files might be overwrote, continue? [y/n]: `, in.Name)
+		if strings.EqualFold(s, "n") {
+			return
+		}
+	}
+	mlog.Print("initializing...")
+
+	// Create project folder and files.
+	var (
+		templateRepoName string
+	)
+	if in.Mono {
+		templateRepoName = cInitMonoRepo
+	} else {
+		templateRepoName = cInitSingleRepo
+	}
+	err = gres.Export(templateRepoName, in.Name, gres.ExportOption{
+		RemovePrefix: templateRepoName,
+	})
+	if err != nil {
+		return
+	}
+
+	// Replace template name to project name.
+	err = gfile.ReplaceDir(
+		cInitRepoPrefix+templateRepoName,
+		gfile.Basename(gfile.RealPath(in.Name)),
+		in.Name,
+		"*",
+		true,
+	)
+	if err != nil {
+		return
+	}
+
+	// Update the GoFrame version.
+	if in.Update {
+		mlog.Print("update goframe...")
+		// go get -u github.com/gogf/gf/v2@latest
+		updateCommand := `go get -u github.com/gogf/gf/v2@latest`
+		if in.Name != "." {
+			updateCommand = fmt.Sprintf(`cd %s && %s`, in.Name, updateCommand)
+		}
+		if err = gproc.ShellRun(ctx, updateCommand); err != nil {
+			mlog.Fatal(err)
+		}
+		// go mod tidy
+		gomModTidyCommand := `go mod tidy`
+		if in.Name != "." {
+			gomModTidyCommand = fmt.Sprintf(`cd %s && %s`, in.Name, gomModTidyCommand)
+		}
+		if err = gproc.ShellRun(ctx, gomModTidyCommand); err != nil {
+			mlog.Fatal(err)
+		}
+	}
+
+	mlog.Print("initialization done! ")
+	if !in.Mono {
+		enjoyCommand := `gf run main.go`
+		if in.Name != "." {
+			enjoyCommand = fmt.Sprintf(`cd %s && %s`, in.Name, enjoyCommand)
+		}
+		mlog.Printf(`you can now run "%s" to start your journey, enjoy!`, enjoyCommand)
+	}
+	return
+}

cmd/gf/internal/cmd/cmd_install.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/service"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+var (
+	Install = cInstall{}
+)
+
+type cInstall struct {
+	g.Meta `name:"install" brief:"install gf binary to system (might need root/admin permission)"`
+}
+
+type cInstallInput struct {
+	g.Meta `name:"install"`
+}
+type cInstallOutput struct{}
+
+func (c cInstall) Index(ctx context.Context, in cInstallInput) (out *cInstallOutput, err error) {
+	err = service.Install.Run(ctx)
+	return
+}

cmd/gf/internal/cmd/cmd_pack.go

@@ -0,0 +1,89 @@
+package cmd
+
+import (
+	"context"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gres"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Pack = cPack{}
+)
+
+type cPack struct {
+	g.Meta `name:"pack" usage:"{cPackUsage}" brief:"{cPackBrief}" eg:"{cPackEg}"`
+}
+
+const (
+	cPackUsage = `gf pack SRC DST`
+	cPackBrief = `packing any file/directory to a resource file, or a go file`
+	cPackEg    = `
+gf pack public data.bin
+gf pack public,template data.bin
+gf pack public,template packed/data.go
+gf pack public,template,config packed/data.go
+gf pack public,template,config packed/data.go -n=packed -p=/var/www/my-app
+gf pack /var/www/public packed/data.go -n=packed
+`
+	cPackSrcBrief = `source path for packing, which can be multiple source paths.`
+	cPackDstBrief = `
+destination file path for packed file. if extension of the filename is ".go" and "-n" option is given, 
+it enables packing SRC to go file, or else it packs SRC into a binary file.
+`
+	cPackNameBrief   = `package name for output go file, it's set as its directory name if no name passed`
+	cPackPrefixBrief = `prefix for each file packed into the resource file`
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cPackUsage`:       cPackUsage,
+		`cPackBrief`:       cPackBrief,
+		`cPackEg`:          cPackEg,
+		`cPackSrcBrief`:    cPackSrcBrief,
+		`cPackDstBrief`:    cPackDstBrief,
+		`cPackNameBrief`:   cPackNameBrief,
+		`cPackPrefixBrief`: cPackPrefixBrief,
+	})
+}
+
+type cPackInput struct {
+	g.Meta `name:"pack"`
+	Src    string `name:"SRC" arg:"true" v:"required" brief:"{cPackSrcBrief}"`
+	Dst    string `name:"DST" arg:"true" v:"required" brief:"{cPackDstBrief}"`
+	Name   string `name:"name"   short:"n" brief:"{cPackNameBrief}"`
+	Prefix string `name:"prefix" short:"p" brief:"{cPackPrefixBrief}"`
+}
+type cPackOutput struct{}
+
+func (c cPack) Index(ctx context.Context, in cPackInput) (out *cPackOutput, err error) {
+	if gfile.Exists(in.Dst) && gfile.IsDir(in.Dst) {
+		mlog.Fatalf("DST path '%s' cannot be a directory", in.Dst)
+	}
+	if !gfile.IsEmpty(in.Dst) && !allyes.Check() {
+		s := gcmd.Scanf("path '%s' is not empty, files might be overwrote, continue? [y/n]: ", in.Dst)
+		if strings.EqualFold(s, "n") {
+			return
+		}
+	}
+	if in.Name == "" && gfile.ExtName(in.Dst) == "go" {
+		in.Name = gfile.Basename(gfile.Dir(in.Dst))
+	}
+	if in.Name != "" {
+		if err = gres.PackToGoFile(in.Src, in.Dst, in.Name, in.Prefix); err != nil {
+			mlog.Fatalf("pack failed: %v", err)
+		}
+	} else {
+		if err = gres.PackToFile(in.Src, in.Dst, in.Prefix); err != nil {
+			mlog.Fatalf("pack failed: %v", err)
+		}
+	}
+	mlog.Print("done!")
+	return
+}

cmd/gf/internal/cmd/cmd_run.go

@@ -0,0 +1,165 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"runtime"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gfsnotify"
+	"github.com/gogf/gf/v2/os/gproc"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/os/gtimer"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+var (
+	Run = cRun{}
+)
+
+type cRun struct {
+	g.Meta `name:"run" usage:"{cRunUsage}" brief:"{cRunBrief}" eg:"{cRunEg}" dc:"{cRunDc}"`
+}
+
+type cRunApp struct {
+	File    string // Go run file name.
+	Path    string // Directory storing built binary.
+	Options string // Extra "go run" options.
+	Args    string // Custom arguments.
+}
+
+const (
+	cRunUsage = `gf run FILE [OPTION]`
+	cRunBrief = `running go codes with hot-compiled-like feature`
+	cRunEg    = `
+gf run main.go
+gf run main.go --args "server -p 8080"
+gf run main.go -mod=vendor
+`
+	cRunDc = `
+The "run" command is used for running go codes with hot-compiled-like feature,
+which compiles and runs the go codes asynchronously when codes change.
+`
+	cRunFileBrief  = `building file path.`
+	cRunPathBrief  = `output directory path for built binary file. it's "manifest/output" in default`
+	cRunExtraBrief = `the same options as "go run"/"go build" except some options as follows defined`
+	cRunArgsBrief  = `custom arguments for your process`
+)
+
+var (
+	process *gproc.Process
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cRunUsage`:      cRunUsage,
+		`cRunBrief`:      cRunBrief,
+		`cRunEg`:         cRunEg,
+		`cRunDc`:         cRunDc,
+		`cRunFileBrief`:  cRunFileBrief,
+		`cRunPathBrief`:  cRunPathBrief,
+		`cRunExtraBrief`: cRunExtraBrief,
+		`cRunArgsBrief`:  cRunArgsBrief,
+	})
+}
+
+type (
+	cRunInput struct {
+		g.Meta `name:"run"`
+		File   string `name:"FILE"  arg:"true" brief:"{cRunFileBrief}" v:"required"`
+		Path   string `name:"path"  short:"p"  brief:"{cRunPathBrief}" d:"./"`
+		Extra  string `name:"extra" short:"e"  brief:"{cRunExtraBrief}"`
+		Args   string `name:"args"  short:"a"  brief:"{cRunArgsBrief}"`
+	}
+	cRunOutput struct{}
+)
+
+func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err error) {
+	// Necessary check.
+	if gproc.SearchBinary("go") == "" {
+		mlog.Fatalf(`command "go" not found in your environment, please install golang first to proceed this command`)
+	}
+
+	app := &cRunApp{
+		File:    in.File,
+		Path:    in.Path,
+		Options: in.Extra,
+		Args:    in.Args,
+	}
+	dirty := gtype.NewBool()
+	_, err = gfsnotify.Add(gfile.RealPath("."), func(event *gfsnotify.Event) {
+		if gfile.ExtName(event.Path) != "go" {
+			return
+		}
+		// Variable `dirty` is used for running the changes only one in one second.
+		if !dirty.Cas(false, true) {
+			return
+		}
+		// With some delay in case of multiple code changes in very short interval.
+		gtimer.SetTimeout(ctx, 1500*gtime.MS, func(ctx context.Context) {
+			defer dirty.Set(false)
+			mlog.Printf(`go file changes: %s`, event.String())
+			app.Run(ctx)
+		})
+	})
+	if err != nil {
+		mlog.Fatal(err)
+	}
+	go app.Run(ctx)
+	select {}
+}
+
+func (app *cRunApp) Run(ctx context.Context) {
+	// Rebuild and run the codes.
+	renamePath := ""
+	mlog.Printf("build: %s", app.File)
+	outputPath := gfile.Join(app.Path, gfile.Name(app.File))
+	if runtime.GOOS == "windows" {
+		outputPath += ".exe"
+		if gfile.Exists(outputPath) {
+			renamePath = outputPath + "~"
+			if err := gfile.Rename(outputPath, renamePath); err != nil {
+				mlog.Print(err)
+			}
+		}
+	}
+	// In case of `pipe: too many open files` error.
+	// Build the app.
+	buildCommand := fmt.Sprintf(
+		`go build -o %s %s %s`,
+		outputPath,
+		app.Options,
+		app.File,
+	)
+	mlog.Print(buildCommand)
+	result, err := gproc.ShellExec(ctx, buildCommand)
+	if err != nil {
+		mlog.Printf("build error: \n%s%s", result, err.Error())
+		return
+	}
+	// Kill the old process if build successfully.
+	if process != nil {
+		if err := process.Kill(); err != nil {
+			mlog.Debugf("kill process error: %s", err.Error())
+			//return
+		}
+	}
+	// Run the binary file.
+	runCommand := fmt.Sprintf(`%s %s`, outputPath, app.Args)
+	mlog.Print(runCommand)
+	if runtime.GOOS == "windows" {
+		// Special handling for windows platform.
+		// DO NOT USE "cmd /c" command.
+		process = gproc.NewProcess(runCommand, nil)
+	} else {
+		process = gproc.NewProcessCmd(runCommand, nil)
+	}
+	if pid, err := process.Start(ctx); err != nil {
+		mlog.Printf("build running error: %s", err.Error())
+	} else {
+		mlog.Printf("build running pid: %d", pid)
+	}
+}

cmd/gf/internal/cmd/cmd_tpl.go

@@ -0,0 +1,167 @@
+package cmd
+
+import (
+	"context"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gtag"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+var (
+	Tpl = cTpl{}
+)
+
+type cTpl struct {
+	g.Meta `name:"tpl" brief:"{cTplBrief}" dc:"{cTplDc}"`
+}
+
+const (
+	cTplBrief = `template parsing and building commands`
+	cTplDc    = `
+The "tpl" command is used for template parsing and building purpose.
+It can parse either template file or folder with multiple types of values support,
+like json/xml/yaml/toml/ini.
+`
+	cTplParseBrief = `parse either template file or folder with multiple types of values`
+	cTplParseEg    = `
+gf tpl parse -p ./template -v values.json -r
+gf tpl parse -p ./template -v values.json -n *.tpl -r
+gf tpl parse -p ./template -v values.json -d '${,}}' -r
+gf tpl parse -p ./template -v values.json -o ./template.parsed
+`
+	cTplSupportValuesFilePattern = `*.json,*.xml,*.yaml,*.yml,*.toml,*.ini`
+)
+
+type (
+	cTplParseInput struct {
+		g.Meta     `name:"parse" brief:"{cTplParseBrief}" eg:"{cTplParseEg}"`
+		Path       string `name:"path"       short:"p" brief:"template file or folder path" v:"required"`
+		Pattern    string `name:"pattern"    short:"n" brief:"template file pattern when path is a folder, default is:*" d:"*"`
+		Recursive  bool   `name:"recursive"  short:"c" brief:"recursively parsing files if path is folder, default is:true" d:"true"`
+		Values     string `name:"values"     short:"v" brief:"template values file/folder, support file types like: json/xml/yaml/toml/ini" v:"required"`
+		Output     string `name:"output"     short:"o" brief:"output file/folder path"`
+		Delimiters string `name:"delimiters" short:"d" brief:"delimiters for template content parsing, default is:{{,}}" d:"{{,}}"`
+		Replace    bool   `name:"replace"    short:"r" brief:"replace original files" orphan:"true"`
+	}
+	cTplParseOutput struct{}
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`cTplBrief`:      cTplBrief,
+		`cTplDc`:         cTplDc,
+		`cTplParseEg`:    cTplParseEg,
+		`cTplParseBrief`: cTplParseBrief,
+	})
+}
+
+func (c *cTpl) Parse(ctx context.Context, in cTplParseInput) (out *cTplParseOutput, err error) {
+	if in.Output == "" && in.Replace == false {
+		return nil, gerror.New(`parameter output and replace should not be both empty`)
+	}
+	delimiters := gstr.SplitAndTrim(in.Delimiters, ",")
+	mlog.Debugf("delimiters input:%s, parsed:%#v", in.Delimiters, delimiters)
+	if len(delimiters) != 2 {
+		return nil, gerror.Newf(`invalid delimiters: %s`, in.Delimiters)
+	}
+	g.View().SetDelimiters(delimiters[0], delimiters[1])
+	valuesMap, err := c.loadValues(ctx, in.Values)
+	if err != nil {
+		return nil, err
+	}
+	if len(valuesMap) == 0 {
+		return nil, gerror.Newf(`empty values loaded from values file/folder "%s"`, in.Values)
+	}
+	err = c.parsePath(ctx, valuesMap, in)
+	if err == nil {
+		mlog.Print("done!")
+	}
+	return
+}
+
+func (c *cTpl) parsePath(ctx context.Context, values g.Map, in cTplParseInput) (err error) {
+	if !gfile.Exists(in.Path) {
+		return gerror.Newf(`path "%s" does not exist`, in.Path)
+	}
+	var (
+		path         string
+		files        []string
+		relativePath string
+		outputPath   string
+	)
+	path = gfile.RealPath(in.Path)
+	if gfile.IsDir(path) {
+		files, err = gfile.ScanDirFile(path, in.Pattern, in.Recursive)
+		if err != nil {
+			return err
+		}
+		for _, file := range files {
+			relativePath = gstr.Replace(file, path, "")
+			if in.Output != "" {
+				outputPath = gfile.Join(in.Output, relativePath)
+			}
+			if err = c.parseFile(ctx, file, outputPath, values, in); err != nil {
+				return
+			}
+		}
+		return
+	}
+	if in.Output != "" {
+		outputPath = in.Output
+	}
+	err = c.parseFile(ctx, path, outputPath, values, in)
+	return
+}
+
+func (c *cTpl) parseFile(ctx context.Context, file string, output string, values g.Map, in cTplParseInput) (err error) {
+	output = gstr.ReplaceByMap(output, g.MapStrStr{
+		`\\`: `\`,
+		`//`: `/`,
+	})
+	content, err := g.View().Parse(ctx, file, values)
+	if err != nil {
+		return err
+	}
+	if output != "" {
+		mlog.Printf(`parse file "%s" to "%s"`, file, output)
+		return gfile.PutContents(output, content)
+	}
+	if in.Replace {
+		mlog.Printf(`parse and replace file "%s"`, file)
+		return gfile.PutContents(file, content)
+	}
+	return nil
+}
+
+func (c *cTpl) loadValues(ctx context.Context, valuesPath string) (data g.Map, err error) {
+	if !gfile.Exists(valuesPath) {
+		return nil, gerror.Newf(`values file/folder "%s" does not exist`, valuesPath)
+	}
+	var j *gjson.Json
+	if gfile.IsDir(valuesPath) {
+		var valueFiles []string
+		valueFiles, err = gfile.ScanDirFile(valuesPath, cTplSupportValuesFilePattern, true)
+		if err != nil {
+			return nil, err
+		}
+		data = make(g.Map)
+		for _, file := range valueFiles {
+			if j, err = gjson.Load(file); err != nil {
+				return nil, err
+			}
+			gutil.MapMerge(data, j.Map())
+		}
+		return
+	}
+	if j, err = gjson.Load(valuesPath); err != nil {
+		return nil, err
+	}
+	data = j.Map()
+	return
+}

cmd/gf/internal/cmd/cmd_version.go

@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gbuild"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+var (
+	Version = cVersion{}
+)
+
+type cVersion struct {
+	g.Meta `name:"version" brief:"show version information of current binary"`
+}
+
+type cVersionInput struct {
+	g.Meta `name:"version"`
+}
+type cVersionOutput struct{}
+
+func (c cVersion) Index(ctx context.Context, in cVersionInput) (*cVersionOutput, error) {
+	info := gbuild.Info()
+	if info.Git == "" {
+		info.Git = "none"
+	}
+	mlog.Printf(`GoFrame CLI Tool %s, https://goframe.org`, gf.VERSION)
+	gfVersion, err := c.getGFVersionOfCurrentProject()
+	if err != nil {
+		gfVersion = err.Error()
+	} else {
+		gfVersion = gfVersion + " in current go.mod"
+	}
+	mlog.Printf(`GoFrame Version: %s`, gfVersion)
+	mlog.Printf(`CLI Installed At: %s`, gfile.SelfPath())
+	if info.GoFrame == "" {
+		mlog.Print(`Current is a custom installed version, no installation information.`)
+		return nil, nil
+	}
+
+	mlog.Print(gstr.Trim(fmt.Sprintf(`
+CLI Built Detail:
+  Go Version:  %s
+  GF Version:  %s
+  Git Commit:  %s
+  Build Time:  %s
+`, info.Golang, info.GoFrame, info.Git, info.Time)))
+	return nil, nil
+}
+
+// getGFVersionOfCurrentProject checks and returns the GoFrame version current project using.
+func (c cVersion) getGFVersionOfCurrentProject() (string, error) {
+	goModPath := gfile.Join(gfile.Pwd(), "go.mod")
+	if gfile.Exists(goModPath) {
+		lines := gstr.SplitAndTrim(gfile.GetContents(goModPath), "\n")
+		for _, line := range lines {
+			line = gstr.Trim(line)
+			// Version 1.
+			match, err := gregex.MatchString(`^github\.com/gogf/gf\s+(.+)$`, line)
+			if err != nil {
+				return "", err
+			}
+			if len(match) <= 1 {
+				// Version > 1.
+				match, err = gregex.MatchString(`^github\.com/gogf/gf/v\d\s+(.+)$`, line)
+				if err != nil {
+					return "", err
+				}
+			}
+			if len(match) > 1 {
+				return gstr.Trim(match[1]), nil
+			}
+		}
+
+		return "", gerror.New("cannot find goframe requirement in go.mod")
+	} else {
+		return "", gerror.New("cannot find go.mod")
+	}
+}

cmd/gf/internal/cmd/gendao/gendao.go

@@ -0,0 +1,363 @@
+package gendao
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+const (
+	CGenDaoConfig = `gfcli.gen.dao`
+	CGenDaoUsage  = `gf gen dao [OPTION]`
+	CGenDaoBrief  = `automatically generate go files for dao/do/entity`
+	CGenDaoEg     = `
+gf gen dao
+gf gen dao -l "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+gf gen dao -p ./model -g user-center -t user,user_detail,user_login
+gf gen dao -r user_
+`
+
+	CGenDaoAd = `
+CONFIGURATION SUPPORT
+    Options are also supported by configuration file.
+    It's suggested using configuration file instead of command line arguments making producing.
+    The configuration node name is "gfcli.gen.dao", which also supports multiple databases, for example(config.yaml):
+	gfcli:
+	  gen:
+		dao:
+		- link:     "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+		  tables:   "order,products"
+		  jsonCase: "CamelLower"
+		- link:   "mysql:root:12345678@tcp(127.0.0.1:3306)/primary"
+		  path:   "./my-app"
+		  prefix: "primary_"
+		  tables: "user, userDetail"
+`
+	CGenDaoBriefPath            = `directory path for generated files`
+	CGenDaoBriefLink            = `database configuration, the same as the ORM configuration of GoFrame`
+	CGenDaoBriefTables          = `generate models only for given tables, multiple table names separated with ','`
+	CGenDaoBriefTablesEx        = `generate models excluding given tables, multiple table names separated with ','`
+	CGenDaoBriefPrefix          = `add prefix for all table of specified link/database tables`
+	CGenDaoBriefRemovePrefix    = `remove specified prefix of the table, multiple prefix separated with ','`
+	CGenDaoBriefStdTime         = `use time.Time from stdlib instead of gtime.Time for generated time/date fields of tables`
+	CGenDaoBriefWithTime        = `add created time for auto produced go files`
+	CGenDaoBriefGJsonSupport    = `use gJsonSupport to use *gjson.Json instead of string for generated json fields of tables`
+	CGenDaoBriefImportPrefix    = `custom import prefix for generated go files`
+	CGenDaoBriefDaoPath         = `directory path for storing generated dao files under path`
+	CGenDaoBriefDoPath          = `directory path for storing generated do files under path`
+	CGenDaoBriefEntityPath      = `directory path for storing generated entity files under path`
+	CGenDaoBriefOverwriteDao    = `overwrite all dao files both inside/outside internal folder`
+	CGenDaoBriefModelFile       = `custom file name for storing generated model content`
+	CGenDaoBriefModelFileForDao = `custom file name generating model for DAO operations like Where/Data. It's empty in default`
+	CGenDaoBriefDescriptionTag  = `add comment to description tag for each field`
+	CGenDaoBriefNoJsonTag       = `no json tag will be added for each field`
+	CGenDaoBriefNoModelComment  = `no model comment will be added for each field`
+	CGenDaoBriefGroup           = `
+specifying the configuration group name of database for generated ORM instance,
+it's not necessary and the default value is "default"
+`
+	CGenDaoBriefJsonCase = `
+generated json tag case for model struct, cases are as follows:
+| Case            | Example            |
+|---------------- |--------------------|
+| Camel           | AnyKindOfString    |
+| CamelLower      | anyKindOfString    | default
+| Snake           | any_kind_of_string |
+| SnakeScreaming  | ANY_KIND_OF_STRING |
+| SnakeFirstUpper | rgb_code_md5       |
+| Kebab           | any-kind-of-string |
+| KebabScreaming  | ANY-KIND-OF-STRING |
+`
+	CGenDaoBriefTplDaoIndexPath    = `template file path for dao index file`
+	CGenDaoBriefTplDaoInternalPath = `template file path for dao internal file`
+	CGenDaoBriefTplDaoDoPathPath   = `template file path for dao do file`
+	CGenDaoBriefTplDaoEntityPath   = `template file path for dao entity file`
+
+	tplVarTableName               = `{TplTableName}`
+	tplVarTableNameCamelCase      = `{TplTableNameCamelCase}`
+	tplVarTableNameCamelLowerCase = `{TplTableNameCamelLowerCase}`
+	tplVarPackageImports          = `{TplPackageImports}`
+	tplVarImportPrefix            = `{TplImportPrefix}`
+	tplVarStructDefine            = `{TplStructDefine}`
+	tplVarColumnDefine            = `{TplColumnDefine}`
+	tplVarColumnNames             = `{TplColumnNames}`
+	tplVarGroupName               = `{TplGroupName}`
+	tplVarDatetimeStr             = `{TplDatetimeStr}`
+	tplVarCreatedAtDatetimeStr    = `{TplCreatedAtDatetimeStr}`
+)
+
+var (
+	createdAt = gtime.Now()
+)
+
+func init() {
+	gtag.Sets(g.MapStrStr{
+		`CGenDaoConfig`:                  CGenDaoConfig,
+		`CGenDaoUsage`:                   CGenDaoUsage,
+		`CGenDaoBrief`:                   CGenDaoBrief,
+		`CGenDaoEg`:                      CGenDaoEg,
+		`CGenDaoAd`:                      CGenDaoAd,
+		`CGenDaoBriefPath`:               CGenDaoBriefPath,
+		`CGenDaoBriefLink`:               CGenDaoBriefLink,
+		`CGenDaoBriefTables`:             CGenDaoBriefTables,
+		`CGenDaoBriefTablesEx`:           CGenDaoBriefTablesEx,
+		`CGenDaoBriefPrefix`:             CGenDaoBriefPrefix,
+		`CGenDaoBriefRemovePrefix`:       CGenDaoBriefRemovePrefix,
+		`CGenDaoBriefStdTime`:            CGenDaoBriefStdTime,
+		`CGenDaoBriefWithTime`:           CGenDaoBriefWithTime,
+		`CGenDaoBriefDaoPath`:            CGenDaoBriefDaoPath,
+		`CGenDaoBriefDoPath`:             CGenDaoBriefDoPath,
+		`CGenDaoBriefEntityPath`:         CGenDaoBriefEntityPath,
+		`CGenDaoBriefGJsonSupport`:       CGenDaoBriefGJsonSupport,
+		`CGenDaoBriefImportPrefix`:       CGenDaoBriefImportPrefix,
+		`CGenDaoBriefOverwriteDao`:       CGenDaoBriefOverwriteDao,
+		`CGenDaoBriefModelFile`:          CGenDaoBriefModelFile,
+		`CGenDaoBriefModelFileForDao`:    CGenDaoBriefModelFileForDao,
+		`CGenDaoBriefDescriptionTag`:     CGenDaoBriefDescriptionTag,
+		`CGenDaoBriefNoJsonTag`:          CGenDaoBriefNoJsonTag,
+		`CGenDaoBriefNoModelComment`:     CGenDaoBriefNoModelComment,
+		`CGenDaoBriefGroup`:              CGenDaoBriefGroup,
+		`CGenDaoBriefJsonCase`:           CGenDaoBriefJsonCase,
+		`CGenDaoBriefTplDaoIndexPath`:    CGenDaoBriefTplDaoIndexPath,
+		`CGenDaoBriefTplDaoInternalPath`: CGenDaoBriefTplDaoInternalPath,
+		`CGenDaoBriefTplDaoDoPathPath`:   CGenDaoBriefTplDaoDoPathPath,
+		`CGenDaoBriefTplDaoEntityPath`:   CGenDaoBriefTplDaoEntityPath,
+	})
+}
+
+type (
+	CGenDao      struct{}
+	CGenDaoInput struct {
+		g.Meta             `name:"dao" config:"{CGenDaoConfig}" usage:"{CGenDaoUsage}" brief:"{CGenDaoBrief}" eg:"{CGenDaoEg}" ad:"{CGenDaoAd}"`
+		Path               string `name:"path"                short:"p"  brief:"{CGenDaoBriefPath}" d:"internal"`
+		Link               string `name:"link"                short:"l"  brief:"{CGenDaoBriefLink}"`
+		Tables             string `name:"tables"              short:"t"  brief:"{CGenDaoBriefTables}"`
+		TablesEx           string `name:"tablesEx"            short:"x"  brief:"{CGenDaoBriefTablesEx}"`
+		Group              string `name:"group"               short:"g"  brief:"{CGenDaoBriefGroup}" d:"default"`
+		Prefix             string `name:"prefix"              short:"f"  brief:"{CGenDaoBriefPrefix}"`
+		RemovePrefix       string `name:"removePrefix"        short:"r"  brief:"{CGenDaoBriefRemovePrefix}"`
+		JsonCase           string `name:"jsonCase"            short:"j"  brief:"{CGenDaoBriefJsonCase}" d:"CamelLower"`
+		ImportPrefix       string `name:"importPrefix"        short:"i"  brief:"{CGenDaoBriefImportPrefix}"`
+		DaoPath            string `name:"daoPath"             short:"d"  brief:"{CGenDaoBriefDaoPath}"    d:"dao"`
+		DoPath             string `name:"doPath"              short:"o"  brief:"{CGenDaoBriefDoPath}"     d:"model/do"`
+		EntityPath         string `name:"entityPath"          short:"e"  brief:"{CGenDaoBriefEntityPath}" d:"model/entity"`
+		TplDaoIndexPath    string `name:"tplDaoIndexPath"     short:"t1" brief:"{CGenDaoBriefTplDaoIndexPath}"`
+		TplDaoInternalPath string `name:"tplDaoInternalPath"  short:"t2" brief:"{CGenDaoBriefTplDaoInternalPath}"`
+		TplDaoDoPath       string `name:"tplDaoDoPath"        short:"t3" brief:"{CGenDaoBriefTplDaoDoPathPath}"`
+		TplDaoEntitylPath  string `name:"tplDaoEntityPath"    short:"t4" brief:"{CGenDaoBriefTplDaoEntityPath}"`
+		StdTime            bool   `name:"stdTime"             short:"s"  brief:"{CGenDaoBriefStdTime}"         orphan:"true"`
+		WithTime           bool   `name:"withTime"            short:"w"  brief:"{CGenDaoBriefWithTime}"        orphan:"true"`
+		GJsonSupport       bool   `name:"gJsonSupport"        short:"n"  brief:"{CGenDaoBriefGJsonSupport}"    orphan:"true"`
+		OverwriteDao       bool   `name:"overwriteDao"        short:"v"  brief:"{CGenDaoBriefOverwriteDao}"    orphan:"true"`
+		DescriptionTag     bool   `name:"descriptionTag"      short:"c"  brief:"{CGenDaoBriefDescriptionTag}"  orphan:"true"`
+		NoJsonTag          bool   `name:"noJsonTag"           short:"k"  brief:"{CGenDaoBriefNoJsonTag}"       orphan:"true"`
+		NoModelComment     bool   `name:"noModelComment"      short:"m"  brief:"{CGenDaoBriefNoModelComment}"  orphan:"true"`
+	}
+	CGenDaoOutput struct{}
+
+	CGenDaoInternalInput struct {
+		CGenDaoInput
+		TableName    string // TableName specifies the table name of the table.
+		NewTableName string // NewTableName specifies the prefix-stripped name of the table.
+		ModName      string // ModName specifies the module name of current golang project, which is used for import purpose.
+	}
+)
+
+func (c CGenDao) Dao(ctx context.Context, in CGenDaoInput) (out *CGenDaoOutput, err error) {
+	if g.Cfg().Available(ctx) {
+		v := g.Cfg().MustGet(ctx, CGenDaoConfig)
+		if v.IsSlice() {
+			for i := 0; i < len(v.Interfaces()); i++ {
+				doGenDaoForArray(ctx, i, in)
+			}
+		} else {
+			doGenDaoForArray(ctx, -1, in)
+		}
+	} else {
+		doGenDaoForArray(ctx, -1, in)
+	}
+	mlog.Print("done!")
+	return
+}
+
+// doGenDaoForArray implements the "gen dao" command for configuration array.
+func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
+	var (
+		err     error
+		db      gdb.DB
+		modName string // Go module name, eg: github.com/gogf/gf.
+	)
+	if index >= 0 {
+		err = g.Cfg().MustGet(
+			ctx,
+			fmt.Sprintf(`%s.%d`, CGenDaoConfig, index),
+		).Scan(&in)
+		if err != nil {
+			mlog.Fatalf(`invalid configuration of "%s": %+v`, CGenDaoConfig, err)
+		}
+	}
+	if dirRealPath := gfile.RealPath(in.Path); dirRealPath == "" {
+		mlog.Fatalf(`path "%s" does not exist`, in.Path)
+	}
+	removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
+	if in.ImportPrefix == "" {
+		if !gfile.Exists("go.mod") {
+			mlog.Fatal("go.mod does not exist in current working directory")
+		}
+		var (
+			goModContent = gfile.GetContents("go.mod")
+			match, _     = gregex.MatchString(`^module\s+(.+)\s*`, goModContent)
+		)
+		if len(match) > 1 {
+			modName = gstr.Trim(match[1])
+		} else {
+			mlog.Fatal("module name does not found in go.mod")
+		}
+	}
+
+	// It uses user passed database configuration.
+	if in.Link != "" {
+		var tempGroup = gtime.TimestampNanoStr()
+		gdb.AddConfigNode(tempGroup, gdb.ConfigNode{
+			Link: in.Link,
+		})
+		if db, err = gdb.Instance(tempGroup); err != nil {
+			mlog.Fatalf(`database initialization failed: %+v`, err)
+		}
+	} else {
+		db = g.DB(in.Group)
+	}
+	if db == nil {
+		mlog.Fatal(`database initialization failed, may be invalid database configuration`)
+	}
+
+	var tableNames []string
+	if in.Tables != "" {
+		tableNames = gstr.SplitAndTrim(in.Tables, ",")
+	} else {
+		tableNames, err = db.Tables(context.TODO())
+		if err != nil {
+			mlog.Fatalf("fetching tables failed: %+v", err)
+		}
+	}
+	// Table excluding.
+	if in.TablesEx != "" {
+		array := garray.NewStrArrayFrom(tableNames)
+		for _, v := range gstr.SplitAndTrim(in.TablesEx, ",") {
+			array.RemoveValue(v)
+		}
+		tableNames = array.Slice()
+	}
+
+	// Generating dao & model go files one by one according to given table name.
+	newTableNames := make([]string, len(tableNames))
+	for i, tableName := range tableNames {
+		newTableName := tableName
+		for _, v := range removePrefixArray {
+			newTableName = gstr.TrimLeftStr(newTableName, v, 1)
+		}
+		newTableName = in.Prefix + newTableName
+		newTableNames[i] = newTableName
+		// Dao.
+		generateDao(ctx, db, CGenDaoInternalInput{
+			CGenDaoInput: in,
+			TableName:    tableName,
+			NewTableName: newTableName,
+			ModName:      modName,
+		})
+	}
+	// Do.
+	generateDo(ctx, db, tableNames, newTableNames, CGenDaoInternalInput{
+		CGenDaoInput: in,
+		ModName:      modName,
+	})
+	// Entity.
+	generateEntity(ctx, db, tableNames, newTableNames, CGenDaoInternalInput{
+		CGenDaoInput: in,
+		ModName:      modName,
+	})
+}
+
+func getImportPartContent(source string, isDo bool) string {
+	var (
+		packageImportsArray = garray.NewStrArray()
+	)
+
+	if isDo {
+		packageImportsArray.Append(`"github.com/gogf/gf/v2/frame/g"`)
+	}
+
+	// Time package recognition.
+	if strings.Contains(source, "gtime.Time") {
+		packageImportsArray.Append(`"github.com/gogf/gf/v2/os/gtime"`)
+	} else if strings.Contains(source, "time.Time") {
+		packageImportsArray.Append(`"time"`)
+	}
+
+	// Json type.
+	if strings.Contains(source, "gjson.Json") {
+		packageImportsArray.Append(`"github.com/gogf/gf/v2/encoding/gjson"`)
+	}
+
+	// Generate and write content to golang file.
+	packageImportsStr := ""
+	if packageImportsArray.Len() > 0 {
+		packageImportsStr = fmt.Sprintf("import(\n%s\n)", packageImportsArray.Join("\n"))
+	}
+	return packageImportsStr
+}
+
+func replaceDefaultVar(in CGenDaoInternalInput, origin string) string {
+	var tplCreatedAtDatetimeStr string
+	var tplDatetimeStr string = createdAt.String()
+	if in.WithTime {
+		tplCreatedAtDatetimeStr = fmt.Sprintf(`Created at %s`, tplDatetimeStr)
+	}
+	return gstr.ReplaceByMap(origin, g.MapStrStr{
+		tplVarDatetimeStr:          tplDatetimeStr,
+		tplVarCreatedAtDatetimeStr: tplCreatedAtDatetimeStr,
+	})
+}
+
+func sortFieldKeyForDao(fieldMap map[string]*gdb.TableField) []string {
+	names := make(map[int]string)
+	for _, field := range fieldMap {
+		names[field.Index] = field.Name
+	}
+	var (
+		i      = 0
+		j      = 0
+		result = make([]string, len(names))
+	)
+	for {
+		if len(names) == 0 {
+			break
+		}
+		if val, ok := names[i]; ok {
+			result[j] = val
+			j++
+			delete(names, i)
+		}
+		i++
+	}
+	return result
+}
+
+func getTemplateFromPathOrDefault(filePath string, def string) string {
+	if filePath != "" {
+		if contents := gfile.GetContents(filePath); contents != "" {
+			return contents
+		}
+	}
+	return def
+}

cmd/gf/internal/cmd/gendao/gendao_dao.go

@@ -0,0 +1,176 @@
+package gendao
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/olekukonko/tablewriter"
+)
+
+// generateDaoContentFile generates the dao and model content of given table.
+func generateDao(ctx context.Context, db gdb.DB, in CGenDaoInternalInput) {
+	// Generating table data preparing.
+	fieldMap, err := db.TableFields(ctx, in.TableName)
+	if err != nil {
+		mlog.Fatalf(`fetching tables fields failed for table "%s": %+v`, in.TableName, err)
+	}
+	var (
+		dirRealPath             = gfile.RealPath(in.Path)
+		dirPathDao              = gfile.Join(in.Path, in.DaoPath)
+		tableNameCamelCase      = gstr.CaseCamel(in.NewTableName)
+		tableNameCamelLowerCase = gstr.CaseCamelLower(in.NewTableName)
+		tableNameSnakeCase      = gstr.CaseSnake(in.NewTableName)
+		importPrefix            = in.ImportPrefix
+	)
+	if importPrefix == "" {
+		if dirRealPath == "" {
+			dirRealPath = in.Path
+			importPrefix = dirRealPath
+			importPrefix = gstr.Trim(dirRealPath, "./")
+		} else {
+			importPrefix = gstr.Replace(dirRealPath, gfile.Pwd(), "")
+		}
+		importPrefix = gstr.Replace(importPrefix, gfile.Separator, "/")
+		importPrefix = gstr.Join(g.SliceStr{in.ModName, importPrefix, in.DaoPath}, "/")
+		importPrefix, _ = gregex.ReplaceString(`\/{2,}`, `/`, gstr.Trim(importPrefix, "/"))
+	} else {
+		importPrefix = gstr.Join(g.SliceStr{importPrefix, in.DaoPath}, "/")
+	}
+
+	fileName := gstr.Trim(tableNameSnakeCase, "-_.")
+	if len(fileName) > 5 && fileName[len(fileName)-5:] == "_test" {
+		// Add suffix to avoid the table name which contains "_test",
+		// which would make the go file a testing file.
+		fileName += "_table"
+	}
+
+	// dao - index
+	generateDaoIndex(in, tableNameCamelCase, tableNameCamelLowerCase, importPrefix, dirPathDao, fileName)
+
+	// dao - internal
+	generateDaoInternal(in, tableNameCamelCase, tableNameCamelLowerCase, importPrefix, dirPathDao, fileName, fieldMap)
+}
+
+func generateDaoIndex(in CGenDaoInternalInput, tableNameCamelCase, tableNameCamelLowerCase, importPrefix, dirPathDao, fileName string) {
+	path := gfile.Join(dirPathDao, fileName+".go")
+	if in.OverwriteDao || !gfile.Exists(path) {
+		indexContent := gstr.ReplaceByMap(
+			getTemplateFromPathOrDefault(in.TplDaoIndexPath, consts.TemplateGenDaoIndexContent),
+			g.MapStrStr{
+				tplVarImportPrefix:            importPrefix,
+				tplVarTableName:               in.TableName,
+				tplVarTableNameCamelCase:      tableNameCamelCase,
+				tplVarTableNameCamelLowerCase: tableNameCamelLowerCase,
+			})
+		indexContent = replaceDefaultVar(in, indexContent)
+		if err := gfile.PutContents(path, strings.TrimSpace(indexContent)); err != nil {
+			mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+		} else {
+			utils.GoFmt(path)
+			mlog.Print("generated:", path)
+		}
+	}
+}
+
+func generateDaoInternal(
+	in CGenDaoInternalInput,
+	tableNameCamelCase, tableNameCamelLowerCase, importPrefix string,
+	dirPathDao, fileName string,
+	fieldMap map[string]*gdb.TableField,
+) {
+	path := gfile.Join(dirPathDao, "internal", fileName+".go")
+	modelContent := gstr.ReplaceByMap(
+		getTemplateFromPathOrDefault(in.TplDaoInternalPath, consts.TemplateGenDaoInternalContent),
+		g.MapStrStr{
+			tplVarImportPrefix:            importPrefix,
+			tplVarTableName:               in.TableName,
+			tplVarGroupName:               in.Group,
+			tplVarTableNameCamelCase:      tableNameCamelCase,
+			tplVarTableNameCamelLowerCase: tableNameCamelLowerCase,
+			tplVarColumnDefine:            gstr.Trim(generateColumnDefinitionForDao(fieldMap)),
+			tplVarColumnNames:             gstr.Trim(generateColumnNamesForDao(fieldMap)),
+		})
+	modelContent = replaceDefaultVar(in, modelContent)
+	if err := gfile.PutContents(path, strings.TrimSpace(modelContent)); err != nil {
+		mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+	} else {
+		utils.GoFmt(path)
+		mlog.Print("generated:", path)
+	}
+}
+
+// generateColumnNamesForDao generates and returns the column names assignment content of column struct
+// for specified table.
+func generateColumnNamesForDao(fieldMap map[string]*gdb.TableField) string {
+	var (
+		buffer = bytes.NewBuffer(nil)
+		array  = make([][]string, len(fieldMap))
+		names  = sortFieldKeyForDao(fieldMap)
+	)
+	for index, name := range names {
+		field := fieldMap[name]
+		array[index] = []string{
+			"            #" + gstr.CaseCamel(field.Name) + ":",
+			fmt.Sprintf(` #"%s",`, field.Name),
+		}
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
+	namesContent := buffer.String()
+	// Let's do this hack of table writer for indent!
+	namesContent = gstr.Replace(namesContent, "  #", "")
+	buffer.Reset()
+	buffer.WriteString(namesContent)
+	return buffer.String()
+}
+
+// generateColumnDefinitionForDao generates and returns the column names definition for specified table.
+func generateColumnDefinitionForDao(fieldMap map[string]*gdb.TableField) string {
+	var (
+		buffer = bytes.NewBuffer(nil)
+		array  = make([][]string, len(fieldMap))
+		names  = sortFieldKeyForDao(fieldMap)
+	)
+	for index, name := range names {
+		var (
+			field   = fieldMap[name]
+			comment = gstr.Trim(gstr.ReplaceByArray(field.Comment, g.SliceStr{
+				"\n", " ",
+				"\r", " ",
+			}))
+		)
+		array[index] = []string{
+			"    #" + gstr.CaseCamel(field.Name),
+			" # " + "string",
+			" #" + fmt.Sprintf(`// %s`, comment),
+		}
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
+	defineContent := buffer.String()
+	// Let's do this hack of table writer for indent!
+	defineContent = gstr.Replace(defineContent, "  #", "")
+	buffer.Reset()
+	buffer.WriteString(defineContent)
+	return buffer.String()
+}

cmd/gf/internal/cmd/gendao/gendao_do.go

@@ -0,0 +1,82 @@
+package gendao
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+func generateDo(ctx context.Context, db gdb.DB, tableNames, newTableNames []string, in CGenDaoInternalInput) {
+	var (
+		doDirPath = gfile.Join(in.Path, in.DoPath)
+	)
+	in.NoJsonTag = true
+	in.DescriptionTag = false
+	in.NoModelComment = false
+	// Model content.
+	for i, tableName := range tableNames {
+		in.TableName = tableName
+		fieldMap, err := db.TableFields(ctx, tableName)
+		if err != nil {
+			mlog.Fatalf("fetching tables fields failed for table '%s':\n%v", in.TableName, err)
+		}
+		var (
+			newTableName     = newTableNames[i]
+			doFilePath       = gfile.Join(doDirPath, gstr.CaseSnake(newTableName)+".go")
+			structDefinition = generateStructDefinition(ctx, generateStructDefinitionInput{
+				CGenDaoInternalInput: in,
+				DB:                   db,
+				StructName:           gstr.CaseCamel(newTableName),
+				FieldMap:             fieldMap,
+				IsDo:                 true,
+			})
+		)
+		// replace all types to interface{}.
+		structDefinition, _ = gregex.ReplaceStringFuncMatch(
+			"([A-Z]\\w*?)\\s+([\\w\\*\\.]+?)\\s+(//)",
+			structDefinition,
+			func(match []string) string {
+				// If the type is already a pointer/slice/map, it does nothing.
+				if !gstr.HasPrefix(match[2], "*") && !gstr.HasPrefix(match[2], "[]") && !gstr.HasPrefix(match[2], "map") {
+					return fmt.Sprintf(`%s interface{} %s`, match[1], match[3])
+				}
+				return match[0]
+			},
+		)
+		modelContent := generateDoContent(
+			in,
+			tableName,
+			gstr.CaseCamel(newTableName),
+			structDefinition,
+		)
+		err = gfile.PutContents(doFilePath, strings.TrimSpace(modelContent))
+		if err != nil {
+			mlog.Fatalf(`writing content to "%s" failed: %v`, doFilePath, err)
+		} else {
+			utils.GoFmt(doFilePath)
+			mlog.Print("generated:", doFilePath)
+		}
+	}
+}
+
+func generateDoContent(in CGenDaoInternalInput, tableName, tableNameCamelCase, structDefine string) string {
+	doContent := gstr.ReplaceByMap(
+		getTemplateFromPathOrDefault(in.TplDaoDoPath, consts.TemplateGenDaoDoContent),
+		g.MapStrStr{
+			tplVarTableName:          tableName,
+			tplVarPackageImports:     getImportPartContent(structDefine, true),
+			tplVarTableNameCamelCase: tableNameCamelCase,
+			tplVarStructDefine:       structDefine,
+		})
+	doContent = replaceDefaultVar(in, doContent)
+	return doContent
+}

cmd/gf/internal/cmd/gendao/gendao_entity.go

@@ -0,0 +1,61 @@
+package gendao
+
+import (
+	"context"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+func generateEntity(ctx context.Context, db gdb.DB, tableNames, newTableNames []string, in CGenDaoInternalInput) {
+	var entityDirPath = gfile.Join(in.Path, in.EntityPath)
+	// Model content.
+	for i, tableName := range tableNames {
+		fieldMap, err := db.TableFields(ctx, tableName)
+		if err != nil {
+			mlog.Fatalf("fetching tables fields failed for table '%s':\n%v", in.TableName, err)
+		}
+		var (
+			newTableName   = newTableNames[i]
+			entityFilePath = gfile.Join(entityDirPath, gstr.CaseSnake(newTableName)+".go")
+			entityContent  = generateEntityContent(
+				in,
+				newTableName,
+				gstr.CaseCamel(newTableName),
+				generateStructDefinition(ctx, generateStructDefinitionInput{
+					CGenDaoInternalInput: in,
+					DB:                   db,
+					StructName:           gstr.CaseCamel(newTableName),
+					FieldMap:             fieldMap,
+					IsDo:                 false,
+				}),
+			)
+		)
+		err = gfile.PutContents(entityFilePath, strings.TrimSpace(entityContent))
+		if err != nil {
+			mlog.Fatalf("writing content to '%s' failed: %v", entityFilePath, err)
+		} else {
+			utils.GoFmt(entityFilePath)
+			mlog.Print("generated:", entityFilePath)
+		}
+	}
+}
+
+func generateEntityContent(in CGenDaoInternalInput, tableName, tableNameCamelCase, structDefine string) string {
+	entityContent := gstr.ReplaceByMap(
+		getTemplateFromPathOrDefault(in.TplDaoEntitylPath, consts.TemplateGenDaoEntityContent),
+		g.MapStrStr{
+			tplVarTableName:          tableName,
+			tplVarPackageImports:     getImportPartContent(structDefine, false),
+			tplVarTableNameCamelCase: tableNameCamelCase,
+			tplVarStructDefine:       structDefine,
+		})
+	entityContent = replaceDefaultVar(in, entityContent)
+	return entityContent
+}

cmd/gf/internal/cmd/gendao/gendao_structure.go

@@ -0,0 +1,153 @@
+package gendao
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/olekukonko/tablewriter"
+)
+
+type generateStructDefinitionInput struct {
+	CGenDaoInternalInput
+	DB         gdb.DB                     // Current DB.
+	StructName string                     // Struct name.
+	FieldMap   map[string]*gdb.TableField // Table field map.
+	IsDo       bool                       // Is generating DTO struct.
+}
+
+func generateStructDefinition(ctx context.Context, in generateStructDefinitionInput) string {
+	buffer := bytes.NewBuffer(nil)
+	array := make([][]string, len(in.FieldMap))
+	names := sortFieldKeyForDao(in.FieldMap)
+	for index, name := range names {
+		field := in.FieldMap[name]
+		array[index] = generateStructFieldDefinition(ctx, field, in)
+	}
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
+	stContent := buffer.String()
+	// Let's do this hack of table writer for indent!
+	stContent = gstr.Replace(stContent, "  #", "")
+	stContent = gstr.Replace(stContent, "` ", "`")
+	stContent = gstr.Replace(stContent, "``", "")
+	buffer.Reset()
+	buffer.WriteString(fmt.Sprintf("type %s struct {\n", in.StructName))
+	if in.IsDo {
+		buffer.WriteString(fmt.Sprintf("g.Meta `orm:\"table:%s, do:true\"`\n", in.TableName))
+	}
+	buffer.WriteString(stContent)
+	buffer.WriteString("}")
+	return buffer.String()
+}
+
+// generateStructFieldForModel generates and returns the attribute definition for specified field.
+func generateStructFieldDefinition(
+	ctx context.Context, field *gdb.TableField, in generateStructDefinitionInput,
+) []string {
+	var (
+		err      error
+		typeName string
+		jsonTag  = getJsonTagFromCase(field.Name, in.JsonCase)
+	)
+	typeName, err = in.DB.CheckLocalTypeForField(ctx, field.Type, nil)
+	if err != nil {
+		panic(err)
+	}
+	switch typeName {
+	case gdb.LocalTypeDate, gdb.LocalTypeDatetime:
+		if in.StdTime {
+			typeName = "time.Time"
+		} else {
+			typeName = "*gtime.Time"
+		}
+
+	case gdb.LocalTypeInt64Bytes:
+		typeName = "int64"
+
+	case gdb.LocalTypeUint64Bytes:
+		typeName = "uint64"
+
+	// Special type handle.
+	case gdb.LocalTypeJson, gdb.LocalTypeJsonb:
+		if in.GJsonSupport {
+			typeName = "*gjson.Json"
+		} else {
+			typeName = "string"
+		}
+	}
+
+	var (
+		tagKey = "`"
+		result = []string{
+			"    #" + gstr.CaseCamel(field.Name),
+			" #" + typeName,
+		}
+		descriptionTag = gstr.Replace(formatComment(field.Comment), `"`, `\"`)
+	)
+
+	result = append(result, " #"+fmt.Sprintf(tagKey+`json:"%s"`, jsonTag))
+	result = append(result, " #"+fmt.Sprintf(`description:"%s"`+tagKey, descriptionTag))
+	result = append(result, " #"+fmt.Sprintf(`// %s`, formatComment(field.Comment)))
+
+	for k, v := range result {
+		if in.NoJsonTag {
+			v, _ = gregex.ReplaceString(`json:".+"`, ``, v)
+		}
+		if !in.DescriptionTag {
+			v, _ = gregex.ReplaceString(`description:".*"`, ``, v)
+		}
+		if in.NoModelComment {
+			v, _ = gregex.ReplaceString(`//.+`, ``, v)
+		}
+		result[k] = v
+	}
+	return result
+}
+
+// formatComment formats the comment string to fit the golang code without any lines.
+func formatComment(comment string) string {
+	comment = gstr.ReplaceByArray(comment, g.SliceStr{
+		"\n", " ",
+		"\r", " ",
+	})
+	comment = gstr.Replace(comment, `\n`, " ")
+	comment = gstr.Trim(comment)
+	return comment
+}
+
+// getJsonTagFromCase call gstr.Case* function to convert the s to specified case.
+func getJsonTagFromCase(str, caseStr string) string {
+	switch gstr.ToLower(caseStr) {
+	case gstr.ToLower("Camel"):
+		return gstr.CaseCamel(str)
+
+	case gstr.ToLower("CamelLower"):
+		return gstr.CaseCamelLower(str)
+
+	case gstr.ToLower("Kebab"):
+		return gstr.CaseKebab(str)
+
+	case gstr.ToLower("KebabScreaming"):
+		return gstr.CaseKebabScreaming(str)
+
+	case gstr.ToLower("Snake"):
+		return gstr.CaseSnake(str)
+
+	case gstr.ToLower("SnakeFirstUpper"):
+		return gstr.CaseSnakeFirstUpper(str)
+
+	case gstr.ToLower("SnakeScreaming"):
+		return gstr.CaseSnakeScreaming(str)
+	}
+	return str
+}

cmd/gf/internal/consts/consts.go

@@ -0,0 +1,7 @@
+package consts
+
+const (
+	// DoNotEditKey is used in generated files,
+	// which marks the files will be overwritten by CLI tool.
+	DoNotEditKey = `DO NOT EDIT`
+)

cmd/gf/internal/consts/consts_gen_dao_template_dao.go

@@ -0,0 +1,108 @@
+package consts
+
+const TemplateGenDaoIndexContent = `
+// =================================================================================
+// This is auto-generated by GoFrame CLI tool only once. Fill this file as you wish.
+// =================================================================================
+
+package dao
+
+import (
+	"{TplImportPrefix}/internal"
+)
+
+// internal{TplTableNameCamelCase}Dao is internal type for wrapping internal DAO implements.
+type internal{TplTableNameCamelCase}Dao = *internal.{TplTableNameCamelCase}Dao
+
+// {TplTableNameCamelLowerCase}Dao is the data access object for table {TplTableName}.
+// You can define custom methods on it to extend its functionality as you wish.
+type {TplTableNameCamelLowerCase}Dao struct {
+	internal{TplTableNameCamelCase}Dao
+}
+
+var (
+	// {TplTableNameCamelCase} is globally public accessible object for table {TplTableName} operations.
+	{TplTableNameCamelCase} = {TplTableNameCamelLowerCase}Dao{
+		internal.New{TplTableNameCamelCase}Dao(),
+	}
+)
+
+// Fill with you ideas below.
+
+`
+
+const TemplateGenDaoInternalContent = `
+// ==========================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT. {TplCreatedAtDatetimeStr}
+// ==========================================================================
+
+package internal
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+// {TplTableNameCamelCase}Dao is the data access object for table {TplTableName}.
+type {TplTableNameCamelCase}Dao struct {
+	table   string          // table is the underlying table name of the DAO.
+	group   string          // group is the database configuration group name of current DAO.
+	columns {TplTableNameCamelCase}Columns // columns contains all the column names of Table for convenient usage.
+}
+
+// {TplTableNameCamelCase}Columns defines and stores column names for table {TplTableName}.
+type {TplTableNameCamelCase}Columns struct {
+	{TplColumnDefine}
+}
+
+//  {TplTableNameCamelLowerCase}Columns holds the columns for table {TplTableName}.
+var {TplTableNameCamelLowerCase}Columns = {TplTableNameCamelCase}Columns{
+	{TplColumnNames}
+}
+
+// New{TplTableNameCamelCase}Dao creates and returns a new DAO object for table data access.
+func New{TplTableNameCamelCase}Dao() *{TplTableNameCamelCase}Dao {
+	return &{TplTableNameCamelCase}Dao{
+		group:   "{TplGroupName}",
+		table:   "{TplTableName}",
+		columns: {TplTableNameCamelLowerCase}Columns,
+	}
+}
+
+// DB retrieves and returns the underlying raw database management object of current DAO.
+func (dao *{TplTableNameCamelCase}Dao) DB() gdb.DB {
+	return g.DB(dao.group)
+}
+
+// Table returns the table name of current dao.
+func (dao *{TplTableNameCamelCase}Dao) Table() string {
+	return dao.table
+}
+
+// Columns returns all column names of current dao.
+func (dao *{TplTableNameCamelCase}Dao) Columns() {TplTableNameCamelCase}Columns {
+	return dao.columns
+}
+
+// Group returns the configuration group name of database of current dao.
+func (dao *{TplTableNameCamelCase}Dao) Group() string {
+	return dao.group
+}
+
+// Ctx creates and returns the Model for current DAO, It automatically sets the context for current operation.
+func (dao *{TplTableNameCamelCase}Dao) Ctx(ctx context.Context) *gdb.Model {
+	return dao.DB().Model(dao.table).Safe().Ctx(ctx)
+}
+
+// Transaction wraps the transaction logic using function f.
+// It rollbacks the transaction and returns the error from function f if it returns non-nil error.
+// It commits the transaction and returns nil if function f returns nil.
+//
+// Note that, you should not Commit or Rollback the transaction in function f
+// as it is automatically handled by this function.
+func (dao *{TplTableNameCamelCase}Dao) Transaction(ctx context.Context, f func(ctx context.Context, tx *gdb.TX) error) (err error) {
+	return dao.Ctx(ctx).Transaction(ctx, f)
+}
+`

cmd/gf/internal/consts/consts_gen_dao_template_do.go

@@ -0,0 +1,14 @@
+package consts
+
+const TemplateGenDaoDoContent = `
+// =================================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT. {TplCreatedAtDatetimeStr}
+// =================================================================================
+
+package do
+
+{TplPackageImports}
+
+// {TplTableNameCamelCase} is the golang structure of table {TplTableName} for DAO operations like Where/Data.
+{TplStructDefine}
+`

cmd/gf/internal/consts/consts_gen_dao_template_entity.go

@@ -0,0 +1,14 @@
+package consts
+
+const TemplateGenDaoEntityContent = `
+// =================================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT. {TplCreatedAtDatetimeStr}
+// =================================================================================
+
+package entity
+
+{TplPackageImports}
+
+// {TplTableNameCamelCase} is the golang structure for table {TplTableName}.
+{TplStructDefine}
+`

cmd/gf/internal/consts/consts_gen_pbentity_template.go

@@ -0,0 +1,17 @@
+package consts
+
+const TemplatePbEntityMessageContent = `
+// ==========================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+syntax = "proto3";
+
+package {PackageName};
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+{OptionContent}
+
+{EntityMessage}
+`

cmd/gf/internal/consts/consts_gen_service_template.go

@@ -0,0 +1,29 @@
+package consts
+
+const TemplateGenServiceContent = `
+// ================================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package {PackageName}
+
+{Imports}
+
+type I{StructName} interface {
+	{FuncDefinition}
+}
+
+var local{StructName} I{StructName}
+
+func {StructName}() I{StructName} {
+	if local{StructName} == nil {
+		panic("implement not found for interface I{StructName}, forgot register?")
+	}
+	return local{StructName}
+}
+
+func Register{StructName}(i I{StructName}) {
+	local{StructName} = i
+}
+`

cmd/gf/internal/consts/consts_gen_service_template_logic.go

@@ -0,0 +1,13 @@
+package consts
+
+const TemplateGenServiceLogicContent = `
+// ==========================================================================
+// Code generated by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+package {PackageName}
+
+import(
+	{Imports}
+)
+`

cmd/gf/internal/packed/packed.go

@@ -0,0 +1 @@
+package packed

cmd/gf/internal/service/install.go

@@ -0,0 +1,235 @@
+package service
+
+import (
+	"context"
+	"runtime"
+	"strings"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/genv"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+var (
+	Install = serviceInstall{}
+)
+
+type serviceInstall struct{}
+
+type serviceInstallAvailablePath struct {
+	dirPath   string
+	filePath  string
+	writable  bool
+	installed bool
+}
+
+func (s serviceInstall) Run(ctx context.Context) (err error) {
+	// Ask where to install.
+	paths := s.getAvailablePaths()
+	if len(paths) <= 0 {
+		mlog.Printf("no path detected, you can manually install gf by copying the binary to path folder.")
+		return
+	}
+	mlog.Printf("I found some installable paths for you(from $PATH): ")
+	mlog.Printf("  %2s | %8s | %9s | %s", "Id", "Writable", "Installed", "Path")
+
+	// Print all paths status and determine the default selectedID value.
+	var (
+		selectedID = -1
+		newPaths   []serviceInstallAvailablePath
+		pathSet    = gset.NewStrSet() // Used for repeated items filtering.
+	)
+	for _, path := range paths {
+		if !pathSet.AddIfNotExist(path.dirPath) {
+			continue
+		}
+		newPaths = append(newPaths, path)
+	}
+	paths = newPaths
+	for id, path := range paths {
+		mlog.Printf("  %2d | %8t | %9t | %s", id, path.writable, path.installed, path.dirPath)
+		if selectedID == -1 {
+			// Use the previously installed path as the most priority choice.
+			if path.installed {
+				selectedID = id
+			}
+		}
+	}
+	// If there's no previously installed path, use the first writable path.
+	if selectedID == -1 {
+		// Order by choosing priority.
+		commonPaths := garray.NewStrArrayFrom(g.SliceStr{
+			s.getGoPathBin(),
+			`/usr/local/bin`,
+			`/usr/bin`,
+			`/usr/sbin`,
+			`C:\Windows`,
+			`C:\Windows\system32`,
+			`C:\Go\bin`,
+			`C:\Program Files`,
+			`C:\Program Files (x86)`,
+		})
+		// Check the common installation directories.
+		commonPaths.Iterator(func(k int, v string) bool {
+			for id, aPath := range paths {
+				if strings.EqualFold(aPath.dirPath, v) {
+					selectedID = id
+					return false
+				}
+			}
+			return true
+		})
+		if selectedID == -1 {
+			selectedID = 0
+		}
+	}
+
+	if allyes.Check() {
+		// Use the default selectedID.
+		mlog.Printf("please choose one installation destination [default %d]: %d", selectedID, selectedID)
+	} else {
+		for {
+			// Get input and update selectedID.
+			var (
+				inputID int
+				input   = gcmd.Scanf("please choose one installation destination [default %d]: ", selectedID)
+			)
+			if input != "" {
+				inputID = gconv.Int(input)
+			}
+			// Check if out of range.
+			if inputID >= len(paths) || inputID < 0 {
+				mlog.Printf("invalid install destination Id: %d", inputID)
+				continue
+			}
+			selectedID = inputID
+			break
+		}
+	}
+
+	// Get selected destination path.
+	dstPath := paths[selectedID]
+
+	// Install the new binary.
+	err = gfile.CopyFile(gfile.SelfPath(), dstPath.filePath)
+	if err != nil {
+		mlog.Printf("install gf binary to '%s' failed: %v", dstPath.dirPath, err)
+		mlog.Printf("you can manually install gf by copying the binary to folder: %s", dstPath.dirPath)
+	} else {
+		mlog.Printf("gf binary is successfully installed to: %s", dstPath.dirPath)
+	}
+
+	// Uninstall the old binary.
+	for _, path := range paths {
+		// Do not delete myself.
+		if path.filePath != "" && path.filePath != dstPath.filePath && gfile.SelfPath() != path.filePath {
+			_ = gfile.Remove(path.filePath)
+		}
+	}
+	return
+}
+
+// IsInstalled checks and returns whether the binary is installed.
+func (s serviceInstall) IsInstalled() bool {
+	paths := s.getAvailablePaths()
+	for _, aPath := range paths {
+		if aPath.installed {
+			return true
+		}
+	}
+	return false
+}
+
+// getGoPathBinFilePath retrieves ad returns the GOPATH/bin path for binary.
+func (s serviceInstall) getGoPathBin() string {
+	if goPath := genv.Get(`GOPATH`).String(); goPath != "" {
+		return gfile.Join(goPath, "bin")
+	}
+	return ""
+}
+
+// getAvailablePaths returns the installation paths data for the binary.
+func (s serviceInstall) getAvailablePaths() []serviceInstallAvailablePath {
+	var (
+		folderPaths    []serviceInstallAvailablePath
+		binaryFileName = "gf" + gfile.Ext(gfile.SelfPath())
+	)
+	// $GOPATH/bin
+	if goPathBin := s.getGoPathBin(); goPathBin != "" {
+		folderPaths = s.checkAndAppendToAvailablePath(
+			folderPaths, goPathBin, binaryFileName,
+		)
+	}
+	switch runtime.GOOS {
+	case "darwin":
+		darwinInstallationCheckPaths := []string{"/usr/local/bin"}
+		for _, v := range darwinInstallationCheckPaths {
+			folderPaths = s.checkAndAppendToAvailablePath(
+				folderPaths, v, binaryFileName,
+			)
+		}
+		fallthrough
+
+	default:
+		// Search and find the writable directory path.
+		envPath := genv.Get("PATH", genv.Get("Path").String()).String()
+		if gstr.Contains(envPath, ";") {
+			// windows.
+			for _, v := range gstr.SplitAndTrim(envPath, ";") {
+				if v == "." {
+					continue
+				}
+				folderPaths = s.checkAndAppendToAvailablePath(
+					folderPaths, v, binaryFileName,
+				)
+			}
+		} else if gstr.Contains(envPath, ":") {
+			// *nix.
+			for _, v := range gstr.SplitAndTrim(envPath, ":") {
+				if v == "." {
+					continue
+				}
+				folderPaths = s.checkAndAppendToAvailablePath(
+					folderPaths, v, binaryFileName,
+				)
+			}
+		} else if envPath != "" {
+			folderPaths = s.checkAndAppendToAvailablePath(
+				folderPaths, envPath, binaryFileName,
+			)
+		} else {
+			folderPaths = s.checkAndAppendToAvailablePath(
+				folderPaths, "/usr/local/bin", binaryFileName,
+			)
+		}
+	}
+	return folderPaths
+}
+
+// checkAndAppendToAvailablePath checks if `path` is writable and already installed.
+// It adds the `path` to `folderPaths` if it is writable or already installed, or else it ignores the `path`.
+func (s serviceInstall) checkAndAppendToAvailablePath(folderPaths []serviceInstallAvailablePath, dirPath string, binaryFileName string) []serviceInstallAvailablePath {
+	var (
+		filePath  = gfile.Join(dirPath, binaryFileName)
+		writable  = gfile.IsWritable(dirPath)
+		installed = gfile.Exists(filePath)
+	)
+	if !writable && !installed {
+		return folderPaths
+	}
+	return append(
+		folderPaths,
+		serviceInstallAvailablePath{
+			dirPath:   dirPath,
+			writable:  writable,
+			filePath:  filePath,
+			installed: installed,
+		})
+}

cmd/gf/internal/utility/allyes/allyes.go

@@ -0,0 +1,22 @@
+package allyes
+
+import (
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/genv"
+)
+
+const (
+	EnvName = "GF_CLI_ALL_YES"
+)
+
+// Init initializes the package manually.
+func Init() {
+	if gcmd.GetOpt("y") != nil {
+		genv.MustSet(EnvName, "1")
+	}
+}
+
+// Check checks whether option allow all yes for command.
+func Check() bool {
+	return genv.Get(EnvName).String() == "1"
+}

cmd/gf/internal/utility/mlog/mlog.go

@@ -0,0 +1,66 @@
+package mlog
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/genv"
+	"github.com/gogf/gf/v2/os/glog"
+)
+
+const (
+	headerPrintEnvName = "GF_CLI_MLOG_HEADER"
+)
+
+var (
+	ctx    = context.TODO()
+	logger = glog.New()
+)
+
+func init() {
+	logger.SetStack(false)
+	if genv.Get(headerPrintEnvName).String() == "1" {
+		logger.SetHeaderPrint(true)
+	} else {
+		logger.SetHeaderPrint(false)
+	}
+	if gcmd.GetOpt("debug") != nil || gcmd.GetOpt("gf.debug") != nil {
+		logger.SetDebug(true)
+	} else {
+		logger.SetDebug(false)
+	}
+}
+
+// SetHeaderPrint enables/disables header printing to stdout.
+func SetHeaderPrint(enabled bool) {
+	logger.SetHeaderPrint(enabled)
+	if enabled {
+		_ = genv.Set(headerPrintEnvName, "1")
+	} else {
+		_ = genv.Set(headerPrintEnvName, "0")
+	}
+}
+
+func Print(v ...interface{}) {
+	logger.Print(ctx, v...)
+}
+
+func Printf(format string, v ...interface{}) {
+	logger.Printf(ctx, format, v...)
+}
+
+func Fatal(v ...interface{}) {
+	logger.Fatal(ctx, v...)
+}
+
+func Fatalf(format string, v ...interface{}) {
+	logger.Fatalf(ctx, format, v...)
+}
+
+func Debug(v ...interface{}) {
+	logger.Debug(ctx, v...)
+}
+
+func Debugf(format string, v ...interface{}) {
+	logger.Debugf(ctx, format, v...)
+}

cmd/gf/internal/utility/utils/utils.go

@@ -0,0 +1,44 @@
+package utils
+
+import (
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+	"golang.org/x/tools/imports"
+)
+
+// GoFmt formats the source file and adds or removes import statements as necessary.
+func GoFmt(path string) {
+	replaceFunc := func(path, content string) string {
+		res, err := imports.Process(path, []byte(content), nil)
+		if err != nil {
+			mlog.Printf(`error format "%s" go files: %v`, path, err)
+			return content
+		}
+		return string(res)
+	}
+
+	var err error
+	if gfile.IsFile(path) {
+		// File format.
+		if gfile.ExtName(path) != "go" {
+			return
+		}
+		err = gfile.ReplaceFileFunc(replaceFunc, path)
+	} else {
+		// Folder format.
+		err = gfile.ReplaceDirFunc(replaceFunc, path, "*.go", true)
+	}
+	if err != nil {
+		mlog.Printf(`error format "%s" go files: %v`, path, err)
+	}
+}
+
+// IsFileDoNotEdit checks and returns whether file contains `do not edit` key.
+func IsFileDoNotEdit(filePath string) bool {
+	if !gfile.Exists(filePath) {
+		return true
+	}
+	return gstr.Contains(gfile.GetContents(filePath), consts.DoNotEditKey)
+}

cmd/gf/main.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/packed"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcfg"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/text/gstr"
+)
+
+const (
+	cliFolderName = `hack`
+)
+
+func main() {
+	defer func() {
+		if exception := recover(); exception != nil {
+			if err, ok := exception.(error); ok {
+				mlog.Print(err.Error())
+			} else {
+				panic(exception)
+			}
+		}
+	}()
+
+	// CLI configuration.
+	if path, _ := gfile.Search(cliFolderName); path != "" {
+		if adapter, ok := g.Cfg().GetAdapter().(*gcfg.AdapterFile); ok {
+			if err := adapter.SetPath(path); err != nil {
+				mlog.Fatal(err)
+			}
+		}
+	}
+
+	// zsh alias "git fetch" conflicts checks.
+	handleZshAlias()
+
+	// -y option checks.
+	allyes.Init()
+
+	var (
+		ctx = gctx.New()
+	)
+	command, err := gcmd.NewFromObject(cmd.GF)
+	if err != nil {
+		panic(err)
+	}
+	err = command.AddObject(
+		cmd.Env,
+		cmd.Run,
+		cmd.Gen,
+		cmd.Tpl,
+		cmd.Init,
+		cmd.Pack,
+		cmd.Build,
+		cmd.Docker,
+		cmd.Install,
+		cmd.Version,
+	)
+	if err != nil {
+		panic(err)
+	}
+	command.Run(ctx)
+}
+
+// zsh alias "git fetch" conflicts checks.
+func handleZshAlias() {
+	if home, err := gfile.Home(); err == nil {
+		zshPath := gfile.Join(home, ".zshrc")
+		if gfile.Exists(zshPath) {
+			var (
+				aliasCommand = `alias gf=gf`
+				content      = gfile.GetContents(zshPath)
+			)
+			if !gstr.Contains(content, aliasCommand) {
+				_ = gfile.PutContentsAppend(zshPath, "\n"+aliasCommand+"\n")
+			}
+		}
+	}
+}

cmd/gf/test/testdata/tpls/tpl1.yaml

@@ -0,0 +1,2 @@
+server:
+  address: {{.server.address}}

cmd/gf/test/testdata/tpls/tpl2.sql

@@ -0,0 +1 @@
+insert into {{.sql.table}}

cmd/gf/test/testdata/values.json

@@ -0,0 +1,8 @@
+{
+    "server": {
+        "address": "https://goframe.org"
+    },
+    "sql":{
+        "table": "table_name"
+    }
+}

container/garray/garray_normal_any.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
@@ -503,16 +504,25 @@ func (a *Array) Search(value interface{}) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *Array) Unique() *Array {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        interface{}
+		uniqueSet   = make(map[interface{}]struct{})
+		uniqueArray = make([]interface{}, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -711,6 +721,9 @@ func (a *Array) IteratorDesc(f func(k int, v interface{}) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *Array) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -808,3 +821,17 @@ func (a *Array) Walk(f func(value interface{}) interface{}) *Array {
 func (a *Array) IsEmpty() bool {
 	return a.Len() == 0
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *Array) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]interface{}, len(a.array))
+	for i, v := range a.array {
+		newSlice[i] = deepcopy.Copy(v)
+	}
+	return NewArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_normal_int.go

@@ -514,16 +514,25 @@ func (a *IntArray) Search(value int) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        int
+		uniqueSet   = make(map[int]struct{})
+		uniqueArray = make([]int, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -722,6 +731,9 @@ func (a *IntArray) IteratorDesc(f func(k int, v int) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *IntArray) String() string {
+	if a == nil {
+		return ""
+	}
 	return "[" + a.Join(",") + "]"
 }
 
@@ -787,3 +799,15 @@ func (a *IntArray) Walk(f func(value int) int) *IntArray {
 func (a *IntArray) IsEmpty() bool {
 	return a.Len() == 0
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *IntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]int, len(a.array))
+	copy(newSlice, a.array)
+	return NewIntArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_normal_str.go

@@ -516,16 +516,25 @@ func (a *StrArray) Search(value string) int {
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); {
-			if a.array[i] == a.array[j] {
-				a.array = append(a.array[:j], a.array[j+1:]...)
-			} else {
-				j++
-			}
-		}
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
 	}
-	a.mu.Unlock()
+	var (
+		ok          bool
+		temp        string
+		uniqueSet   = make(map[string]struct{})
+		uniqueArray = make([]string, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
 	return a
 }
 
@@ -724,6 +733,9 @@ func (a *StrArray) IteratorDesc(f func(k int, v string) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *StrArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -800,3 +812,15 @@ func (a *StrArray) Walk(f func(value string) string) *StrArray {
 func (a *StrArray) IsEmpty() bool {
 	return a.Len() == 0
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *StrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]string, len(a.array))
+	copy(newSlice, a.array)
+	return NewStrArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_sorted_any.go

@@ -12,6 +12,7 @@ import (
 	"math"
 	"sort"
 
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
@@ -36,9 +37,9 @@ type SortedArray struct {
 // NewSortedArray creates and returns an empty sorted array.
 // The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.
 // The parameter `comparator` used to compare values to sort in array,
-// if it returns value < 0, means v1 < v2; the v1 will be inserted before v2;
-// if it returns value = 0, means v1 = v2; the v1 will be replaced by v2;
-// if it returns value > 0, means v1 > v2; the v1 will be inserted after v2;
+// if it returns value < 0, means `a` < `b`; the `a` will be inserted before `b`;
+// if it returns value = 0, means `a` = `b`; the `a` will be replaced by     `b`;
+// if it returns value > 0, means `a` > `b`; the `a` will be inserted after  `b`;
 func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	return NewSortedArraySize(0, comparator, safe...)
 }
@@ -653,6 +654,9 @@ func (a *SortedArray) IteratorDesc(f func(k int, v interface{}) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -793,3 +797,17 @@ func (a *SortedArray) getComparator() func(a, b interface{}) int {
 	}
 	return a.comparator
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *SortedArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]interface{}, len(a.array))
+	for i, v := range a.array {
+		newSlice[i] = deepcopy.Copy(v)
+	}
+	return NewSortedArrayFrom(newSlice, a.comparator, a.mu.IsSafe())
+}

container/garray/garray_sorted_int.go

@@ -646,6 +646,9 @@ func (a *SortedIntArray) IteratorDesc(f func(k int, v int) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedIntArray) String() string {
+	if a == nil {
+		return ""
+	}
 	return "[" + a.Join(",") + "]"
 }
 
@@ -741,3 +744,15 @@ func (a *SortedIntArray) getComparator() func(a, b int) int {
 	}
 	return a.comparator
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *SortedIntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]int, len(a.array))
+	copy(newSlice, a.array)
+	return NewSortedIntArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_sorted_str.go

@@ -648,6 +648,9 @@ func (a *SortedStrArray) IteratorDesc(f func(k int, v string) bool) {
 
 // String returns current array as a string, which implements like json.Marshal does.
 func (a *SortedStrArray) String() string {
+	if a == nil {
+		return ""
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -754,3 +757,15 @@ func (a *SortedStrArray) getComparator() func(a, b string) int {
 	}
 	return a.comparator
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *SortedStrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]string, len(a.array))
+	copy(newSlice, a.array)
+	return NewSortedStrArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_z_example_normal_any_test.go

@@ -46,6 +46,8 @@ func ExampleNew() {
 	a.Set(0, 100)
 	fmt.Println(a.Slice())
 
+	fmt.Println(a.At(0))
+
 	// Search item and return its index.
 	fmt.Println(a.Search(5))
 
@@ -66,6 +68,7 @@ func ExampleNew() {
 	// false
 	// [0 1 2 3 4 5 6 7 8 9 10 11]
 	// [100 1 2 3 4 5 6 7 8 9 10 11]
+	// 100
 	// 5
 	// [1 2 3 4 5 6 7 8 9 10 11]
 	// [1 2 3 4 5 6 7 8 9 10 11]

container/garray/garray_z_example_normal_int_test.go

@@ -54,6 +54,14 @@ func ExampleNewIntArraySize() {
 	// [10 20 15] 3 5
 }
 
+func ExampleNewIntArrayRange() {
+	s := garray.NewIntArrayRange(1, 5, 1)
+	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
+
+	// Output:
+	// [1 2 3 4 5] 5 5
+}
+
 func ExampleNewIntArrayFrom() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 20, 15, 30})
 	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
@@ -83,9 +91,12 @@ func ExampleIntArray_Get() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 20, 15, 30})
 	sGet, sBool := s.Get(3)
 	fmt.Println(sGet, sBool)
+	sGet, sBool = s.Get(99)
+	fmt.Println(sGet, sBool)
 
 	// Output:
 	// 30 true
+	// 0 false
 }
 
 func ExampleIntArray_Set() {

container/garray/garray_z_unit_normal_any_test.go

@@ -25,9 +25,24 @@ func Test_Array_Basic(t *testing.T) {
 		array := garray.NewArrayFrom(expect)
 		array2 := garray.NewArrayFrom(expect)
 		array3 := garray.NewArrayFrom([]interface{}{})
+		array4 := garray.NewArrayRange(1, 5, 1)
+
 		t.Assert(array.Slice(), expect)
 		t.Assert(array.Interfaces(), expect)
-		array.Set(0, 100)
+		err := array.Set(0, 100)
+		t.AssertNil(err)
+
+		err = array.Set(100, 100)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.IsEmpty(), false)
+
+		copyArray := array.DeepCopy()
+		ca := copyArray.(*garray.Array)
+		ca.Set(0, 1)
+		cval, _ := ca.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 
 		v, ok := array.Get(0)
 		t.Assert(v, 100)
@@ -37,6 +52,10 @@ func Test_Array_Basic(t *testing.T) {
 		t.Assert(v, 1)
 		t.Assert(ok, true)
 
+		v, ok = array.Get(4)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
 		t.Assert(array.Search(100), 0)
 		t.Assert(array3.Search(100), -1)
 		t.Assert(array.Contains(100), true)
@@ -71,6 +90,12 @@ func Test_Array_Basic(t *testing.T) {
 		array.InsertAfter(6, 400)
 		t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 300, 4, 400})
 		t.Assert(array.Clear().Len(), 0)
+		err = array.InsertBefore(99, 9900)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 9900)
+		t.AssertNE(err, nil)
+
+		t.Assert(array4.String(), "[1,2,3,4,5]")
 	})
 }
 
@@ -99,6 +124,11 @@ func TestArray_Unique(t *testing.T) {
 		array := garray.NewArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3, 4, 5})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		expect := []interface{}{}
+		array := garray.NewArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []interface{}{})
+	})
 }
 
 func TestArray_PushAndPop(t *testing.T) {
@@ -382,6 +412,21 @@ func TestArray_Rand(t *testing.T) {
 		t.Assert(a1.Contains(i1), true)
 		t.Assert(a1.Len(), 4)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		rand, found := array1.Rand()
+		t.AssertNil(rand)
+		t.Assert(found, false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		rand := array1.Rands(1)
+		t.AssertNil(rand)
+	})
 }
 
 func TestArray_Shuffle(t *testing.T) {
@@ -412,6 +457,12 @@ func TestArray_Join(t *testing.T) {
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.Join("."), `0.1."a".\a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		t.Assert(len(array1.Join(".")), 0)
+	})
 }
 
 func TestArray_String(t *testing.T) {
@@ -419,6 +470,8 @@ func TestArray_String(t *testing.T) {
 		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -576,7 +629,7 @@ func TestArray_Json(t *testing.T) {
 
 		var a3 garray.Array
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// value.
@@ -595,7 +648,7 @@ func TestArray_Json(t *testing.T) {
 
 		var a3 garray.Array
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// pointer
@@ -609,11 +662,11 @@ func TestArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -628,11 +681,11 @@ func TestArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -720,7 +773,7 @@ func TestArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": g.Slice{1, 2, 3},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})

container/garray/garray_z_unit_normal_int_test.go

@@ -63,6 +63,19 @@ func Test_IntArray_Basic(t *testing.T) {
 		array.InsertAfter(6, 400)
 		t.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
 		t.Assert(array.Clear().Len(), 0)
+		err := array.InsertBefore(99, 300)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 400)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom([]int{0, 1, 2, 3})
+		copyArray := array.DeepCopy().(*garray.IntArray)
+		copyArray.Set(0, 1)
+		cval, _ := copyArray.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 	})
 }
 
@@ -89,6 +102,8 @@ func TestIntArray_Unique(t *testing.T) {
 		expect := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array := garray.NewIntArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []int{1, 2, 3, 4, 5})
+		array2 := garray.NewIntArrayFrom([]int{})
+		t.Assert(array2.Unique().Slice(), []int{})
 	})
 }
 
@@ -374,6 +389,14 @@ func TestIntArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.AssertIN(v, a1)
 		t.Assert(ok, true)
+
+		array2 := garray.NewIntArrayFrom([]int{})
+		v, ok = array2.Rand()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+
+		intSlices := array2.Rands(1)
+		t.Assert(intSlices, nil)
 	})
 }
 
@@ -420,6 +443,8 @@ func TestIntArray_String(t *testing.T) {
 		a1 := []int{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewIntArrayFrom(a1)
 		t.Assert(array1.String(), "[0,1,2,3,4,5,6]")
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -619,7 +644,7 @@ func TestIntArray_Json(t *testing.T) {
 
 		var a3 garray.IntArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array value
@@ -637,7 +662,7 @@ func TestIntArray_Json(t *testing.T) {
 
 		var a3 garray.IntArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array pointer
@@ -651,11 +676,11 @@ func TestIntArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -670,11 +695,11 @@ func TestIntArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -752,7 +777,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": []byte(`[1,2,3]`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
@@ -763,7 +788,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) {
 	//		"name":  "john",
 	//		"array": g.Slice{1, 2, 3},
 	//	}, &v)
-	//	t.Assert(err, nil)
+	//	t.AssertNil(err)
 	//	t.Assert(v.Name, "john")
 	//	t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	// })

container/garray/garray_z_unit_normal_str_test.go

@@ -34,6 +34,10 @@ func Test_StrArray_Basic(t *testing.T) {
 		t.Assert(v, 100)
 		t.Assert(ok, true)
 
+		v, ok = array3.Get(0)
+		t.Assert(v, "")
+		t.Assert(ok, false)
+
 		t.Assert(array.Search("100"), 0)
 		t.Assert(array.Contains("100"), true)
 
@@ -61,12 +65,28 @@ func Test_StrArray_Basic(t *testing.T) {
 		t.Assert(array.Clear().Len(), 0)
 		t.Assert(array2.Slice(), expect)
 		t.Assert(array3.Search("100"), -1)
+		err := array.InsertBefore(99, "300")
+		t.AssertNE(err, nil)
+		array.InsertAfter(99, "400")
+		t.AssertNE(err, nil)
+
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom([]string{"0", "1", "2", "3"})
+
+		copyArray := array.DeepCopy().(*garray.StrArray)
+		copyArray.Set(0, "1")
+		cval, _ := copyArray.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 	})
 }
 
 func TestStrArray_ContainsI(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		s := garray.NewStrArray()
+		t.Assert(s.Contains("A"), false)
 		s.Append("a", "b", "C")
 		t.Assert(s.Contains("A"), false)
 		t.Assert(s.Contains("a"), true)
@@ -94,6 +114,8 @@ func TestStrArray_Unique(t *testing.T) {
 		expect := []string{"1", "1", "2", "2", "3", "3", "2", "2"}
 		array := garray.NewStrArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
+		array1 := garray.NewStrArrayFrom([]string{})
+		t.Assert(array1.Unique().Slice(), []string{})
 	})
 }
 
@@ -364,6 +386,13 @@ func TestStrArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.Assert(ok, true)
 		t.AssertIN(v, a1)
+
+		array2 := garray.NewStrArrayFrom([]string{})
+		v, ok = array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, "")
+		strArray := array2.Rands(1)
+		t.AssertNil(strArray)
 	})
 }
 
@@ -406,6 +435,11 @@ func TestStrArray_Join(t *testing.T) {
 		array1 := garray.NewStrArrayFrom(a1)
 		t.Assert(array1.Join("."), `0.1."a".\a`)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{}
+		array1 := garray.NewStrArrayFrom(a1)
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestStrArray_String(t *testing.T) {
@@ -413,6 +447,9 @@ func TestStrArray_String(t *testing.T) {
 		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStrArrayFrom(a1)
 		t.Assert(array1.String(), `["0","1","2","3","4","5","6"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -619,7 +656,7 @@ func TestStrArray_Json(t *testing.T) {
 
 		var a3 garray.StrArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array value
@@ -637,7 +674,7 @@ func TestStrArray_Json(t *testing.T) {
 
 		var a3 garray.StrArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array pointer
@@ -651,11 +688,11 @@ func TestStrArray_Json(t *testing.T) {
 			"Scores": []string{"A+", "A", "A"},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -670,11 +707,11 @@ func TestStrArray_Json(t *testing.T) {
 			"Scores": []string{"A+", "A", "A"},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, data["Scores"])
 	})
@@ -751,7 +788,7 @@ func TestStrArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": []byte(`["1","2","3"]`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})
@@ -762,7 +799,7 @@ func TestStrArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": g.SliceStr{"1", "2", "3"},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})

container/garray/garray_z_unit_sorted_any_test.go

@@ -61,6 +61,18 @@ func TestNewSortedArrayFromCopy(t *testing.T) {
 	})
 }
 
+func TestNewSortedArrayRange(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		func1 := func(v1, v2 interface{}) int {
+			return gconv.Int(v1) - gconv.Int(v2)
+		}
+
+		array1 := garray.NewSortedArrayRange(1, 5, 1, func1)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
+	})
+}
+
 func TestSortedArray_SetArray(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []interface{}{"a", "f", "c"}
@@ -106,10 +118,26 @@ func TestSortedArray_Get(t *testing.T) {
 		v, ok = array1.Get(1)
 		t.Assert(v, "c")
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
 	})
 
 }
 
+func TestSortedArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		v := array1.At(2)
+		t.Assert(v, "f")
+	})
+}
+
 func TestSortedArray_Remove(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []interface{}{"a", "d", "c", "b"}
@@ -461,6 +489,11 @@ func TestSortedArray_Rand(t *testing.T) {
 		t.Assert(ok, true)
 		t.AssertIN(i1, []interface{}{"a", "d", "c"})
 		t.Assert(array1.Len(), 3)
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
+		v, ok := array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, nil)
 	})
 }
 
@@ -479,6 +512,10 @@ func TestSortedArray_Rands(t *testing.T) {
 
 		i1 = array1.Rands(4)
 		t.Assert(len(i1), 4)
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
+		v := array2.Rands(1)
+		t.Assert(v, nil)
 	})
 }
 
@@ -498,6 +535,12 @@ func TestSortedArray_Join(t *testing.T) {
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.Join("."), `"a".0.1.\a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestSortedArray_String(t *testing.T) {
@@ -505,6 +548,9 @@ func TestSortedArray_String(t *testing.T) {
 		a1 := []interface{}{0, 1, "a", "b"}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.String(), `[0,1,"a","b"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -541,6 +587,11 @@ func TestSortedArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 5)
 		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorInt)
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []interface{}{})
 	})
 }
 
@@ -661,7 +712,7 @@ func TestSortedArray_Json(t *testing.T) {
 
 		var a3 garray.SortedArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
@@ -681,7 +732,7 @@ func TestSortedArray_Json(t *testing.T) {
 
 		var a3 garray.SortedArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
@@ -696,11 +747,11 @@ func TestSortedArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.AssertNE(user.Scores, nil)
 		t.Assert(user.Scores.Len(), 3)
@@ -732,11 +783,11 @@ func TestSortedArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.AssertNE(user.Scores, nil)
 		t.Assert(user.Scores.Len(), 3)
@@ -830,7 +881,7 @@ func TestSortedArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": []byte(`[2,3,1]`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
@@ -841,7 +892,7 @@ func TestSortedArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": g.Slice{2, 3, 1},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
@@ -878,3 +929,22 @@ func TestSortedArray_Walk(t *testing.T) {
 		}), g.Slice{"key-1", "key-2"})
 	})
 }
+
+func TestSortedArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorString)
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom([]interface{}{1, 2, 3, 4, 5}, gutil.ComparatorString)
+		copyArray := array.DeepCopy().(*garray.SortedArray)
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}

container/garray/garray_z_unit_sorted_int_test.go

@@ -19,6 +19,26 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+func TestNewSortedIntArrayComparator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{0, 3, 2, 1, 4, 5, 6}
+		array1 := garray.NewSortedIntArrayComparator(func(a, b int) int {
+			return a - b
+		}, true)
+		array1.Append(a1...)
+		t.Assert(array1.Len(), 7)
+		t.Assert(array1.Interfaces(), []int{0, 1, 2, 3, 4, 5, 6})
+	})
+}
+
+func TestNewSortedIntArrayRange(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedIntArrayRange(1, 5, 1)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1.Interfaces(), []int{1, 2, 3, 4, 5})
+	})
+}
+
 func TestNewSortedIntArrayFrom(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{0, 3, 2, 1, 4, 5, 6}
@@ -37,6 +57,17 @@ func TestNewSortedIntArrayFromCopy(t *testing.T) {
 	})
 }
 
+func TestSortedIntArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{0, 3, 2, 1}
+
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		v := array1.At(1)
+
+		t.Assert(v, 1)
+	})
+}
+
 func TestSortedIntArray_SetArray(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{0, 1, 2, 3}
@@ -78,6 +109,10 @@ func TestSortedIntArray_Get(t *testing.T) {
 		v, ok = array1.Get(3)
 		t.Assert(v, 5)
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
 	})
 }
 
@@ -294,6 +329,9 @@ func TestSortedIntArray_Join(t *testing.T) {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		t.Assert(array1.Join("."), `1.3.5`)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		t.Assert(array2.Join("."), "")
 	})
 }
 
@@ -302,6 +340,9 @@ func TestSortedIntArray_String(t *testing.T) {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		t.Assert(array1.String(), `[1,3,5]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -406,6 +447,11 @@ func TestSortedIntArray_Rand(t *testing.T) {
 		ns1, ok := array1.Rand()
 		t.AssertIN(ns1, a1)
 		t.Assert(ok, true)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		ns2, ok := array2.Rand()
+		t.Assert(ns2, 0)
+		t.Assert(ok, false)
 	})
 }
 
@@ -419,6 +465,10 @@ func TestSortedIntArray_Rands(t *testing.T) {
 
 		ns2 := array1.Rands(6)
 		t.Assert(len(ns2), 6)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		val := array2.Rands(1)
+		t.Assert(val, nil)
 	})
 }
 
@@ -450,6 +500,10 @@ func TestSortedIntArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 5)
 		t.Assert(array1, []int{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
 	})
 }
 
@@ -561,7 +615,7 @@ func TestSortedIntArray_Json(t *testing.T) {
 
 		var a3 garray.SortedIntArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array value
@@ -580,7 +634,7 @@ func TestSortedIntArray_Json(t *testing.T) {
 
 		var a3 garray.SortedIntArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 	})
 	// array pointer
@@ -594,11 +648,11 @@ func TestSortedIntArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, []int{98, 99, 100})
 	})
@@ -613,11 +667,11 @@ func TestSortedIntArray_Json(t *testing.T) {
 			"Scores": []int{99, 100, 98},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, []int{98, 99, 100})
 	})
@@ -695,7 +749,7 @@ func TestSortedIntArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": []byte(`[2,3,1]`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
@@ -706,7 +760,7 @@ func TestSortedIntArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": g.Slice{2, 3, 1},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
@@ -731,3 +785,22 @@ func TestSortedIntArray_Walk(t *testing.T) {
 		}), g.Slice{11, 12})
 	})
 }
+
+func TestSortedIntArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom([]int{})
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedIntArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom([]int{1, 2, 3, 4, 5})
+		copyArray := array.DeepCopy().(*garray.SortedIntArray)
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}

container/garray/garray_z_unit_sorted_str_test.go

@@ -9,6 +9,7 @@
 package garray_test
 
 import (
+	"github.com/gogf/gf/v2/text/gstr"
 	"testing"
 	"time"
 
@@ -19,6 +20,18 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+func TestNewSortedStrArrayComparator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStrArrayComparator(func(a, b string) int {
+			return gstr.Compare(a, b)
+		})
+		s1.Add(a1...)
+		t.Assert(s1.Len(), 4)
+		t.Assert(s1, []string{"a", "b", "c", "d"})
+	})
+}
+
 func TestNewSortedStrArrayFrom(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []string{"a", "d", "c", "b"}
@@ -58,6 +71,9 @@ func TestSortedStrArray_ContainsI(t *testing.T) {
 		t.Assert(s.Contains("A"), false)
 		t.Assert(s.Contains("a"), true)
 		t.Assert(s.ContainsI("A"), true)
+
+		s = garray.NewSortedStrArray()
+		t.Assert(s.Contains("A"), false)
 	})
 }
 
@@ -85,6 +101,10 @@ func TestSortedStrArray_Get(t *testing.T) {
 		v, ok = array1.Get(0)
 		t.Assert(v, "a")
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, "")
+		t.Assert(ok, false)
 	})
 }
 
@@ -361,6 +381,11 @@ func TestSortedStrArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.AssertIN(v, []string{"e", "a", "d"})
 		t.Assert(ok, true)
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		v, ok = array2.Rand()
+		t.Assert(v, "")
+		t.Assert(ok, false)
 	})
 }
 
@@ -375,6 +400,10 @@ func TestSortedStrArray_Rands(t *testing.T) {
 
 		s1 = array1.Rands(4)
 		t.Assert(len(s1), 4)
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		val := array2.Rands(1)
+		t.Assert(val, nil)
 	})
 }
 
@@ -391,6 +420,11 @@ func TestSortedStrArray_Join(t *testing.T) {
 		array1 := garray.NewSortedStrArrayFrom(a1)
 		t.Assert(array1.Join("."), `"b".\c.a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedStrArrayFrom([]string{})
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestSortedStrArray_String(t *testing.T) {
@@ -398,6 +432,9 @@ func TestSortedStrArray_String(t *testing.T) {
 		a1 := []string{"e", "a", "d"}
 		array1 := garray.NewSortedStrArrayFrom(a1)
 		t.Assert(array1.String(), `["a","d","e"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -469,6 +506,11 @@ func TestSortedStrArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1, []string{"1", "2", "3"})
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []string{})
 	})
 }
 
@@ -583,7 +625,7 @@ func TestSortedStrArray_Json(t *testing.T) {
 
 		var a3 garray.SortedStrArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
@@ -604,7 +646,7 @@ func TestSortedStrArray_Json(t *testing.T) {
 
 		var a3 garray.SortedStrArray
 		err := json.UnmarshalUseNumber(b2, &a3)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
@@ -619,11 +661,11 @@ func TestSortedStrArray_Json(t *testing.T) {
 			"Scores": []string{"A+", "A", "A"},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, []string{"A", "A", "A+"})
 	})
@@ -638,11 +680,11 @@ func TestSortedStrArray_Json(t *testing.T) {
 			"Scores": []string{"A+", "A", "A"},
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		user := new(User)
 		err = json.UnmarshalUseNumber(b, user)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(user.Name, data["Name"])
 		t.Assert(user.Scores, []string{"A", "A", "A+"})
 	})
@@ -719,7 +761,7 @@ func TestSortedStrArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": []byte(`["1","3","2"]`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})
@@ -730,7 +772,7 @@ func TestSortedStrArray_UnmarshalValue(t *testing.T) {
 			"name":  "john",
 			"array": g.SliceStr{"1", "3", "2"},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
 	})
@@ -755,3 +797,15 @@ func TestSortedStrArray_Walk(t *testing.T) {
 		}), g.Slice{"key-1", "key-2"})
 	})
 }
+
+func TestSortedStrArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom([]string{"a", "b", "c", "d"})
+		copyArray := array.DeepCopy().(*garray.SortedStrArray)
+		array.Add("e")
+		copyArray.Add("f")
+		cval, _ := copyArray.Get(4)
+		val, _ := array.Get(4)
+		t.AssertNE(cval, val)
+	})
+}

container/glist/glist.go

@@ -12,6 +12,7 @@ import (
 	"bytes"
 	"container/list"
 
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -503,11 +504,14 @@ func (l *List) Join(glue string) string {
 
 // String returns current list as a string.
 func (l *List) String() string {
+	if l == nil {
+		return ""
+	}
 	return "[" + l.Join(",") + "]"
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (l *List) MarshalJSON() ([]byte, error) {
+func (l List) MarshalJSON() ([]byte, error) {
 	return json.Marshal(l.FrontAll())
 }
 
@@ -543,3 +547,27 @@ func (l *List) UnmarshalValue(value interface{}) (err error) {
 	l.PushBacks(array)
 	return err
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (l *List) DeepCopy() interface{} {
+	if l == nil {
+		return nil
+	}
+
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	if l.list == nil {
+		return nil
+	}
+	var (
+		length = l.list.Len()
+		values = make([]interface{}, length)
+	)
+	if length > 0 {
+		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
+			values[i] = deepcopy.Copy(e.Value)
+		}
+	}
+	return NewFrom(values, l.mu.IsSafe())
+}

container/glist/glist_z_unit_test.go

@@ -709,20 +709,20 @@ func TestList_Json(t *testing.T) {
 		a := []interface{}{"a", "b", "c"}
 		l := New()
 		b, err := json.Marshal(a)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		err = json.UnmarshalUseNumber(b, l)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(l.FrontAll(), a)
 	})
 	gtest.C(t, func(t *gtest.T) {
 		var l List
 		a := []interface{}{"a", "b", "c"}
 		b, err := json.Marshal(a)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		err = json.UnmarshalUseNumber(b, &l)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(l.FrontAll(), a)
 	})
 }
@@ -739,7 +739,7 @@ func TestList_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"list": []byte(`[1,2,3]`),
 		}, &tlist)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(tlist.Name, "john")
 		t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
 	})
@@ -750,8 +750,18 @@ func TestList_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"list": []interface{}{1, 2, 3},
 		}, &tlist)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(tlist.Name, "john")
 		t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
 	})
 }
+
+func TestList_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
+		copyList := l.DeepCopy()
+		cl := copyList.(*List)
+		cl.PopBack()
+		t.AssertNE(l.Size(), cl.Size())
+	})
+}

container/gmap/gmap_hash_any_any_map.go

@@ -8,12 +8,14 @@ package gmap
 
 import (
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+// AnyAnyMap wraps map type `map[interface{}]interface{}` and provides more map features.
 type AnyAnyMap struct {
 	mu   rwmutex.RWMutex
 	data map[interface{}]interface{}
@@ -72,7 +74,7 @@ func (m *AnyAnyMap) Map() map[interface{}]interface{} {
 	return data
 }
 
-// MapCopy returns a copy of the underlying data of the hash map.
+// MapCopy returns a shallow copy of the underlying data of the hash map.
 func (m *AnyAnyMap) MapCopy() map[interface{}]interface{} {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -456,12 +458,15 @@ func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
 
 // String returns the map as a string.
 func (m *AnyAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *AnyAnyMap) MarshalJSON() ([]byte, error) {
+func (m AnyAnyMap) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))
 }
 
@@ -494,3 +499,18 @@ func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *AnyAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[interface{}]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v)
+	}
+	return NewFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_int_any_map.go

@@ -9,6 +9,7 @@ package gmap
 
 import (
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
@@ -455,12 +456,15 @@ func (m *IntAnyMap) Merge(other *IntAnyMap) {
 
 // String returns the map as a string.
 func (m *IntAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *IntAnyMap) MarshalJSON() ([]byte, error) {
+func (m IntAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -496,3 +500,17 @@ func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *IntAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v)
+	}
+	return NewIntAnyMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_int_int_map.go

@@ -426,12 +426,15 @@ func (m *IntIntMap) Merge(other *IntIntMap) {
 
 // String returns the map as a string.
 func (m *IntIntMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *IntIntMap) MarshalJSON() ([]byte, error) {
+func (m IntIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -467,3 +470,17 @@ func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *IntIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]int, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewIntIntMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_int_str_map.go

@@ -426,12 +426,15 @@ func (m *IntStrMap) Merge(other *IntStrMap) {
 
 // String returns the map as a string.
 func (m *IntStrMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *IntStrMap) MarshalJSON() ([]byte, error) {
+func (m IntStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -467,3 +470,17 @@ func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *IntStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]string, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewIntStrMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_str_any_map.go

@@ -9,6 +9,7 @@ package gmap
 
 import (
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
@@ -451,12 +452,15 @@ func (m *StrAnyMap) Merge(other *StrAnyMap) {
 
 // String returns the map as a string.
 func (m *StrAnyMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *StrAnyMap) MarshalJSON() ([]byte, error) {
+func (m StrAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -482,3 +486,17 @@ func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
 	m.data = gconv.Map(value)
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *StrAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[string]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v)
+	}
+	return NewStrAnyMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_str_int_map.go

@@ -430,12 +430,15 @@ func (m *StrIntMap) Merge(other *StrIntMap) {
 
 // String returns the map as a string.
 func (m *StrIntMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *StrIntMap) MarshalJSON() ([]byte, error) {
+func (m StrIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -471,3 +474,17 @@ func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *StrIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[string]int, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewStrIntMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_hash_str_str_map.go

@@ -429,12 +429,15 @@ func (m *StrStrMap) Merge(other *StrStrMap) {
 
 // String returns the map as a string.
 func (m *StrStrMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *StrStrMap) MarshalJSON() ([]byte, error) {
+func (m StrStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	return json.Marshal(m.data)
@@ -460,3 +463,17 @@ func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
 	m.data = gconv.MapStrStr(value)
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *StrStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[string]string, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewStrStrMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_list_map.go

@@ -7,14 +7,25 @@
 package gmap
 
 import (
+	"bytes"
+	"fmt"
+
 	"github.com/gogf/gf/v2/container/glist"
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+// ListMap is a map that preserves insertion-order.
+//
+// It is backed by a hash table to store values and doubly-linked list to store ordering.
+//
+// Structure is not thread safe.
+//
+// Reference: http://en.wikipedia.org/wiki/Associative_array
 type ListMap struct {
 	mu   rwmutex.RWMutex
 	data map[interface{}]*glist.Element
@@ -58,7 +69,7 @@ func (m *ListMap) IteratorAsc(f func(key interface{}, value interface{}) bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	if m.list != nil {
-		node := (*gListMapNode)(nil)
+		var node *gListMapNode
 		m.list.IteratorAsc(func(e *glist.Element) bool {
 			node = e.Value.(*gListMapNode)
 			return f(node.key, node.value)
@@ -72,7 +83,7 @@ func (m *ListMap) IteratorDesc(f func(key interface{}, value interface{}) bool)
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	if m.list != nil {
-		node := (*gListMapNode)(nil)
+		var node *gListMapNode
 		m.list.IteratorDesc(func(e *glist.Element) bool {
 			node = e.Value.(*gListMapNode)
 			return f(node.key, node.value)
@@ -146,8 +157,10 @@ func (m *ListMap) MapStrAny() map[string]interface{} {
 func (m *ListMap) FilterEmpty() {
 	m.mu.Lock()
 	if m.list != nil {
-		keys := make([]interface{}, 0)
-		node := (*gListMapNode)(nil)
+		var (
+			keys = make([]interface{}, 0)
+			node *gListMapNode
+		)
 		m.list.IteratorAsc(func(e *glist.Element) bool {
 			node = e.Value.(*gListMapNode)
 			if empty.IsEmpty(node.value) {
@@ -495,7 +508,7 @@ func (m *ListMap) Merge(other *ListMap) {
 		other.mu.RLock()
 		defer other.mu.RUnlock()
 	}
-	node := (*gListMapNode)(nil)
+	var node *gListMapNode
 	other.list.IteratorAsc(func(e *glist.Element) bool {
 		node = e.Value.(*gListMapNode)
 		if e, ok := m.data[node.key]; !ok {
@@ -509,13 +522,34 @@ func (m *ListMap) Merge(other *ListMap) {
 
 // String returns the map as a string.
 func (m *ListMap) String() string {
+	if m == nil {
+		return ""
+	}
 	b, _ := m.MarshalJSON()
 	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (m *ListMap) MarshalJSON() ([]byte, error) {
-	return json.Marshal(gconv.Map(m.Map()))
+func (m ListMap) MarshalJSON() (jsonBytes []byte, err error) {
+	if m.data == nil {
+		return []byte("null"), nil
+	}
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('{')
+	m.Iterator(func(key, value interface{}) bool {
+		valueBytes, valueJsonErr := json.Marshal(value)
+		if valueJsonErr != nil {
+			err = valueJsonErr
+			return false
+		}
+		if buffer.Len() > 1 {
+			buffer.WriteByte(',')
+		}
+		buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes))
+		return true
+	})
+	buffer.WriteByte('}')
+	return buffer.Bytes(), nil
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
@@ -557,3 +591,22 @@ func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
 	}
 	return
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (m *ListMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[interface{}]interface{}, len(m.data))
+	if m.list != nil {
+		var node *gListMapNode
+		m.list.IteratorAsc(func(e *glist.Element) bool {
+			node = e.Value.(*gListMapNode)
+			data[node.key] = deepcopy.Copy(node.value)
+			return true
+		})
+	}
+	return NewListMapFrom(data, m.mu.IsSafe())
+}

container/gmap/gmap_z_example_any_any_test.go

@@ -602,8 +602,12 @@ func ExampleAnyAnyMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.Map = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"k1":"v1"}
+	// 0
 }
 
 func ExampleAnyAnyMap_MarshalJSON() {

container/gmap/gmap_z_example_int_any_test.go

@@ -601,8 +601,12 @@ func ExampleIntAnyMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.IntAnyMap = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"1":"v1"}
+	// 0
 }
 
 func ExampleIntAnyMap_MarshalJSON() {

container/gmap/gmap_z_example_int_int_test.go

@@ -529,8 +529,12 @@ func ExampleIntIntMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.IntIntMap = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"1":1}
+	// 0
 }
 
 func ExampleIntIntMap_MarshalJSON() {

container/gmap/gmap_z_example_list_test.go

@@ -8,6 +8,7 @@ package gmap_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@@ -195,7 +196,7 @@ func ExampleListMap_Sets() {
 	m.Sets(addMap)
 	fmt.Println(m)
 
-	// Output:
+	// May Output:
 	// {"key1":"val1","key2":"val2","key3":"val3"}
 }
 
@@ -562,12 +563,10 @@ func ExampleListMap_String() {
 
 func ExampleListMap_MarshalJSON() {
 	var m gmap.ListMap
-	m.Sets(g.MapAnyAny{
-		"k1": "v1",
-		"k2": "v2",
-		"k3": "v3",
-		"k4": "v4",
-	})
+	m.Set("k1", "v1")
+	m.Set("k2", "v2")
+	m.Set("k3", "v3")
+	m.Set("k4", "v4")
 
 	bytes, err := json.Marshal(&m)
 	if err == nil {

container/gmap/gmap_z_example_str_any_test.go

@@ -599,8 +599,12 @@ func ExampleStrAnyMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.StrAnyMap = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"k1":"v1"}
+	// 0
 }
 
 func ExampleStrAnyMap_MarshalJSON() {

container/gmap/gmap_z_example_str_int_test.go

@@ -8,11 +8,10 @@ package gmap_test
 
 import (
 	"fmt"
+	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/util/gconv"
-
-	"github.com/gogf/gf/v2/container/gmap"
 )
 
 func ExampleStrIntMap_Iterator() {
@@ -535,8 +534,12 @@ func ExampleStrIntMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.StrIntMap = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"k1":1}
+	// 0
 }
 
 func ExampleStrIntMap_MarshalJSON() {

container/gmap/gmap_z_example_str_str_test.go

@@ -531,8 +531,12 @@ func ExampleStrStrMap_String() {
 
 	fmt.Println(m.String())
 
+	var m1 *gmap.StrStrMap = nil
+	fmt.Println(len(m1.String()))
+
 	// Output:
 	// {"k1":"v1"}
+	// 0
 }
 
 func ExampleStrStrMap_MarshalJSON() {

container/gmap/gmap_z_example_test.go

@@ -8,6 +8,7 @@ package gmap_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/util/gutil"
 
 	"github.com/gogf/gf/v2/container/gmap"
@@ -89,7 +90,7 @@ func ExampleNewFrom() {
 }
 
 func ExampleNewHashMap() {
-	m := gmap.New()
+	m := gmap.NewHashMap()
 
 	m.Set("key1", "val1")
 	fmt.Println(m)
@@ -104,7 +105,7 @@ func ExampleNewHashMapFrom() {
 	m.Set("key1", "val1")
 	fmt.Println(m)
 
-	n := gmap.NewFrom(m.MapCopy(), true)
+	n := gmap.NewHashMapFrom(m.MapCopy(), true)
 	fmt.Println(n)
 
 	// Output:
@@ -277,7 +278,7 @@ func ExampleNewListMapFrom() {
 	n := gmap.NewListMapFrom(m.Map(), true)
 	fmt.Println(n)
 
-	// Output:
+	// May Output:
 	// {"key1":"var1","key2":"var2"}
 	// {"key1":"var1","key2":"var2"}
 }
@@ -290,7 +291,7 @@ func ExampleNewTreeMap() {
 
 	fmt.Println(m.Map())
 
-	// Output:
+	// May Output:
 	// map[key1:var1 key2:var2]
 }
 
@@ -305,7 +306,7 @@ func ExampleNewTreeMapFrom() {
 	n := gmap.NewListMapFrom(m.Map(), true)
 	fmt.Println(n.Map())
 
-	// Output:
+	// May Output:
 	// map[key1:var1 key2:var2]
 	// map[key1:var1 key2:var2]
 }

container/gmap/gmap_z_unit_hash_any_any_test.go

@@ -171,6 +171,9 @@ func Test_AnyAnyMap_Merge(t *testing.T) {
 		m2.Set(2, "2")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[interface{}]interface{}{1: 1, 2: "2"})
+		m3 := gmap.NewAnyAnyMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -253,11 +256,11 @@ func Test_AnyAnyMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.New()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -267,11 +270,11 @@ func Test_AnyAnyMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.Map
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -296,6 +299,10 @@ func Test_AnyAnyMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.AssertNil(k3)
+		t.AssertNil(v3)
 	})
 }
 
@@ -327,6 +334,11 @@ func Test_AnyAnyMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -342,7 +354,7 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
@@ -358,10 +370,24 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
 				"k2": "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
 		t.Assert(v.Map.Get("k2"), "v2")
 	})
 }
+
+func Test_AnyAnyMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewAnyAnyMapFrom(g.MapAnyAny{
+			"k1": "v1",
+			"k2": "v2",
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.AnyAnyMap)
+		n.Set("k1", "val1")
+		t.AssertNE(m.Get("k1"), n.Get("k1"))
+	})
+}

container/gmap/gmap_z_unit_hash_int_any_test.go

@@ -82,6 +82,12 @@ func Test_IntAnyMap_Basic(t *testing.T) {
 		m2 := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
 		t.Assert(m2.Map(), map[int]interface{}{1: 1, 2: "2"})
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntAnyMap(true)
+		m.Set(1, 1)
+		t.Assert(m.Map(), map[int]interface{}{1: 1})
+	})
 }
 
 func Test_IntAnyMap_Set_Fun(t *testing.T) {
@@ -171,6 +177,9 @@ func Test_IntAnyMap_Merge(t *testing.T) {
 		m2.Set(2, "2")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[int]interface{}{1: 1, 2: "2"})
+		m3 := gmap.NewIntAnyMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -242,11 +251,11 @@ func Test_IntAnyMap_Json(t *testing.T) {
 			2: "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewIntAnyMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get(1), data[1])
 		t.Assert(m.Get(2), data[2])
 	})
@@ -271,6 +280,10 @@ func Test_IntAnyMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, 0)
+		t.AssertNil(v3)
 	})
 }
 
@@ -302,6 +315,11 @@ func Test_IntAnyMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -317,7 +335,7 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"1":"v1","2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "v1")
@@ -333,10 +351,24 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) {
 				2: "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "v1")
 		t.Assert(v.Map.Get(2), "v2")
 	})
 }
+
+func Test_IntAnyMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntAnyMapFrom(g.MapIntAny{
+			1: "v1",
+			2: "v2",
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.IntAnyMap)
+		n.Set(1, "val1")
+		t.AssertNE(m.Get(1), n.Get(1))
+	})
+}

container/gmap/gmap_z_unit_hash_int_int_test.go

@@ -86,6 +86,12 @@ func Test_IntIntMap_Basic(t *testing.T) {
 		m2 := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
 		t.Assert(m2.Map(), map[int]int{1: 1, 2: 2})
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntIntMap(true)
+		m.Set(1, 1)
+		t.Assert(m.Map(), map[int]int{1: 1})
+	})
 }
 
 func Test_IntIntMap_Set_Fun(t *testing.T) {
@@ -102,6 +108,11 @@ func Test_IntIntMap_Set_Fun(t *testing.T) {
 		t.Assert(m.SetIfNotExistFuncLock(2, getInt), false)
 		t.Assert(m.SetIfNotExistFuncLock(4, getInt), true)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntIntMapFrom(nil)
+		t.Assert(m.GetOrSetFuncLock(1, getInt), getInt())
+	})
 }
 
 func Test_IntIntMap_Batch(t *testing.T) {
@@ -177,6 +188,9 @@ func Test_IntIntMap_Merge(t *testing.T) {
 		m2.Set(2, 2)
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[int]int{1: 1, 2: 2})
+		m3 := gmap.NewIntIntMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -248,11 +262,11 @@ func Test_IntIntMap_Json(t *testing.T) {
 			2: 20,
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewIntIntMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get(1), data[1])
 		t.Assert(m.Get(2), data[2])
 	})
@@ -277,6 +291,10 @@ func Test_IntIntMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, 0)
+		t.Assert(v3, 0)
 	})
 }
 
@@ -308,6 +326,11 @@ func Test_IntIntMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -323,7 +346,7 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"1":1,"2":2}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "1")
@@ -339,10 +362,24 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) {
 				2: 2,
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "1")
 		t.Assert(v.Map.Get(2), "2")
 	})
 }
+
+func Test_IntIntMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntIntMapFrom(g.MapIntInt{
+			1: 1,
+			2: 2,
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.IntIntMap)
+		n.Set(1, 2)
+		t.AssertNE(m.Get(1), n.Get(1))
+	})
+}

container/gmap/gmap_z_unit_hash_int_str_test.go

@@ -63,6 +63,7 @@ func Test_IntStrMap_Basic(t *testing.T) {
 		t.Assert(m.Size(), 1)
 		t.Assert(m.IsEmpty(), false)
 
+		t.Assert(m.GetOrSet(1, "a"), "a")
 		t.Assert(m.GetOrSet(2, "b"), "b")
 		t.Assert(m.SetIfNotExist(2, "b"), false)
 
@@ -90,6 +91,29 @@ func Test_IntStrMap_Basic(t *testing.T) {
 		m2 := gmap.NewIntStrMapFrom(map[int]string{1: "a", 2: "b"})
 		t.Assert(m2.Map(), map[int]string{1: "a", 2: "b"})
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMap(true)
+		m.Set(1, "val1")
+		t.Assert(m.Map(), map[int]string{1: "val1"})
+	})
+}
+
+func TestIntStrMap_MapStrAny(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMap()
+		m.GetOrSetFunc(1, getStr)
+		m.GetOrSetFuncLock(2, getStr)
+		t.Assert(m.MapStrAny(), g.MapStrAny{"1": "z", "2": "z"})
+	})
+}
+
+func TestIntStrMap_Sets(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(nil)
+		m.Sets(g.MapIntStr{1: "z", 2: "z"})
+		t.Assert(len(m.Map()), 2)
+	})
 }
 
 func Test_IntStrMap_Set_Fun(t *testing.T) {
@@ -97,6 +121,8 @@ func Test_IntStrMap_Set_Fun(t *testing.T) {
 		m := gmap.NewIntStrMap()
 		m.GetOrSetFunc(1, getStr)
 		m.GetOrSetFuncLock(2, getStr)
+		t.Assert(m.GetOrSetFunc(1, getStr), "z")
+		t.Assert(m.GetOrSetFuncLock(2, getStr), "z")
 		t.Assert(m.Get(1), "z")
 		t.Assert(m.Get(2), "z")
 		t.Assert(m.SetIfNotExistFunc(1, getStr), false)
@@ -105,6 +131,16 @@ func Test_IntStrMap_Set_Fun(t *testing.T) {
 		t.Assert(m.SetIfNotExistFuncLock(2, getStr), false)
 		t.Assert(m.SetIfNotExistFuncLock(4, getStr), true)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(nil)
+		t.Assert(m.GetOrSetFuncLock(1, getStr), "z")
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(nil)
+		t.Assert(m.SetIfNotExistFuncLock(1, getStr), true)
+	})
 }
 
 func Test_IntStrMap_Batch(t *testing.T) {
@@ -176,6 +212,10 @@ func Test_IntStrMap_Merge(t *testing.T) {
 		m2.Set(2, "b")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[int]string{1: "a", 2: "b"})
+
+		m3 := gmap.NewIntStrMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -246,11 +286,11 @@ func Test_IntStrMap_Json(t *testing.T) {
 			2: "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewIntStrMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get(1), data[1])
 		t.Assert(m.Get(2), data[2])
 	})
@@ -275,6 +315,10 @@ func Test_IntStrMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, 0)
+		t.Assert(v3, "")
 	})
 }
 
@@ -306,6 +350,11 @@ func Test_IntStrMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -321,7 +370,7 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"1":"v1","2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "v1")
@@ -337,10 +386,62 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) {
 				2: "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get(1), "v1")
 		t.Assert(v.Map.Get(2), "v2")
 	})
 }
+
+func TestIntStrMap_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(g.MapIntStr{
+			1: "v1",
+			2: "v2",
+			3: "v3",
+		})
+
+		t.Assert(m.Get(1), "v1")
+		t.Assert(m.Get(2), "v2")
+		t.Assert(m.Get(3), "v3")
+
+		m.Replace(g.MapIntStr{
+			1: "v2",
+			2: "v3",
+			3: "v1",
+		})
+
+		t.Assert(m.Get(1), "v2")
+		t.Assert(m.Get(2), "v3")
+		t.Assert(m.Get(3), "v1")
+	})
+}
+
+func TestIntStrMap_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(g.MapIntStr{
+			1: "v1",
+			2: "v2",
+			3: "v3",
+		})
+		t.Assert(m.String(), "{\"1\":\"v1\",\"2\":\"v2\",\"3\":\"v3\"}")
+
+		m = nil
+		t.Assert(len(m.String()), 0)
+	})
+}
+
+func Test_IntStrMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewIntStrMapFrom(g.MapIntStr{
+			1: "val1",
+			2: "val2",
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.IntStrMap)
+		n.Set(1, "v1")
+		t.AssertNE(m.Get(1), n.Get(1))
+	})
+}

container/gmap/gmap_z_unit_hash_str_any_test.go

@@ -169,6 +169,10 @@ func Test_StrAnyMap_Merge(t *testing.T) {
 		m2.Set("b", "2")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[string]interface{}{"a": 1, "b": "2"})
+
+		m3 := gmap.NewStrAnyMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -240,11 +244,11 @@ func Test_StrAnyMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewStrAnyMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -254,11 +258,11 @@ func Test_StrAnyMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.StrAnyMap
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -283,6 +287,10 @@ func Test_StrAnyMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, "")
+		t.Assert(v3, "")
 	})
 }
 
@@ -314,6 +322,11 @@ func Test_StrAnyMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -329,7 +342,7 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
@@ -345,10 +358,24 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) {
 				"k2": "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
 		t.Assert(v.Map.Get("k2"), "v2")
 	})
 }
+
+func Test_StrAnyMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewStrAnyMapFrom(g.MapStrAny{
+			"key1": "val1",
+			"key2": "val2",
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.StrAnyMap)
+		n.Set("key1", "v1")
+		t.AssertNE(m.Get("key1"), n.Get("key1"))
+	})
+}

container/gmap/gmap_z_unit_hash_str_int_test.go

@@ -100,6 +100,11 @@ func Test_StrIntMap_Set_Fun(t *testing.T) {
 		t.Assert(m.SetIfNotExistFuncLock("b", getInt), false)
 		t.Assert(m.SetIfNotExistFuncLock("d", getInt), true)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewStrIntMapFrom(nil)
+		t.Assert(m.GetOrSetFuncLock("a", getInt), 123)
+	})
 }
 
 func Test_StrIntMap_Batch(t *testing.T) {
@@ -173,6 +178,9 @@ func Test_StrIntMap_Merge(t *testing.T) {
 		m2.Set("b", 2)
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[string]int{"a": 1, "b": 2})
+		m3 := gmap.NewStrIntMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -244,11 +252,11 @@ func Test_StrIntMap_Json(t *testing.T) {
 			"k2": 2,
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewStrIntMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -258,11 +266,11 @@ func Test_StrIntMap_Json(t *testing.T) {
 			"k2": 2,
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.StrIntMap
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -287,6 +295,10 @@ func Test_StrIntMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, "")
+		t.Assert(v3, 0)
 	})
 }
 
@@ -318,6 +330,11 @@ func Test_StrIntMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -333,7 +350,7 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"k1":1,"k2":2}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), 1)
@@ -349,10 +366,24 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) {
 				"k2": 2,
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), 1)
 		t.Assert(v.Map.Get("k2"), 2)
 	})
 }
+
+func Test_StrIntMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewStrIntMapFrom(g.MapStrInt{
+			"key1": 1,
+			"key2": 2,
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.StrIntMap)
+		n.Set("key1", 2)
+		t.AssertNE(m.Get("key1"), n.Get("key1"))
+	})
+}

container/gmap/gmap_z_unit_hash_str_str_test.go

@@ -98,6 +98,12 @@ func Test_StrStrMap_Set_Fun(t *testing.T) {
 		t.Assert(m.SetIfNotExistFuncLock("b", getStr), false)
 		t.Assert(m.SetIfNotExistFuncLock("d", getStr), true)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewStrStrMapFrom(nil)
+
+		t.Assert(m.GetOrSetFuncLock("b", getStr), "z")
+	})
 }
 
 func Test_StrStrMap_Batch(t *testing.T) {
@@ -170,6 +176,9 @@ func Test_StrStrMap_Merge(t *testing.T) {
 		m2.Set("b", "b")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[string]string{"a": "a", "b": "b"})
+		m3 := gmap.NewStrStrMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -241,11 +250,11 @@ func Test_StrStrMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewStrStrMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -255,11 +264,11 @@ func Test_StrStrMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(data)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.StrStrMap
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -284,6 +293,10 @@ func Test_StrStrMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.Assert(k3, "")
+		t.Assert(v3, "")
 	})
 }
 
@@ -315,6 +328,11 @@ func Test_StrStrMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -330,7 +348,7 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
@@ -346,10 +364,24 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) {
 				"k2": "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
 		t.Assert(v.Map.Get("k2"), "v2")
 	})
 }
+
+func Test_StrStrMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewStrStrMapFrom(g.MapStrStr{
+			"key1": "val1",
+			"key2": "val2",
+		})
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.StrStrMap)
+		n.Set("key1", "v1")
+		t.AssertNE(m.Get("key1"), n.Get("key1"))
+	})
+}

container/gmap/gmap_z_unit_list_map_test.go

@@ -154,6 +154,9 @@ func Test_ListMap_Basic_Merge(t *testing.T) {
 		m2.Set("key2", "val2")
 		m1.Merge(m2)
 		t.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
+		m3 := gmap.NewListMapFrom(nil)
+		m3.Merge(m2)
+		t.Assert(m3.Map(), m2.Map())
 	})
 }
 
@@ -186,12 +189,12 @@ func Test_ListMap_Json(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		data := g.MapAnyAny{
 			"k1": "v1",
-			"k2": "v2",
 		}
 		m1 := gmap.NewListMapFrom(data)
 		b1, err1 := json.Marshal(m1)
+		t.AssertNil(err1)
 		b2, err2 := json.Marshal(gconv.Map(data))
-		t.Assert(err1, err2)
+		t.AssertNil(err2)
 		t.Assert(b1, b2)
 	})
 	// Unmarshal
@@ -201,11 +204,11 @@ func Test_ListMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewListMap()
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -216,16 +219,37 @@ func Test_ListMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.ListMap
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
 }
 
+func Test_ListMap_Json_Sequence(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListMap()
+		for i := 'z'; i >= 'a'; i-- {
+			m.Set(string(i), i)
+		}
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(b, `{"z":122,"y":121,"x":120,"w":119,"v":118,"u":117,"t":116,"s":115,"r":114,"q":113,"p":112,"o":111,"n":110,"m":109,"l":108,"k":107,"j":106,"i":105,"h":104,"g":103,"f":102,"e":101,"d":100,"c":99,"b":98,"a":97}`)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListMap()
+		for i := 'a'; i <= 'z'; i++ {
+			m.Set(string(i), i)
+		}
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(b, `{"a":97,"b":98,"c":99,"d":100,"e":101,"f":102,"g":103,"h":104,"i":105,"j":106,"k":107,"l":108,"m":109,"n":110,"o":111,"p":112,"q":113,"r":114,"s":115,"t":116,"u":117,"v":118,"w":119,"x":120,"y":121,"z":122}`)
+	})
+}
+
 func Test_ListMap_Pop(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		m := gmap.NewListMapFrom(g.MapAnyAny{
@@ -245,6 +269,10 @@ func Test_ListMap_Pop(t *testing.T) {
 
 		t.AssertNE(k1, k2)
 		t.AssertNE(v1, v2)
+
+		k3, v3 := m.Pop()
+		t.AssertNil(k3)
+		t.AssertNil(v3)
 	})
 }
 
@@ -276,6 +304,11 @@ func Test_ListMap_Pops(t *testing.T) {
 
 		t.Assert(kArray.Unique().Len(), 3)
 		t.Assert(vArray.Unique().Len(), 3)
+
+		v := m.Pops(1)
+		t.AssertNil(v)
+		v = m.Pops(-1)
+		t.AssertNil(v)
 	})
 }
 
@@ -291,7 +324,7 @@ func TestListMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"1":"v1","2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("1"), "v1")
@@ -307,10 +340,51 @@ func TestListMap_UnmarshalValue(t *testing.T) {
 				2: "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("1"), "v1")
 		t.Assert(v.Map.Get("2"), "v2")
 	})
 }
+
+func TestListMap_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListMap()
+		m.Set(1, "")
+		m.Set(2, "2")
+		t.Assert(m.String(), "{\"1\":\"\",\"2\":\"2\"}")
+
+		m1 := gmap.NewListMapFrom(nil)
+		t.Assert(m1.String(), "{}")
+	})
+}
+
+func TestListMap_MarshalJSON(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListMap()
+		m.Set(1, "")
+		m.Set(2, "2")
+		res, err := m.MarshalJSON()
+		t.Assert(res, []byte("{\"1\":\"\",\"2\":\"2\"}"))
+		t.AssertNil(err)
+
+		m1 := gmap.NewListMapFrom(nil)
+		res, err = m1.MarshalJSON()
+		t.Assert(res, []byte("{}"))
+		t.AssertNil(err)
+	})
+}
+
+func TestListMap_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewListMap()
+		m.Set(1, "1")
+		m.Set(2, "2")
+		t.Assert(m.Size(), 2)
+
+		n := m.DeepCopy().(*gmap.ListMap)
+		n.Set(1, "val1")
+		t.AssertNE(m.Get(1), n.Get(1))
+	})
+}

container/gmap/gmap_z_unit_tree_map_test.go

@@ -185,11 +185,11 @@ func Test_TreeMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		m := gmap.NewTreeMap(gutil.ComparatorString)
 		err = json.UnmarshalUseNumber(b, m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -199,11 +199,11 @@ func Test_TreeMap_Json(t *testing.T) {
 			"k2": "v2",
 		}
 		b, err := json.Marshal(gconv.Map(data))
-		t.Assert(err, nil)
+		t.AssertNil(err)
 
 		var m gmap.TreeMap
 		err = json.UnmarshalUseNumber(b, &m)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(m.Get("k1"), data["k1"])
 		t.Assert(m.Get("k2"), data["k2"])
 	})
@@ -221,7 +221,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) {
 			"name": "john",
 			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")
@@ -237,7 +237,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) {
 				"k2": "v2",
 			},
 		}, &v)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(v.Name, "john")
 		t.Assert(v.Map.Size(), 2)
 		t.Assert(v.Map.Get("k1"), "v1")

container/gpool/gpool.go

@@ -109,7 +109,7 @@ func (p *Pool) Get() (interface{}, error) {
 			if f.expireAt == 0 || f.expireAt > gtime.TimestampMilli() {
 				return f.value, nil
 			} else if p.ExpireFunc != nil {
-				// TODO: move expire function calling asynchronously from `Get` operation.
+				// TODO: move expire function calling asynchronously out from `Get` operation.
 				p.ExpireFunc(f.value)
 			}
 		} else {
@@ -129,7 +129,7 @@ func (p *Pool) Size() int {
 
 // Close closes the pool. If `p` has ExpireFunc,
 // then it automatically closes all items using this function before it's closed.
-// Commonly you do not need call this function manually.
+// Commonly you do not need to call this function manually.
 func (p *Pool) Close() {
 	p.closed.Set(true)
 }