Temp

Author: BrynCooke

crates/apollo-smith/Cargo.toml

@@ -28,6 +28,8 @@ arbitrary = { version = "1.3.0", features = ["derive"] }
 indexmap = "2.0.0"
 once_cell = "1.9.0"
 thiserror = "1.0.37"
+paste = "1.0.0"
+uuid = { version = "1.7.0", features = ["v4"] }
 
 [dev-dependencies]
 expect-test = "1.4"

crates/apollo-smith/src/lib.rs

@@ -11,7 +11,7 @@ pub(crate) mod input_object;
 pub(crate) mod input_value;
 pub(crate) mod interface;
 pub(crate) mod name;
-mod next;
+pub mod next;
 pub(crate) mod object;
 pub(crate) mod operation;
 pub(crate) mod scalar;

crates/apollo-smith/src/next/ast/definition.rs

@@ -0,0 +1,83 @@
+use apollo_compiler::ast::{Definition, InputObjectTypeDefinition, Name, Type};
+use apollo_compiler::schema::ExtendedType;
+use arbitrary::Unstructured;
+
+pub(crate) trait DefinitionExt {
+    fn ty(&self, u: &mut Unstructured) -> arbitrary::Result<Type>;
+}
+
+impl DefinitionExt for Definition {
+    fn ty(&self, u: &mut Unstructured) -> arbitrary::Result<Type> {
+        let name = self.name().expect("definition must have a name").clone();
+        Ok(ty(u, name)?)
+    }
+}
+
+impl DefinitionExt for InputObjectTypeDefinition {
+    fn ty(&self, u: &mut Unstructured) -> arbitrary::Result<Type> {
+        Ok(ty(u, self.name.clone())?)
+    }
+}
+
+fn ty(u: &mut Unstructured, name: Name) -> arbitrary::Result<Type> {
+    let mut ty = if u.arbitrary()? {
+        Type::Named(name)
+    } else {
+        Type::NonNullNamed(name)
+    };
+
+    for _ in 0..u.int_in_range(0..=5)? {
+        if u.arbitrary()? {
+            ty = Type::List(Box::new(ty))
+        } else {
+            ty = Type::NonNullList(Box::new(ty))
+        };
+    }
+    Ok(ty)
+}
+
+#[derive(Debug)]
+pub(crate) enum DefinitionKind {
+    OperationDefinition,
+    FragmentDefinition,
+    DirectiveDefinition,
+    SchemaDefinition,
+    ScalarTypeDefinition,
+    ObjectTypeDefinition,
+    InterfaceTypeDefinition,
+    UnionTypeDefinition,
+    EnumTypeDefinition,
+    InputObjectTypeDefinition,
+    SchemaExtension,
+    ScalarTypeExtension,
+    ObjectTypeExtension,
+    InterfaceTypeExtension,
+    UnionTypeExtension,
+    EnumTypeExtension,
+    InputObjectTypeExtension,
+}
+
+impl DefinitionKind {
+    pub(crate) fn matches(&self, definition: &Definition) -> bool {
+        match (self, definition) {
+            (Self::OperationDefinition, Definition::OperationDefinition(_)) => true,
+            (Self::FragmentDefinition, Definition::FragmentDefinition(_)) => true,
+            (Self::DirectiveDefinition, Definition::DirectiveDefinition(_)) => true,
+            (Self::SchemaDefinition, Definition::SchemaDefinition(_)) => true,
+            (Self::ScalarTypeDefinition, Definition::ScalarTypeDefinition(_)) => true,
+            (Self::ObjectTypeDefinition, Definition::ObjectTypeDefinition(_)) => true,
+            (Self::InterfaceTypeDefinition, Definition::InterfaceTypeDefinition(_)) => true,
+            (Self::UnionTypeDefinition, Definition::UnionTypeDefinition(_)) => true,
+            (Self::EnumTypeDefinition, Definition::EnumTypeDefinition(_)) => true,
+            (Self::InputObjectTypeDefinition, Definition::InputObjectTypeDefinition(_)) => true,
+            (Self::SchemaExtension, Definition::SchemaExtension(_)) => true,
+            (Self::ScalarTypeExtension, Definition::ScalarTypeExtension(_)) => true,
+            (Self::ObjectTypeExtension, Definition::ObjectTypeExtension(_)) => true,
+            (Self::InterfaceTypeExtension, Definition::InterfaceTypeExtension(_)) => true,
+            (Self::UnionTypeExtension, Definition::UnionTypeExtension(_)) => true,
+            (Self::EnumTypeExtension, Definition::EnumTypeExtension(_)) => true,
+            (Self::InputObjectTypeExtension, Definition::InputObjectTypeExtension(_)) => true,
+            _ => false,
+        }
+    }
+}

crates/apollo-smith/src/next/ast/directive_definition.rs

@@ -0,0 +1,74 @@
+use super::document::DocumentExt;
+use apollo_compiler::ast::{
+    Argument, Directive, DirectiveDefinition, DirectiveList, DirectiveLocation, Document,
+};
+use apollo_compiler::{Node, Schema};
+use arbitrary::Unstructured;
+use std::ops::Deref;
+
+pub(crate) struct LocationFilter<I>(I, DirectiveLocation);
+
+impl<'a, T> Iterator for LocationFilter<T>
+where
+    T: Iterator<Item = &'a Node<DirectiveDefinition>>,
+{
+    type Item = &'a Node<DirectiveDefinition>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.find(|d| d.locations.contains(&self.1))
+    }
+}
+
+pub(crate) trait DirectiveDefinitionIterExt {
+    fn with_location<'a>(self, location: DirectiveLocation) -> LocationFilter<Self>
+    where
+        Self: Iterator<Item = &'a Node<DirectiveDefinition>> + Sized;
+
+    fn try_collect<'a>(
+        self,
+        u: &mut Unstructured,
+        doc: &Document,
+        schema: &Schema,
+    ) -> arbitrary::Result<DirectiveList>
+    where
+        Self: Iterator<Item = &'a Node<DirectiveDefinition>> + Sized;
+}
+
+impl<I: ?Sized> DirectiveDefinitionIterExt for I {
+    fn with_location<'a>(self, location: DirectiveLocation) -> LocationFilter<Self>
+    where
+        I: Iterator<Item = &'a Node<DirectiveDefinition>>,
+        Self: Sized,
+    {
+        LocationFilter(self, location)
+    }
+
+    fn try_collect<'a>(
+        mut self,
+        u: &mut Unstructured,
+        doc: &Document,
+        schema: &Schema,
+    ) -> arbitrary::Result<DirectiveList>
+    where
+        Self: Iterator<Item = &'a Node<DirectiveDefinition>> + Sized,
+    {
+        let mut directives = DirectiveList::new();
+        while let Some(d) = self.next() {
+            let mut arguments = Vec::new();
+            for arg in &d.arguments {
+                if arg.is_required() || u.arbitrary()? {
+                    arguments.push(Node::new(Argument {
+                        name: arg.name.clone(),
+                        value: Node::new(doc.arbitrary_value(u, arg.ty.deref(), schema)?),
+                    }))
+                }
+            }
+
+            directives.push(Node::new(Directive {
+                name: d.name.clone(),
+                arguments,
+            }))
+        }
+        Ok(directives)
+    }
+}