Add CI

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  run_cargo_lints:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+      - name: Rustup install nightly
+        run: rustup toolchain install nightly
+      - name: Rustup install rustfmt
+        run: rustup component add rustfmt --toolchain nightly
+      - name: Run Cargo fmt
+        run: cargo +nightly fmt --all -- --check
+      - name: Run Cargo clippy
+        run: cargo clippy --all-targets --all-features
+  run_cargo_tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+      - name: Run Cargo test
+        run: cargo test --all-features

codama-attributes/src/attributes.rs

@@ -7,7 +7,7 @@ use std::ops::{Deref, DerefMut, Index, IndexMut};
 pub struct Attributes<'a>(pub Vec<Attribute<'a>>);
 
 impl<'a> Attributes<'a> {
-    pub fn parse(attrs: &'a Vec<syn::Attribute>, ctx: AttributeContext<'a>) -> syn::Result<Self> {
+    pub fn parse(attrs: &'a [syn::Attribute], ctx: AttributeContext<'a>) -> syn::Result<Self> {
         let attributes = Self(
             attrs
                 .iter()

codama-attributes/src/codama_attribute.rs

@@ -20,7 +20,7 @@ impl<'a> CodamaAttribute<'a> {
         };
 
         let mut directive = SetOnce::<CodamaDirective>::new("codama");
-        list.each(|ref meta| directive.set(CodamaDirective::parse(&meta, ctx)?, meta))?;
+        list.each(|ref meta| directive.set(CodamaDirective::parse(meta, ctx)?, meta))?;
         Ok(Self {
             ast,
             directive: directive.take(attr)?,

codama-attributes/src/codama_directives/account_directive.rs

@@ -18,11 +18,11 @@ impl AccountDirective {
     pub fn parse(meta: &Meta, ctx: &AttributeContext) -> syn::Result<Self> {
         meta.assert_directive("account")?;
         let mut name = SetOnce::<CamelCaseString>::new("name");
-        match ctx {
-            AttributeContext::Field(syn::Field {
-                ident: Some(ident), ..
-            }) => name = name.initial_value(ident.to_string().into()),
-            _ => (),
+        if let AttributeContext::Field(syn::Field {
+            ident: Some(ident), ..
+        }) = ctx
+        {
+            name = name.initial_value(ident.to_string().into())
         }
         let mut is_writable = SetOnce::<bool>::new("writable").initial_value(false);
         let mut is_signer = SetOnce::<IsAccountSigner>::new("signer").initial_value(false.into());

codama-attributes/src/codama_directives/type_nodes/boolean_type_node.rs

@@ -6,7 +6,7 @@ impl FromMeta for BooleanTypeNode {
     fn from_meta(meta: &Meta) -> syn::Result<Self> {
         let mut size: SetOnce<TypeNode> = SetOnce::new("size");
         if meta.is_path_or_empty_list() {
-            return Ok(BooleanTypeNode::default().into());
+            return Ok(BooleanTypeNode::default());
         }
         meta.as_path_list()?
             .each(|ref meta| match (meta.path_str().as_str(), meta) {

codama-attributes/src/codama_directives/type_nodes/fixed_size_type_node.rs

@@ -23,10 +23,7 @@ impl FromMeta for FixedSizeTypeNode<TypeNode> {
                 (_, Meta::Expr(expr)) => size.set(expr.as_literal_integer()?, meta),
                 _ => Err(meta.error("unrecognized attribute")),
             })?;
-        let r#type = match TypeNode::try_from(r#type.take(meta)?) {
-            Ok(node) => node,
-            Err(_) => return Err(meta.error("type must be a TypeNode")),
-        };
+        let r#type = r#type.take(meta)?;
         Ok(Self::new(r#type, size.take(meta)?))
     }
 }

codama-attributes/src/codama_directives/type_nodes/string_type_node.rs

@@ -7,7 +7,7 @@ impl FromMeta for StringTypeNode {
     fn from_meta(meta: &Meta) -> syn::Result<Self> {
         let mut encoding: SetOnce<BytesEncoding> = SetOnce::new("encoding");
         if meta.is_path_or_empty_list() {
-            return Ok(StringTypeNode::utf8().into());
+            return Ok(StringTypeNode::utf8());
         }
         meta.as_path_list()?
             .each(|ref meta| match (meta.path_str().as_str(), meta) {

codama-attributes/src/utils/macros.rs

@@ -3,7 +3,7 @@ macro_rules! assert_type {
     ({$($attr:tt)*}, $expected:expr) => {
         {
             let meta: codama_syn_helpers::Meta = syn::parse_quote! { type = $($attr)* };
-            let node = crate::TypeDirective::parse(&meta).unwrap().node;
+            let node = $crate::TypeDirective::parse(&meta).unwrap().node;
             assert_eq!(node, $expected);
         }
     };
@@ -14,7 +14,7 @@ macro_rules! assert_type_err {
     ({$($attr:tt)*}, $expected:expr) => {
         {
             let meta: codama_syn_helpers::Meta = syn::parse_quote! { type = $($attr)* };
-            let message = crate::TypeDirective::parse(&meta).unwrap_err().to_string();
+            let message = $crate::TypeDirective::parse(&meta).unwrap_err().to_string();
             assert_eq!(message, $expected);
         }
     };

codama-korok-plugins/src/default_plugin.rs

@@ -22,16 +22,16 @@ impl KorokPlugin for DefaultPlugin {
 
 pub fn get_default_visitor<'a>() -> ComposeVisitor<'a> {
     ComposeVisitor::new()
-        .add(FilterItemsVisitor::new(
+        .with(FilterItemsVisitor::new(
             |item| item.attributes().unwrap().has_any_codama_derive(),
             ComposeVisitor::new()
-                .add(SetBorshTypesVisitor::new())
-                .add(SetLinkTypesVisitor::new()),
+                .with(SetBorshTypesVisitor::new())
+                .with(SetLinkTypesVisitor::new()),
         ))
-        .add(SetProgramMetadataVisitor::new())
-        .add(ApplyCodamaTypeAttributesVisitor::new())
-        .add(SetDefinedTypesVisitor::new())
-        .add(SetAccountsVisitor::new())
-        .add(SetInstructionsVisitor::new())
-        .add(CombineModulesVisitor::new())
+        .with(SetProgramMetadataVisitor::new())
+        .with(ApplyCodamaTypeAttributesVisitor::new())
+        .with(SetDefinedTypesVisitor::new())
+        .with(SetAccountsVisitor::new())
+        .with(SetInstructionsVisitor::new())
+        .with(CombineModulesVisitor::new())
 }

codama-korok-plugins/src/plugin.rs

@@ -9,6 +9,8 @@ pub trait KorokPlugin {
     ) -> CodamaResult<()>;
 }
 
+pub type ResolvePluginsResult<'a> = Box<dyn Fn(&mut dyn KorokVisitable) -> CodamaResult<()> + 'a>;
+
 /// Reduce all plugins into a single function that runs them in sequence.
 ///
 /// For instance, imagine we have a list of plugins [A, B, C] implemented as:
@@ -40,9 +42,7 @@ pub trait KorokPlugin {
 /// Plugin B - after
 /// Plugin C - after
 /// ```
-pub fn resolve_plugins<'a>(
-    plugins: &'a [Box<dyn KorokPlugin + 'a>],
-) -> Box<dyn Fn(&mut dyn KorokVisitable) -> CodamaResult<()> + 'a> {
+pub fn resolve_plugins<'a>(plugins: &'a [Box<dyn KorokPlugin + 'a>]) -> ResolvePluginsResult<'a> {
     // We fold from the left to ensure that any code before the
     // `next` call is run before the previous plugin on the list.
     plugins.iter().fold(
@@ -61,14 +61,14 @@ pub fn resolve_plugins<'a>(
 mod tests {
     use super::*;
     use codama_korok_visitors::KorokVisitor;
-    use std::{cell::RefCell, sync::Arc};
+    use std::{cell::RefCell, rc::Rc};
 
     struct LoggingPluging {
         id: String,
-        logs: Arc<RefCell<Vec<String>>>,
+        logs: Rc<RefCell<Vec<String>>>,
     }
     impl LoggingPluging {
-        fn new(id: &str, logs: Arc<RefCell<Vec<String>>>) -> Self {
+        fn new(id: &str, logs: Rc<RefCell<Vec<String>>>) -> Self {
             Self {
                 id: id.into(),
                 logs,
@@ -104,7 +104,7 @@ mod tests {
 
     #[test]
     fn test_resolve_plugins() -> CodamaResult<()> {
-        let logs = Arc::new(RefCell::new(Vec::new()));
+        let logs = Rc::new(RefCell::new(Vec::new()));
         let plugins: Vec<Box<dyn KorokPlugin>> = vec![
             Box::new(LoggingPluging::new("A", logs.clone())),
             Box::new(LoggingPluging::new("B", logs.clone())),

codama-korok-visitors/src/apply_codama_type_attributes_visitor.rs

@@ -94,17 +94,13 @@ fn apply_codama_attributes(mut korok: KorokMut) -> CodamaResult<()> {
             Attribute::Codama(attribute) => Some(attribute),
             _ => None,
         })
-        .fold(
-            Ok(korok.node().clone()),
-            |current_node, attribute| match current_node {
-                Ok(current_node) => apply_codama_attribute(ApplyAttributeInput {
-                    node: current_node,
-                    attribute,
-                    korok: &korok,
-                }),
-                Err(e) => Err(e),
-            },
-        )?;
+        .try_fold(korok.node().clone(), |current_node, attribute| {
+            apply_codama_attribute(ApplyAttributeInput {
+                node: current_node,
+                attribute,
+                korok: &korok,
+            })
+        })?;
 
     korok.set_node(node);
     Ok(())
@@ -128,8 +124,8 @@ fn apply_type_directive(
     match input.korok {
         // If the `type` directive is applied to a named field then
         // we need to wrap the provided node in a `StructFieldTypeNode`.
-        KorokMut::Field(korok) => match (TypeNode::try_from(node.clone()).ok(), &korok.ast.ident) {
-            (Some(type_node), Some(ident)) => Ok(Some(
+        KorokMut::Field(korok) => match (node.clone(), &korok.ast.ident) {
+            (type_node, Some(ident)) => Ok(Some(
                 StructFieldTypeNode::new(ident.to_string(), type_node).into(),
             )),
             _ => Ok(Some(node.into())),
@@ -223,16 +219,14 @@ fn update_type_node(
 
     match TypeNode::try_from(node.clone()) {
         Ok(type_node) => Ok(Some(update(type_node)?.into())),
-        Err(_) => {
-            return Err(input
-                .attribute
-                .ast
-                .error(format!(
-                    "Cannot apply attribute `#[codama({})]` on a node of kind `{}`",
-                    input.attribute.directive.name(),
-                    node.kind()
-                ))
-                .into());
-        }
+        Err(_) => Err(input
+            .attribute
+            .ast
+            .error(format!(
+                "Cannot apply attribute `#[codama({})]` on a node of kind `{}`",
+                input.attribute.directive.name(),
+                node.kind()
+            ))
+            .into()),
     }
 }

codama-korok-visitors/src/combine_types_visitor.rs

@@ -82,7 +82,7 @@ impl CombineTypesVisitor {
                 .ast
                 .error(format!(
                     "Variant `{}` of {} does not resolve to a `EnumVariantTypeNode`",
-                    variant.ast.ident.to_string(),
+                    variant.ast.ident,
                     parent.identifier()
                 ))
                 .into())),
@@ -98,7 +98,7 @@ impl CombineTypesVisitor {
                 .ast
                 .error(format!(
                     "Field `{}` in {} does not resolve to a `structFieldTypeNode`",
-                    field.ast.ident.as_ref().unwrap().to_string(),
+                    field.ast.ident.as_ref().unwrap(),
                     parent.identifier()
                 ))
                 .into())),
@@ -115,7 +115,7 @@ impl CombineTypesVisitor {
                 .ast
                 .error(format!(
                     "Field `{}` in {} does not resolve to a `TypeNode`",
-                    index.to_string(),
+                    index,
                     parent.identifier()
                 ))
                 .into())),

codama-korok-visitors/src/compose_visitor.rs

@@ -13,8 +13,8 @@ impl<'a> ComposeVisitor<'a> {
         Self::default()
     }
 
-    /// Add a new visitor to the composition.
-    pub fn add<T: KorokVisitor + 'a>(mut self, visitor: T) -> Self {
+    /// Adds a new visitor to the composition.
+    pub fn with<T: KorokVisitor + 'a>(mut self, visitor: T) -> Self {
         self.visitors.push(Box::new(visitor));
         self
     }

codama-korok-visitors/src/set_accounts_visitor.rs

@@ -126,7 +126,7 @@ impl KorokVisitor for SetAccountsVisitor {
             .map_nested_type_node(|node| {
                 let mut fields = node.fields;
                 fields.insert(0, discriminator);
-                StructTypeNode { fields, ..node }
+                StructTypeNode { fields }
             });
         let discriminator_node = FieldDiscriminatorNode::new(discriminator_name, 0);
 
@@ -160,7 +160,7 @@ fn get_nested_struct_type_node_from_struct(
     // Handle error.
     let message = format!(
         "The \"{}\" struct could not be used as an Account because its type is not a `NestedTypeNode<StructTypeNode>`.",
-        korok.ast.ident.to_string(),
+        korok.ast.ident,
     );
     Err(korok.ast.error(message).into())
 }