use libgit for cloning; minor fixes

Author: medvednikov

git/libgit.v

@@ -47,6 +47,10 @@ struct C.git_error {
 
 [typedef]
 struct C.git_tree_entry {}
+struct C.git_clone_options {
+mut:
+	bare int
+}
 
 fn C.git_commit_message(voidptr) &char
 fn C.git_reference_lookup(&&C.git_reference, &C.git_repository, &char)
@@ -71,6 +75,8 @@ fn C.git_tree_entry_id(&C.git_tree_entry) &C.git_oid
 fn C.git_blob_rawcontent(&C.git_blob) voidptr
 fn C.git_blob_rawsize(&C.git_blob) int
 fn C.git_blob_free(&C.git_blob)
+fn C.git_clone(&&C.git_repository, &char, &char, &C.git_clone_options) int
+fn C.git_clone_options_init(&C.git_clone_options, int)
 
 fn init() {
 	C.git_libgit2_init()
@@ -151,19 +157,19 @@ fn (r Repo) log(p LogParams) []Commit {
 	return commits
 }
 
-fn new_repo(path string) Repo {
+pub fn new_repo(path string) &Repo {
 	repo_obj := &C.git_repository(unsafe { nil })
 	// ret := C.git_repository_init(&repo_obj, path.str, false)
 	ret := C.git_repository_open(&repo_obj, path.str)
 	println('ff ${ret}')
 	// git_reference_free(head_ref);
-	return Repo{
+	return &Repo{
 		obj: repo_obj
 		path: path
 	}
 }
 
-fn (r &Repo) current_branch() string {
+pub fn (r &Repo) current_branch() string {
 	head_ref := &C.git_reference(unsafe { nil })
 	C.git_reference_lookup(&head_ref, r.obj, c'HEAD')
 	symbolic_ref := C.git_reference_symbolic_target(head_ref)
@@ -223,6 +229,30 @@ pub fn (r &Repo) show_file_blob(branch string, file_path string) !string {
 	return ''
 }
 
+pub fn clone(url string, path string) {
+	mut r := new_repo(path)
+	r.clone(url, path)
+}
+
+pub fn (mut r Repo) clone(url string, path string) {
+	println('new clone url="${url}" path="${path}"')
+	// Clone options
+	mut clone_opts := C.git_clone_options{} //( unsafe{nil})
+	C.git_clone_options_init(&clone_opts, C.GIT_CLONE_OPTIONS_VERSION)
+
+	// Set the bare flag to create a bare repository
+	clone_opts.bare = 1
+
+	// Clone the repository
+	// r.git_repo = &C.git_repository(unsafe { nil })
+	ret := C.git_clone(&r.obj, url.str, path.str, &clone_opts)
+	if ret != 0 {
+		C.printf(c'Failed to clone: %s\n', C.git_error_last().message)
+	} else {
+		println('Bare repository cloned successfully!\n')
+	}
+}
+
 /*
 fn main() {
 	t0 := time.now()

src/issue_routes.v

@@ -84,11 +84,11 @@ pub fn (mut app App) issues(username string, repo_name string, page int) vweb.Re
 	}
 	mut first := false
 	mut last := false
-	if repo.open_issues_count > commits_per_page {
+	if repo.nr_open_issues > commits_per_page {
 		offset := page * commits_per_page
-		delta := repo.open_issues_count - offset
+		delta := repo.nr_open_issues - offset
 		if delta > 0 {
-			if delta == repo.open_issues_count && page == 0 {
+			if delta == repo.nr_open_issues && page == 0 {
 				first = true
 			} else {
 				last = true
@@ -98,7 +98,7 @@ pub fn (mut app App) issues(username string, repo_name string, page int) vweb.Re
 		last = true
 		first = true
 	}
-	page_count := calculate_pages(repo.open_issues_count, commits_per_page)
+	page_count := calculate_pages(repo.nr_open_issues, commits_per_page)
 	prev_page, next_page := generate_prev_next_pages(page)
 	return $vweb.html()
 }

src/repo.v

@@ -10,7 +10,6 @@ import validation
 
 struct Repo {
 	id                 int       [primary; sql: serial]
-	git_repo           &git.Repo [skip] // libgit wrapper repo
 	git_dir            string
 	name               string
 	user_id            int
@@ -21,24 +20,26 @@ struct Repo {
 	is_public          bool
 	users_contributed  []string  [skip]
 	users_authorized   []string  [skip]
-	topics_count       int       [skip]
+	nr_topics          int       [skip]
 	views_count        int
 	latest_update_hash string    [skip]
 	latest_activity    time.Time [skip]
 mut:
-	webhook_secret     string
-	tags_count         int
-	open_issues_count  int
-	open_prs_count     int
-	releases_count     int
-	branches_count     int
-	stars_count        int
-	lang_stats         []LangStat        [skip]
-	created_at         int
-	contributors_count int
-	labels             []Label           [skip]
-	status             RepoStatus        [skip]
-	msg_cache          map[string]string [skip]
+	git_repo        &git.Repo         [skip] // libgit wrapper repo
+	webhook_secret  string
+	tags_count      int
+	nr_open_issues  int               [orm: 'open_issues_count']
+	nr_open_prs     int               [orm: 'open_prs_count']
+	nr_releases     int               [orm: 'releases_count']
+	nr_branches     int               [orm: 'branches_count']
+	nr_tags         int
+	nr_stars        int               [orm: 'stars_count']
+	lang_stats      []LangStat        [skip]
+	created_at      int
+	nr_contributors int
+	labels          []Label           [skip]
+	status          RepoStatus        [skip]
+	msg_cache       map[string]string [skip]
 }
 
 // log_field_separator is declared as constant in case we need to change it later
@@ -74,32 +75,37 @@ fn (mut app App) save_repo(repo Repo) ! {
 	webhook_secret := repo.webhook_secret
 	tags_count := repo.tags_count
 	is_public := if repo.is_public { 1 } else { 0 }
-	open_issues_count := repo.open_issues_count
-	open_prs_count := repo.open_prs_count
-	branches_count := repo.branches_count
-	releases_count := repo.releases_count
-	stars_count := repo.stars_count
-	contributors_count := repo.contributors_count
+	open_issues_count := repo.nr_open_issues
+	open_prs_count := repo.nr_open_prs
+	branches_count := repo.nr_branches
+	releases_count := repo.nr_releases
+	stars_count := repo.nr_stars
+	contributors_count := repo.nr_contributors
+
+	// XTODO sql update all fields automatically
+	// repo.update()
 
 	sql app.db {
 		update Repo set description = desc, views_count = views_count, is_public = is_public,
-		webhook_secret = webhook_secret, tags_count = tags_count, open_issues_count = open_issues_count,
-		open_prs_count = open_prs_count, releases_count = releases_count, contributors_count = contributors_count,
-		stars_count = stars_count, branches_count = branches_count where id == id
+		webhook_secret = webhook_secret, tags_count = tags_count, nr_open_issues = open_issues_count,
+		nr_open_prs = open_prs_count, nr_releases = releases_count, nr_contributors = contributors_count,
+		nr_stars = stars_count, nr_branches = branches_count where id == id
 	}!
 }
 
 fn (app App) find_repo_by_name_and_user_id(repo_name string, user_id int) ?Repo {
 	repos := sql app.db {
 		select from Repo where name == repo_name && user_id == user_id limit 1
-	} or { []Repo{} }
+	} or { return none }
 
 	if repos.len == 0 {
 		return none
 	}
 
-	mut repo := repos.first()
+	mut repo := repos[0]
 	repo.lang_stats = app.find_repo_lang_stats(repo.id)
+	println('GIT DIR = ${repo.git_dir}')
+	repo.git_repo = git.new_repo(repo.git_dir)
 
 	return repo
 }
@@ -145,7 +151,7 @@ fn (app App) search_public_repos(query string) []Repo {
 			name: row.vals[1]
 			user_name: user.username
 			description: row.vals[3]
-			stars_count: row.vals[4].int()
+			nr_stars: row.vals[4].int()
 		}
 	}
 
@@ -175,13 +181,13 @@ fn (mut app App) increment_repo_views(repo_id int) ! {
 
 fn (mut app App) increment_repo_stars(repo_id int) ! {
 	sql app.db {
-		update Repo set stars_count = stars_count + 1 where id == repo_id
+		update Repo set nr_stars = nr_stars + 1 where id == repo_id
 	}!
 }
 
 fn (mut app App) decrement_repo_stars(repo_id int) ! {
 	sql app.db {
-		update Repo set stars_count = stars_count - 1 where id == repo_id
+		update Repo set nr_stars = nr_stars - 1 where id == repo_id
 	}!
 }
 
@@ -199,7 +205,7 @@ fn (mut app App) set_repo_webhook_secret(repo_id int, secret string) ! {
 
 fn (mut app App) increment_repo_issues(repo_id int) ! {
 	sql app.db {
-		update Repo set open_issues_count = open_issues_count + 1 where id == repo_id
+		update Repo set nr_open_issues = nr_open_issues + 1 where id == repo_id
 	}!
 }
 
@@ -254,9 +260,9 @@ fn (mut app App) update_repo_from_fs(mut repo Repo) ! {
 
 	app.db.exec('BEGIN TRANSACTION')!
 
-	repo.analyse_lang(app)!
+	repo.analyze_lang(app)!
 
-	app.info(repo.contributors_count.str())
+	app.info(repo.nr_contributors.str())
 	app.fetch_branches(repo)!
 
 	branches_output := repo.git('branch -a')
@@ -267,14 +273,14 @@ fn (mut app App) update_repo_from_fs(mut repo Repo) ! {
 		app.update_repo_branch_from_fs(mut repo, branch_name)!
 	}
 
-	repo.contributors_count = app.get_count_repo_contributors(repo_id)!
-	repo.branches_count = app.get_count_repo_branches(repo_id)
+	repo.nr_contributors = app.get_count_repo_contributors(repo_id)!
+	repo.nr_branches = app.get_count_repo_branches(repo_id)
 
 	// TODO: TEMPORARY - UNTIL WE GET PERSISTENT RELEASE INFO
 	for tag in app.get_all_repo_tags(repo_id) {
 		app.add_release(tag.id, repo_id, time.unix(tag.created_at), tag.message)!
 
-		repo.releases_count++
+		repo.nr_releases++
 	}
 
 	app.save_repo(repo)!
@@ -329,9 +335,9 @@ fn (mut app App) update_repo_from_remote(mut repo Repo) ! {
 
 	app.db.exec('BEGIN TRANSACTION')!
 
-	repo.analyse_lang(app)!
+	repo.analyze_lang(app)!
 
-	app.info(repo.contributors_count.str())
+	app.info(repo.nr_contributors.str())
 	app.fetch_branches(repo)!
 	app.fetch_tags(repo)!
 
@@ -345,12 +351,11 @@ fn (mut app App) update_repo_from_remote(mut repo Repo) ! {
 
 	for tag in app.get_all_repo_tags(repo_id) {
 		app.add_release(tag.id, repo_id, time.unix(tag.created_at), tag.message)!
-
-		repo.releases_count++
+		repo.nr_releases++
 	}
 
-	repo.contributors_count = app.get_count_repo_contributors(repo_id)!
-	repo.branches_count = app.get_count_repo_branches(repo_id)
+	repo.nr_contributors = app.get_count_repo_contributors(repo_id)!
+	repo.nr_branches = app.get_count_repo_branches(repo_id)
 
 	app.save_repo(repo)!
 	app.db.exec('END TRANSACTION')!
@@ -404,7 +409,7 @@ fn (mut app App) update_repo_after_push(repo_id int, branch_name string) ! {
 	app.delete_repository_files_in_branch(repo_id, branch_name)!
 }
 
-fn (r &Repo) analyse_lang(app &App) ! {
+fn (r &Repo) analyze_lang(app &App) ! {
 	file_paths := r.get_all_file_paths()
 
 	mut all_size := 0
@@ -760,6 +765,15 @@ fn (mut app App) update_repo_primary_branch(repo_id int, branch string) ! {
 }
 
 fn (mut r Repo) clone() {
+	if r.git_repo != unsafe { nil } {
+		r.git_repo.clone(r.clone_url, r.git_dir)
+	} else {
+		println('nil')
+	}
+
+	/*
+	cmd := 'git clone --bare "${r.clone_url}" ${r.git_dir}'
+	println('CLONE() ${cmd}')
 	clone_result := os.execute('git clone --bare "${r.clone_url}" ${r.git_dir}')
 	close_exit_code := clone_result.exit_code
 
@@ -768,17 +782,22 @@ fn (mut r Repo) clone() {
 		println('git clone failed with exit code ${close_exit_code}')
 		return
 	}
+	*/
 
 	r.status = .clone_done
 }
 
 fn (r &Repo) read_file(branch string, path string) string {
 	// valid_path := path.trim_string_left('/')
 
-	println('yEPP')
+	println('yEPP path=${valid_path}')
+	if r.git_repo == unsafe { nil } {
+		return 'nil'
+	}
 	t := time.now()
 	// s := r.git('--no-pager show ${branch}:${valid_path}')
-	s := r.git_repo.show_file_blob(branch, path) or { '' }
+
+	s := r.git_repo.show_file_blob(branch, valid_path) or { '' }
 	println(time.since(t))
 	println(':)')
 	return s