gitten.rs

mod configuration;
mod errors;
mod git;

use crate::errors::{ Result };
use crate::git::{ Git, GitObjectKind, GitObjectMetadata, Oid, Repository, RepositoryExtensions };

use axum::{ Router, serve };
use axum::extract::{ Path, State };
use axum::response::{ Html, };
use axum::routing::{ get };
use serde::{ Serialize };
use tera::{ Context, Tera };
use tokio::net::{ TcpListener };
use tower_http::services::{ ServeDir };
use tower_http::trace::{ TraceLayer };

use std::process::{ ExitCode };
use std::sync::{ Arc };

// -------------------------------------------------------------------------------------------------
// Application -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

#[tokio::main]
async fn main() -> ExitCode {
	let result = run_server().await;

	match result {
		Ok(_) => ExitCode::SUCCESS,
		Err(e) => {
			eprintln!("{}", e);
			ExitCode::FAILURE
		},
	}
}

struct ApplicationState {
	application_name: String,
	git: Git,
	tera: Tera,
}

async fn run_server() -> Result<()> {
	let configuration = configuration::configure()?;

	// Configure the shared server state object
	let application_state = ApplicationState {
		application_name: configuration.application_name.clone(),
		git: Git::open(std::path::Path::new(&configuration.git_root))?,
		tera: Tera::new("templates/**/*.tera.html")?,
	};

	// Define the application routing structure
	let router = Router::new()
		.layer(TraceLayer::new_for_http())
		.route("/", get(index_handler))
		.route("/repository/:repository", get(repository_handler))
		.route("/repository/:repository/tree/:tree", get(tree_handler))
		.route("/repository/:repository/blob/:blob", get(blob_handler))
		.nest_service("/static", ServeDir::new("static"))
		.with_state(Arc::new(application_state));

	// Bind to an address
	let address = format!("{}:{}", configuration.network_host, configuration.network_port);
	let listener = TcpListener::bind(address).await?;
	tracing::debug!("{} v0.1.0 now listening on {}", configuration.application_name, listener.local_addr()?);

	// Start the server
	serve(listener, router).await?;
	Ok(())
}

// -------------------------------------------------------------------------------------------------
// Route handlers ----------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

async fn index_handler(State(application_state): State<Arc<ApplicationState>>) -> Result<Html<String>> {
	let context = index_context(&application_state)?;
	let html = application_state.tera.render("index.tera.html", &context)?;
	Ok(Html(html))
}

async fn repository_handler(
	State(application_state): State<Arc<ApplicationState>>,
	Path(repository_name): Path<String>,
) -> Result<Html<String>> {
	let repository = application_state.git.find_repository_by_name(&repository_name)?;
	let context = repository_context(&application_state, &repository)?;

	let html = if repository.is_empty()? {
		application_state.tera.render("empty_repository.tera.html", &context)?
	} else {
		application_state.tera.render("repository.tera.html", &context)?
	};

	Ok(Html(html))
}

async fn tree_handler(
	State(application_state): State<Arc<ApplicationState>>,
	Path((repository_name, tree_id)): Path<(String, String)>,
) -> Result<Html<String>> {
	let repository = application_state.git.find_repository_by_name(&repository_name)?;
	let tree_id = Oid::from_str(&tree_id)?;
	let context = tree_context(&application_state, &repository, tree_id)?;
	let html = application_state.tera.render("tree.tera.html", &context)?;
	Ok(Html(html))
}

async fn blob_handler(
	State(application_state): State<Arc<ApplicationState>>,
	Path((repository_name, blob_id)): Path<(String, String)>,
) -> Result<Html<String>> {
	let repository = application_state.git.find_repository_by_name(&repository_name)?;
	let blob_id = Oid::from_str(&blob_id)?;
	let context = blob_context(&application_state, &repository, blob_id)?;
	let html = application_state.tera.render("blob.tera.html", &context)?;
	Ok(Html(html))
}

// -------------------------------------------------------------------------------------------------
// Template contexts -------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

#[derive(Serialize)]
struct ApplicationContext {
	name: String,
}

