Add support for sdist tar,bztar and xztar formats

Author: messense

Cargo.toml

@@ -12,8 +12,10 @@ repository = "https://github.com/messense/python-pkginfo-rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+bzip2 = "0.4.2"
 flate2 = "1.0.20"
 fs-err = "2.6.0"
 mailparse = "0.13.4"
 tar = "0.4.35"
+xz = "0.1.0"
 zip = "0.5.12"

src/distribution.rs

@@ -1,7 +1,10 @@
 use std::io::{BufReader, Read};
 use std::path::Path;
+use std::str::FromStr;
 
+use bzip2::read::BzDecoder;
 use flate2::read::GzDecoder;
+use xz::read::XzDecoder;
 use zip::ZipArchive;
 
 use crate::{Error, Metadata};
@@ -20,7 +23,10 @@ pub enum DistributionType {
 #[derive(Debug, Clone, Copy)]
 enum SDistType {
     Zip,
-    TarGz,
+    Tar,
+    GzTar,
+    BzTar,
+    XzTar,
 }
 
 /// Python package distribution
@@ -30,24 +36,36 @@ pub struct Distribution {
     metadata: Metadata,
 }
 
+impl FromStr for SDistType {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let dist_type = match s {
+            "zip" => SDistType::Zip,
+            "tar" => SDistType::Tar,
+            "gz" => SDistType::GzTar,
+            "bz2" => SDistType::BzTar,
+            "xz" => SDistType::XzTar,
+            _ => return Err(Error::UnknownDistributionType),
+        };
+        Ok(dist_type)
+    }
+}
+
 impl Distribution {
     /// Open and parse a distribution from `path`
     pub fn new(path: impl AsRef<Path>) -> Result<Self, Error> {
         let path = path.as_ref();
         if let Some(ext) = path.extension().and_then(|ext| ext.to_str()) {
             let dist_type = match ext {
-                "zip" | "gz" => DistributionType::SDist,
+                "zip" | "tar" | "gz" | "bz2" | "xz" => DistributionType::SDist,
                 "egg" => DistributionType::Egg,
                 "whl" => DistributionType::Wheel,
                 _ => return Err(Error::UnknownDistributionType),
             };
             let metadata = match dist_type {
                 DistributionType::SDist => {
-                    let sdist_type = match ext {
-                        "zip" => SDistType::Zip,
-                        "gz" => SDistType::TarGz,
-                        _ => return Err(Error::UnknownDistributionType),
-                    };
+                    let sdist_type: SDistType = ext.parse()?;
                     Self::parse_sdist(path, sdist_type)
                 }
                 DistributionType::Egg => Self::parse_egg(path),
@@ -74,28 +92,15 @@ impl Distribution {
     fn parse_sdist(path: &Path, sdist_type: SDistType) -> Result<Metadata, Error> {
         match sdist_type {
             SDistType::Zip => Self::parse_zip(path, "PKG-INFO"),
-            SDistType::TarGz => {
-                let mut reader =
-                    tar::Archive::new(GzDecoder::new(BufReader::new(fs_err::File::open(path)?)));
-                let metadata_file = reader
-                    .entries()?
-                    .map(|entry| -> Result<_, Error> {
-                        let entry = entry?;
-                        if entry.path()?.ends_with("PKG-INFO") {
-                            Ok(Some(entry))
-                        } else {
-                            Ok(None)
-                        }
-                    })
-                    .find_map(|x| x.transpose());
-                if let Some(metadata_file) = metadata_file {
-                    let mut entry = metadata_file?;
-                    let mut buf = Vec::new();
-                    entry.read_to_end(&mut buf)?;
-                    Metadata::parse(&buf)
-                } else {
-                    Err(Error::MetadataNotFound)
-                }
+            SDistType::GzTar => {
+                Self::parse_tar(GzDecoder::new(BufReader::new(fs_err::File::open(path)?)))
+            }
+            SDistType::Tar => Self::parse_tar(BufReader::new(fs_err::File::open(path)?)),
+            SDistType::BzTar => {
+                Self::parse_tar(BzDecoder::new(BufReader::new(fs_err::File::open(path)?)))
+            }
+            SDistType::XzTar => {
+                Self::parse_tar(XzDecoder::new(BufReader::new(fs_err::File::open(path)?)))
             }
         }
     }
@@ -108,6 +113,29 @@ impl Distribution {
         Self::parse_zip(path, ".dist-info/METADATA")
     }
 
+    fn parse_tar<R: Read>(reader: R) -> Result<Metadata, Error> {
+        let mut reader = tar::Archive::new(reader);
+        let metadata_file = reader
+            .entries()?
+            .map(|entry| -> Result<_, Error> {
+                let entry = entry?;
+                if entry.path()?.ends_with("PKG-INFO") {
+                    Ok(Some(entry))
+                } else {
+                    Ok(None)
+                }
+            })
+            .find_map(|x| x.transpose());
+        if let Some(metadata_file) = metadata_file {
+            let mut entry = metadata_file?;
+            let mut buf = Vec::new();
+            entry.read_to_end(&mut buf)?;
+            Metadata::parse(&buf)
+        } else {
+            Err(Error::MetadataNotFound)
+        }
+    }
+
     fn parse_zip(path: &Path, metadata_file_suffix: &str) -> Result<Metadata, Error> {
         let reader = BufReader::new(fs_err::File::open(path)?);
         let mut archive = ZipArchive::new(reader)?;

tests/fixtures/build-0.4.0.tar

@@ -33,6 +33,17 @@ fn test_parse_sdist_zip() {
     assert!(metadata.download_url.is_none());
 }
 
+#[test]
+fn test_parse_sdist_tar() {
+    let dist = Distribution::new("tests/fixtures/build-0.4.0.tar").unwrap();
+    assert_eq!(dist.r#type(), DistributionType::SDist);
+    let metadata = dist.metadata();
+    assert_eq!(metadata.metadata_version, "2.1");
+    assert_eq!(metadata.name, "build");
+    assert!(metadata.home_page.is_none());
+    assert!(metadata.download_url.is_none());
+}
+
 #[test]
 fn test_parse_sdist_tar_gz() {
     let dist = Distribution::new("tests/fixtures/build-0.4.0.tar.gz").unwrap();
@@ -43,3 +54,25 @@ fn test_parse_sdist_tar_gz() {
     assert!(metadata.home_page.is_none());
     assert!(metadata.download_url.is_none());
 }
+
+#[test]
+fn test_parse_sdist_tar_bz2() {
+    let dist = Distribution::new("tests/fixtures/build-0.4.0.tar.bz2").unwrap();
+    assert_eq!(dist.r#type(), DistributionType::SDist);
+    let metadata = dist.metadata();
+    assert_eq!(metadata.metadata_version, "2.1");
+    assert_eq!(metadata.name, "build");
+    assert!(metadata.home_page.is_none());
+    assert!(metadata.download_url.is_none());
+}
+
+#[test]
+fn test_parse_sdist_tar_xz() {
+    let dist = Distribution::new("tests/fixtures/build-0.4.0.tar.xz").unwrap();
+    assert_eq!(dist.r#type(), DistributionType::SDist);
+    let metadata = dist.metadata();
+    assert_eq!(metadata.metadata_version, "2.1");
+    assert_eq!(metadata.name, "build");
+    assert!(metadata.home_page.is_none());
+    assert!(metadata.download_url.is_none());
+}