@@ -0,0 +1,219 @@
1+use std::fs::read_to_string;
2+use std::path::{Path, PathBuf};
3+
4+use walkdir::DirEntry;
5+
6+use crate::error::*;
7+
8+struct PathAndStem {
9+ path: PathBuf,
10+ stem: String,
11+ relative_path: String,
12+}
13+
14+/// Looks for LICENSE and NOTICE files in `source_dir`, does some rudimentary
15+/// analysis, and compiles them together in a single string that is meant to be
16+/// used in the output to `--acknowledgements`
17+pub fn build_acknowledgements(
18+ source_dir: &Path,
19+ include_acknowledgements: bool,
20+) -> Result<Option<String>> {
21+ if !include_acknowledgements {
22+ return Ok(None);
23+ }
24+
25+ let mut acknowledgements = format!("{}\n\n", include_str!("../../../NOTICE"));
26+
27+ // Sort entries so the order is stable over time
28+ let entries = walkdir::WalkDir::new(source_dir).sort_by(|a, b| a.path().cmp(b.path()));
29+ for path_and_stem in entries
30+ .into_iter()
31+ .flatten()
32+ .flat_map(|entry| to_path_and_stem(source_dir, entry))
33+ {
34+ if let Some(license_text) = handle_file(&path_and_stem)? {
35+ append_to_acknowledgements(
36+ &mut acknowledgements,
37+ &path_and_stem.relative_path,
38+ &license_text,
39+ )
40+ }
41+ }
42+
43+ Ok(Some(acknowledgements))
44+}
45+
46+fn to_path_and_stem(source_dir: &Path, entry: DirEntry) -> Option<PathAndStem> {
47+ let path = entry.path();
48+
49+ Some(PathAndStem {
50+ path: path.to_owned(),
51+ stem: path.file_stem().map(|s| s.to_string_lossy().to_string())?,
52+ relative_path: path
53+ .strip_prefix(source_dir)
54+ .map(|p| p.to_string_lossy().to_string())
55+ .ok()?,
56+ })
57+}
58+
59+fn handle_file(path_and_stem: &PathAndStem) -> Result<Option<String>> {
60+ if path_and_stem.stem == "NOTICE" {
61+ handle_notice(&path_and_stem.path)
62+ } else if path_and_stem.stem.to_ascii_uppercase() == "LICENSE" {
63+ handle_license(&path_and_stem.path)
64+ } else {
65+ Ok(None)
66+ }
67+}
68+
69+fn handle_notice(path: &Path) -> Result<Option<String>> {
70+ // Assume NOTICE as defined by Apache License 2.0. These must be part of acknowledgements.
71+ Ok(Some(read_to_string(path)?))
72+}
73+
74+fn handle_license(path: &Path) -> Result<Option<String>> {
75+ let license_text = read_to_string(path)?;
76+
77+ if include_license_in_acknowledgments(&license_text) {
78+ Ok(Some(license_text))
79+ } else if license_not_needed_in_acknowledgements(&license_text) {
80+ Ok(None)
81+ } else {
82+ Err(format!("ERROR: License is of unknown type: {:?}", path).into())
83+ }
84+}
85+
86+fn include_license_in_acknowledgments(license_text: &str) -> bool {
87+ let markers = vec![
88+ // MIT
89+ "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.",
90+
91+ // BSD
92+ "Redistributions in binary form must reproduce the above copyright notice,",
93+
94+ // Apache 2.0
95+ "Apache License Version 2.0, January 2004 http://www.apache.org/licenses/",
96+ "Licensed under the Apache License, Version 2.0 (the \"License\");",
97+ ];
98+
99+ license_contains_marker(license_text, &markers)
100+}
101+
102+fn license_not_needed_in_acknowledgements(license_text: &str) -> bool {
103+ let markers = vec![
104+ // Public domain
105+ "This is free and unencumbered software released into the public domain.",
106+
107+ // Special license of assets/syntaxes/01_Packages/LICENSE
108+ "Permission to copy, use, modify, sell and distribute this software is granted. This software is provided \"as is\" without express or implied warranty, and with no claim as to its suitability for any purpose."
109+ ];
110+
111+ license_contains_marker(license_text, &markers)
112+}
113+
114+fn license_contains_marker(license_text: &str, markers: &[&str]) -> bool {
115+ let normalized_license_text = normalize_license_text(license_text);
116+ markers.iter().any(|m| normalized_license_text.contains(m))
117+}
118+
119+fn append_to_acknowledgements(
120+ acknowledgements: &mut String,
121+ relative_path: &str,
122+ license_text: &str,
123+) {
124+ acknowledgements.push_str(&format!("## {}\n\n{}", relative_path, license_text));
125+
126+ // Make sure the last char is a newline to not mess up formatting later
127+ if acknowledgements
128+ .chars()
129+ .last()
130+ .expect("acknowledgements is not the empty string")
131+ != '\n'
132+ {
133+ acknowledgements.push('\n');
134+ }
135+
136+ // Add two more newlines to make it easy to distinguish where this text ends
137+ // and the next starts
138+ acknowledgements.push_str("\n\n");
139+}
140+
141+/// Replaces newlines with a space character, and replaces multiple spaces with one space.
142+/// This makes the text easier to analyze.
143+fn normalize_license_text(license_text: &str) -> String {
144+ use regex::Regex;
145+
146+ let whitespace_and_newlines = Regex::new(r"\s").unwrap();
147+ let as_single_line = whitespace_and_newlines.replace_all(license_text, " ");
148+
149+ let many_spaces = Regex::new(" +").unwrap();
150+ many_spaces.replace_all(&as_single_line, " ").to_string()
151+}
152+
153+#[cfg(test)]
154+mod tests {
155+ #[cfg(test)]
156+ use super::*;
157+
158+ #[test]
159+ fn test_normalize_license_text() {
160+ let license_text = "This is a license text with these terms:
161+ * Complicated multi-line
162+ term with indentation";
163+
164+ assert_eq!(
165+ "This is a license text with these terms: * Complicated multi-line term with indentation".to_owned(),
166+ normalize_license_text(license_text),
167+ );
168+ }
169+
170+ #[test]
171+ fn test_normalize_license_text_with_windows_line_endings() {
172+ let license_text = "This license text includes windows line endings\r
173+and we need to handle that.";
174+
175+ assert_eq!(
176+ "This license text includes windows line endings and we need to handle that."
177+ .to_owned(),
178+ normalize_license_text(license_text),
179+ );
180+ }
181+
182+ #[test]
183+ fn test_append_to_acknowledgements_adds_newline_if_missing() {
184+ let mut acknowledgements = "preamble\n\n\n".to_owned();
185+
186+ append_to_acknowledgements(&mut acknowledgements, "some/path", "line without newline");
187+ assert_eq!(
188+ "preamble
189+
190+
191+## some/path
192+
193+line without newline
194+
195+
196+",
197+ acknowledgements
198+ );
199+
200+ append_to_acknowledgements(&mut acknowledgements, "another/path", "line with newline\n");
201+ assert_eq!(
202+ "preamble
203+
204+
205+## some/path
206+
207+line without newline
208+
209+
210+## another/path
211+
212+line with newline
213+
214+
215+",
216+ acknowledgements
217+ );
218+ }
219+}