dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed CondensedDirectory support from license tools. 

Now that we have reuse-tool 4.0, we no longer need to massage the JSON license data to collapse LLVM into a single copyright notice and license - reuse-tool can do it for us using an annotation in REUSE.toml.

This effectively reverts c6eb03b.
This commit is contained in:
Jonathan Pallant 2024-07-22 10:44:18 +01:00
parent 445e70bc04
commit 2e971bf5c6
No known key found for this signature in database
3 changed files with 11 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/tools/collect-license-metadata/src/main.rs
View File

@ -6,16 +6,6 @@ use crate::licenses::LicensesInterner;
use anyhow::Error;
use std::path::PathBuf;
// Some directories have too many slight license differences that'd result in a
// huge report, and could be considered a standalone project anyway. Those
// directories are "condensed" into a single licensing block for ease of
// reading, merging the licensing information.
//
// For every `(dir, file)``, every file in `dir` is considered to have the
// license info of `file`.
const CONDENSED_DIRECTORIES: &[(&str, &str)] =
&[("./src/llvm-project/", "./src/llvm-project/README.md")];
fn main() -> Result<(), Error> {
let reuse_exe: PathBuf = std::env::var_os("REUSE_EXE").expect("Missing REUSE_EXE").into();
let dest: PathBuf = std::env::var_os("DEST").expect("Missing DEST").into();

52
src/tools/collect-license-metadata/src/path_tree.rs
View File

@ -4,7 +4,7 @@
//! passes over the tree to remove redundant information.
use crate::licenses::{License, LicenseId, LicensesInterner};
use std::collections::{BTreeMap, BTreeSet};
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
#[derive(serde::Serialize)]
@ -12,7 +12,6 @@ use std::path::{Path, PathBuf};
pub(crate) enum Node<L> {
Root { children: Vec<Node<L>> },
Directory { name: PathBuf, children: Vec<Node<L>>, license: Option<L> },
CondensedDirectory { name: PathBuf, licenses: Vec<L> },
File { name: PathBuf, license: L },
Group { files: Vec<PathBuf>, directories: Vec<PathBuf>, license: L },
Empty,
@ -59,8 +58,6 @@ impl Node<LicenseId> {
directories.entry(name).or_insert_with(Vec::new).append(&mut children);
}
file @ Node::File { .. } => files.push(file),
// Propagate condensed directories as-is.
condensed @ Node::CondensedDirectory { .. } => files.push(condensed),
Node::Empty => {}
Node::Root { .. } => {
panic!("can't have a root inside another element");
@ -87,7 +84,6 @@ impl Node<LicenseId> {
}
Node::Empty => {}
Node::File { .. } => {}
Node::CondensedDirectory { .. } => {}
Node::Group { .. } => {
panic!("Group should not be present at this stage");
}
@ -134,7 +130,6 @@ impl Node<LicenseId> {
}
}
Node::File { .. } => {}
Node::CondensedDirectory { .. } => {}
Node::Group { .. } => panic!("group should not be present at this stage"),
Node::Empty => {}
}
@ -177,9 +172,6 @@ impl Node<LicenseId> {
Node::Directory { name: child_child_name, .. } => {
*child_child_name = child_name.join(&child_child_name);
}
Node::CondensedDirectory { name: child_child_name, .. } => {
*child_child_name = child_name.join(&child_child_name);
}
Node::File { name: child_child_name, .. } => {
*child_child_name = child_name.join(&child_child_name);
}
@ -194,7 +186,6 @@ impl Node<LicenseId> {
}
Node::Empty => {}
Node::File { .. } => {}
Node::CondensedDirectory { .. } => {}
Node::Group { .. } => panic!("Group should not be present at this stage"),
}
}
@ -262,7 +253,6 @@ impl Node<LicenseId> {
}
}
Node::File { .. } => {}
Node::CondensedDirectory { .. } => {}
Node::Group { .. } => panic!("FileGroup should not be present at this stage"),
Node::Empty => {}
}
@ -278,7 +268,6 @@ impl Node<LicenseId> {
}
children.retain(|child| !matches!(child, Node::Empty));
}
Node::CondensedDirectory { .. } => {}
Node::Group { .. } => {}
Node::File { .. } => {}
Node::Empty => {}
@ -302,24 +291,7 @@ pub(crate) fn build(mut input: Vec<(PathBuf, LicenseId)>) -> Node<LicenseId> {
// Ensure reproducibility of all future steps.
input.sort();
let mut condensed_directories = BTreeMap::new();
'outer: for (path, license) in input {
// Files in condensed directories are handled separately.
for (condensed_directory, allowed_file) in super::CONDENSED_DIRECTORIES {
if path.starts_with(condensed_directory) {
if path.as_path() == Path::new(allowed_file) {
// The licence on our allowed file is used to represent the entire directory
condensed_directories
.entry(*condensed_directory)
.or_insert_with(BTreeSet::new)
.insert(license);
} else {
// don't add the file
}
continue 'outer;
}
}
for (path, license) in input {
let mut node = Node::File { name: path.file_name().unwrap().into(), license };
for component in path.parent().unwrap_or_else(|| Path::new(".")).components().rev() {
node = Node::Directory {
@ -332,22 +304,6 @@ pub(crate) fn build(mut input: Vec<(PathBuf, LicenseId)>) -> Node<LicenseId> {
children.push(node);
}
for (path, licenses) in condensed_directories {
let path = Path::new(path);
let mut node = Node::CondensedDirectory {
name: path.file_name().unwrap().into(),
licenses: licenses.iter().copied().collect(),
};
for component in path.parent().unwrap_or_else(|| Path::new(".")).components().rev() {
node = Node::Directory {
name: component.as_os_str().into(),
children: vec![node],
license: None,
};
}
children.push(node);
}
Node::Root { children }
}
@ -376,10 +332,6 @@ pub(crate) fn expand_interned_licenses(
Node::Group { files, directories, license } => {
Node::Group { files, directories, license: interner.resolve(license) }
}
Node::CondensedDirectory { name, licenses } => Node::CondensedDirectory {
name,
licenses: licenses.into_iter().map(|license| interner.resolve(license)).collect(),
},
Node::Empty => Node::Empty,
}
}

38
src/tools/generate-copyright/src/main.rs
View File

@ -1,5 +1,4 @@
use anyhow::Error;
use std::collections::BTreeSet;
use std::io::Write;
use std::path::PathBuf;
@ -27,7 +26,7 @@ fn render_recursive(node: &Node, buffer: &mut Vec<u8>, depth: usize) -> Result<(
}
}
Node::Directory { name, children, license } => {
render_license(&prefix, std::iter::once(name), license.iter(), buffer)?;
render_license(&prefix, std::iter::once(name), license.as_ref(), buffer)?;
if !children.is_empty() {
writeln!(buffer, "{prefix}")?;
writeln!(buffer, "{prefix}*Exceptions:*")?;
@ -37,19 +36,11 @@ fn render_recursive(node: &Node, buffer: &mut Vec<u8>, depth: usize) -> Result<(
}
}
}
Node::CondensedDirectory { name, licenses } => {
render_license(&prefix, std::iter::once(name), licenses.iter(), buffer)?;
}
Node::Group { files, directories, license } => {
render_license(
&prefix,
directories.iter().chain(files.iter()),
std::iter::once(license),
buffer,
)?;
render_license(&prefix, directories.iter().chain(files.iter()), Some(license), buffer)?;
}
Node::File { name, license } => {
render_license(&prefix, std::iter::once(name), std::iter::once(license), buffer)?;
render_license(&prefix, std::iter::once(name), Some(license), buffer)?;
}
}
@ -59,27 +50,17 @@ fn render_recursive(node: &Node, buffer: &mut Vec<u8>, depth: usize) -> Result<(
fn render_license<'a>(
prefix: &str,
names: impl Iterator<Item = &'a String>,
licenses: impl Iterator<Item = &'a License>,
license: Option<&License>,
buffer: &mut Vec<u8>,
) -> Result<(), Error> {
let mut spdxs = BTreeSet::new();
let mut copyrights = BTreeSet::new();
for license in licenses {
spdxs.insert(&license.spdx);
for copyright in &license.copyright {
copyrights.insert(copyright);
}
}
for name in names {
writeln!(buffer, "{prefix}**`{name}`** ")?;
}
for spdx in spdxs.iter() {
writeln!(buffer, "{prefix}License: `{spdx}` ")?;
}
for (i, copyright) in copyrights.iter().enumerate() {
let suffix = if i == copyrights.len() - 1 { "" } else { " " };
writeln!(buffer, "{prefix}Copyright: {copyright}{suffix}")?;
if let Some(license) = license {
writeln!(buffer, "{prefix}License: `{}`", license.spdx)?;
for copyright in license.copyright.iter() {
writeln!(buffer, "{prefix}Copyright: {copyright}")?;
}
}
Ok(())
@ -95,7 +76,6 @@ struct Metadata {
pub(crate) enum Node {
Root { children: Vec<Node> },
Directory { name: String, children: Vec<Node>, license: Option<License> },
CondensedDirectory { name: String, licenses: Vec<License> },
File { name: String, license: License },
Group { files: Vec<String>, directories: Vec<String>, license: License },
}