#[derive(Serialize)]
struct IndexContext {
	repositories: Vec<RepositoryMetadata>,
}

#[derive(Serialize)]
struct RepositoryContext {
	name: String,
	trees: Vec<GitObjectMetadata>,
	blobs: Vec<GitObjectMetadata>,
}

#[derive(Serialize)]
struct TreeContext {
	path: String,
	trees: Vec<GitObjectMetadata>,
	blobs: Vec<GitObjectMetadata>,
}

#[derive(Serialize)]
struct BlobContext {
	path: String,
	text: String,
	lines: Vec<String>,
}

#[derive(Serialize)]
struct RepositoryMetadata {
	name: String,
	link: String,
}

fn index_context(application_state: &ApplicationState) -> Result<Context> {
	let mut context = Context::new();

	let application_context = ApplicationContext {
		name: application_state.application_name.clone(),
	};

	let index_context = IndexContext {
		repositories: application_state.git.repositories()?.map(|r| {
			let repo_name = r?.name()?;
			Ok(RepositoryMetadata {
				name: repo_name.clone(),
				link: format!("/repository/{}", repo_name),
			})
		}).collect::<Result<Vec<RepositoryMetadata>>>()?,
	};

	context.insert("application", &application_context);
	context.insert("index", &index_context);

	Ok(context)
}

fn repository_context(application_state: &ApplicationState, repository: &Repository) -> Result<Context> {
	let mut context = Context::new();

	let head_content = if !repository.is_empty()? {
		repository
			.list_tree_by_commit_name("HEAD")?
			.into_iter()
			.collect()
	} else {
		Vec::new()
	};

	let trees = head_content
		.iter()
		.filter(|object| object.kind == GitObjectKind::Tree)
		.map(|object| object.clone())
		.collect::<Vec<_>>();

	let blobs = head_content
		.iter()
		.filter(|object| object.kind == GitObjectKind::Blob)
		.map(|object| object.clone())
		.collect::<Vec<_>>();

	let application_context = ApplicationContext {
		name: application_state.application_name.clone(),
	};

	let repository_context = RepositoryContext {
		name: repository.name()?,
		trees,
		blobs,
	};

	context.insert("application", &application_context);
	context.insert("repository", &repository_context);

	Ok(context)
}

fn tree_context(application_state: &ApplicationState, repository: &Repository, tree_id: Oid) -> Result<Context> {
	let mut context = Context::new();

	let tree_path = format!("{}/{}", repository.name()?, tree_id);
	let tree_content = repository
		.list_tree_by_id(tree_id)?
		.into_iter()
		.collect::<Vec<_>>();

	let trees = tree_content
		.iter()
		.filter(|object| object.kind == GitObjectKind::Tree)
		.map(|object| object.clone())
		.collect::<Vec<_>>();

	let blobs = tree_content
		.iter()
		.filter(|object| object.kind == GitObjectKind::Blob)
		.map(|object| object.clone())
		.collect::<Vec<_>>();

	let application_context = ApplicationContext {
		name: application_state.application_name.clone(),
	};

	let tree_context = TreeContext {
		path: tree_path,
		trees,
		blobs,
	};

	context.insert("application", &application_context);
	context.insert("tree", &tree_context);

	Ok(context)
}

fn blob_context(application_state: &ApplicationState, repository: &Repository, blob_id: Oid) -> Result<Context> {
	let mut context = Context::new();

	let blob_path = format!("{}/{}", repository.name()?, blob_id);
	let blob_text = repository.get_blob_text_by_id(blob_id)?;
	let blob_lines = {
		let mut line = 1;

		blob_text
			.lines()
			.map(|_| {
				let next = line;
				line += 1;
				next.to_string()
			})
			.collect::<Vec<_>>()
	};

	let application_context = ApplicationContext {
		name: application_state.application_name.clone(),
	};

	let blob_context = BlobContext {
		path: blob_path,
		text: blob_text,
		lines: blob_lines,
	};

	context.insert("application", &application_context);
	context.insert("blob", &blob_context);

	Ok(context)
}