Merge branch 'main' into update-i.8713187.xyz/google/go-github

Author: harryzcy

.gitpod.yml

@@ -23,13 +23,6 @@ tasks:
       gp sync-await setup
       make watch-frontend
     openMode: split-right
-  - name: Run docs
-    command: |
-      gp sync-await setup
-      cd docs
-      make clean update
-      hugo server -D -F --baseUrl $(gp url 1313) --liveReloadPort=443 --appendPort=false --bind=0.0.0.0
-    openMode: split-right
 
 vscode:
   extensions:
@@ -46,5 +39,3 @@ vscode:
 ports:
   - name: Gitea
     port: 3000
-  - name: Docs
-    port: 1313

models/organization/org.go

@@ -100,6 +100,11 @@ func (org *Organization) IsOwnedBy(uid int64) (bool, error) {
 	return IsOrganizationOwner(db.DefaultContext, org.ID, uid)
 }
 
+// IsOrgAdmin returns true if given user is in the owner team or an admin team.
+func (org *Organization) IsOrgAdmin(uid int64) (bool, error) {
+	return IsOrganizationAdmin(db.DefaultContext, org.ID, uid)
+}
+
 // IsOrgMember returns true if given user is member of organization.
 func (org *Organization) IsOrgMember(uid int64) (bool, error) {
 	return IsOrganizationMember(db.DefaultContext, org.ID, uid)

models/organization/org_user.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 
 	"code.gitea.io/gitea/models/db"
+	"code.gitea.io/gitea/models/perm"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/log"
 
@@ -53,6 +54,20 @@ func IsOrganizationOwner(ctx context.Context, orgID, uid int64) (bool, error) {
 	return IsTeamMember(ctx, orgID, ownerTeam.ID, uid)
 }
 
+// IsOrganizationAdmin returns true if given user is in the owner team or an admin team.
+func IsOrganizationAdmin(ctx context.Context, orgID, uid int64) (bool, error) {
+	teams, err := GetUserOrgTeams(ctx, orgID, uid)
+	if err != nil {
+		return false, err
+	}
+	for _, t := range teams {
+		if t.AccessMode >= perm.AccessModeAdmin {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
 // IsOrganizationMember returns true if given user is member of organization.
 func IsOrganizationMember(ctx context.Context, orgID, uid int64) (bool, error) {
 	return db.GetEngine(ctx).

modules/repository/delete.go

@@ -21,11 +21,11 @@ func CanUserDelete(repo *repo_model.Repository, user *user_model.User) (bool, er
 	}
 
 	if repo.Owner.IsOrganization() {
-		isOwner, err := organization.OrgFromUser(repo.Owner).IsOwnedBy(user.ID)
+		isAdmin, err := organization.OrgFromUser(repo.Owner).IsOrgAdmin(user.ID)
 		if err != nil {
 			return false, err
 		}
-		return isOwner, nil
+		return isAdmin, nil
 	}
 
 	return false, nil

modules/session/redis.go

@@ -183,16 +183,21 @@ func (p *RedisProvider) Regenerate(oldsid, sid string) (_ session.RawStore, err
 		}
 	}
 
-	if err = p.c.Rename(graceful.GetManager().HammerContext(), poldsid, psid).Err(); err != nil {
+	// do not use Rename here, because the old sid and new sid may be in different redis cluster slot.
+	kvs, err := p.c.Get(graceful.GetManager().HammerContext(), poldsid).Result()
+	if err != nil {
 		return nil, err
 	}
 
-	var kv map[interface{}]interface{}
-	kvs, err := p.c.Get(graceful.GetManager().HammerContext(), psid).Result()
-	if err != nil {
+	if err = p.c.Del(graceful.GetManager().HammerContext(), poldsid).Err(); err != nil {
 		return nil, err
 	}
 
+	if err = p.c.Set(graceful.GetManager().HammerContext(), psid, kvs, p.duration).Err(); err != nil {
+		return nil, err
+	}
+
+	var kv map[interface{}]interface{}
 	if len(kvs) == 0 {
 		kv = make(map[interface{}]interface{})
 	} else {

modules/templates/helper.go

@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"html"
 	"html/template"
@@ -219,20 +218,6 @@ func NewFuncMap() []template.FuncMap {
 		"DisableImportLocal": func() bool {
 			return !setting.ImportLocalPaths
 		},
-		"Dict": func(values ...interface{}) (map[string]interface{}, error) {
-			if len(values)%2 != 0 {
-				return nil, errors.New("invalid dict call")
-			}
-			dict := make(map[string]interface{}, len(values)/2)
-			for i := 0; i < len(values); i += 2 {
-				key, ok := values[i].(string)
-				if !ok {
-					return nil, errors.New("dict keys must be strings")
-				}
-				dict[key] = values[i+1]
-			}
-			return dict, nil
-		},
 		"Printf":   fmt.Sprintf,
 		"Escape":   Escape,
 		"Sec2Time": util.SecToTime,
@@ -242,35 +227,7 @@ func NewFuncMap() []template.FuncMap {
 		"DefaultTheme": func() string {
 			return setting.UI.DefaultTheme
 		},
-		// pass key-value pairs to a partial template which receives them as a dict
-		"dict": func(values ...interface{}) (map[string]interface{}, error) {
-			if len(values) == 0 {
-				return nil, errors.New("invalid dict call")
-			}
-
-			dict := make(map[string]interface{})
-			return util.MergeInto(dict, values...)
-		},
-		/* like dict but merge key-value pairs into the first dict and return it */
-		"mergeinto": func(root map[string]interface{}, values ...interface{}) (map[string]interface{}, error) {
-			if len(values) == 0 {
-				return nil, errors.New("invalid mergeinto call")
-			}
-
-			dict := make(map[string]interface{})
-			for key, value := range root {
-				dict[key] = value
-			}
-
-			return util.MergeInto(dict, values...)
-		},
-		"percentage": func(n int, values ...int) float32 {
-			sum := 0
-			for i := 0; i < len(values); i++ {
-				sum += values[i]
-			}
-			return float32(n) * 100 / float32(sum)
-		},
+		"dict":                dict,
 		"CommentMustAsDiff":   gitdiff.CommentMustAsDiff,
 		"MirrorRemoteAddress": mirrorRemoteAddress,
 		"NotificationSettings": func() map[string]interface{} {
@@ -413,52 +370,13 @@ func NewTextFuncMap() []texttmpl.FuncMap {
 		},
 		"EllipsisString": base.EllipsisString,
 		"URLJoin":        util.URLJoin,
-		"Dict": func(values ...interface{}) (map[string]interface{}, error) {
-			if len(values)%2 != 0 {
-				return nil, errors.New("invalid dict call")
-			}
-			dict := make(map[string]interface{}, len(values)/2)
-			for i := 0; i < len(values); i += 2 {
-				key, ok := values[i].(string)
-				if !ok {
-					return nil, errors.New("dict keys must be strings")
-				}
-				dict[key] = values[i+1]
-			}
-			return dict, nil
-		},
-		"Printf":   fmt.Sprintf,
-		"Escape":   Escape,
-		"Sec2Time": util.SecToTime,
+		"Printf":         fmt.Sprintf,
+		"Escape":         Escape,
+		"Sec2Time":       util.SecToTime,
 		"ParseDeadline": func(deadline string) []string {
 			return strings.Split(deadline, "|")
 		},
-		"dict": func(values ...interface{}) (map[string]interface{}, error) {
-			if len(values) == 0 {
-				return nil, errors.New("invalid dict call")
-			}
-
-			dict := make(map[string]interface{})
-
-			for i := 0; i < len(values); i++ {
-				switch key := values[i].(type) {
-				case string:
-					i++
-					if i == len(values) {
-						return nil, errors.New("specify the key for non array values")
-					}
-					dict[key] = values[i]
-				case map[string]interface{}:
-					m := values[i].(map[string]interface{})
-					for i, v := range m {
-						dict[i] = v
-					}
-				default:
-					return nil, errors.New("dict values must be maps")
-				}
-			}
-			return dict, nil
-		},
+		"dict":        dict,
 		"QueryEscape": url.QueryEscape,
 		"Eval":        Eval,
 	}}

modules/templates/util.go

@@ -0,0 +1,47 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package templates
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func dictMerge(base map[string]any, arg any) bool {
+	if arg == nil {
+		return true
+	}
+	rv := reflect.ValueOf(arg)
+	if rv.Kind() == reflect.Map {
+		for _, k := range rv.MapKeys() {
+			base[k.String()] = rv.MapIndex(k).Interface()
+		}
+		return true
+	}
+	return false
+}
+
+// dict is a helper function for creating a map[string]any from a list of key-value pairs.
+// If the key is dot ".", the value is merged into the base map, just like Golang template's dot syntax: dot means current
+// The dot syntax is highly discouraged because it might cause unclear key conflicts. It's always good to use explicit keys.
+func dict(args ...any) (map[string]any, error) {
+	if len(args)%2 != 0 {
+		return nil, fmt.Errorf("invalid dict constructor syntax: must have key-value pairs")
+	}
+	m := make(map[string]any, len(args)/2)
+	for i := 0; i < len(args); i += 2 {
+		key, ok := args[i].(string)
+		if !ok {
+			return nil, fmt.Errorf("invalid dict constructor syntax: unable to merge args[%d]", i)
+		}
+		if key == "." {
+			if ok = dictMerge(m, args[i+1]); !ok {
+				return nil, fmt.Errorf("invalid dict constructor syntax: dot arg[%d] must be followed by a dict", i)
+			}
+		} else {
+			m[key] = args[i+1]
+		}
+	}
+	return m, nil
+}

modules/templates/util_test.go

@@ -0,0 +1,43 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package templates
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDict(t *testing.T) {
+	type M map[string]any
+	cases := []struct {
+		args []any
+		want map[string]any
+	}{
+		{[]any{"a", 1, "b", 2}, M{"a": 1, "b": 2}},
+		{[]any{".", M{"base": 1}, "b", 2}, M{"base": 1, "b": 2}},
+		{[]any{"a", 1, ".", M{"extra": 2}}, M{"a": 1, "extra": 2}},
+		{[]any{"a", 1, ".", map[string]int{"int": 2}}, M{"a": 1, "int": 2}},
+		{[]any{".", nil, "b", 2}, M{"b": 2}},
+	}
+
+	for _, c := range cases {
+		got, err := dict(c.args...)
+		if assert.NoError(t, err) {
+			assert.EqualValues(t, c.want, got)
+		}
+	}
+
+	bads := []struct {
+		args []any
+	}{
+		{[]any{"a", 1, "b"}},
+		{[]any{1}},
+		{[]any{struct{}{}}},
+	}
+	for _, c := range bads {
+		_, err := dict(c.args...)
+		assert.Error(t, err)
+	}
+}

modules/util/util.go

@@ -6,7 +6,6 @@ package util
 import (
 	"bytes"
 	"crypto/rand"
-	"errors"
 	"fmt"
 	"math/big"
 	"strconv"
@@ -117,29 +116,6 @@ func NormalizeEOL(input []byte) []byte {
 	return tmp[:pos]
 }
 
-// MergeInto merges pairs of values into a "dict"
-func MergeInto(dict map[string]interface{}, values ...interface{}) (map[string]interface{}, error) {
-	for i := 0; i < len(values); i++ {
-		switch key := values[i].(type) {
-		case string:
-			i++
-			if i == len(values) {
-				return nil, errors.New("specify the key for non array values")
-			}
-			dict[key] = values[i]
-		case map[string]interface{}:
-			m := values[i].(map[string]interface{})
-			for i, v := range m {
-				dict[i] = v
-			}
-		default:
-			return nil, errors.New("dict values must be maps")
-		}
-	}
-
-	return dict, nil
-}
-
 // CryptoRandomInt returns a crypto random integer between 0 and limit, inclusive
 func CryptoRandomInt(limit int64) (int64, error) {
 	rInt, err := rand.Int(rand.Reader, big.NewInt(limit))

package-lock.json

@@ -9,6 +9,7 @@ import (
 
 	actions_model "code.gitea.io/gitea/models/actions"
 	secret_model "code.gitea.io/gitea/models/secret"
+	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/json"
 	"code.gitea.io/gitea/modules/log"
 	secret_module "code.gitea.io/gitea/modules/secret"
@@ -98,7 +99,7 @@ func generateTaskContext(t *actions_model.ActionTask) *structpb.Struct {
 		"head_ref":          "",                                                   // string, The head_ref or source branch of the pull request in a workflow run. This property is only available when the event that triggers a workflow run is either pull_request or pull_request_target.
 		"job":               fmt.Sprint(t.JobID),                                  // string, The job_id of the current job.
 		"ref":               t.Job.Run.Ref,                                        // string, The fully-formed ref of the branch or tag that triggered the workflow run. For workflows triggered by push, this is the branch or tag ref that was pushed. For workflows triggered by pull_request, this is the pull request merge branch. For workflows triggered by release, this is the release tag created. For other triggers, this is the branch or tag ref that triggered the workflow run. This is only set if a branch or tag is available for the event type. The ref given is fully-formed, meaning that for branches the format is refs/heads/<branch_name>, for pull requests it is refs/pull/<pr_number>/merge, and for tags it is refs/tags/<tag_name>. For example, refs/heads/feature-branch-1.
-		"ref_name":          t.Job.Run.Ref,                                        // string, The short ref name of the branch or tag that triggered the workflow run. This value matches the branch or tag name shown on GitHub. For example, feature-branch-1.
+		"ref_name":          git.RefEndName(t.Job.Run.Ref),                        // string, The short ref name of the branch or tag that triggered the workflow run. This value matches the branch or tag name shown on GitHub. For example, feature-branch-1.
 		"ref_protected":     false,                                                // boolean, true if branch protections are configured for the ref that triggered the workflow run.
 		"ref_type":          "",                                                   // string, The type of ref that triggered the workflow run. Valid values are branch or tag.
 		"path":              "",                                                   // string, Path on the runner to the file that sets system PATH variables from workflow commands. This file is unique to the current step and is a different file for each step in a job. For more information, see "Workflow commands for GitHub Actions."

routers/api/actions/runner/utils.go

@@ -75,6 +75,7 @@ type ViewJob struct {
 	Name     string `json:"name"`
 	Status   string `json:"status"`
 	CanRerun bool   `json:"canRerun"`
+	Duration string `json:"duration"`
 }
 
 type ViewCommit struct {
@@ -144,6 +145,7 @@ func ViewPost(ctx *context_module.Context) {
 			Name:     v.Name,
 			Status:   v.Status.String(),
 			CanRerun: v.Status.IsDone() && ctx.Repo.CanWrite(unit.TypeActions),
+			Duration: v.Duration().String(),
 		})
 	}