feat: functioning incremental pushes and pulls

Author: nitsky

packages/cli/src/lib.rs

@@ -127,18 +127,12 @@ enum Command {
 
 	Download(self::blob::download::Args),
 
-	#[command(hide = true)]
-	Export(self::object::export::Args),
-
 	Format(self::package::format::Args),
 
 	Get(self::get::Args),
 
 	Health(self::health::Args),
 
-	#[command(hide = true)]
-	Import(self::object::import::Args),
-
 	Init(self::package::init::Args),
 
 	#[command(alias = "ls")]
@@ -456,7 +450,7 @@ impl Cli {
 			build_indexer: None,
 			database,
 			messenger: tangram_server::config::Messenger::default(),
-			object_indexer: None,
+			object_indexer: Some(tangram_server::config::ObjectIndexer::default()),
 			path,
 			store: None,
 			url,
@@ -844,11 +838,9 @@ impl Cli {
 			Command::Clean(args) => self.command_clean(args).boxed(),
 			Command::Document(args) => self.command_package_document(args).boxed(),
 			Command::Download(args) => self.command_blob_download(args).boxed(),
-			Command::Export(args) => self.command_object_export(args).boxed(),
 			Command::Format(args) => self.command_package_format(args).boxed(),
 			Command::Get(args) => self.command_get(args).boxed(),
 			Command::Health(args) => self.command_health(args).boxed(),
-			Command::Import(args) => self.command_object_import(args).boxed(),
 			Command::Init(args) => self.command_package_init(args).boxed(),
 			Command::List(args) => self.command_tag_list(args).boxed(),
 			Command::Log(args) => self.command_build_log(args).boxed(),
@@ -1062,7 +1054,7 @@ impl Cli {
 			None
 		};
 		let default = crate::config::Tracing {
-	    filter: "tangram=info,tangram_client=info,tangram_database=info,tangram_server=info,tangram_vfs=info".to_owned(),
+	    filter: "tangram_cli=info,tangram_client=info,tangram_database=info,tangram_server=info,tangram_vfs=info".to_owned(),
 	    format: Some(crate::config::TracingFormat::Pretty),
 		};
 		let output_layer = config

packages/cli/src/object.rs

@@ -1,9 +1,7 @@
 use crate::Cli;
 use tangram_client as tg;
 
-pub mod export;
 pub mod get;
-pub mod import;
 pub mod metadata;
 pub mod pull;
 pub mod push;
@@ -19,9 +17,7 @@ pub struct Args {
 
 #[derive(Clone, Debug, clap::Subcommand)]
 pub enum Command {
-	Export(self::export::Args),
 	Get(self::get::Args),
-	Import(self::import::Args),
 	Metadata(self::metadata::Args),
 	Pull(self::pull::Args),
 	Push(self::push::Args),
@@ -31,15 +27,9 @@ pub enum Command {
 impl Cli {
 	pub async fn command_object(&self, args: Args) -> tg::Result<()> {
 		match args.command {
-			Command::Export(args) => {
-				self.command_object_export(args).await?;
-			},
 			Command::Get(args) => {
 				self.command_object_get(args).await?;
 			},
-			Command::Import(args) => {
-				self.command_object_import(args).await?;
-			},
 			Command::Metadata(args) => {
 				self.command_object_metadata(args).await?;
 			},

packages/cli/src/object/export.rs

@@ -1,9 +1,10 @@
-use crate::Cli;
+use crate::{viewer::clip, Cli};
 use crossterm::{self as ct, style::Stylize as _};
-use futures::{stream::TryStreamExt as _, Stream};
+use futures::{Stream, StreamExt as _};
 use indexmap::IndexMap;
 use num::ToPrimitive as _;
 use std::{
+	fmt::Write as _,
 	io::{IsTerminal as _, Write as _},
 	pin::pin,
 };
@@ -15,7 +16,6 @@ impl Cli {
 		&self,
 		stream: impl Stream<Item = tg::Result<tg::progress::Event<T>>>,
 	) -> tg::Result<T> {
-		let mut indicators = IndexMap::new();
 		let mut tty = std::io::stderr();
 		let mut stream = pin!(stream);
 
@@ -27,8 +27,14 @@ impl Cli {
 				.ok_or_else(|| tg::error!("stream ended without output"));
 		}
 
+		let mut indicators = IndexMap::new();
 		let mut lines = None;
-		while let Some(event) = stream.try_next().await? {
+		while let Some(result) = stream.next().await {
+			// Get the size of the tty.
+			let size = ct::terminal::size().map_or((64, 64), |(columns, rows)| {
+				(columns.to_usize().unwrap(), rows.to_usize().unwrap())
+			});
+
 			// Clear the indicators.
 			if let Some(lines) = lines {
 				ct::queue!(
@@ -39,6 +45,11 @@ impl Cli {
 				.unwrap();
 			}
 
+			let event = match result {
+				Ok(event) => event,
+				Err(error) => return Err(error),
+			};
+
 			match event {
 				tg::progress::Event::Log(log) => {
 					if let Some(level) = log.level {
@@ -78,8 +89,73 @@ impl Cli {
 			}
 
 			// Render the indicators.
+			let title_length = indicators
+				.values()
+				.map(|indicator| indicator.title.len())
+				.max();
+			let now = std::time::SystemTime::now()
+				.duration_since(std::time::UNIX_EPOCH)
+				.unwrap()
+				.as_millis();
 			for indicator in indicators.values() {
-				writeln!(tty, "{indicator}").unwrap();
+				const LENGTH: u64 = 20;
+				const SPINNER: [char; 10] = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+				let position = (now / (1000 / 10)) % 10;
+				let position = position.to_usize().unwrap();
+				let spinner = crossterm::style::Stylize::blue(SPINNER[position]);
+				let mut line = String::new();
+				write!(line, "{spinner} ").unwrap();
+				write!(
+					tty,
+					"{:title_length$} ",
+					indicator.title,
+					title_length = title_length.unwrap(),
+				)
+				.unwrap();
+				if let (Some(current), Some(total)) = (indicator.current, indicator.total) {
+					write!(line, " [").unwrap();
+					let last = current * LENGTH / total;
+					for _ in 0..last {
+						write!(line, "=").unwrap();
+					}
+					if current < total {
+						write!(line, ">").unwrap();
+					} else {
+						write!(line, "=").unwrap();
+					}
+					for _ in last..LENGTH {
+						write!(line, " ").unwrap();
+					}
+					write!(line, "]").unwrap();
+				}
+				if let Some(current) = indicator.current {
+					match indicator.format {
+						tg::progress::IndicatorFormat::Normal => {
+							write!(line, " {current}").unwrap();
+						},
+						tg::progress::IndicatorFormat::Bytes => {
+							let current = byte_unit::Byte::from_u64(current)
+								.get_appropriate_unit(byte_unit::UnitType::Decimal);
+							write!(line, " {current:#.1}").unwrap();
+						},
+					}
+					if let Some(total) = indicator.total {
+						match indicator.format {
+							tg::progress::IndicatorFormat::Normal => {
+								write!(line, " of {total}").unwrap();
+							},
+							tg::progress::IndicatorFormat::Bytes => {
+								let total = byte_unit::Byte::from_u64(total)
+									.get_appropriate_unit(byte_unit::UnitType::Decimal);
+								write!(line, " of {total:#.1}").unwrap();
+							},
+						}
+						let percent = 100.0 * current.to_f64().unwrap() / total.to_f64().unwrap();
+						write!(line, " {percent:.2}%").unwrap();
+					}
+				}
+				let line = clip(&line, size.0);
+				writeln!(tty, "{line}").unwrap();
 			}
 			lines = Some(indicators.len().to_u16().unwrap());
 

packages/cli/src/object/import.rs

@@ -349,15 +349,15 @@ fn render_block_and_get_area(title: &str, focused: bool, area: Rect, buf: &mut B
 		.unwrap_or(area)
 }
 
-fn clip(string: &str, mut width: usize) -> &str {
-	let mut boundary = 0;
+pub(crate) fn clip(string: &str, mut width: usize) -> &str {
+	let mut len = 0;
 	let mut chars = string.chars();
 	while width > 0 {
 		let Some(char) = chars.next() else {
 			break;
 		};
-		boundary += char.len_utf8();
+		len += char.len_utf8();
 		width = width.saturating_sub(char.width().unwrap_or(0));
 	}
-	&string[0..boundary]
+	&string[0..len]
 }