This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12564

rust-revlog: make `IndexEntryBuilder` build a whole entry
Needs ReviewPublic

Authored by martinvonz on Sat, Apr 16, 1:47 AM.

Download Raw Diff

Details

Reviewers

None

Group Reviewers

hg-reviewers

Summary

The IndexEntryBuilder we have in tests only built part of a revlog
entry before this patch. It's more useful if it can build a full
entry. As part of fixing that, I also added a (non-test)
IndexEntry::link_revision().

Diff Detail

Repository

rHG Mercurial

Branch

default

Lint

No Linters Available

Unit

No Unit Test Coverage

Event Timeline

martinvonz created this revision.Sat, Apr 16, 1:47 AM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptSat, Apr 16, 1:47 AM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

martinvonz added a child revision: D12565: rust-revlog: add tests for p1/p2 getters, as promised in D12442.Sat, Apr 16, 1:47 AM

Revision Contents
Changeset List

			Path	Packages
M			rust/hg-core/src/revlog/index.rs (88 lines)

Commit	Parents	Author	Summary	Date
e65ba8a86274	a88de419d502	Martin von Zweigbergk		Fri, Apr 15, 9:20 PM

Status	Author	Revision
Needs Review	martinvonz	D12494 [RFC] rust-revlog: create nodemap on the fly if it's not persisted
Needs Review	martinvonz	D12424 rust: upgrade zstd from 0.5.3 to 0.11.1
Accepted	martinvonz	D12548 changelog: avoid copying changeset data into `ChangesetRevisionData`
Accepted	martinvonz	D12486 rust-nodemap: remove unnecessary explicit lifetime
Needs Review	martinvonz	D12565 rust-revlog: add tests for p1/p2 getters, as promised in D12442
Needs Review	martinvonz	D12564 rust-revlog: make `IndexEntryBuilder` build a whole entry
Needs Review	martinvonz	D12563 rust-revlog: change default version from 2 to 1 in test builder
Needs Review	martinvonz	D12562 rust-repo: extract a function for checking nodemap requirement
Needs Review	martinvonz	D12561 rust-revlog: make `Changelog` and `ManifestLog` unaware of `Repo`
Closed	martinvonz	D12442 rust-revlog: add methods for getting parent revs and entries
Accepted	martinvonz	D12547 rust-revlog: make unaware of `Repo`
Accepted	martinvonz	D12558 rust-filelog: don't use persistent nodemap (to match Python)
Needs Review	martinvonz	D12546 rust-revlog: move check for nodemap requirement to caller
Accepted	martinvonz	D12545 rust-nodemap-docket: make unaware of `Repo`
Accepted	martinvonz	D12544 rust-nodemap-docket: move check of nodemap requirement to caller
Closed	martinvonz	D12439 rust-changelog: start parsing changeset data
Closed	martinvonz	D12438 rust-changelog: remove special parsing of empty changelog data for null rev
Closed	martinvonz	D12426 rust-changelog: don't skip empty lines when iterating over changeset lines
Closed	martinvonz	D12425 rust-requirements: allow loading repos with `bookmarksinstore` requirement

Diff 33188

