Read and store origin url when adding repo

* add Git trait abstraction and inject
* add test coverage for read/write url
* remove old unit test that's now covered with integration test
* update test.sh for remotes

I'm not super-happy with the toml layout, but the format I designed
isn't supported by toml.rs yet - see toml-rs/toml-rs#406

Author: timabell

src/git.rs

@@ -0,0 +1,34 @@
+use std::process::Command;
+
+pub trait Git {
+	fn read_url(&self, path: &str, remote_name: &str) -> String;
+}
+
+pub struct GitImpl {}
+
+impl Git for GitImpl {
+	/// hacky call to external git command to get url of origin
+	fn read_url(&self, path: &str, remote_name: &str) -> String {
+		repo_capture_exec(
+			&path,
+			"git",
+			&["config".to_string(), format!("remote.{}.url", remote_name)].to_vec(),
+		)
+		.trim()
+		.to_owned()
+	}
+}
+
+/// Run a command and capture the output for use internally
+fn repo_capture_exec(path: &str, cmd: &str, args: &Vec<String>) -> String {
+	let output = Command::new(cmd)
+		.args(args)
+		.current_dir(path)
+		.output()
+		.expect(&format!(
+			"Error running external command {} {:?} in folder {}",
+			cmd, args, path
+		));
+
+	String::from_utf8(output.stdout).expect("Error converting stdout to string")
+}

src/gitopolis.rs

@@ -1,19 +1,31 @@
+use crate::git::Git;
 use crate::repos::{Repo, Repos};
 use crate::storage::Storage;
