14 use crate::dirstate::DirstateV2Data;

    15 use crate::dirstate::ParentFileData;

    22 use crate::DirstateMapError;

    41 #[derive(Debug)]

    77 #[derive(Debug)]

    83 #[derive(Debug)]

    89 #[derive(Debug)]

    95 #[derive(Debug)]

   407 #[derive(Debug)]

   429         match self {

   430             NodeData::Entry(entry) => Some(entry),

   431             _ => None,

   432         }

   433     }

   434 

   435     fn as_entry_mut(&mut self) -> Option<&mut DirstateEntry> {

   550     /// `each_ancestor` is a callback that is called for each ancestor node

   551     /// when descending the tree. It is used to keep the different counters

   552     /// of the `DirstateMap` up-to-date.

   553     fn get_node_mut<'tree>(

   554         &'tree mut self,

   555         path: &HgPath,

   556         each_ancestor: impl FnMut(&mut Node),

   557     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {

   558         Self::get_node_mut_inner(

   559             self.on_disk,

   560             &mut self.unreachable_bytes,

   561             &mut self.root,

   562             path,

   563             each_ancestor,

   564         )

   565     }

   566 

   567     /// Lower-level version of `get_node_mut`.

   568     ///

   580         mut each_ancestor: impl FnMut(&mut Node),

   592                     each_ancestor(child);

  1339                 |_ancestor| {},

  1429     }

  1430 

  1431     /// Only public because it needs to be exposed to the Python layer.

  1432     /// It is not the full `setparents` logic, only the parts that mutate the

  1433     /// entries.

  1434     pub fn setparents_fixup(

  1435         &mut self,

  1436     ) -> Result<Vec<(HgPathBuf, HgPathBuf)>, DirstateV2ParseError> {

  1437         // XXX

  1438         // All the copying and re-querying is quite inefficient, but this is

  1439         // still a lot better than doing it from Python.

  1440         //

  1441         // The better solution is to develop a mechanism for `iter_mut`,

  1442         // which will be a lot more involved: we're dealing with a lazy,

  1443         // append-mostly, tree-like data structure. This will do for now.

  1444         let mut copies = vec![];

  1445         let mut files_with_p2_info = vec![];

  1446         for res in self.iter() {

  1447             let (path, entry) = res?;

  1448             if entry.p2_info() {

  1449                 files_with_p2_info.push(path.to_owned())

  1450             }

  1451         }

  1452         self.with_dmap_mut(|map| {

  1453             for path in files_with_p2_info.iter() {

  1454                 let node = map.get_or_insert_node(path, |_| {})?;

  1455                 let entry =

  1456                     node.data.as_entry_mut().expect("entry should exist");

  1457                 entry.drop_merge_data();

  1458                 if let Some(source) = node.copy_source.take().as_deref() {

  1459                     copies.push((path.to_owned(), source.to_owned()));

  1460                 }

  1461             }

  1462             Ok(copies)

  1463         })

  1493 #[cfg(test)]

  1494 mod tests {

  1495     use super::*;

  1496 

  1497     /// Shortcut to return tracked descendants of a path.

  1498     /// Panics if the path does not exist.

  1499     fn tracked_descendants(map: &OwningDirstateMap, path: &[u8]) -> u32 {

  1500         let path = dbg!(HgPath::new(path));

  1501         let node = map.get_map().get_node(path);

  1502         node.unwrap().unwrap().tracked_descendants_count()

  1503     }

  1504 

  1505     /// Shortcut to return descendants with an entry.

  1506     /// Panics if the path does not exist.

  1507     fn descendants_with_an_entry(map: &OwningDirstateMap, path: &[u8]) -> u32 {

  1508         let path = dbg!(HgPath::new(path));

  1509         let node = map.get_map().get_node(path);

  1510         node.unwrap().unwrap().descendants_with_entry_count()

  1511     }

  1512 

  1513     fn assert_does_not_exist(map: &OwningDirstateMap, path: &[u8]) {

  1514         let path = dbg!(HgPath::new(path));

  1515         let node = map.get_map().get_node(path);

  1516         assert!(node.unwrap().is_none());

  1517     }

  1518 

  1519     /// Shortcut for path creation in tests

  1520     fn p(b: &[u8]) -> &HgPath {

  1521         HgPath::new(b)

  1522     }

  1523 

  1524     /// Test the very simple case a single tracked file

  1525     #[test]

  1526     fn test_tracked_descendants_simple() -> Result<(), DirstateError> {

  1527         let mut map = OwningDirstateMap::new_empty(vec![]);

  1528         assert_eq!(map.len(), 0);

  1529 

  1530         map.set_tracked(p(b"some/nested/path"))?;

  1531 

  1532         assert_eq!(map.len(), 1);

  1533         assert_eq!(tracked_descendants(&map, b"some"), 1);

  1534         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);

  1535         assert_eq!(tracked_descendants(&map, b"some/nested/path"), 0);

  1536 

  1537         map.set_untracked(p(b"some/nested/path"))?;

  1538         assert_eq!(map.len(), 0);

  1539         assert!(map.get_map().get_node(p(b"some"))?.is_none());

  1540 

  1541         Ok(())

  1542     }

  1543 

  1544     /// Test the simple case of all tracked, but multiple files

  1545     #[test]

  1546     fn test_tracked_descendants_multiple() -> Result<(), DirstateError> {

  1547         let mut map = OwningDirstateMap::new_empty(vec![]);

  1548 

  1549         map.set_tracked(p(b"some/nested/path"))?;

  1550         map.set_tracked(p(b"some/nested/file"))?;

  1551         // one layer without any files to test deletion cascade

  1552         map.set_tracked(p(b"some/other/nested/path"))?;

  1553         map.set_tracked(p(b"root_file"))?;

  1554         map.set_tracked(p(b"some/file"))?;

  1555         map.set_tracked(p(b"some/file2"))?;

  1556         map.set_tracked(p(b"some/file3"))?;

  1557 

  1558         assert_eq!(map.len(), 7);

  1559         assert_eq!(tracked_descendants(&map, b"some"), 6);

  1560         assert_eq!(tracked_descendants(&map, b"some/nested"), 2);

  1561         assert_eq!(tracked_descendants(&map, b"some/other"), 1);

  1562         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);

  1563         assert_eq!(tracked_descendants(&map, b"some/nested/path"), 0);

  1564 

  1565         map.set_untracked(p(b"some/nested/path"))?;

  1566         assert_eq!(map.len(), 6);

  1567         assert_eq!(tracked_descendants(&map, b"some"), 5);

  1568         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);

  1569         assert_eq!(tracked_descendants(&map, b"some/other"), 1);

  1570         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);

  1571 

  1572         map.set_untracked(p(b"some/nested/file"))?;

  1573         assert_eq!(map.len(), 5);

  1574         assert_eq!(tracked_descendants(&map, b"some"), 4);

  1575         assert_eq!(tracked_descendants(&map, b"some/other"), 1);

  1576         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);

  1577         assert_does_not_exist(&map, b"some_nested");

  1578 

  1579         map.set_untracked(p(b"some/other/nested/path"))?;

  1580         assert_eq!(map.len(), 4);

  1581         assert_eq!(tracked_descendants(&map, b"some"), 3);

  1582         assert_does_not_exist(&map, b"some/other");

  1583 

  1584         map.set_untracked(p(b"root_file"))?;

  1585         assert_eq!(map.len(), 3);

  1586         assert_eq!(tracked_descendants(&map, b"some"), 3);

  1587         assert_does_not_exist(&map, b"root_file");

  1588 

  1589         map.set_untracked(p(b"some/file"))?;

  1590         assert_eq!(map.len(), 2);

  1591         assert_eq!(tracked_descendants(&map, b"some"), 2);

  1592         assert_does_not_exist(&map, b"some/file");

  1593 

  1594         map.set_untracked(p(b"some/file2"))?;

  1595         assert_eq!(map.len(), 1);

  1596         assert_eq!(tracked_descendants(&map, b"some"), 1);

  1597         assert_does_not_exist(&map, b"some/file2");

  1598 

  1599         map.set_untracked(p(b"some/file3"))?;

  1600         assert_eq!(map.len(), 0);

  1601         assert_does_not_exist(&map, b"some/file3");

  1602 

  1603         Ok(())

  1604     }

  1605 

  1606     /// Check with a mix of tracked and non-tracked items

  1607     #[test]

  1608     fn test_tracked_descendants_different() -> Result<(), DirstateError> {

  1609         let mut map = OwningDirstateMap::new_empty(vec![]);

  1610 

  1611         // A file that was just added

  1612         map.set_tracked(p(b"some/nested/path"))?;

  1613         // This has no information, the dirstate should ignore it

  1614         map.reset_state(p(b"some/file"), false, false, false, false, None)?;

  1615         assert_does_not_exist(&map, b"some/file");

  1616 

  1617         // A file that was removed

  1618         map.reset_state(

  1619             p(b"some/nested/file"),

  1620             false,

  1621             true,

  1622             false,

  1623             false,

  1624             None,

  1625         )?;

  1626         assert!(!map.get(p(b"some/nested/file"))?.unwrap().tracked());

  1627         // Only present in p2

  1628         map.reset_state(p(b"some/file3"), false, false, true, false, None)?;

  1629         assert!(!map.get(p(b"some/file3"))?.unwrap().tracked());

  1630         // A file that was merged

  1631         map.reset_state(p(b"root_file"), true, true, true, false, None)?;

  1632         assert!(map.get(p(b"root_file"))?.unwrap().tracked());

  1633         // A file that is added, with info from p2

  1634         // XXX is that actually possible?

  1635         map.reset_state(p(b"some/file2"), true, false, true, false, None)?;

  1636         assert!(map.get(p(b"some/file2"))?.unwrap().tracked());

  1637         // A clean file

  1638         // One layer without any files to test deletion cascade

  1639         map.reset_state(

  1640             p(b"some/other/nested/path"),

  1641             true,

  1642             true,

  1643             false,

  1644             false,

  1645             None,

  1646         )?;

  1647         assert!(map.get(p(b"some/other/nested/path"))?.unwrap().tracked());

  1648 

  1649         assert_eq!(map.len(), 6);

  1650         assert_eq!(tracked_descendants(&map, b"some"), 3);

  1651         assert_eq!(descendants_with_an_entry(&map, b"some"), 5);

  1652         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);

  1653         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);

  1654         assert_eq!(tracked_descendants(&map, b"some/other/nested/path"), 0);

  1655         assert_eq!(

  1656             descendants_with_an_entry(&map, b"some/other/nested/path"),

  1657             0

  1658         );

  1659         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);

  1660         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);

  1661 

  1662         // might as well check this

  1663         map.set_untracked(p(b"path/does/not/exist"))?;

  1664         assert_eq!(map.len(), 6);

  1665 

  1666         map.set_untracked(p(b"some/other/nested/path"))?;

  1667         // It is set untracked but not deleted since it held other information

  1668         assert_eq!(map.len(), 6);

  1669         assert_eq!(tracked_descendants(&map, b"some"), 2);

  1670         assert_eq!(descendants_with_an_entry(&map, b"some"), 5);

  1671         assert_eq!(descendants_with_an_entry(&map, b"some/other"), 1);

  1672         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);

  1673         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);

  1674         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);

  1675 

  1676         map.set_untracked(p(b"some/nested/path"))?;

  1677         // It is set untracked *and* deleted since it was only added

  1678         assert_eq!(map.len(), 5);

  1679         assert_eq!(tracked_descendants(&map, b"some"), 1);

  1680         assert_eq!(descendants_with_an_entry(&map, b"some"), 4);

  1681         assert_eq!(tracked_descendants(&map, b"some/nested"), 0);

  1682         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 1);

  1683         assert_does_not_exist(&map, b"some/nested/path");

  1684 

  1685         map.set_untracked(p(b"root_file"))?;

  1686         // Untracked but not deleted

  1687         assert_eq!(map.len(), 5);

  1688         assert!(map.get(p(b"root_file"))?.is_some());

  1689 

  1690         map.set_untracked(p(b"some/file2"))?;

  1691         assert_eq!(map.len(), 5);

  1692         assert_eq!(tracked_descendants(&map, b"some"), 0);

  1693         assert!(map.get(p(b"some/file2"))?.is_some());

  1694 

  1695         map.set_untracked(p(b"some/file3"))?;

  1696         assert_eq!(map.len(), 5);

  1697         assert_eq!(tracked_descendants(&map, b"some"), 0);

  1698         assert!(map.get(p(b"some/file3"))?.is_some());

  1699 

  1700         Ok(())

  1701     }

  1702 

  1703     /// Check that copies counter is correctly updated

  1704     #[test]

  1705     fn test_copy_source() -> Result<(), DirstateError> {

  1706         let mut map = OwningDirstateMap::new_empty(vec![]);

  1707 

  1708         // Clean file

  1709         map.reset_state(p(b"files/clean"), true, true, false, false, None)?;

  1710         // Merged file

  1711         map.reset_state(p(b"files/from_p2"), true, true, true, false, None)?;

  1712         // Removed file

  1713         map.reset_state(p(b"removed"), false, true, false, false, None)?;

  1714         // Added file

  1715         map.reset_state(p(b"files/added"), true, false, false, false, None)?;

  1716         // Add copy

  1717         map.copy_map_insert(p(b"files/clean"), p(b"clean_copy_source"))?;

  1718         assert_eq!(map.copy_map_len(), 1);

  1719 

  1720         // Copy override

  1721         map.copy_map_insert(p(b"files/clean"), p(b"other_clean_copy_source"))?;

  1722         assert_eq!(map.copy_map_len(), 1);

  1723 

  1724         // Multiple copies

  1725         map.copy_map_insert(p(b"removed"), p(b"removed_copy_source"))?;

  1726         assert_eq!(map.copy_map_len(), 2);

  1727 

  1728         map.copy_map_insert(p(b"files/added"), p(b"added_copy_source"))?;

  1729         assert_eq!(map.copy_map_len(), 3);

  1730 

  1731         // Added, so the entry is completely removed

  1732         map.set_untracked(p(b"files/added"))?;

  1733         assert_does_not_exist(&map, b"files/added");

  1734         assert_eq!(map.copy_map_len(), 2);

  1735 

  1736         // Removed, so the entry is kept around, so is its copy

  1737         map.set_untracked(p(b"removed"))?;

  1738         assert!(map.get(p(b"removed"))?.is_some());

  1739         assert_eq!(map.copy_map_len(), 2);

  1740 

  1741         // Clean, so the entry is kept around, but not its copy

  1742         map.set_untracked(p(b"files/clean"))?;

  1743         assert!(map.get(p(b"files/clean"))?.is_some());

  1744         assert_eq!(map.copy_map_len(), 1);

  1745 

  1746         map.copy_map_insert(p(b"files/from_p2"), p(b"from_p2_copy_source"))?;

  1747         assert_eq!(map.copy_map_len(), 2);

  1748 

  1749         // Info from p2, so its copy source info is kept around

  1750         map.set_untracked(p(b"files/from_p2"))?;

  1751         assert!(map.get(p(b"files/from_p2"))?.is_some());

  1752         assert_eq!(map.copy_map_len(), 2);

  1753 

  1754         Ok(())

  1755     }

  1756 

  1757     /// Test with "on disk" data. For the sake of this test, the "on disk" data

  1758     /// does not actually come from the disk, but it's opaque to the code being

  1759     /// tested.

  1760     #[test]

  1761     fn test_on_disk() -> Result<(), DirstateError> {

  1762         // First let's create some data to put "on disk"

  1763         let mut map = OwningDirstateMap::new_empty(vec![]);

  1764 

  1765         // A file that was just added

  1766         map.set_tracked(p(b"some/nested/added"))?;

  1767         map.copy_map_insert(p(b"some/nested/added"), p(b"added_copy_source"))?;

  1768 

  1769         // A file that was removed

  1770         map.reset_state(

  1771             p(b"some/nested/removed"),

  1772             false,

  1773             true,

  1774             false,

  1775             false,

  1776             None,

  1777         )?;

  1778         // Only present in p2

  1779         map.reset_state(

  1780             p(b"other/p2_info_only"),

  1781             false,

  1782             false,

  1783             true,

  1784             false,

  1785             None,

  1786         )?;

  1787         map.copy_map_insert(

  1788             p(b"other/p2_info_only"),

  1789             p(b"other/p2_info_copy_source"),

  1790         )?;

  1791         // A file that was merged

  1792         map.reset_state(p(b"merged"), true, true, true, false, None)?;

  1793         // A file that is added, with info from p2

  1794         // XXX is that actually possible?

  1795         map.reset_state(

  1796             p(b"other/added_with_p2"),

  1797             true,

  1798             false,

  1799             true,

  1800             false,

  1801             None,

  1802         )?;

  1803         // One layer without any files to test deletion cascade

  1804         // A clean file

  1805         map.reset_state(

  1806             p(b"some/other/nested/clean"),

  1807             true,

  1808             true,

  1809             false,

  1810             false,

  1811             None,

  1812         )?;

  1813 

  1814         let (packed, metadata, _should_append, _old_data_size) =

  1815             map.pack_v2(false)?;

  1816         let packed_len = packed.len();

  1817         assert!(packed_len > 0);

  1818 

  1819         // Recreate "from disk"

  1820         let mut map = OwningDirstateMap::new_v2(

  1821             packed,

  1822             packed_len,

  1823             metadata.as_bytes(),

  1824         )?;

  1825 

  1826         // Check that everything is accounted for

  1827         assert!(map.contains_key(p(b"some/nested/added"))?);

  1828         assert!(map.contains_key(p(b"some/nested/removed"))?);

  1829         assert!(map.contains_key(p(b"merged"))?);

  1830         assert!(map.contains_key(p(b"other/p2_info_only"))?);

  1831         assert!(map.contains_key(p(b"other/added_with_p2"))?);

  1832         assert!(map.contains_key(p(b"some/other/nested/clean"))?);

  1833         assert_eq!(

  1834             map.copy_map_get(p(b"some/nested/added"))?,

  1835             Some(p(b"added_copy_source"))

  1836         );

  1837         assert_eq!(

  1838             map.copy_map_get(p(b"other/p2_info_only"))?,

  1839             Some(p(b"other/p2_info_copy_source"))

  1840         );

  1841         assert_eq!(tracked_descendants(&map, b"some"), 2);

  1842         assert_eq!(descendants_with_an_entry(&map, b"some"), 3);

  1843         assert_eq!(tracked_descendants(&map, b"other"), 1);

  1844         assert_eq!(descendants_with_an_entry(&map, b"other"), 2);

  1845         assert_eq!(tracked_descendants(&map, b"some/other"), 1);

  1846         assert_eq!(descendants_with_an_entry(&map, b"some/other"), 1);

  1847         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);

  1848         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);

  1849         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);

  1850         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);

  1851         assert_eq!(map.len(), 6);

  1852         assert_eq!(map.get_map().unreachable_bytes, 0);

  1853         assert_eq!(map.copy_map_len(), 2);

  1854 

  1855         // Shouldn't change anything since it's already not tracked

  1856         map.set_untracked(p(b"some/nested/removed"))?;

  1857         assert_eq!(map.get_map().unreachable_bytes, 0);

  1858 

  1859         match map.get_map().root {

  1860             ChildNodes::InMemory(_) => {

  1861                 panic!("root should not have been mutated")

  1862             }

  1863             _ => (),

  1864         }

  1865         // We haven't mutated enough (nothing, actually), we should still be in

  1866         // the append strategy

  1867         assert!(map.get_map().write_should_append());

  1868 

  1869         // But this mutates the structure, so there should be unreachable_bytes

  1870         assert!(map.set_untracked(p(b"some/nested/added"))?);

  1871         let unreachable_bytes = map.get_map().unreachable_bytes;

  1872         assert!(unreachable_bytes > 0);

  1873 

  1874         match map.get_map().root {

  1875             ChildNodes::OnDisk(_) => panic!("root should have been mutated"),

  1876             _ => (),

  1877         }

  1878 

  1879         // This should not mutate the structure either, since `root` has

  1880         // already been mutated along with its direct children.

  1881         map.set_untracked(p(b"merged"))?;

  1882         assert_eq!(map.get_map().unreachable_bytes, unreachable_bytes);

  1883