Mercurial > core / rust/lib/obj/src/config/repo/hg.rs

 use super::SubRepo;
 use crate::Result;
 use hg_parser::{
   file_content, FileType, ManifestEntryDetails, MercurialRepository, Revision,
 };
 
 use logger::log::{error, info, trace};
 use serde::{Deserialize, Serialize};
 use std::{
   collections::HashMap,
   fs::File,
   io::{LineWriter, Read, Write},
   net::SocketAddr,
   path::{Path, PathBuf},
   time::Instant,
 };
 
 /// Mercurial configuration type -- corresponds to .hgrc file
 ///
 /// TODO set 'default' and 'default_push' paths
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct MercurialConfig {
   pub ui: HashMap<String, String>,
   pub extensions: Option<HashMap<String, Option<String>>>,
   pub paths: Option<HashMap<String, String>>,
   pub web: HgwebConfig,
 }
 
 impl MercurialConfig {
   pub fn handle<P: AsRef<Path>>(path: P) -> MercurialRepository {
     MercurialRepository::open(path).unwrap()
   }
 }
 
 /// Mercurial '.hgsub' file handle, which is just a list of PATH=SOURCE pairs.
 pub struct HgSubFile {
   pub path: PathBuf,          // path to the .hgsub file
   pub subrepos: Vec<SubRepo>, // Vec containing `SubRepo` handles
 }
 
 impl HgSubFile {
   /// Create a new '.hgsub' file handle
   pub fn new() -> Self {
     HgSubFile {
       path: PathBuf::from(".hgsub"),
       subrepos: vec![],
     }
   }
   /// ensure that the path is in a hg repo.
   fn parent_is_hg(&self) -> bool {
     if self.path.parent().unwrap().join(".hg").exists() {
       true
     } else {
       false
     }
   }
   /// insert a subrepo into this HgSubFile. does not clone the source
   /// or ensure that path exists. Takes an optional argument of 'hg'
   /// or 'git' to indicate the subrepo-type. Value can be ommitted to
   pub fn insert(
     &mut self,
     path: &str,
     source: &str,
     vcs: Option<&str>,
   ) -> Result<()> {
     let mut prefix = "";
     // set prefix based on vcs (repo type)
     if let Some(i) = vcs {
       match i {
         "hg" => prefix = "hg",
         "git" => prefix = "git",
         _ => {
           error!("failed to recognize repo type")
         }
       }
     }
 
     let source = format!("{}:{}", prefix, source);
 
     let subrepo = SubRepo {
       vcs: vcs.unwrap().to_string(),
       origin: source.to_string(),
       path: path.to_string(),
     };
 
     self.subrepos.push(subrepo);
     Ok(())
   }
 
   /// Save subs to `.hgsub` file specified in the `path` field of
   /// this struct. This will overwrite any existing file at that path.
   pub fn save(self) -> Result<()> {
     match self.parent_is_hg() {
       true => {
         let mut file = File::open(self.path).unwrap();
         for i in self.subrepos.iter() {
           write!(file, "{} = {}", i.path, i.origin)?;
         }
       }
       false => {
         error!("Parent is not a Mercurial repo!")
       }
     }
     Ok(())
   }
 
   /// Sort the full contents of a .hgsub file alphabetically.
   pub fn sort(self) -> Result<Self> {
     let mut fd = File::open(&self.path)?;
     let len = fd.metadata().unwrap().len() as usize;
     let mut bufr = String::with_capacity(len);
     fd.read_to_string(&mut bufr).unwrap(); // This reads the entire file into memory.
     drop(fd); // drop the old readonly file descriptor
 
     let mut subs = Vec::new();
 
     trace!("starting sort of {:?} lines", &self.path.canonicalize()?);
     for line in bufr.lines() {
       subs.push(line.as_bytes());
     }
     subs.sort_unstable();
     trace!("lines have been sorted");
 
     let file = File::create(&self.path)?;
     let mut file = LineWriter::new(file);
     for sub in subs.iter() {
       file.write_all(sub)?;
       file.write_all(b"\n")?;
     }
 
     file.flush()?;
     info!("sorted {:?}", &self.path.canonicalize()?);
 
     Ok(self)
   }
 }
 
 impl Default for HgSubFile {
   fn default() -> Self {
     HgSubFile {
       path: PathBuf::from(".hgsub"),
       subrepos: vec![],
     }
   }
 }
 
 /// Hgweb configuration type
 ///
 /// Based on the configuration file for 'hgweb' scripts.
 ///
 /// We don't store the file path in a field because all HgwebConfig
 /// values are relative to env::current_dir()
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct HgwebConfig {
   pub name: String,
   pub contact: String,
   pub description: String,
   pub extensions: Vec<String>,
   pub socket: SocketAddr,
   pub paths: HashMap<PathBuf, PathBuf>,
 }
 
 impl Default for HgwebConfig {
   fn default() -> Self {
     HgwebConfig {
       name: "".to_string(),
       contact: "".to_string(),
       description: "".to_string(),
       extensions: vec![],
       socket: "0.0.0.0:0"
         .parse()
         .expect("could not parse hgweb socketaddr"),
       paths: HashMap::new(),
     }
   }
 }
 
 /// from hg_parser crate docs - given a mercurial repo as a path,
 /// exports to git fast-import format (to stdout)
 pub fn export_hg_git<P: AsRef<Path>>(path: P) -> Result<()> {
   let start = Instant::now();
   let repo = MercurialRepository::open(path).expect("could not open repo path");
 
   let stdout = std::io::stdout();
   let mut writer = stdout.lock();
 
   for changeset in &repo {
     let revision = changeset.revision;
     eprintln!("rev: {:?}", revision);
 
     let header = &changeset.header;
     let mut branch = None;
     let mut closed = false;
     for (key, value) in &header.extra {
       if key == b"branch" {
         branch = Some(value.as_slice());
       }
 
       if key == b"close" && value == b"1" {
         closed = true;
       }
     }
 
     let mut branch: Vec<_> = branch.unwrap_or_else(|| b"master").into();
     for b in branch.iter_mut() {
       if *b == b' ' {
         *b = b'-';
       }
     }
 
     let user = String::from_utf8_lossy(&header.user);
     let desc = String::from_utf8_lossy(&header.comment);
 
     let time = header.time.timestamp_secs();
     let timezone = header.time.tz_offset_secs();
     let tz =
       format!("{:+03}{:02}", -timezone / 3600, ((-timezone % 3600) / 60));
 
     write!(writer, "reset refs/heads/")?;
     writer.write_all(&mut branch)?;
     write!(writer, "\ncommit refs/heads/")?;
     writer.write_all(&mut branch)?;
     writeln!(writer, "\nmark :{}", mark(revision))?;
 
     writeln!(writer, "author {} {} {}", user, time, tz)?;
     writeln!(writer, "committer {} {} {}", user, time, tz)?;
     writeln!(writer, "data {}", desc.len() + 1)?;
     writeln!(writer, "{}\n", desc)?;
 
     match (header.p1, header.p2) {
       (Some(p1), Some(p2)) => {
         writeln!(writer, "from :{}", mark(p1))?;
         writeln!(writer, "merge :{}", mark(p2))?;
       }
       (Some(p), None) | (None, Some(p)) => {
         writeln!(writer, "from :{}", mark(p))?;
       }
       _ => (),
     }
 
     for mut file in changeset.files {
       match (file.data, file.manifest_entry) {
         (None, None) => {
           write!(writer, "D ")?;
           writer.write_all(&mut file.path)?;
           writeln!(writer)?;
         }
         (Some(data), Some(manifest_entry)) => {
           write!(
             writer,
             "M {} inline ",
             match manifest_entry.details {
               ManifestEntryDetails::File(FileType::Symlink) => "120000",
               ManifestEntryDetails::File(FileType::Executable) => "100755",
               ManifestEntryDetails::Tree
               | ManifestEntryDetails::File(FileType::Regular) => "100644",
             }
           )?;
           writer.write_all(&mut file.path)?;
           let data = file_content(&data);
           writeln!(writer, "\ndata {}", data.len())?;
           writer.write_all(&data[..])?;
         }
         _ => panic!("Wrong file data!"),
       }
     }
 
     if closed {
       write!(writer, "reset refs/tags/archive/")?;
       writer.write_all(&mut branch)?;
       writeln!(writer, "\nfrom :{}\n", mark(revision))?;
 
       write!(writer, "reset refs/heads/")?;
       writer.write_all(&mut branch)?;
       writeln!(writer, "\nfrom 0000000000000000000000000000000000000000\n")?;
     }
   }
 
   for (rev, tag) in repo.tags().unwrap() {
     eprintln!("export tag {}", tag.name);
     writeln!(writer, "reset refs/tags/{}", tag.name).unwrap();
     writeln!(writer, "from :{}", mark(rev)).unwrap();
     writeln!(writer).unwrap();
   }
 
   eprintln!("Done. Elapsed: {:?}", start.elapsed());
   Ok(())
 }
 
 fn mark<R: Into<Revision>>(rev: R) -> usize {
   (rev.into() + 1).0 as usize
 }