rust/hg-core/src/revlog/index.rs

	/// Return the revision upon which the data has been derived.			/// Return the revision upon which the data has been derived.
	pub fn base_revision_or_base_of_delta_chain(&self) -> Revision {			pub fn base_revision_or_base_of_delta_chain(&self) -> Revision {
	// TODO Maybe return an Option when base_revision == rev?			// TODO Maybe return an Option when base_revision == rev?
	// Requires to add rev to IndexEntry			// Requires to add rev to IndexEntry

	BigEndian::read_i32(&self.bytes[16..])			BigEndian::read_i32(&self.bytes[16..])
	}			}

				pub fn link_revision(&self) -> Revision {
				BigEndian::read_i32(&self.bytes[20..])
				}

	pub fn p1(&self) -> Revision {			pub fn p1(&self) -> Revision {
	BigEndian::read_i32(&self.bytes[24..])			BigEndian::read_i32(&self.bytes[24..])
	}			}

	pub fn p2(&self) -> Revision {			pub fn p2(&self) -> Revision {
	BigEndian::read_i32(&self.bytes[28..])			BigEndian::read_i32(&self.bytes[28..])
	}			}

	/// Return the hash of revision's full text.			/// Return the hash of revision's full text.
	///			///
	/// Currently, SHA-1 is used and only the first 20 bytes of this field			/// Currently, SHA-1 is used and only the first 20 bytes of this field
	/// are used.			/// are used.
	pub fn hash(&self) -> &'a Node {			pub fn hash(&self) -> &'a Node {
	(&self.bytes[32..52]).try_into().unwrap()			(&self.bytes[32..52]).try_into().unwrap()
	}			}
	}			}

	#[cfg(test)]			#[cfg(test)]
	mod tests {			mod tests {
	use super::*;			use super::*;
				use crate::node::NULL_NODE;

	#[cfg(test)]			#[cfg(test)]
	#[derive(Debug, Copy, Clone)]			#[derive(Debug, Copy, Clone)]
	pub struct IndexEntryBuilder {			pub struct IndexEntryBuilder {
	is_first: bool,			is_first: bool,
	is_inline: bool,			is_inline: bool,
	is_general_delta: bool,			is_general_delta: bool,
	version: u16,			version: u16,
	offset: usize,			offset: usize,
	compressed_len: usize,			compressed_len: usize,
	uncompressed_len: usize,			uncompressed_len: usize,
	base_revision_or_base_of_delta_chain: Revision,			base_revision_or_base_of_delta_chain: Revision,
				link_revision: Revision,
				p1: Revision,
				p2: Revision,
				node: Node,
	}			}

	#[cfg(test)]			#[cfg(test)]
	impl IndexEntryBuilder {			impl IndexEntryBuilder {
	pub fn new() -> Self {			pub fn new() -> Self {
	Self {			Self {
	is_first: false,			is_first: false,
	is_inline: false,			is_inline: false,
	is_general_delta: true,			is_general_delta: true,
	version: 1,			version: 1,
	offset: 0,			offset: 0,
	compressed_len: 0,			compressed_len: 0,
	uncompressed_len: 0,			uncompressed_len: 0,
	base_revision_or_base_of_delta_chain: 0,			base_revision_or_base_of_delta_chain: 0,
				link_revision: 0,
				p1: NULL_REVISION,
				p2: NULL_REVISION,
				node: NULL_NODE,
	}			}
	}			}

	pub fn is_first(&mut self, value: bool) -> &mut Self {			pub fn is_first(&mut self, value: bool) -> &mut Self {
	self.is_first = value;			self.is_first = value;
	self			self
	}			}

	pub fn with_base_revision_or_base_of_delta_chain(			pub fn with_base_revision_or_base_of_delta_chain(
	&mut self,			&mut self,
	value: Revision,			value: Revision,
	) -> &mut Self {			) -> &mut Self {
	self.base_revision_or_base_of_delta_chain = value;			self.base_revision_or_base_of_delta_chain = value;
	self			self
	}			}

				pub fn with_link_revision(&mut self, value: Revision) -> &mut Self {
				self.link_revision = value;
				self
				}

				pub fn with_p1(&mut self, value: Revision) -> &mut Self {
				self.p1 = value;
				self
				}

				pub fn with_p2(&mut self, value: Revision) -> &mut Self {
				self.p2 = value;
				self
				}

				pub fn with_node(&mut self, value: Node) -> &mut Self {
				self.node = value;
				self
				}

	pub fn build(&self) -> Vec<u8> {			pub fn build(&self) -> Vec<u8> {
	let mut bytes = Vec::with_capacity(INDEX_ENTRY_SIZE);			let mut bytes = Vec::with_capacity(INDEX_ENTRY_SIZE);
	if self.is_first {			if self.is_first {
	bytes.extend(&match (self.is_general_delta, self.is_inline) {			bytes.extend(&match (self.is_general_delta, self.is_inline) {
	(false, false) => [0u8, 0],			(false, false) => [0u8, 0],
	(false, true) => [0u8, 1],			(false, true) => [0u8, 1],
	(true, false) => [0u8, 2],			(true, false) => [0u8, 2],
	(true, true) => [0u8, 3],			(true, true) => [0u8, 3],
	});			});
	bytes.extend(&self.version.to_be_bytes());			bytes.extend(&self.version.to_be_bytes());
	// Remaining offset bytes.			// Remaining offset bytes.
	bytes.extend(&[0u8; 2]);			bytes.extend(&[0u8; 2]);
	} else {			} else {
	// Offset stored on 48 bits (6 bytes)			// Offset stored on 48 bits (6 bytes)
	bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);			bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);
	}			}
	bytes.extend(&[0u8; 2]); // Revision flags.			bytes.extend(&[0u8; 2]); // Revision flags.
	bytes.extend(&(self.compressed_len as u32).to_be_bytes());			bytes.extend(&(self.compressed_len as u32).to_be_bytes());
	bytes.extend(&(self.uncompressed_len as u32).to_be_bytes());			bytes.extend(&(self.uncompressed_len as u32).to_be_bytes());
	bytes.extend(			bytes.extend(
	&self.base_revision_or_base_of_delta_chain.to_be_bytes(),			&self.base_revision_or_base_of_delta_chain.to_be_bytes(),
	);			);
				bytes.extend(&self.link_revision.to_be_bytes());
				bytes.extend(&self.p1.to_be_bytes());
				bytes.extend(&self.p2.to_be_bytes());
				bytes.extend(self.node.as_bytes());
				bytes.extend(vec![0u8; 12]);
	bytes			bytes
	}			}
	}			}

	pub fn is_inline(index_bytes: &[u8]) -> bool {			pub fn is_inline(index_bytes: &[u8]) -> bool {
	IndexHeader::parse(index_bytes)			IndexHeader::parse(index_bytes)
	.expect("too short")			.expect("too short")
	.format_flags()			.format_flags()
	bytes: &bytes,			bytes: &bytes,
	offset_override: None,			offset_override: None,
	};			};

	assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1)			assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1)
	}			}

	#[test]			#[test]
				fn link_revision_test() {
				let bytes = IndexEntryBuilder::new().with_link_revision(123).build();

				let entry = IndexEntry {
				bytes: &bytes,
				offset_override: None,
				};

				assert_eq!(entry.link_revision(), 123);
				}

				#[test]
				fn p1_test() {
				let bytes = IndexEntryBuilder::new().with_p1(123).build();

				let entry = IndexEntry {
				bytes: &bytes,
				offset_override: None,
				};

				assert_eq!(entry.p1(), 123);
				}

				#[test]
				fn p2_test() {
				let bytes = IndexEntryBuilder::new().with_p2(123).build();

				let entry = IndexEntry {
				bytes: &bytes,
				offset_override: None,
				};

				assert_eq!(entry.p2(), 123);
				}

				#[test]
				fn node_test() {
				let node = Node::from_hex("0123456789012345678901234567890123456789")
				.unwrap();
				let bytes = IndexEntryBuilder::new().with_node(node).build();

				let entry = IndexEntry {
				bytes: &bytes,
				offset_override: None,
				};

				assert_eq!(*entry.hash(), node);
				}

				#[test]
	fn version_test() {			fn version_test() {
	let bytes = IndexEntryBuilder::new()			let bytes = IndexEntryBuilder::new()
	.is_first(true)			.is_first(true)
	.with_version(2)			.with_version(2)
	.build();			.build();

	assert_eq!(get_version(&bytes), 2)			assert_eq!(get_version(&bytes), 2)
	}			}
	}			}

	#[cfg(test)]			#[cfg(test)]
	pub use tests::IndexEntryBuilder;			pub use tests::IndexEntryBuilder;

Diff	ID	Base	Description	Created	Lint	Unit
Base			Base
Diff 1	33188			Sat, Apr 16, 1:47 AM	★	★