shape/

child_shape.rs

use super::Shape;
use super::ShapeCase;
use crate::case_enum::Error;
use crate::location::Location;
use crate::name::Name;
use crate::name::NameCase;

impl Shape {
    /// Returns a new [`Shape`] representing the shape of a given subproperty
    /// (field name) of the `self` shape.
    #[must_use]
    pub fn field(&self, field_name: &str, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::Object { fields, rest } => {
                if let Some(shape) = fields.get(field_name) {
                    shape.clone().with_locations(locations.iter())
                } else {
                    // The rest shape might be ShapeCase::None, so the
                    // ShapeCase::One will simplify to just ShapeCase::None.
                    Shape::one(
                        [rest.clone().with_locations(locations.iter()), Shape::none()],
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Array { prefix, tail } => {
                // Following GraphQL logic, map key over the array and make
                // a new ShapeCase::Array with the resulting shapes.
                let new_items = prefix
                    .iter()
                    .map(|shape| shape.field(field_name, locations.clone()))
                    .collect::<Vec<_>>();

                let new_rest = tail.field(field_name, locations.clone());

                // If we tried mapping a field name over an array, and all
                // we got back was an empty array, then we can simplify to
                // ShapeCase::None.
                if new_rest.is_none() && new_items.iter().all(Shape::is_none) {
                    Shape::none()
                } else {
                    Shape::array(new_items, new_rest, locations.clone())
                }
            }

            ShapeCase::One(shapes) => Shape::one(
                shapes
                    .iter()
                    .map(|shape| shape.field(field_name, locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes
                    .iter()
                    .map(|shape| shape.field(field_name, locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.field(field_name, locations.clone())
                } else {
                    Shape::new(
                        ShapeCase::Name(name.field(field_name, locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => {
                partial.as_ref().map_or(Shape::none(), |shape| {
                    shape.field(field_name, locations.clone())
                })
            }

            ShapeCase::Unknown => self.clone().with_locations(locations.iter()),

            _ => Shape::none(),
        };

        self.propagate_names_to_child(child_shape.with_locations(locations.iter()), |name| {
            name.field(field_name, locations.clone())
        })
    }

    fn propagate_names_to_child(
        &self,
        child_shape: Shape,
        name_mapper: impl Fn(&Name) -> Name,
    ) -> Shape {
        let mapped_names = self.names().map(name_mapper);
        let mut named = child_shape;
        for name in mapped_names {
            named = named.with_name(&name);
        }
        named
    }

    /// Returns a new [`Shape`] representing the union of all field shapes of
    /// object shapes, or just the shape itself for non-object shapes.
    #[must_use]
    pub fn any_field(&self, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::Object { fields, rest } => {
                let mut subshapes = Vec::new();
                for shape in fields.values() {
                    subshapes.push(shape.clone());
                }
                if !rest.is_none() {
                    subshapes.push(rest.clone());
                }
                Shape::one(subshapes, locations.clone())
            }

            ShapeCase::Array { prefix, tail } => Shape::array(
                prefix
                    .iter()
                    .map(|shape| shape.any_field(locations.clone())),
                tail.any_field(locations.clone()),
                locations.clone(),
            ),

            ShapeCase::One(shapes) => Shape::one(
                shapes
                    .iter()
                    .map(|shape| shape.any_field(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes
                    .iter()
                    .map(|shape| shape.any_field(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.any_field(locations.clone())
                } else {
                    // If the name is not bound to a shape, we create a new
                    // ShapeCase::Name with the wildcard applied.
                    Shape::new(
                        ShapeCase::Name(name.any_field(locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => partial
                .as_ref()
                .map_or(Shape::none(), |shape| shape.any_field(locations.clone())),

            // Non-object, non-array shapes are returned as-is by the .**
            // wildcard, with the additional locations (if any).
            _ => self.clone(),
        };

        // Since the shape.any_field method returns a union of preexisting
        // shapes, which should already have had any names that were given to
        // self propagated appropriately to them, we do not need to call
        // self.propagate_names_to_child here just to assign MyObject.** as a
        // low-quality name to every member of the union.
        child_shape.with_locations(locations.iter())
    }

    /// Returns a new [`Shape`] representing the shape of a given element of an
    /// array shape.
    #[must_use]
    pub fn item(&self, index: usize, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::Array { prefix, tail } => {
                if let Some(shape) = prefix.get(index) {
                    shape.clone().with_locations(locations.iter())
                } else {
                    // The rest shape might be ShapeCase::None, so the
                    // ShapeCase::One will simplify to just ShapeCase::None.
                    Shape::one([tail.clone(), Shape::none()], locations.clone())
                }
            }

            ShapeCase::String(value) => {
                if let Some(singleton) = value {
                    if let Some(ch) = singleton.chars().nth(index) {
                        Shape::string_value(ch.to_string().as_str(), locations.clone())
                    } else {
                        Shape::none()
                    }
                } else {
                    Shape::one(
                        [Shape::string(locations.clone()), Shape::none()],
                        locations.clone(),
                    )
                }
            }

            ShapeCase::One(shapes) => Shape::one(
                shapes
                    .iter()
                    .map(|shape| shape.item(index, locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes
                    .iter()
                    .map(|shape| shape.item(index, locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.item(index, locations.clone())
                } else {
                    Shape::new(
                        ShapeCase::Name(name.item(index, locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => partial
                .as_ref()
                .map_or(Shape::none(), |shape| shape.item(index, locations.clone())),

            ShapeCase::Unknown => self.clone(),

            _ => Shape::none(),
        };

        self.propagate_names_to_child(child_shape.with_locations(locations.iter()), |name| {
            name.item(index, locations.clone())
        })
    }

    /// Returns a new [`Shape`] representing the union of all element shapes of
    /// array shapes, or just the shape itself for non-array shapes.
    #[must_use]
    pub fn any_item(&self, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::Array { prefix, tail } => {
                let mut subshapes = Vec::new();
                for shape in prefix {
                    subshapes.push(shape.clone());
                }
                if !tail.is_none() {
                    subshapes.push(tail.clone());
                }
                Shape::one(subshapes, locations.clone())
            }

            ShapeCase::String(value) => {
                if let Some(singleton) = value {
                    let mut subshapes = Vec::new();
                    for ch in singleton.chars() {
                        subshapes.push(Shape::string_value(ch.to_string().as_str(), []));
                    }
                    Shape::one(subshapes, locations.clone())
                } else {
                    Shape::string(locations.clone())
                }
            }

            ShapeCase::One(shapes) => Shape::one(
                shapes.iter().map(|shape| shape.any_item(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes.iter().map(|shape| shape.any_item(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.any_item(locations.clone())
                } else {
                    Shape::new(
                        ShapeCase::Name(name.any_item(locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => partial
                .as_ref()
                .map_or(Shape::none(), |shape| shape.any_item(locations.clone())),

            // Non-array shapes are returned as-is by the .* wildcard.
            _ => self.clone(),
        };

        // Since the shape.any_item method returns a union of preexisting
        // shapes, which should already have had any names that were given to
        // self propagated appropriately to them, we do not need to call
        // self.propagate_names_to_child here just to assign SomeArray.* as a
        // low-quality name to every member of the union.
        child_shape.with_locations(locations.iter())
    }

    /// Returns a new [`Shape`] representing the input shape with any
    /// possibility of `null` replaced by `None`, but otherwise unchanged. This
    /// models the behavior of a `?` optional chainining operator, which
    /// additionally silences some errors related to missing fields at runtime.
    /// When a [`ShapeCase::Name`] shape reference has a `?` step in its
    /// subpath, that `?` step can be applied to the shape when/if the named
    /// shape is declared/resolved, so the effect of the `?` is not lost.
    #[must_use]
    pub fn question(&self, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::Null => Shape::none().with_locations(locations.iter()),

            ShapeCase::One(shapes) => Shape::one(
                shapes.iter().map(|shape| shape.question(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes.iter().map(|shape| shape.question(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.question(locations.clone())
                } else {
                    Shape::new(
                        ShapeCase::Name(name.question(locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => partial
                .as_ref()
                .map_or(Shape::none(), |shape| shape.question(locations.clone())),

            // All other shapes (primitives, objects, arrays, etc.) are neither
            // null nor None, so ? has no effect.
            _ => self.clone(),
        };

        self.propagate_names_to_child(child_shape.with_locations(locations.iter()), |name| {
            name.question(locations.clone())
        })
    }

    /// Returns a new [`Shape`] representing the input shape with any
    /// possibility of `None` removed, but otherwise unchanged. This models the
    /// behavior of a hypothetical `!` non-`None` assertion operator. When a
    /// [`ShapeCase::Name`] shape reference has a `!` step in its subpath, that
    /// `!` step can be applied to the shape when/if the named shape is later
    /// declared/resolved, so the effect of the `!` is not lost.
    #[must_use]
    pub fn not_none(&self, locations: impl IntoIterator<Item = Location>) -> Shape {
        let locations = locations.into_iter().collect::<Vec<_>>();

        let child_shape = match self.case() {
            ShapeCase::None => Shape::never(locations.clone()),

            ShapeCase::One(shapes) => Shape::one(
                shapes.iter().map(|shape| shape.not_none(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::All(shapes) => Shape::all(
                shapes.iter().map(|shape| shape.not_none(locations.clone())),
                locations.clone(),
            ),

            ShapeCase::Name(name, weak) => {
                if let Some(named_shape) = weak.upgrade(name) {
                    named_shape.not_none(locations.clone())
                } else {
                    Shape::new(
                        ShapeCase::Name(name.not_none(locations.clone()), weak.clone()),
                        locations.clone(),
                    )
                }
            }

            ShapeCase::Error(Error { partial, .. }) => partial
                .as_ref()
                .map_or(Shape::none(), |shape| shape.not_none(locations.clone())),

            // All other shapes (primitives, objects, arrays, etc.) are not None,
            // so ! has no effect.
            _ => self.clone(),
        };

        self.propagate_names_to_child(child_shape.with_locations(locations.iter()), |name| {
            name.not_none(locations.clone())
        })
    }

    /// Applies an arbitrary [`NameCase`] to the current shape, returning a new
    /// child shape. Any parent [`Name`]s of the [`NameCase`] are ignored, and
    /// the resulting shape does not inherit any name(s) from the [`NameCase`].
    #[must_use]
    pub(crate) fn apply_name_case(
        &self,
        case: &NameCase,
        locations: impl IntoIterator<Item = Location>,
    ) -> Self {
        match case {
            NameCase::Base(name) => Self::name(name, locations),
            NameCase::Field(_, name) => self.field(name, locations),
            NameCase::AnyField(_) => self.any_field(locations),
            NameCase::Item(_, index) => self.item(*index, locations),
            NameCase::AnyItem(_) => self.any_item(locations),
            NameCase::Question(_) => self.question(locations),
            NameCase::NotNone(_) => self.not_none(locations),
        }
    }

    #[must_use]
    pub fn apply_name(&self, name: &Name) -> Self {
        self.apply_name_case(name.case(), name.locs().cloned())
    }
}