Enum PackagePublish

#[non_exhaustive]
pub enum PackagePublish<'g> {
    Unrestricted,
    Registries(&'g [String]),
}

Locations that a package can be published to.

Returned by PackageMetadata::publish.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unrestricted

Publication of this package is unrestricted.

Registries(&'g [String])

This package can only be published to the listed package registry.

If the list is empty, this package cannot be published to any registries.

Implementations

impl<'g> PackagePublish<'g>

pub const CRATES_IO: &'static str = "crates-io"

The string "crates-io", indicating that a package can be published to crates.io.

pub fn is_unrestricted(&self) -> bool

Returns true if this package can be published to any package registry.

Examples

use guppy::graph::PackagePublish;

assert!(PackagePublish::Unrestricted.is_unrestricted());
assert!(!PackagePublish::Registries(&[PackagePublish::CRATES_IO.to_owned()]).is_unrestricted());
assert!(!PackagePublish::Registries(&[]).is_unrestricted());

pub fn can_publish_to(&self, registry: impl AsRef<str>) -> bool

Returns true if a package can be published to the given package registry.

Examples

use guppy::graph::PackagePublish;

// Unrestricted means this package can be published to any registry.
assert!(PackagePublish::Unrestricted.can_publish_to(PackagePublish::CRATES_IO));
assert!(PackagePublish::Unrestricted.can_publish_to("my-registry"));

// Publish to specific registries but not others.
let crates_io = &[PackagePublish::CRATES_IO.to_owned()];
let crates_io_publish = PackagePublish::Registries(crates_io);
assert!(crates_io_publish.can_publish_to(PackagePublish::CRATES_IO));
assert!(!crates_io_publish.can_publish_to("my-registry"));

// Cannot publish to any registries.
assert!(!PackagePublish::Registries(&[]).can_publish_to(PackagePublish::CRATES_IO));

pub fn can_publish_to_crates_io(&self) -> bool

Returns true if a package can be published to crates.io.

pub fn is_never(&self) -> bool

Returns true if a package cannot be published to any registries.

Examples

use guppy::graph::PackagePublish;

assert!(!PackagePublish::Unrestricted.is_never());
assert!(!PackagePublish::Registries(&[PackagePublish::CRATES_IO.to_owned()]).is_never());
assert!(PackagePublish::Registries(&[]).is_never());

Trait Implementations

impl<'g> Clone for PackagePublish<'g>

fn clone(&self) -> PackagePublish<'g>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'g> Debug for PackagePublish<'g>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'g> Hash for PackagePublish<'g>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'g> PartialEq for PackagePublish<'g>

fn eq(&self, other: &PackagePublish<'g>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'g> Copy for PackagePublish<'g>

impl<'g> Eq for PackagePublish<'g>

impl<'g> StructuralPartialEq for PackagePublish<'g>