项目作者: mikedilger

项目描述 :
Dependency Resolver written in rust
高级语言: Rust
项目地址: git://github.com/mikedilger/solvent.git
创建时间: 2014-09-10T02:24:53Z
项目社区:https://github.com/mikedilger/solvent

开源协议:MIT License

下载


solvent

Solvent is a dependency resolver library written in rust.

Build Status
MIT licensed

Documentation is available at https://docs.rs/solvent

Solvent helps you to resolve dependency orderings by building up a dependency graph and then
resolving the dependences of some target node in an order such that each output depends only upon
the previous outputs.

It is currently quite simple, but is still useful.

The type of the nodes should be small (as you will pass them) and should implement Eq. References
are good choices.

Example

  1. extern crate solvent;
  2. use solvent::DepGraph;
  3. fn main() {
  4. // Create a new empty DepGraph.
  5. let mut depgraph: DepGraph<&str> = DepGraph::new();
  6. // You can register a dependency like this. Solvent will automatically create nodes for any
  7. // term it has not seen before. This means 'b' depends on 'd'
  8. depgraph.register_dependency("b","d");
  9. // You can also register multiple dependencies at once
  10. depgraph.register_dependencies("a",vec!["b","c","d"]);
  11. depgraph.register_dependencies("c",vec!["e"]);
  12. // Iterate through each dependency of "a". The dependencies will be returned in an order such
  13. // that each output only depends on the previous outputs (or nothing). The target itself will
  14. // be output last.
  15. for node in depgraph.dependencies_of(&"a").unwrap() {
  16. print!("{} ", node.unwrap());
  17. }
  18. }

The above will output: d b e c a or e c d b a or some other valid dependency order.

The algorithm is not deterministic, and may give a different answer each time it is run.

The iterator dependencies_of() returns an Option<Result<T, SolventError>>. The for loop
handles the Option part for you, but you may want to check the result for SolventError. Once
an error is returned, all subsequent calls to the iterator next() will yield None.

You can also mark some elements as already satisfied, and the iterator will take that into account:

  1. depgraph.mark_as_satisfied(["e","c"]).unwrap();

Dependency cycles are detected and will return SolventError::CycleDetected.

Use Cases

These kinds of calculations are useful in the following example situations:

  • System package management: packages depending on other packages
  • Build systems such as ‘make’ or ‘cargo’ to handle dependencies (note: neither cargo nor rustc use
    solvent)
  • Complex software configurations such as Linux kernel configurations
  • Database schema upgrades which don’t need to be strictly sequential (e.g. multiple developers
    working on separate git branches being able to commit database schema upgrades independently,
    without merge conflicts) — the author wrote solvent for this purpose.

This crate is NOT a SAT solver, it is much simpler.

Other Details

Solvent does not yet handle boolean logic. See issue [#1]
(https://github.com/mikedilger/solvent/issues/1).