+use log::info;
 use std::collections::BTreeMap;
 
 pub struct Gitopolis {
 	storage: Box<dyn Storage>,
+	git: Box<dyn Git>,
 }
 
 impl Gitopolis {
-	pub fn new(storage: Box<dyn Storage>) -> Gitopolis {
-		Gitopolis { storage }
+	pub fn new(storage: Box<dyn Storage>, git: Box<dyn Git>) -> Gitopolis {
+		Gitopolis { storage, git }
 	}
 
 	pub fn add(&mut self, repo_folders: &Vec<String>) {
 		let mut repos = self.load();
-		repos.add(repo_folders);
+		for repo_folder in repo_folders {
+			if let Some(_) = repos.repo_index(repo_folder) {
+				info!("{} already added, ignoring.", repo_folder);
+				continue;
+			}
+			// todo: read all remotes, not just origin https://github.com/timabell/gitopolis/i
+			let remote_name = "origin";
+			let url = self.git.read_url(&repo_folder, remote_name);
+			repos.add(repo_folder, url, remote_name);
+		}
 		self.save(repos)
 	}
 	pub fn remove(&mut self, repo_folders: &Vec<String>) {

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod exec;
+pub mod git;
 pub mod gitopolis;
 pub mod list;
 pub mod repos;

src/main.rs

@@ -1,5 +1,6 @@
 use clap::{Parser, Subcommand};
 use gitopolis::exec::exec;
+use gitopolis::git::GitImpl;
 use gitopolis::gitopolis::Gitopolis;
 use gitopolis::list::list;
 use gitopolis::storage::StorageImpl;
@@ -48,9 +49,12 @@ fn main() {
 
 	let args = Args::parse();
 
-	let mut gitopolis = Gitopolis::new(Box::new(StorageImpl {
-		path: ".gitopolis.toml",
-	}));
+	let mut gitopolis = Gitopolis::new(
+		Box::new(StorageImpl {
+			path: ".gitopolis.toml",
+		}),
+		Box::new(GitImpl {}),
+	);
 
 	match &args.command {
 		Some(Commands::Add { repo_folders }) => {

src/repos.rs

@@ -1,5 +1,6 @@
 use log::info;
 use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Repos {
@@ -11,7 +12,7 @@ pub struct Repos {
 pub struct Repo {
 	pub path: String,
 	pub tags: Vec<String>,
-	// pub remotes: Vec<Remote>,
+	pub remotes: BTreeMap<String, Remote>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -36,20 +37,23 @@ impl Repos {
 		self.repos.iter().position(|r| r.path == *folder_name)
 	}
 
-	pub fn add(&mut self, repo_folders: &Vec<String>) {
-		for repo_folder in repo_folders {
-			if let Some(_) = self.repo_index(repo_folder) {
-				info!("{} already added, ignoring.", repo_folder);
-				continue;
-			}
-			let repo = Repo {
-				path: repo_folder.to_owned(),
-				tags: Vec::new(),
-				// remotes: Vec::new(),
-			};
-			self.repos.push(repo);
-			info!("Added {}", repo_folder);
-		}
+	pub fn add(&mut self, repo_folder: &str, url: String, remote_name: &str) {
+		let mut remotes: BTreeMap<String, Remote> = BTreeMap::new();
+		remotes.insert(
+			remote_name.to_owned(),
+			Remote {
+				name: remote_name.to_owned(),
+				url: url.to_owned(),
+			},
+		);
+
+		let repo = Repo {
+			path: repo_folder.to_owned(),
+			tags: Vec::new(),
+			remotes,
+		};
+		self.repos.push(repo);
+		info!("Added {}", repo_folder);
 	}
 
 	pub fn remove(&mut self, repo_folders: &Vec<String>) {
@@ -82,18 +86,3 @@ impl Repos {
 		}
 	}
 }
-
-#[cfg(test)]
-mod tests {
-	use crate::repos::Repos;
-
-	#[test]
-	fn add() {
-		let mut repos = Repos::new();
-		let mut folders: Vec<String> = Vec::new();
-		folders.push("onions.git".to_owned());
-		folders.push("potatoes".to_owned());
-		repos.add(&folders);
-		assert_eq!(folders.len(), repos.repos.len());
-	}
-}

test.sh

@@ -1,14 +1,48 @@
-#!/bin/sh -v
-set -e
+#!/bin/sh
+# Hacky smoke test of whole thing, needs making proper
+set -e # stop on error
 
-if [ -f .gitopolis.toml ]; then
-	rm .gitopolis.toml
+# Arrange - make test folder & repos
+src=`pwd`
+exe="$src/target/debug/gitopolis"
+cd /tmp/
+
+test_folder=gitopolis_test
+if [ -d "$test_folder"  ]; then
+	rm -rf "$test_folder"
 fi
-cargo run help
-cargo run add foo bar "baz aroony" deleteme
-cargo run list
-cargo run remove deleteme
-cargo run tag red foo bar
-cargo run tag deadtag bar
-cargo run tag -r deadtag bar
+mkdir "$test_folder"
+cd "$test_folder"
+
+(
+	mkdir foo
+	cd foo
+	git init >> /dev/null
+	git remote add origin "[email protected]/some_repo.git"
+)
+
+# Act - try various commands
+echo "$exe help"
+eval "$exe help"
+echo
+
+echo "$exe add foo"
+eval "$exe add foo"
+eval "$exe tag RED foo"
+echo
+echo "====== .gitopolis.toml ======"
+cat .gitopolis.toml
+echo
+
+echo "$exe list"
+eval "$exe list"
+eval "$exe tag -r RED foo"
+echo
+echo "====== .gitopolis.toml ======"
+cat .gitopolis.toml
+echo
+
+echo "$exe remove foo"
+eval "$exe remove foo"
+echo "====== .gitopolis.toml ======"
 cat .gitopolis.toml

tests/gitopolis_tests.rs

@@ -1,43 +1,48 @@
+use gitopolis::git::Git;
 use gitopolis::gitopolis::Gitopolis;
-use gitopolis::repos::Repos;
 use gitopolis::storage::Storage;
 
 #[test]
 fn add_repo() {
 	let expected_toml = "[[repos]]
-path = \"foo\"
+path = \"test_repo\"
 tags = []
+[repos.remotes.origin]
+name = \"origin\"
+url = \"git://example.org/test_url\"
 ";
-	let mut gitopolis = Gitopolis::new(Box::new(FakeStorage {
-		exists: false,
-		contents: "".to_string(),
-		file_saved_callback: Box::new(|state| assert_eq!(expected_toml.to_owned(), state)),
-	}));
+	let mut gitopolis = Gitopolis::new(
+		Box::new(FakeStorage {
+			exists: false,
+			contents: "".to_string(),
+			file_saved_callback: Box::new(|state| assert_eq!(expected_toml.to_owned(), state)),
+		}),
+		Box::new(FakeGit {}),
+	);
 	let mut folders = Vec::new();
-	folders.push("foo".to_string());
+	folders.push("test_repo".to_string());
 	gitopolis.add(&folders);
 }
 
 #[test]
 fn read() {
-	let gitopolis = Gitopolis::new(Box::new(FakeStorage {
-		exists: true,
-		contents: "[[repos]]
-path = \"foo\"
-tags = [\"red\"]
-
-[[repos]]
-path = \"bar\"
-tags = [\"red\"]
-
-[[repos]]
-path = \"baz aroony\"
-tags = []"
+	let gitopolis = Gitopolis::new(
+		Box::new(FakeStorage {
+			exists: true,
+			contents: "[[repos]]
+path = \"test_repo\"
+tags = []
+[repos.remotes.origin]
+name = \"origin\"
+url = \"git://example.org/test_url\"\
+"
 			.to_string(),
-		file_saved_callback: Box::new(|_| {}),
-	}));
+			file_saved_callback: Box::new(|_| {}),
+		}),
+		Box::new(FakeGit {}),
+	);
 	let r = gitopolis.read();
-	assert_eq!(3, r.repos.len())
+	assert_eq!(1, r.repos.len())
 }
 
 struct FakeStorage {
@@ -59,3 +64,11 @@ impl Storage for FakeStorage {
 		self.contents.to_owned()
 	}
 }
+
+struct FakeGit {}
+
+impl Git for FakeGit {
+	fn read_url(&self, _path: &str, _remote_name: &str) -> String {
+		"git://example.org/test_url".to_string()
+	}
+}