Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 18 additions & 8 deletions core/src/compat.rs
Original file line number Diff line number Diff line change
Expand Up @@ -647,6 +647,22 @@ struct ProtocolDecl<'a> {
functions: Vec<(&'a str, &'a [FrozenUnit])>,
}

/// The names a version's compiled schemas are split off by, as
/// dependencies' rather than the package's own: its `dependencies`, and
/// `std`, which is built in and never vendored (no `dep_std` entry) yet
/// compiled into every build, so it's compared by reach like the rest.
pub fn dependency_names<'a>(dependencies: impl IntoIterator<Item = &'a str>) -> BTreeSet<&'a str> {
dependencies.into_iter().chain(std::iter::once("std")).collect()
}

/// A build tree's vendored dependencies: its `dep_<name>` entries.
pub fn vendored(tree: &Tree) -> impl Iterator<Item = &str> {
tree.entries
.iter()
.filter(|e| e.mode == EntryMode::Tree)
.filter_map(|e| e.name.strip_prefix("dep_"))
}

/// A stored version: its own schemas, its dependencies' (vendored), and
/// its configs, its own and its dependencies' (what a version stored before
/// core#251 doesn't hold of them is unseen, see [`StoredConfigs`]).
Expand All @@ -660,12 +676,7 @@ impl Loaded {
fn of(store: &ObjectStore, tree: &Tree) -> Result<Self> {
use crate::schema::ir::frozen::cas::blob::load_schema_from_tree;

let dependency_names: BTreeSet<&str> = tree
.entries
.iter()
.filter(|e| e.mode == EntryMode::Tree)
.filter_map(|e| e.name.strip_prefix("dep_"))
.collect();
let dependency_names = dependency_names(vendored(tree));
let mut own = vec![];
let mut dependencies: BTreeMap<String, Schemas> = BTreeMap::new();
for entry in &tree.entries {
Expand Down Expand Up @@ -802,8 +813,7 @@ pub fn facts_of_context(context: &ProjectContext, version: &str) -> PackageFacts
.iter()
.filter_map(|s| s.borrow().frozen_schema.borrow().clone())
.collect();
let dependency_names: BTreeSet<&str> =
context.dependency_configs.iter().map(|(n, _)| n.as_str()).collect();
let dependency_names = dependency_names(context.dependency_configs.iter().map(|(n, _)| n.as_str()));
let (mut mine, mut theirs) = (vec![], vec![]);
for units in own {
let first = schema_namespace(&units).and_then(|ns| ns.split_once("::").map(|(f, _)| f.to_string()));
Expand Down
11 changes: 3 additions & 8 deletions core/src/package/build/cas/build.rs
Original file line number Diff line number Diff line change
Expand Up @@ -195,14 +195,9 @@ pub fn compare(store: &ObjectStore, old: &Tree, new: &Tree) -> Result<Comparison

// A package's compiled schemas include every dependency's, each under
// the dependency's name (`shared_types::models`): those are split off
// and compared by reach below.
let dependency_names: BTreeSet<&str> = old
.entries
.iter()
.chain(&new.entries)
.filter(|e| e.mode == EntryMode::Tree)
.filter_map(|e| e.name.strip_prefix("dep_"))
.collect();
// and compared by reach below, `std`'s too.
use crate::compat::{dependency_names, vendored};
let dependency_names = dependency_names(vendored(old).chain(vendored(new)));
type Schemas = Vec<Vec<crate::schema::ir::frozen::unit::FrozenUnit>>;
let split = |schemas: Schemas| -> (Schemas, BTreeMap<String, Schemas>) {
let mut own = vec![];
Expand Down
1 change: 1 addition & 0 deletions core/tests/cas/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@ pub mod dependency_vendoring_tests;
#[cfg(feature = "deps")]
pub mod dependency_configs_tests;
pub mod release_tests;
pub mod std_reach_tests;
pub mod compat_tests;
pub mod reconcile_tests;
pub mod store_never_wiped_tests;
55 changes: 55 additions & 0 deletions core/tests/cas/std_reach_tests.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,55 @@
// `std` is built in and never vendored, so a build has no `dep_std`
// entry, yet its compiled schemas are in every build. It's compared by
// reach, like a vendored dependency: what the package doesn't reach of it
// is neither the package's change nor a version bump.

use comline_core::package::build::cas::objects::{EntryMode, Tree};
use comline_core::package::build::cas::ObjectStore;
use comline_core::package::build::VersionBump;
use tempfile::TempDir;

/// A built version's root tree holding `schemas`, each as a `schema_<i>`
/// entry, the way a build writes them.
fn tree_of(store: &ObjectStore, schemas: &[Vec<comline_core::schema::ir::frozen::unit::FrozenUnit>]) -> Tree {
use comline_core::schema::ir::frozen::cas::blob::build_tree_from_schema;
let mut root = Tree::new();
for (i, schema) in schemas.iter().enumerate() {
let tree = build_tree_from_schema(schema, store).unwrap();
let hash = store.write(&tree.to_bytes().unwrap()).unwrap();
root.add_entry(EntryMode::Tree, format!("schema_{i}"), hash);
}
root
}

#[test]
fn std_is_compared_by_reach_like_a_dependency() {
// `std` is built in, never vendored (no `dep_std` entry), yet its
// compiled schemas are in every build. A declaration `std` gains that
// the package doesn't reach is neither the package's own feature nor a
// version bump.
use comline_core::package::build::cas::build::compare;
use comline_core::schema::ir::frozen::unit::FrozenUnit;

let unit = |name: &str| FrozenUnit::Struct {
docstring: None,
parameters: vec![],
name: name.to_string(),
fields: vec![],
span: (0, 0),
};
let own = vec![FrozenUnit::Namespace("api".into()), unit("Holder")];
let std_before = vec![FrozenUnit::Namespace("std::extra".into()), unit("Existing")];
let std_after = vec![FrozenUnit::Namespace("std::extra".into()), unit("Existing"), unit("Added")];

let dir = TempDir::new().unwrap();
let store = ObjectStore::new(dir.path());
store.init().unwrap();
let old = tree_of(&store, &[own.clone(), std_before]);
let new = tree_of(&store, &[own, std_after]);

let comparison = compare(&store, &old, &new).unwrap();
assert!(comparison.schema_changes.is_empty(), "{:?}", comparison.schema_changes);
assert!(comparison.dependency_changes.is_empty(), "{:?}", comparison.dependency_changes);
// Trees with no stored config count it unseen, at most a patch.
assert!(comparison.bump < VersionBump::Minor, "{:?}", comparison.bump);
}
Loading