mass renaming of gitlab to gitea

2022-02-19 17:25:38 +05:30
parent 1bb88c7a05
commit 67f60bae11
14 changed files with 341 additions and 342 deletions
--- a/check_command.go
+++ b/check_command.go
@@ -4,26 +4,26 @@ import (
 	"sort"

 	"github.com/cppforlife/go-semi-semantic/version"
-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"
 )

 type CheckCommand struct {
-	gitlab GitLab
+	gitea Gitea
 }

-func NewCheckCommand(gitlab GitLab) *CheckCommand {
+func NewCheckCommand(gitea Gitea) *CheckCommand {
 	return &CheckCommand{
-		gitlab: gitlab,
+		gitea: gitea,
 	}
 }

 func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) {
-	var tags []*gitlab.Tag
+	var tags []*gitea.Tag
 	var err error
 	if (request.Version == Version{}) {
-		tags, err = c.gitlab.ListTags()
+		tags, err = c.gitea.ListTags()
 	} else {
-		tags, err = c.gitlab.ListTagsUntil(request.Version.Tag)
+		tags, err = c.gitea.ListTagsUntil(request.Version.Tag)
 	}

 	if err != nil {
@@ -34,7 +34,7 @@ func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) {
 		return []Version{}, nil
 	}

-	var filteredTags []*gitlab.Tag
+	var filteredTags []*gitea.Tag

 	// TODO: make ListTagsUntil work better with this
 	versionParser, err := newVersionParser(request.Source.TagFilter)
@@ -47,9 +47,9 @@ func (c *CheckCommand) Run(request CheckRequest) ([]Version, error) {
 			continue
 		}

-		if tag.Release == nil {
+/*		if tag.Release == nil {
 			continue
-		}
+		}*/

 		filteredTags = append(filteredTags, tag)
 	}
--- a/check_command_test.go
+++ b/check_command_test.go
@@ -4,35 +4,35 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"

-	"github.com/edtan/gitlab-release-resource"
-	"github.com/edtan/gitlab-release-resource/fakes"
+	"github.com/natto1784/gitea-release-resource"
+	"github.com/natto1784/gitea-release-resource/fakes"
 )

 var _ = Describe("Check Command", func() {
 	var (
-		gitlabClient *fakes.FakeGitLab
+		giteaClient *fakes.FakeGitea
 		command      *resource.CheckCommand

-		returnedTags []*gitlab.Tag
+		returnedTags []*gitea.Tag
 	)

 	BeforeEach(func() {
-		gitlabClient = &fakes.FakeGitLab{}
-		command = resource.NewCheckCommand(gitlabClient)
+		giteaClient = &fakes.FakeGitea{}
+		command = resource.NewCheckCommand(giteaClient)

-		returnedTags = []*gitlab.Tag{}
+		returnedTags = []*gitea.Tag{}
 	})

 	JustBeforeEach(func() {
-		gitlabClient.ListTagsReturns(returnedTags, nil)
+		giteaClient.ListTagsReturns(returnedTags, nil)
 	})

 	Context("when this is the first time that the resource has been run", func() {
 		Context("when there are no releases", func() {
 			BeforeEach(func() {
-				returnedTags = []*gitlab.Tag{}
+				returnedTags = []*gitea.Tag{}
 			})

 			It("returns no versions", func() {
@@ -44,7 +44,7 @@ var _ = Describe("Check Command", func() {

 		Context("when there are releases", func() {
 			BeforeEach(func() {
-				returnedTags = []*gitlab.Tag{
+				returnedTags = []*gitea.Tag{
 					newTag("v0.4.0", "abc123"),
 					newTag("0.1.3", "bdc234"),
 					newTag("v0.1.2", "cde345"),
@@ -52,7 +52,7 @@ var _ = Describe("Check Command", func() {
 			})

 			It("outputs the most recent version only", func() {
-				command := resource.NewCheckCommand(gitlabClient)
+				command := resource.NewCheckCommand(giteaClient)

 				response, err := command.Run(resource.CheckRequest{})
 				Ω(err).ShouldNot(HaveOccurred())
@@ -68,7 +68,7 @@ var _ = Describe("Check Command", func() {
 	Context("when there are prior versions", func() {
 		Context("when there are no releases", func() {
 			BeforeEach(func() {
-				returnedTags = []*gitlab.Tag{}
+				returnedTags = []*gitea.Tag{}
 			})

 			It("returns no versions", func() {
@@ -81,7 +81,7 @@ var _ = Describe("Check Command", func() {
 		Context("when there are releases", func() {
 			Context("and there is a custom tag filter", func() {
 				BeforeEach(func() {
-					returnedTags = []*gitlab.Tag{
+					returnedTags = []*gitea.Tag{
 						newTag("package-0.1.4", "abc123"),
 						newTag("package-0.4.0", "bcd234"),
 						newTag("package-0.1.3", "cde345"),
@@ -90,7 +90,7 @@ var _ = Describe("Check Command", func() {
 				})

 				It("returns all of the versions that are newer", func() {
-					command := resource.NewCheckCommand(gitlabClient)
+					command := resource.NewCheckCommand(giteaClient)

 					response, err := command.Run(resource.CheckRequest{
 						Version: resource.Version{
@@ -109,7 +109,7 @@ var _ = Describe("Check Command", func() {

 			Context("and the releases do not contain a draft release", func() {
 				BeforeEach(func() {
-					returnedTags = []*gitlab.Tag{
+					returnedTags = []*gitea.Tag{
 						newTag("v0.1.4", "abc123"),
 						newTag("0.4.0", "bcd234"),
 						newTag("v0.1.3", "cde345"),
@@ -118,7 +118,7 @@ var _ = Describe("Check Command", func() {
 				})

 				It("returns an empty list if the latest version has been checked", func() {
-					command := resource.NewCheckCommand(gitlabClient)
+					command := resource.NewCheckCommand(giteaClient)

 					response, err := command.Run(resource.CheckRequest{
 						Version: resource.Version{
@@ -131,7 +131,7 @@ var _ = Describe("Check Command", func() {
 				})

 				It("returns all of the versions that are newer", func() {
-					command := resource.NewCheckCommand(gitlabClient)
+					command := resource.NewCheckCommand(giteaClient)

 					response, err := command.Run(resource.CheckRequest{
 						Version: resource.Version{
@@ -148,7 +148,7 @@ var _ = Describe("Check Command", func() {
 				})

 				It("returns the latest version if the current version is not found", func() {
-					command := resource.NewCheckCommand(gitlabClient)
+					command := resource.NewCheckCommand(giteaClient)

 					response, err := command.Run(resource.CheckRequest{
 						Version: resource.Version{
@@ -169,7 +169,7 @@ var _ = Describe("Check Command", func() {
 					})

 					It("combines them with the semver versions in a reasonable order", func() {
-						command := resource.NewCheckCommand(gitlabClient)
+						command := resource.NewCheckCommand(giteaClient)

 						response, err := command.Run(resource.CheckRequest{
 							Version: resource.Version{
--- a/fakes/fake_git_lab.go
+++ b/fakes/fake_git_lab.go
@@ -4,37 +4,37 @@ package fakes
 import (
 	sync "sync"

-	resource "github.com/edtan/gitlab-release-resource"
-	gitlab "github.com/xanzy/go-gitlab"
+	resource "github.com/natto1784/gitea-release-resource"
+	gitea "code.gitea.io/sdk/gitea"
 )

-type FakeGitLab struct {
-	CreateReleaseStub        func(string, string) (*gitlab.Release, error)
+type FakeGitea struct {
+	CreateReleaseStub        func(string, string) (*gitea.Release, error)
 	createReleaseMutex       sync.RWMutex
 	createReleaseArgsForCall []struct {
 		arg1 string
 		arg2 string
 	}
 	createReleaseReturns struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}
 	createReleaseReturnsOnCall map[int]struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}
-	CreateTagStub        func(string, string) (*gitlab.Tag, error)
+	CreateTagStub        func(string, string) (*gitea.Tag, error)
 	createTagMutex       sync.RWMutex
 	createTagArgsForCall []struct {
 		arg1 string
 		arg2 string
 	}
 	createTagReturns struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}
 	createTagReturnsOnCall map[int]struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}
 	DownloadProjectFileStub        func(string, string) error
@@ -49,76 +49,76 @@ type FakeGitLab struct {
 	downloadProjectFileReturnsOnCall map[int]struct {
 		result1 error
 	}
-	GetTagStub        func(string) (*gitlab.Tag, error)
+	GetTagStub        func(string) (*gitea.Tag, error)
 	getTagMutex       sync.RWMutex
 	getTagArgsForCall []struct {
 		arg1 string
 	}
 	getTagReturns struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}
 	getTagReturnsOnCall map[int]struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}
-	ListTagsStub        func() ([]*gitlab.Tag, error)
+	ListTagsStub        func() ([]*gitea.Tag, error)
 	listTagsMutex       sync.RWMutex
 	listTagsArgsForCall []struct {
 	}
 	listTagsReturns struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}
 	listTagsReturnsOnCall map[int]struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}
-	ListTagsUntilStub        func(string) ([]*gitlab.Tag, error)
+	ListTagsUntilStub        func(string) ([]*gitea.Tag, error)
 	listTagsUntilMutex       sync.RWMutex
 	listTagsUntilArgsForCall []struct {
 		arg1 string
 	}
 	listTagsUntilReturns struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}
 	listTagsUntilReturnsOnCall map[int]struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}
-	UpdateReleaseStub        func(string, string) (*gitlab.Release, error)
+	UpdateReleaseStub        func(string, string) (*gitea.Release, error)
 	updateReleaseMutex       sync.RWMutex
 	updateReleaseArgsForCall []struct {
 		arg1 string
 		arg2 string
 	}
 	updateReleaseReturns struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}
 	updateReleaseReturnsOnCall map[int]struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}
-	UploadProjectFileStub        func(string) (*gitlab.ProjectFile, error)
+	UploadProjectFileStub        func(string) (*gitea.ProjectFile, error)
 	uploadProjectFileMutex       sync.RWMutex
 	uploadProjectFileArgsForCall []struct {
 		arg1 string
 	}
 	uploadProjectFileReturns struct {
-		result1 *gitlab.ProjectFile
+		result1 *gitea.ProjectFile
 		result2 error
 	}
 	uploadProjectFileReturnsOnCall map[int]struct {
-		result1 *gitlab.ProjectFile
+		result1 *gitea.ProjectFile
 		result2 error
 	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }

-func (fake *FakeGitLab) CreateRelease(arg1 string, arg2 string) (*gitlab.Release, error) {
+func (fake *FakeGitea) CreateRelease(arg1 string, arg2 string) (*gitea.Release, error) {
 	fake.createReleaseMutex.Lock()
 	ret, specificReturn := fake.createReleaseReturnsOnCall[len(fake.createReleaseArgsForCall)]
 	fake.createReleaseArgsForCall = append(fake.createReleaseArgsForCall, struct {
@@ -137,52 +137,52 @@ func (fake *FakeGitLab) CreateRelease(arg1 string, arg2 string) (*gitlab.Release
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) CreateReleaseCallCount() int {
+func (fake *FakeGitea) CreateReleaseCallCount() int {
 	fake.createReleaseMutex.RLock()
 	defer fake.createReleaseMutex.RUnlock()
 	return len(fake.createReleaseArgsForCall)
 }

-func (fake *FakeGitLab) CreateReleaseCalls(stub func(string, string) (*gitlab.Release, error)) {
+func (fake *FakeGitea) CreateReleaseCalls(stub func(string, string) (*gitea.Release, error)) {
 	fake.createReleaseMutex.Lock()
 	defer fake.createReleaseMutex.Unlock()
 	fake.CreateReleaseStub = stub
 }

-func (fake *FakeGitLab) CreateReleaseArgsForCall(i int) (string, string) {
+func (fake *FakeGitea) CreateReleaseArgsForCall(i int) (string, string) {
 	fake.createReleaseMutex.RLock()
 	defer fake.createReleaseMutex.RUnlock()
 	argsForCall := fake.createReleaseArgsForCall[i]
 	return argsForCall.arg1, argsForCall.arg2
 }

-func (fake *FakeGitLab) CreateReleaseReturns(result1 *gitlab.Release, result2 error) {
+func (fake *FakeGitea) CreateReleaseReturns(result1 *gitea.Release, result2 error) {
 	fake.createReleaseMutex.Lock()
 	defer fake.createReleaseMutex.Unlock()
 	fake.CreateReleaseStub = nil
 	fake.createReleaseReturns = struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) CreateReleaseReturnsOnCall(i int, result1 *gitlab.Release, result2 error) {
+func (fake *FakeGitea) CreateReleaseReturnsOnCall(i int, result1 *gitea.Release, result2 error) {
 	fake.createReleaseMutex.Lock()
 	defer fake.createReleaseMutex.Unlock()
 	fake.CreateReleaseStub = nil
 	if fake.createReleaseReturnsOnCall == nil {
 		fake.createReleaseReturnsOnCall = make(map[int]struct {
-			result1 *gitlab.Release
+			result1 *gitea.Release
 			result2 error
 		})
 	}
 	fake.createReleaseReturnsOnCall[i] = struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) CreateTag(arg1 string, arg2 string) (*gitlab.Tag, error) {
+func (fake *FakeGitea) CreateTag(arg1 string, arg2 string) (*gitea.Tag, error) {
 	fake.createTagMutex.Lock()
 	ret, specificReturn := fake.createTagReturnsOnCall[len(fake.createTagArgsForCall)]
 	fake.createTagArgsForCall = append(fake.createTagArgsForCall, struct {
@@ -201,52 +201,52 @@ func (fake *FakeGitLab) CreateTag(arg1 string, arg2 string) (*gitlab.Tag, error)
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) CreateTagCallCount() int {
+func (fake *FakeGitea) CreateTagCallCount() int {
 	fake.createTagMutex.RLock()
 	defer fake.createTagMutex.RUnlock()
 	return len(fake.createTagArgsForCall)
 }

-func (fake *FakeGitLab) CreateTagCalls(stub func(string, string) (*gitlab.Tag, error)) {
+func (fake *FakeGitea) CreateTagCalls(stub func(string, string) (*gitea.Tag, error)) {
 	fake.createTagMutex.Lock()
 	defer fake.createTagMutex.Unlock()
 	fake.CreateTagStub = stub
 }

-func (fake *FakeGitLab) CreateTagArgsForCall(i int) (string, string) {
+func (fake *FakeGitea) CreateTagArgsForCall(i int) (string, string) {
 	fake.createTagMutex.RLock()
 	defer fake.createTagMutex.RUnlock()
 	argsForCall := fake.createTagArgsForCall[i]
 	return argsForCall.arg1, argsForCall.arg2
 }

-func (fake *FakeGitLab) CreateTagReturns(result1 *gitlab.Tag, result2 error) {
+func (fake *FakeGitea) CreateTagReturns(result1 *gitea.Tag, result2 error) {
 	fake.createTagMutex.Lock()
 	defer fake.createTagMutex.Unlock()
 	fake.CreateTagStub = nil
 	fake.createTagReturns = struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) CreateTagReturnsOnCall(i int, result1 *gitlab.Tag, result2 error) {
+func (fake *FakeGitea) CreateTagReturnsOnCall(i int, result1 *gitea.Tag, result2 error) {
 	fake.createTagMutex.Lock()
 	defer fake.createTagMutex.Unlock()
 	fake.CreateTagStub = nil
 	if fake.createTagReturnsOnCall == nil {
 		fake.createTagReturnsOnCall = make(map[int]struct {
-			result1 *gitlab.Tag
+			result1 *gitea.Tag
 			result2 error
 		})
 	}
 	fake.createTagReturnsOnCall[i] = struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) DownloadProjectFile(arg1 string, arg2 string) error {
+func (fake *FakeGitea) DownloadProjectFile(arg1 string, arg2 string) error {
 	fake.downloadProjectFileMutex.Lock()
 	ret, specificReturn := fake.downloadProjectFileReturnsOnCall[len(fake.downloadProjectFileArgsForCall)]
 	fake.downloadProjectFileArgsForCall = append(fake.downloadProjectFileArgsForCall, struct {
@@ -265,26 +265,26 @@ func (fake *FakeGitLab) DownloadProjectFile(arg1 string, arg2 string) error {
 	return fakeReturns.result1
 }

-func (fake *FakeGitLab) DownloadProjectFileCallCount() int {
+func (fake *FakeGitea) DownloadProjectFileCallCount() int {
 	fake.downloadProjectFileMutex.RLock()
 	defer fake.downloadProjectFileMutex.RUnlock()
 	return len(fake.downloadProjectFileArgsForCall)
 }

-func (fake *FakeGitLab) DownloadProjectFileCalls(stub func(string, string) error) {
+func (fake *FakeGitea) DownloadProjectFileCalls(stub func(string, string) error) {
 	fake.downloadProjectFileMutex.Lock()
 	defer fake.downloadProjectFileMutex.Unlock()
 	fake.DownloadProjectFileStub = stub
 }

-func (fake *FakeGitLab) DownloadProjectFileArgsForCall(i int) (string, string) {
+func (fake *FakeGitea) DownloadProjectFileArgsForCall(i int) (string, string) {
 	fake.downloadProjectFileMutex.RLock()
 	defer fake.downloadProjectFileMutex.RUnlock()
 	argsForCall := fake.downloadProjectFileArgsForCall[i]
 	return argsForCall.arg1, argsForCall.arg2
 }

-func (fake *FakeGitLab) DownloadProjectFileReturns(result1 error) {
+func (fake *FakeGitea) DownloadProjectFileReturns(result1 error) {
 	fake.downloadProjectFileMutex.Lock()
 	defer fake.downloadProjectFileMutex.Unlock()
 	fake.DownloadProjectFileStub = nil
@@ -293,7 +293,7 @@ func (fake *FakeGitLab) DownloadProjectFileReturns(result1 error) {
 	}{result1}
 }

-func (fake *FakeGitLab) DownloadProjectFileReturnsOnCall(i int, result1 error) {
+func (fake *FakeGitea) DownloadProjectFileReturnsOnCall(i int, result1 error) {
 	fake.downloadProjectFileMutex.Lock()
 	defer fake.downloadProjectFileMutex.Unlock()
 	fake.DownloadProjectFileStub = nil
@@ -307,7 +307,7 @@ func (fake *FakeGitLab) DownloadProjectFileReturnsOnCall(i int, result1 error) {
 	}{result1}
 }

-func (fake *FakeGitLab) GetTag(arg1 string) (*gitlab.Tag, error) {
+func (fake *FakeGitea) GetTag(arg1 string) (*gitea.Tag, error) {
 	fake.getTagMutex.Lock()
 	ret, specificReturn := fake.getTagReturnsOnCall[len(fake.getTagArgsForCall)]
 	fake.getTagArgsForCall = append(fake.getTagArgsForCall, struct {
@@ -325,52 +325,52 @@ func (fake *FakeGitLab) GetTag(arg1 string) (*gitlab.Tag, error) {
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) GetTagCallCount() int {
+func (fake *FakeGitea) GetTagCallCount() int {
 	fake.getTagMutex.RLock()
 	defer fake.getTagMutex.RUnlock()
 	return len(fake.getTagArgsForCall)
 }

-func (fake *FakeGitLab) GetTagCalls(stub func(string) (*gitlab.Tag, error)) {
+func (fake *FakeGitea) GetTagCalls(stub func(string) (*gitea.Tag, error)) {
 	fake.getTagMutex.Lock()
 	defer fake.getTagMutex.Unlock()
 	fake.GetTagStub = stub
 }

-func (fake *FakeGitLab) GetTagArgsForCall(i int) string {
+func (fake *FakeGitea) GetTagArgsForCall(i int) string {
 	fake.getTagMutex.RLock()
 	defer fake.getTagMutex.RUnlock()
 	argsForCall := fake.getTagArgsForCall[i]
 	return argsForCall.arg1
 }

-func (fake *FakeGitLab) GetTagReturns(result1 *gitlab.Tag, result2 error) {
+func (fake *FakeGitea) GetTagReturns(result1 *gitea.Tag, result2 error) {
 	fake.getTagMutex.Lock()
 	defer fake.getTagMutex.Unlock()
 	fake.GetTagStub = nil
 	fake.getTagReturns = struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) GetTagReturnsOnCall(i int, result1 *gitlab.Tag, result2 error) {
+func (fake *FakeGitea) GetTagReturnsOnCall(i int, result1 *gitea.Tag, result2 error) {
 	fake.getTagMutex.Lock()
 	defer fake.getTagMutex.Unlock()
 	fake.GetTagStub = nil
 	if fake.getTagReturnsOnCall == nil {
 		fake.getTagReturnsOnCall = make(map[int]struct {
-			result1 *gitlab.Tag
+			result1 *gitea.Tag
 			result2 error
 		})
 	}
 	fake.getTagReturnsOnCall[i] = struct {
-		result1 *gitlab.Tag
+		result1 *gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) ListTags() ([]*gitlab.Tag, error) {
+func (fake *FakeGitea) ListTags() ([]*gitea.Tag, error) {
 	fake.listTagsMutex.Lock()
 	ret, specificReturn := fake.listTagsReturnsOnCall[len(fake.listTagsArgsForCall)]
 	fake.listTagsArgsForCall = append(fake.listTagsArgsForCall, struct {
@@ -387,45 +387,45 @@ func (fake *FakeGitLab) ListTags() ([]*gitlab.Tag, error) {
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) ListTagsCallCount() int {
+func (fake *FakeGitea) ListTagsCallCount() int {
 	fake.listTagsMutex.RLock()
 	defer fake.listTagsMutex.RUnlock()
 	return len(fake.listTagsArgsForCall)
 }

-func (fake *FakeGitLab) ListTagsCalls(stub func() ([]*gitlab.Tag, error)) {
+func (fake *FakeGitea) ListTagsCalls(stub func() ([]*gitea.Tag, error)) {
 	fake.listTagsMutex.Lock()
 	defer fake.listTagsMutex.Unlock()
 	fake.ListTagsStub = stub
 }

-func (fake *FakeGitLab) ListTagsReturns(result1 []*gitlab.Tag, result2 error) {
+func (fake *FakeGitea) ListTagsReturns(result1 []*gitea.Tag, result2 error) {
 	fake.listTagsMutex.Lock()
 	defer fake.listTagsMutex.Unlock()
 	fake.ListTagsStub = nil
 	fake.listTagsReturns = struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) ListTagsReturnsOnCall(i int, result1 []*gitlab.Tag, result2 error) {
+func (fake *FakeGitea) ListTagsReturnsOnCall(i int, result1 []*gitea.Tag, result2 error) {
 	fake.listTagsMutex.Lock()
 	defer fake.listTagsMutex.Unlock()
 	fake.ListTagsStub = nil
 	if fake.listTagsReturnsOnCall == nil {
 		fake.listTagsReturnsOnCall = make(map[int]struct {
-			result1 []*gitlab.Tag
+			result1 []*gitea.Tag
 			result2 error
 		})
 	}
 	fake.listTagsReturnsOnCall[i] = struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) ListTagsUntil(arg1 string) ([]*gitlab.Tag, error) {
+func (fake *FakeGitea) ListTagsUntil(arg1 string) ([]*gitea.Tag, error) {
 	fake.listTagsUntilMutex.Lock()
 	ret, specificReturn := fake.listTagsUntilReturnsOnCall[len(fake.listTagsUntilArgsForCall)]
 	fake.listTagsUntilArgsForCall = append(fake.listTagsUntilArgsForCall, struct {
@@ -443,52 +443,52 @@ func (fake *FakeGitLab) ListTagsUntil(arg1 string) ([]*gitlab.Tag, error) {
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) ListTagsUntilCallCount() int {
+func (fake *FakeGitea) ListTagsUntilCallCount() int {
 	fake.listTagsUntilMutex.RLock()
 	defer fake.listTagsUntilMutex.RUnlock()
 	return len(fake.listTagsUntilArgsForCall)
 }

-func (fake *FakeGitLab) ListTagsUntilCalls(stub func(string) ([]*gitlab.Tag, error)) {
+func (fake *FakeGitea) ListTagsUntilCalls(stub func(string) ([]*gitea.Tag, error)) {
 	fake.listTagsUntilMutex.Lock()
 	defer fake.listTagsUntilMutex.Unlock()
 	fake.ListTagsUntilStub = stub
 }

-func (fake *FakeGitLab) ListTagsUntilArgsForCall(i int) string {
+func (fake *FakeGitea) ListTagsUntilArgsForCall(i int) string {
 	fake.listTagsUntilMutex.RLock()
 	defer fake.listTagsUntilMutex.RUnlock()
 	argsForCall := fake.listTagsUntilArgsForCall[i]
 	return argsForCall.arg1
 }

-func (fake *FakeGitLab) ListTagsUntilReturns(result1 []*gitlab.Tag, result2 error) {
+func (fake *FakeGitea) ListTagsUntilReturns(result1 []*gitea.Tag, result2 error) {
 	fake.listTagsUntilMutex.Lock()
 	defer fake.listTagsUntilMutex.Unlock()
 	fake.ListTagsUntilStub = nil
 	fake.listTagsUntilReturns = struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) ListTagsUntilReturnsOnCall(i int, result1 []*gitlab.Tag, result2 error) {
+func (fake *FakeGitea) ListTagsUntilReturnsOnCall(i int, result1 []*gitea.Tag, result2 error) {
 	fake.listTagsUntilMutex.Lock()
 	defer fake.listTagsUntilMutex.Unlock()
 	fake.ListTagsUntilStub = nil
 	if fake.listTagsUntilReturnsOnCall == nil {
 		fake.listTagsUntilReturnsOnCall = make(map[int]struct {
-			result1 []*gitlab.Tag
+			result1 []*gitea.Tag
 			result2 error
 		})
 	}
 	fake.listTagsUntilReturnsOnCall[i] = struct {
-		result1 []*gitlab.Tag
+		result1 []*gitea.Tag
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) UpdateRelease(arg1 string, arg2 string) (*gitlab.Release, error) {
+func (fake *FakeGitea) UpdateRelease(arg1 string, arg2 string) (*gitea.Release, error) {
 	fake.updateReleaseMutex.Lock()
 	ret, specificReturn := fake.updateReleaseReturnsOnCall[len(fake.updateReleaseArgsForCall)]
 	fake.updateReleaseArgsForCall = append(fake.updateReleaseArgsForCall, struct {
@@ -507,52 +507,52 @@ func (fake *FakeGitLab) UpdateRelease(arg1 string, arg2 string) (*gitlab.Release
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) UpdateReleaseCallCount() int {
+func (fake *FakeGitea) UpdateReleaseCallCount() int {
 	fake.updateReleaseMutex.RLock()
 	defer fake.updateReleaseMutex.RUnlock()
 	return len(fake.updateReleaseArgsForCall)
 }

-func (fake *FakeGitLab) UpdateReleaseCalls(stub func(string, string) (*gitlab.Release, error)) {
+func (fake *FakeGitea) UpdateReleaseCalls(stub func(string, string) (*gitea.Release, error)) {
 	fake.updateReleaseMutex.Lock()
 	defer fake.updateReleaseMutex.Unlock()
 	fake.UpdateReleaseStub = stub
 }

-func (fake *FakeGitLab) UpdateReleaseArgsForCall(i int) (string, string) {
+func (fake *FakeGitea) UpdateReleaseArgsForCall(i int) (string, string) {
 	fake.updateReleaseMutex.RLock()
 	defer fake.updateReleaseMutex.RUnlock()
 	argsForCall := fake.updateReleaseArgsForCall[i]
 	return argsForCall.arg1, argsForCall.arg2
 }

-func (fake *FakeGitLab) UpdateReleaseReturns(result1 *gitlab.Release, result2 error) {
+func (fake *FakeGitea) UpdateReleaseReturns(result1 *gitea.Release, result2 error) {
 	fake.updateReleaseMutex.Lock()
 	defer fake.updateReleaseMutex.Unlock()
 	fake.UpdateReleaseStub = nil
 	fake.updateReleaseReturns = struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) UpdateReleaseReturnsOnCall(i int, result1 *gitlab.Release, result2 error) {
+func (fake *FakeGitea) UpdateReleaseReturnsOnCall(i int, result1 *gitea.Release, result2 error) {
 	fake.updateReleaseMutex.Lock()
 	defer fake.updateReleaseMutex.Unlock()
 	fake.UpdateReleaseStub = nil
 	if fake.updateReleaseReturnsOnCall == nil {
 		fake.updateReleaseReturnsOnCall = make(map[int]struct {
-			result1 *gitlab.Release
+			result1 *gitea.Release
 			result2 error
 		})
 	}
 	fake.updateReleaseReturnsOnCall[i] = struct {
-		result1 *gitlab.Release
+		result1 *gitea.Release
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) UploadProjectFile(arg1 string) (*gitlab.ProjectFile, error) {
+func (fake *FakeGitea) UploadProjectFile(arg1 string) (*gitea.ProjectFile, error) {
 	fake.uploadProjectFileMutex.Lock()
 	ret, specificReturn := fake.uploadProjectFileReturnsOnCall[len(fake.uploadProjectFileArgsForCall)]
 	fake.uploadProjectFileArgsForCall = append(fake.uploadProjectFileArgsForCall, struct {
@@ -570,52 +570,52 @@ func (fake *FakeGitLab) UploadProjectFile(arg1 string) (*gitlab.ProjectFile, err
 	return fakeReturns.result1, fakeReturns.result2
 }

-func (fake *FakeGitLab) UploadProjectFileCallCount() int {
+func (fake *FakeGitea) UploadProjectFileCallCount() int {
 	fake.uploadProjectFileMutex.RLock()
 	defer fake.uploadProjectFileMutex.RUnlock()
 	return len(fake.uploadProjectFileArgsForCall)
 }

-func (fake *FakeGitLab) UploadProjectFileCalls(stub func(string) (*gitlab.ProjectFile, error)) {
+func (fake *FakeGitea) UploadProjectFileCalls(stub func(string) (*gitea.ProjectFile, error)) {
 	fake.uploadProjectFileMutex.Lock()
 	defer fake.uploadProjectFileMutex.Unlock()
 	fake.UploadProjectFileStub = stub
 }

-func (fake *FakeGitLab) UploadProjectFileArgsForCall(i int) string {
+func (fake *FakeGitea) UploadProjectFileArgsForCall(i int) string {
 	fake.uploadProjectFileMutex.RLock()
 	defer fake.uploadProjectFileMutex.RUnlock()
 	argsForCall := fake.uploadProjectFileArgsForCall[i]
 	return argsForCall.arg1
 }

-func (fake *FakeGitLab) UploadProjectFileReturns(result1 *gitlab.ProjectFile, result2 error) {
+func (fake *FakeGitea) UploadProjectFileReturns(result1 *gitea.ProjectFile, result2 error) {
 	fake.uploadProjectFileMutex.Lock()
 	defer fake.uploadProjectFileMutex.Unlock()
 	fake.UploadProjectFileStub = nil
 	fake.uploadProjectFileReturns = struct {
-		result1 *gitlab.ProjectFile
+		result1 *gitea.ProjectFile
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) UploadProjectFileReturnsOnCall(i int, result1 *gitlab.ProjectFile, result2 error) {
+func (fake *FakeGitea) UploadProjectFileReturnsOnCall(i int, result1 *gitea.ProjectFile, result2 error) {
 	fake.uploadProjectFileMutex.Lock()
 	defer fake.uploadProjectFileMutex.Unlock()
 	fake.UploadProjectFileStub = nil
 	if fake.uploadProjectFileReturnsOnCall == nil {
 		fake.uploadProjectFileReturnsOnCall = make(map[int]struct {
-			result1 *gitlab.ProjectFile
+			result1 *gitea.ProjectFile
 			result2 error
 		})
 	}
 	fake.uploadProjectFileReturnsOnCall[i] = struct {
-		result1 *gitlab.ProjectFile
+		result1 *gitea.ProjectFile
 		result2 error
 	}{result1, result2}
 }

-func (fake *FakeGitLab) Invocations() map[string][][]interface{} {
+func (fake *FakeGitea) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
 	fake.createReleaseMutex.RLock()
@@ -641,7 +641,7 @@ func (fake *FakeGitLab) Invocations() map[string][][]interface{} {
 	return copiedInvocations
 }

-func (fake *FakeGitLab) recordInvocation(key string, args []interface{}) {
+func (fake *FakeGitea) recordInvocation(key string, args []interface{}) {
 	fake.invocationsMutex.Lock()
 	defer fake.invocationsMutex.Unlock()
 	if fake.invocations == nil {
@@ -653,4 +653,4 @@ func (fake *FakeGitLab) recordInvocation(key string, args []interface{}) {
 	fake.invocations[key] = append(fake.invocations[key], args)
 }

-var _ resource.GitLab = new(FakeGitLab)
+var _ resource.Gitea = new(FakeGitea)
--- a/gitlab.go
+++ b/gitlab.go
@@ -15,30 +15,30 @@ import (

 	"context"

-	"github.com/xanzy/go-gitlab"
+  "code.gitea.io/sdk/gitea"
 )

-//go:generate counterfeiter . GitLab
+//go:generate counterfeiter . Gitea

-type GitLab interface {
-	ListTags() ([]*gitlab.Tag, error)
-	ListTagsUntil(tag_name string) ([]*gitlab.Tag, error)
-	GetTag(tag_name string) (*gitlab.Tag, error)
-	CreateTag(tag_name string, ref string) (*gitlab.Tag, error)
-	CreateRelease(tag_name string, description string) (*gitlab.Release, error)
-	UpdateRelease(tag_name string, description string) (*gitlab.Release, error)
-	UploadProjectFile(file string) (*gitlab.ProjectFile, error)
+type Gitea interface {
+	ListTags() ([]*gitea.Tag, error)
+	ListTagsUntil(tag_name string) ([]*gitea.Tag, error)
+	GetTag(tag_name string) (*gitea.Tag, error)
+	CreateTag(tag_name string, ref string) (*gitea.Tag, error)
+	CreateRelease(tag_name string, description string) (*gitea.Release, error)
+	UpdateRelease(tag_name string, description string) (*gitea.Release, error)
+	UploadProjectFile(file string) (*gitea.ProjectFile, error)
 	DownloadProjectFile(url, file string) error
 }

-type GitlabClient struct {
-	client *gitlab.Client
+type GiteaClient struct {
+	client *gitea.Client

 	accessToken string
 	repository  string
 }

-func NewGitLabClient(source Source) (*GitlabClient, error) {
+func NewGiteaClient(source Source) (*GiteaClient, error) {
 	var httpClient = &http.Client{}
 	var ctx = context.TODO()

@@ -49,40 +49,40 @@ func NewGitLabClient(source Source) (*GitlabClient, error) {
 		ctx = context.WithValue(ctx, oauth2.HTTPClient, httpClient)
 	}

-	client := gitlab.NewClient(httpClient, source.AccessToken)
+	client := gitea.NewClient(httpClient, source.AccessToken)

-	if source.GitLabAPIURL != "" {
+	if source.GiteaAPIURL != "" {
 		var err error
-		baseUrl, err := url.Parse(source.GitLabAPIURL)
+		baseUrl, err := url.Parse(source.GiteaAPIURL)
 		if err != nil {
 			return nil, err
 		}
 		client.SetBaseURL(baseUrl.String())
 	}

-	return &GitlabClient{
+	return &GiteaClient{
 		client:      client,
 		repository:  source.Repository,
 		accessToken: source.AccessToken,
 	}, nil
 }

-func (g *GitlabClient) ListTags() ([]*gitlab.Tag, error) {
-	var allTags []*gitlab.Tag
+func (g *GiteaClient) ListTags() ([]*gitea.Tag, error) {
+	var allTags []*gitea.Tag

-	opt := &gitlab.ListTagsOptions{
-		ListOptions: gitlab.ListOptions{
+	opt := &gitea.ListTagsOptions{
+		ListOptions: gitea.ListOptions{
 			PerPage: 100,
 			Page:    1,
 		},
-		OrderBy: gitlab.String("updated"),
-		Sort:    gitlab.String("desc"),
+		OrderBy: gitea.String("updated"),
+		Sort:    gitea.String("desc"),
 	}

 	for {
 		tags, res, err := g.client.Tags.ListTags(g.repository, opt)
 		if err != nil {
-			return []*gitlab.Tag{}, err
+			return []*gitea.Tag{}, err
 		}

 		allTags = append(allTags, tags...)
@@ -97,25 +97,25 @@ func (g *GitlabClient) ListTags() ([]*gitlab.Tag, error) {
 	return allTags, nil
 }

-func (g *GitlabClient) ListTagsUntil(tag_name string) ([]*gitlab.Tag, error) {
-	var allTags []*gitlab.Tag
+func (g *GiteaClient) ListTagsUntil(tag_name string) ([]*gitea.Tag, error) {
+	var allTags []*gitea.Tag

 	pageSize := 100

-	opt := &gitlab.ListTagsOptions{
-		ListOptions: gitlab.ListOptions{
+	opt := &gitea.ListTagsOptions{
+		ListOptions: gitea.ListOptions{
 			PerPage: pageSize,
 			Page:    1,
 		},
-		OrderBy: gitlab.String("updated"),
-		Sort:    gitlab.String("desc"),
+		OrderBy: gitea.String("updated"),
+		Sort:    gitea.String("desc"),
 	}

-	var foundTag *gitlab.Tag
+	var foundTag *gitea.Tag
 	for {
 		tags, res, err := g.client.Tags.ListTags(g.repository, opt)
 		if err != nil {
-			return []*gitlab.Tag{}, err
+			return []*gitea.Tag{}, err
 		}

 		skipToNextPage := false
@@ -167,10 +167,10 @@ func (g *GitlabClient) ListTagsUntil(tag_name string) ([]*gitlab.Tag, error) {
 	return allTags, nil
 }

-func (g *GitlabClient) GetTag(tag_name string) (*gitlab.Tag, error) {
+func (g *GiteaClient) GetTag(tag_name string) (*gitea.Tag, error) {
 	tag, res, err := g.client.Tags.GetTag(g.repository, tag_name)
 	if err != nil {
-		return &gitlab.Tag{}, err
+		return &gitea.Tag{}, err
 	}

 	err = res.Body.Close()
@@ -181,16 +181,16 @@ func (g *GitlabClient) GetTag(tag_name string) (*gitlab.Tag, error) {
 	return tag, nil
 }

-func (g *GitlabClient) CreateTag(ref string, tag_name string) (*gitlab.Tag, error) {
-	opt := &gitlab.CreateTagOptions{
-		TagName: gitlab.String(tag_name),
-		Ref:     gitlab.String(ref),
-		Message: gitlab.String(tag_name),
+func (g *GiteaClient) CreateTag(ref string, tag_name string) (*gitea.Tag, error) {
+	opt := &gitea.CreateTagOptions{
+		TagName: gitea.String(tag_name),
+		Ref:     gitea.String(ref),
+		Message: gitea.String(tag_name),
 	}

 	tag, res, err := g.client.Tags.CreateTag(g.repository, opt)
 	if err != nil {
-		return &gitlab.Tag{}, err
+		return &gitea.Tag{}, err
 	}

 	err = res.Body.Close()
@@ -201,17 +201,17 @@ func (g *GitlabClient) CreateTag(ref string, tag_name string) (*gitlab.Tag, erro
 	return tag, nil
 }

-func (g *GitlabClient) CreateRelease(tag_name string, description string) (*gitlab.Release, error) {
-	opt := &gitlab.CreateReleaseOptions{
-		Description: gitlab.String(description),
+func (g *GiteaClient) CreateRelease(tag_name string, description string) (*gitea.Release, error) {
+	opt := &gitea.CreateReleaseOptions{
+		Description: gitea.String(description),
 	}

 	release, res, err := g.client.Tags.CreateRelease(g.repository, tag_name, opt)
 	if err != nil {
-		return &gitlab.Release{}, err
+		return &gitea.Release{}, err
 	}

-	// https://docs.gitlab.com/ce/api/tags.html#create-a-new-release
+	// https://docs.gitea.com/ce/api/tags.html#create-a-new-release
 	// returns 409 if release already exists
 	if res.StatusCode == http.StatusConflict {
 		return nil, errors.New("release already exists")
@@ -225,14 +225,14 @@ func (g *GitlabClient) CreateRelease(tag_name string, description string) (*gitl
 	return release, nil
 }

-func (g *GitlabClient) UpdateRelease(tag_name string, description string) (*gitlab.Release, error) {
-	opt := &gitlab.UpdateReleaseOptions{
-		Description: gitlab.String(description),
+func (g *GiteaClient) UpdateRelease(tag_name string, description string) (*gitea.Release, error) {
+	opt := &gitea.UpdateReleaseOptions{
+		Description: gitea.String(description),
 	}

 	release, res, err := g.client.Tags.UpdateRelease(g.repository, tag_name, opt)
 	if err != nil {
-		return &gitlab.Release{}, err
+		return &gitea.Release{}, err
 	}

 	err = res.Body.Close()
@@ -243,10 +243,10 @@ func (g *GitlabClient) UpdateRelease(tag_name string, description string) (*gitl
 	return release, nil
 }

-func (g *GitlabClient) UploadProjectFile(file string) (*gitlab.ProjectFile, error) {
+func (g *GiteaClient) UploadProjectFile(file string) (*gitea.ProjectFile, error) {
 	projectFile, res, err := g.client.Projects.UploadFile(g.repository, file)
 	if err != nil {
-		return &gitlab.ProjectFile{}, err
+		return &gitea.ProjectFile{}, err
 	}

 	err = res.Body.Close()
@@ -257,7 +257,7 @@ func (g *GitlabClient) UploadProjectFile(file string) (*gitlab.ProjectFile, erro
 	return projectFile, nil
 }

-func (g *GitlabClient) DownloadProjectFile(filePath, destPath string) error {
+func (g *GiteaClient) DownloadProjectFile(filePath, destPath string) error {
 	out, err := os.Create(destPath)
 	if err != nil {
 		return err
@@ -270,10 +270,10 @@ func (g *GitlabClient) DownloadProjectFile(filePath, destPath string) error {
 		return err
 	}

-	// e.g. (https://gitlab-instance/api/v4) + (/group/project/uploads/hash/filename)
+	// e.g. (https://gitea-instance/api/v4) + (/group/project/uploads/hash/filename)
 	projectFileUrl := g.client.BaseURL().ResolveReference(filePathRef)

-	// https://gitlab.com/gitlab-org/gitlab-ce/issues/51447
+	// https://gitea.com/gitea-org/gitea-ce/issues/51447
 	nonApiUrl := strings.Replace(projectFileUrl.String(), "/api/v4", "", 1)
 	projectFileUrl, err = url.Parse(nonApiUrl)
 	if err != nil {
--- a/gitlab_test.go
+++ b/gitlab_test.go
@@ -3,18 +3,18 @@ package resource_test
 import (
 	"net/http"

-	. "github.com/edtan/gitlab-release-resource"
+	. "github.com/natto1784/gitea-release-resource"

 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

+	"code.gitea.io/sdk/gitea"
 	"github.com/onsi/gomega/ghttp"
-	"github.com/xanzy/go-gitlab"
 )

-var _ = Describe("GitLab Client", func() {
+var _ = Describe("Gitea Client", func() {
 	var server *ghttp.Server
-	var client *GitlabClient
+	var client *GiteaClient
 	var source Source

 	BeforeEach(func() {
@@ -22,10 +22,10 @@ var _ = Describe("GitLab Client", func() {
 	})

 	JustBeforeEach(func() {
-		source.GitLabAPIURL = server.URL()
+		source.GiteaAPIURL = server.URL()

 		var err error
-		client, err = NewGitLabClient(source)
+		client, err = NewGiteaClient(source)
 		Ω(err).ShouldNot(HaveOccurred())
 	})

@@ -39,9 +39,9 @@ var _ = Describe("GitLab Client", func() {
 		})

 		It("returns an error if the API URL is bad", func() {
-			source.GitLabAPIURL = ":"
+			source.GiteaAPIURL = ":"

-			_, err := NewGitLabClient(source)
+			_, err := NewGiteaClient(source)
 			Ω(err).Should(HaveOccurred())
 		})
 	})
@@ -104,7 +104,7 @@ var _ = Describe("GitLab Client", func() {
 			}
 		})

-		Context("When GitLab responds successfully", func() {
+		Context("When Gitea responds successfully", func() {
 			BeforeEach(func() {
 				server.AppendHandlers(
 					ghttp.CombineHandlers(
@@ -115,8 +115,8 @@ var _ = Describe("GitLab Client", func() {
 			})

 			It("Returns a populated github.Tag", func() {
-				expectedRelease := &gitlab.Tag{
-					Name: *gitlab.String("1"),
+				expectedRelease := &gitea.Tag{
+					Name: *gitea.String("1"),
 				}

 				release, err := client.GetTag("some-tag")
--- a/go.mod
+++ b/go.mod
@@ -1,4 +1,4 @@
-module github.com/edtan/gitlab-release-resource
+module github.com/natto1784/gitea-release-resource

 require (
 	github.com/concourse/github-release-resource v1.0.0
--- a/in_command.go
+++ b/in_command.go
@@ -8,11 +8,11 @@ import (
 	"path/filepath"
 	"strings"

-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"
 )

 type InCommand struct {
-	gitlab GitLab
+	gitea Gitea
 	writer io.Writer
 }

@@ -21,9 +21,9 @@ type attachment struct {
 	URL  string
 }

-func NewInCommand(gitlab GitLab, writer io.Writer) *InCommand {
+func NewInCommand(gitea Gitea, writer io.Writer) *InCommand {
 	return &InCommand{
-		gitlab: gitlab,
+		gitea: gitea,
 		writer: writer,
 	}
 }
@@ -34,9 +34,9 @@ func (c *InCommand) Run(destDir string, request InRequest) (InResponse, error) {
 		return InResponse{}, err
 	}

-	var foundTag *gitlab.Tag
+	var foundTag *gitea.Tag

-	foundTag, err = c.gitlab.GetTag(request.Version.Tag)
+	foundTag, err = c.gitea.GetTag(request.Version.Tag)
 	if err != nil {
 		return InResponse{}, err
 	}
@@ -108,7 +108,7 @@ func (c *InCommand) Run(destDir string, request InRequest) (InResponse, error) {
 			continue
 		}

-		err := c.gitlab.DownloadProjectFile(attachment.URL, path)
+		err := c.gitea.DownloadProjectFile(attachment.URL, path)
 		if err != nil {
 			return InResponse{}, err
 		}
--- a/in_command_test.go
+++ b/in_command_test.go
@@ -11,17 +11,16 @@ import (
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/ghttp"

-	"github.com/xanzy/go-gitlab"
-
-	"github.com/edtan/gitlab-release-resource"
-	"github.com/edtan/gitlab-release-resource/fakes"
+	"code.gitea.io/sdk/gitea"
+	"github.com/natto1784/gitea-release-resource"
+	"github.com/natto1784/gitea-release-resource/fakes"
 )

 var _ = Describe("In Command", func() {
 	var (
-		command      *resource.InCommand
-		gitlabClient *fakes.FakeGitLab
-		gitlabServer *ghttp.Server
+		command     *resource.InCommand
+		giteaClient *fakes.FakeGitea
+		giteaServer *ghttp.Server

 		inRequest resource.InRequest

@@ -35,16 +34,16 @@ var _ = Describe("In Command", func() {
 	BeforeEach(func() {
 		var err error

-		gitlabClient = &fakes.FakeGitLab{}
-		gitlabServer = ghttp.NewServer()
-		command = resource.NewInCommand(gitlabClient, ioutil.Discard)
+		giteaClient = &fakes.FakeGitea{}
+		giteaServer = ghttp.NewServer()
+		command = resource.NewInCommand(giteaClient, ioutil.Discard)

-		tmpDir, err = ioutil.TempDir("", "gitlab-release")
+		tmpDir, err = ioutil.TempDir("", "gitea-release")
 		Ω(err).ShouldNot(HaveOccurred())

 		destDir = filepath.Join(tmpDir, "destination")

-		gitlabClient.DownloadProjectFileReturns(nil)
+		giteaClient.DownloadProjectFileReturns(nil)

 		inRequest = resource.InRequest{}
 	})
@@ -53,19 +52,19 @@ var _ = Describe("In Command", func() {
 		Ω(os.RemoveAll(tmpDir)).Should(Succeed())
 	})

-	buildTag := func(sha, tag string) *gitlab.Tag {
-		return &gitlab.Tag{
-			Commit: &gitlab.Commit{
-				ID: *gitlab.String(sha),
+	buildTag := func(sha, tag string) *gitea.Tag {
+		return &gitea.Tag{
+			Commit: &gitea.Commit{
+				ID: *gitea.String(sha),
 			},
-			Name: *gitlab.String(tag),
+			Name: *gitea.String(tag),
 		}
 	}

 	Context("when there is a tagged release", func() {
 		Context("when a present version is specified", func() {
 			BeforeEach(func() {
-				gitlabClient.GetTagReturns(buildTag("v0.35.0", "abc123"), nil)
+				giteaClient.GetTagReturns(buildTag("v0.35.0", "abc123"), nil)

 				inRequest.Version = &resource.Version{
 					Tag: "v0.35.0",
@@ -103,18 +102,18 @@ var _ = Describe("In Command", func() {
 				It("calls #GetTag with the correct arguments", func() {
 					command.Run(destDir, inRequest)

-					Ω(gitlabClient.GetTagArgsForCall(0)).Should(Equal("v0.35.0"))
+					Ω(giteaClient.GetTagArgsForCall(0)).Should(Equal("v0.35.0"))
 				})

 				It("downloads only the files that match the globs", func() {
 					inResponse, inErr = command.Run(destDir, inRequest)

-					Expect(gitlabClient.DownloadProjectFileCallCount()).To(Equal(2))
-					arg1, arg2 := gitlabClient.DownloadProjectFileArgsForCall(0)
+					Expect(giteaClient.DownloadProjectFileCallCount()).To(Equal(2))
+					arg1, arg2 := giteaClient.DownloadProjectFileArgsForCall(0)
 					Ω(arg1).Should(Equal("example.txt"))
 					Ω(arg2).Should(Equal("path"))

-					arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(1)
+					arg1, arg2 = giteaClient.DownloadProjectFileArgsForCall(1)
 					Ω(arg1).Should(Equal("example.rtf"))
 					Ω(arg2).Should(Equal("path"))
 				})
@@ -144,7 +143,7 @@ var _ = Describe("In Command", func() {
 						inRequest.Source = resource.Source{
 							TagFilter: "package-(.*)",
 						}
-						gitlabClient.GetTagReturns(buildTag("package-0.35.0", "abc123"), nil)
+						giteaClient.GetTagReturns(buildTag("package-0.35.0", "abc123"), nil)
 						inResponse, inErr = command.Run(destDir, inRequest)
 					})

@@ -194,15 +193,15 @@ var _ = Describe("In Command", func() {
 				})

 				It("downloads all of the files", func() {
-					arg1, arg2 := gitlabClient.DownloadProjectFileArgsForCall(0)
+					arg1, arg2 := giteaClient.DownloadProjectFileArgsForCall(0)
 					Ω(arg1).Should(Equal("example.txt"))
 					Ω(arg2).Should(Equal("path"))

-					arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(1)
+					arg1, arg2 = giteaClient.DownloadProjectFileArgsForCall(1)
 					Ω(arg1).Should(Equal("example.rtf"))
 					Ω(arg2).Should(Equal("path"))

-					arg1, arg2 = gitlabClient.DownloadProjectFileArgsForCall(2)
+					arg1, arg2 = giteaClient.DownloadProjectFileArgsForCall(2)
 					Ω(arg1).Should(Equal("example.rtf"))
 					Ω(arg2).Should(Equal("path"))
 				})
@@ -210,7 +209,7 @@ var _ = Describe("In Command", func() {

 			Context("when downloading an asset fails", func() {
 				BeforeEach(func() {
-					gitlabClient.DownloadProjectFileReturns(errors.New("not this time"))
+					giteaClient.DownloadProjectFileReturns(errors.New("not this time"))
 					inResponse, inErr = command.Run(destDir, inRequest)
 				})

@@ -223,7 +222,7 @@ var _ = Describe("In Command", func() {

 	Context("when no tagged release is present", func() {
 		BeforeEach(func() {
-			gitlabClient.GetTagReturns(nil, nil)
+			giteaClient.GetTagReturns(nil, nil)

 			inRequest.Version = &resource.Version{
 				Tag: "v0.40.0",
@@ -241,7 +240,7 @@ var _ = Describe("In Command", func() {
 		disaster := errors.New("nope")

 		BeforeEach(func() {
-			gitlabClient.GetTagReturns(nil, disaster)
+			giteaClient.GetTagReturns(nil, disaster)

 			inRequest.Version = &resource.Version{
 				Tag: "some-tag",
--- a/metadata.go
+++ b/metadata.go
@@ -1,6 +1,6 @@
 package resource

-import "github.com/xanzy/go-gitlab"
+import "code.gitea.io/sdk/gitea"

 func metadataFromTag(tag *gitlab.Tag) []MetadataPair {
 	metadata := []MetadataPair{}
--- a/out_command.go
+++ b/out_command.go
@@ -10,13 +10,13 @@ import (
 )

 type OutCommand struct {
-	gitlab GitLab
+	gitea Gitea
 	writer io.Writer
 }

-func NewOutCommand(gitlab GitLab, writer io.Writer) *OutCommand {
+func NewOutCommand(gitea Gitea, writer io.Writer) *OutCommand {
 	return &OutCommand{
-		gitlab: gitlab,
+		gitea: gitea,
 		writer: writer,
 	}
 }
@@ -44,7 +44,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err
 	// }

 	tagExists := true
-	tag, err := c.gitlab.GetTag(tag_name)
+	tag, err := c.gitea.GetTag(tag_name)
 	if err != nil {
 		//TODO: improve the check to be based on the specific error
 		tagExists = false
@@ -56,7 +56,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err
 		if err != nil {
 			return OutResponse{}, err
 		}
-		tag, err = c.gitlab.CreateTag(targetCommitish, tag_name)
+		tag, err = c.gitea.CreateTag(targetCommitish, tag_name)
 		if err != nil {
 			return OutResponse{}, err
 		}
@@ -64,7 +64,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err

 	// create a new release if it doesn't exist yet
 	if tag.Release == nil {
-		_, err = c.gitlab.CreateRelease(tag_name, "Auto-generated from Concourse GitLab Release Resource")
+		_, err = c.gitea.CreateRelease(tag_name, "Auto-generated from Concourse Gitea Release Resource")
 		if err != nil {
 			return OutResponse{}, err
 		}
@@ -83,7 +83,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err
 		}

 		for _, filePath := range matches {
-			projectFile, err := c.gitlab.UploadProjectFile(filePath)
+			projectFile, err := c.gitea.UploadProjectFile(filePath)
 			if err != nil {
 				return OutResponse{}, err
 			}
@@ -92,7 +92,7 @@ func (c *OutCommand) Run(sourceDir string, request OutRequest) (OutResponse, err
 	}

 	// update the release
-	_, err = c.gitlab.UpdateRelease(tag_name, strings.Join(fileLinks, "\n"))
+	_, err = c.gitea.UpdateRelease(tag_name, strings.Join(fileLinks, "\n"))
 	if err != nil {
 		return OutResponse{}, errors.New("could not get saved tag")
 	}
--- a/out_command_test.go
+++ b/out_command_test.go
@@ -9,10 +9,10 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"

-	"github.com/edtan/gitlab-release-resource"
-	"github.com/edtan/gitlab-release-resource/fakes"
+	"github.com/natto1784/gitea-release-resource"
+	"github.com/natto1784/gitea-release-resource/fakes"
 )

 func file(path, contents string) {
@@ -22,7 +22,7 @@ func file(path, contents string) {
 var _ = Describe("Out Command", func() {
 	var (
 		command      *resource.OutCommand
-		gitlabClient *fakes.FakeGitLab
+		giteaClient *fakes.FakeGitea

 		sourcesDir string

@@ -32,22 +32,22 @@ var _ = Describe("Out Command", func() {
 	BeforeEach(func() {
 		var err error

-		gitlabClient = &fakes.FakeGitLab{}
-		command = resource.NewOutCommand(gitlabClient, ioutil.Discard)
+		giteaClient = &fakes.FakeGitea{}
+		command = resource.NewOutCommand(giteaClient, ioutil.Discard)

-		sourcesDir, err = ioutil.TempDir("", "gitlab-release")
+		sourcesDir, err = ioutil.TempDir("", "gitea-release")
 		Ω(err).ShouldNot(HaveOccurred())

-		gitlabClient.CreateReleaseStub = func(gh gitlab.Tag) (*gitlab.Tag, error) {
+		giteaClient.CreateReleaseStub = func(gh gitea.Tag) (*gitea.Tag, error) {
 			createdRel := gh
-			createdRel.ID = gitlab.Int(112)
-			createdRel.HTMLURL = gitlab.String("http://google.com")
-			createdRel.Name = gitlab.String("release-name")
-			createdRel.Body = gitlab.String("*markdown*")
+			createdRel.ID = gitea.Int(112)
+			createdRel.HTMLURL = gitea.String("http://google.com")
+			createdRel.Name = gitea.String("release-name")
+			createdRel.Body = gitea.String("*markdown*")
 			return &createdRel, nil
 		}

-		gitlabClient.UpdateReleaseStub = func(gh gitlab.Tag) (*gitlab.Tag, error) {
+		giteaClient.UpdateReleaseStub = func(gh gitea.Tag) (*gitea.Tag, error) {
 			return &gh, nil
 		}
 	})
@@ -57,34 +57,34 @@ var _ = Describe("Out Command", func() {
 	})

 	Context("when the release has already been created", func() {
-		existingAssets := []gitlab.ReleaseAsset{
+		existingAssets := []gitea.ReleaseAsset{
 			{
-				ID:   gitlab.Int(456789),
-				Name: gitlab.String("unicorns.txt"),
+				ID:   gitea.Int(456789),
+				Name: gitea.String("unicorns.txt"),
 			},
 			{
-				ID:    gitlab.Int(3450798),
-				Name:  gitlab.String("rainbows.txt"),
-				State: gitlab.String("new"),
+				ID:    gitea.Int(3450798),
+				Name:  gitea.String("rainbows.txt"),
+				State: gitea.String("new"),
 			},
 		}

-		existingReleases := []gitlab.Tag{
+		existingReleases := []gitea.Tag{
 			{
-				ID:    gitlab.Int(1),
-				Draft: gitlab.Bool(true),
+				ID:    gitea.Int(1),
+				Draft: gitea.Bool(true),
 			},
 			{
-				ID:      gitlab.Int(112),
-				TagName: gitlab.String("some-tag-name"),
-				Assets:  []gitlab.ReleaseAsset{existingAssets[0]},
-				Draft:   gitlab.Bool(false),
+				ID:      gitea.Int(112),
+				TagName: gitea.String("some-tag-name"),
+				Assets:  []gitea.ReleaseAsset{existingAssets[0]},
+				Draft:   gitea.Bool(false),
 			},
 		}

 		BeforeEach(func() {
-			gitlabClient.ListReleasesStub = func() ([]*gitlab.Tag, error) {
-				rels := []*gitlab.Tag{}
+			giteaClient.ListReleasesStub = func() ([]*gitea.Tag, error) {
+				rels := []*gitea.Tag{}
 				for _, r := range existingReleases {
 					c := r
 					rels = append(rels, &c)
@@ -93,8 +93,8 @@ var _ = Describe("Out Command", func() {
 				return rels, nil
 			}

-			gitlabClient.ListReleaseAssetsStub = func(gitlab.Tag) ([]*gitlab.ReleaseAsset, error) {
-				assets := []*gitlab.ReleaseAsset{}
+			giteaClient.ListReleaseAssetsStub = func(gitea.Tag) ([]*gitea.ReleaseAsset, error) {
+				assets := []*gitea.ReleaseAsset{}
 				for _, a := range existingAssets {
 					c := a
 					assets = append(assets, &c)
@@ -124,13 +124,13 @@ var _ = Describe("Out Command", func() {
 			_, err := command.Run(sourcesDir, request)
 			Ω(err).ShouldNot(HaveOccurred())

-			Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(1))
-			Ω(gitlabClient.ListReleaseAssetsArgsForCall(0)).Should(Equal(existingReleases[1]))
+			Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(1))
+			Ω(giteaClient.ListReleaseAssetsArgsForCall(0)).Should(Equal(existingReleases[1]))

-			Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(2))
+			Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(2))

-			Ω(gitlabClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0]))
-			Ω(gitlabClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1]))
+			Ω(giteaClient.DeleteReleaseAssetArgsForCall(0)).Should(Equal(existingAssets[0]))
+			Ω(giteaClient.DeleteReleaseAssetArgsForCall(1)).Should(Equal(existingAssets[1]))
 		})

 		Context("when not set as a draft release", func() {
@@ -142,9 +142,9 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1))
+				Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))

-				updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0)
+				updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
 				Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 				Ω(*updatedRelease.Draft).Should(Equal(false))
 			})
@@ -159,9 +159,9 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1))
+				Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))

-				updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0)
+				updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
 				Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 				Ω(*updatedRelease.Draft).Should(Equal(true))
 			})
@@ -176,9 +176,9 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1))
+				Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))

-				updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0)
+				updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
 				Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 				Ω(updatedRelease.Body).Should(BeNil())
 			})
@@ -189,12 +189,12 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1))
+				Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))

-				updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0)
+				updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
 				Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 				Ω(*updatedRelease.Body).Should(Equal("this is a great release"))
-				Ω(updatedRelease.TargetCommitish).Should(Equal(gitlab.String("")))
+				Ω(updatedRelease.TargetCommitish).Should(Equal(gitea.String("")))
 			})
 		})

@@ -209,12 +209,12 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UpdateReleaseCallCount()).Should(Equal(1))
+				Ω(giteaClient.UpdateReleaseCallCount()).Should(Equal(1))

-				updatedRelease := gitlabClient.UpdateReleaseArgsForCall(0)
+				updatedRelease := giteaClient.UpdateReleaseArgsForCall(0)
 				Ω(*updatedRelease.Name).Should(Equal("v0.3.12"))
 				Ω(*updatedRelease.Body).Should(Equal("this is a great release"))
-				Ω(updatedRelease.TargetCommitish).Should(Equal(gitlab.String("1z22f1")))
+				Ω(updatedRelease.TargetCommitish).Should(Equal(gitea.String("1z22f1")))
 			})
 		})
 	})
@@ -242,27 +242,27 @@ var _ = Describe("Out Command", func() {
 				request.Params.CommitishPath = "commitish"
 			})

-			It("creates a release on gitlab with the commitish", func() {
+			It("creates a release on gitea with the commitish", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

-				Ω(release.TargetCommitish).Should(Equal(gitlab.String("a2f4a3")))
+				Ω(release.TargetCommitish).Should(Equal(gitea.String("a2f4a3")))
 			})
 		})

 		Context("without a commitish", func() {
-			It("creates a release on gitlab without the commitish", func() {
+			It("creates a release on gitea without the commitish", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

-				// gitlab treats empty string the same as not suppying the field.
-				Ω(release.TargetCommitish).Should(Equal(gitlab.String("")))
+				// gitea treats empty string the same as not suppying the field.
+				Ω(release.TargetCommitish).Should(Equal(gitea.String("")))
 			})
 		})

@@ -273,12 +273,12 @@ var _ = Describe("Out Command", func() {
 				request.Params.BodyPath = "body"
 			})

-			It("creates a release on gitlab", func() {
+			It("creates a release on gitea", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("0.3.12"))
@@ -291,8 +291,8 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("0.3.12"))
@@ -304,8 +304,8 @@ var _ = Describe("Out Command", func() {
 			_, err := command.Run(sourcesDir, request)
 			Ω(err).ShouldNot(HaveOccurred())

-			Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-			release := gitlabClient.CreateReleaseArgsForCall(0)
+			Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+			release := giteaClient.CreateReleaseArgsForCall(0)

 			Ω(*release.Draft).Should(Equal(false))
 		})
@@ -318,12 +318,12 @@ var _ = Describe("Out Command", func() {
 				request.Source.PreRelease = true
 			})

-			It("creates a non-draft pre-release in gitlab", func() {
+			It("creates a non-draft pre-release in gitea", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("0.3.12"))
@@ -354,12 +354,12 @@ var _ = Describe("Out Command", func() {
 				request.Source.PreRelease = true
 			})

-			It("creates a final release in gitlab", func() {
+			It("creates a final release in gitea", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("0.3.12"))
@@ -388,12 +388,12 @@ var _ = Describe("Out Command", func() {
 				request.Source.Drafts = true
 			})

-			It("creates a release on gitlab in draft mode", func() {
+			It("creates a release on gitea in draft mode", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("0.3.12"))
@@ -445,8 +445,8 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(1))
-				release, name, file := gitlabClient.UploadReleaseAssetArgsForCall(0)
+				Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(1))
+				release, name, file := giteaClient.UploadReleaseAssetArgsForCall(0)

 				Ω(*release.ID).Should(Equal(112))
 				Ω(name).Should(Equal("great-file.tgz"))
@@ -479,23 +479,23 @@ var _ = Describe("Out Command", func() {
 			Context("when upload release asset fails", func() {
 				BeforeEach(func() {
 					existingAsset := false
-					gitlabClient.DeleteReleaseAssetStub = func(gitlab.ReleaseAsset) error {
+					giteaClient.DeleteReleaseAssetStub = func(gitea.ReleaseAsset) error {
 						existingAsset = false
 						return nil
 					}

-					gitlabClient.ListReleaseAssetsReturns([]*gitlab.ReleaseAsset{
+					giteaClient.ListReleaseAssetsReturns([]*gitea.ReleaseAsset{
 						{
-							ID:   gitlab.Int(456789),
-							Name: gitlab.String("great-file.tgz"),
+							ID:   gitea.Int(456789),
+							Name: gitea.String("great-file.tgz"),
 						},
 						{
-							ID:   gitlab.Int(3450798),
-							Name: gitlab.String("whatever.tgz"),
+							ID:   gitea.Int(3450798),
+							Name: gitea.String("whatever.tgz"),
 						},
 					}, nil)

-					gitlabClient.UploadReleaseAssetStub = func(rel gitlab.Tag, name string, file *os.File) error {
+					giteaClient.UploadReleaseAssetStub = func(rel gitea.Tag, name string, file *os.File) error {
 						Expect(ioutil.ReadAll(file)).To(Equal([]byte("matching")))
 						Expect(existingAsset).To(BeFalse())
 						existingAsset = true
@@ -507,17 +507,17 @@ var _ = Describe("Out Command", func() {
 					_, err := command.Run(sourcesDir, request)
 					Expect(err).To(Equal(errors.New("some-error")))

-					Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(10))
-					Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(10))
-					Ω(*gitlabClient.ListReleaseAssetsArgsForCall(9).ID).Should(Equal(112))
+					Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(10))
+					Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(10))
+					Ω(*giteaClient.ListReleaseAssetsArgsForCall(9).ID).Should(Equal(112))

-					actualRelease, actualName, actualFile := gitlabClient.UploadReleaseAssetArgsForCall(9)
+					actualRelease, actualName, actualFile := giteaClient.UploadReleaseAssetArgsForCall(9)
 					Ω(*actualRelease.ID).Should(Equal(112))
 					Ω(actualName).Should(Equal("great-file.tgz"))
 					Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz")))

-					Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(10))
-					actualAsset := gitlabClient.DeleteReleaseAssetArgsForCall(8)
+					Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(10))
+					actualAsset := giteaClient.DeleteReleaseAssetArgsForCall(8)
 					Expect(*actualAsset.ID).To(Equal(456789))
 				})

@@ -531,7 +531,7 @@ var _ = Describe("Out Command", func() {
 						results <- nil
 						results <- errors.New("6")

-						gitlabClient.UploadReleaseAssetStub = func(gitlab.Tag, string, *os.File) error {
+						giteaClient.UploadReleaseAssetStub = func(gitea.Tag, string, *os.File) error {
 							return <-results
 						}
 					})
@@ -540,17 +540,17 @@ var _ = Describe("Out Command", func() {
 						_, err := command.Run(sourcesDir, request)
 						Expect(err).ToNot(HaveOccurred())

-						Ω(gitlabClient.UploadReleaseAssetCallCount()).Should(Equal(5))
-						Ω(gitlabClient.ListReleaseAssetsCallCount()).Should(Equal(4))
-						Ω(*gitlabClient.ListReleaseAssetsArgsForCall(3).ID).Should(Equal(112))
+						Ω(giteaClient.UploadReleaseAssetCallCount()).Should(Equal(5))
+						Ω(giteaClient.ListReleaseAssetsCallCount()).Should(Equal(4))
+						Ω(*giteaClient.ListReleaseAssetsArgsForCall(3).ID).Should(Equal(112))

-						actualRelease, actualName, actualFile := gitlabClient.UploadReleaseAssetArgsForCall(4)
+						actualRelease, actualName, actualFile := giteaClient.UploadReleaseAssetArgsForCall(4)
 						Ω(*actualRelease.ID).Should(Equal(112))
 						Ω(actualName).Should(Equal("great-file.tgz"))
 						Ω(actualFile.Name()).Should(Equal(filepath.Join(sourcesDir, "great-file.tgz")))

-						Ω(gitlabClient.DeleteReleaseAssetCallCount()).Should(Equal(4))
-						actualAsset := gitlabClient.DeleteReleaseAssetArgsForCall(3)
+						Ω(giteaClient.DeleteReleaseAssetCallCount()).Should(Equal(4))
+						actualAsset := giteaClient.DeleteReleaseAssetArgsForCall(3)
 						Expect(*actualAsset.ID).To(Equal(456789))
 					})
 				})
@@ -578,8 +578,8 @@ var _ = Describe("Out Command", func() {
 				_, err := command.Run(sourcesDir, request)
 				Ω(err).ShouldNot(HaveOccurred())

-				Ω(gitlabClient.CreateReleaseCallCount()).Should(Equal(1))
-				release := gitlabClient.CreateReleaseArgsForCall(0)
+				Ω(giteaClient.CreateReleaseCallCount()).Should(Equal(1))
+				release := giteaClient.CreateReleaseArgsForCall(0)

 				Ω(*release.Name).Should(Equal("v0.3.12"))
 				Ω(*release.TagName).Should(Equal("version-0.3.12"))
--- a/resource_suite_test.go
+++ b/resource_suite_test.go
@@ -5,19 +5,19 @@ import (

 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"
 )

 func TestGithubReleaseResource(t *testing.T) {
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "GitLab Release Resource Suite")
+	RunSpecs(t, "Gitea Release Resource Suite")
 }

-func newTag(name, sha string) *gitlab.Tag {
-	return &gitlab.Tag{
-		Commit: &gitlab.Commit{
-			ID: *gitlab.String(sha),
+func newTag(name, sha string) *gitea.Tag {
+	return &gitea.Tag{
+		Commit: &gitea.Commit{
+			ID: *gitea.String(sha),
 		},
-		Name: *gitlab.String(name),
+		Name: *gitea.String(name),
 	}
 }
--- a/resources.go
+++ b/resources.go
@@ -3,7 +3,7 @@ package resource
 type Source struct {
 	Repository string `json:"repository"`

-	GitLabAPIURL string `json:"gitlab_api_url"`
+	GiteaAPIURL string `json:"gitea_api_url"`
 	AccessToken  string `json:"access_token"`
 	Insecure     bool   `json:"insecure"`

--- a/versions.go
+++ b/versions.go
@@ -3,7 +3,7 @@ package resource
 import (
 	"regexp"

-	"github.com/xanzy/go-gitlab"
+	"code.gitea.io/sdk/gitea"
 )

 var defaultTagFilter = "^v?([^v].*)"
@@ -31,7 +31,7 @@ func (vp *versionParser) parse(tag string) string {
 	return ""
 }

-func versionFromTag(tag *gitlab.Tag) Version {
+func versionFromTag(tag *gitea.Tag) Version {
 	return Version{
 		Tag:       tag.Name,
 		CommitSHA: tag.Commit.ID,