ran cargo fmt

seaofvoices · Dec 20, 2024 · 9e9db7f · 9e9db7f
1 parent 75c5b66
commit 9e9db7f
Show file tree

Hide file tree

Showing 11 changed files with 206 additions and 87 deletions.
diff --git a/src/rules/bundle/hybrid_require_mode/mod.rs b/src/rules/bundle/hybrid_require_mode/mod.rs
@@ -1,4 +1,12 @@
-use crate::{nodes::Block, process::{NodeVisitor, ScopeVisitor}, rules::{bundle::BundleOptions, require::HybridRequireMode, Context, FlawlessRule, ReplaceReferencedTokens}, utils::Timer};
+use crate::{
+    nodes::Block,
+    process::{NodeVisitor, ScopeVisitor},
+    rules::{
+        bundle::BundleOptions, require::HybridRequireMode, Context, FlawlessRule,
+        ReplaceReferencedTokens,
+    },
+    utils::Timer,
+};
 
 use super::path_require_mode::RequirePathProcessor;
 
@@ -29,4 +37,4 @@ pub(crate) fn process_block(
     let mut processor = RequirePathProcessor::new(context, options, path_require_mode);
     ScopeVisitor::visit_block(block, &mut processor);
     processor.apply(block, context)
-}
+}
diff --git a/src/rules/bundle/mod.rs b/src/rules/bundle/mod.rs
@@ -1,5 +1,5 @@
-pub(crate) mod path_require_mode;
 pub(crate) mod hybrid_require_mode;
+pub(crate) mod path_require_mode;
 mod require_mode;
 
 use std::path::Path;

diff --git a/src/rules/bundle/path_require_mode/mod.rs b/src/rules/bundle/path_require_mode/mod.rs
@@ -47,7 +47,9 @@ pub(crate) struct RequirePathProcessor<'a, 'b, 'resources, 'code, T: RequirePath
     errors: Vec<String>,
 }
 
-impl<'a, 'b, 'code, 'resources, T: RequirePathLocatorMode> RequirePathProcessor<'a, 'b, 'code, 'resources, T> {
+impl<'a, 'b, 'code, 'resources, T: RequirePathLocatorMode>
+    RequirePathProcessor<'a, 'b, 'code, 'resources, T>
+{
     pub(crate) fn new<'context>(
         context: &'context Context<'b, 'resources, 'code>,
         options: &'a BundleOptions,
@@ -87,11 +89,12 @@ impl<'a, 'b, 'code, 'resources, T: RequirePathLocatorMode> RequirePathProcessor<
 
     fn require_call(&self, call: &FunctionCall) -> Option<PathBuf> {
         if let Some(x) = self.path_locator.require_call(call, &self.source) {
-            return Some(x)
+            return Some(x);
         }
-        
+
         if is_require_call(call, self) {
-            self.path_locator.match_path_require_call(call, &self.source)
+            self.path_locator
+                .match_path_require_call(call, &self.source)
         } else {
             None
         }
@@ -265,15 +268,19 @@ impl<'a, 'b, 'code, 'resources, T: RequirePathLocatorMode> RequirePathProcessor<
     }
 }
 
-impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> Deref for RequirePathProcessor<'a, 'b, 'resources, 'code, T> {
+impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> Deref
+    for RequirePathProcessor<'a, 'b, 'resources, 'code, T>
+{
     type Target = IdentifierTracker;
 
     fn deref(&self) -> &Self::Target {
         &self.identifier_tracker
     }
 }
 
-impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> DerefMut for RequirePathProcessor<'a, 'b, 'resources, 'code, T> {
+impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> DerefMut
+    for RequirePathProcessor<'a, 'b, 'resources, 'code, T>
+{
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.identifier_tracker
     }
@@ -304,7 +311,9 @@ where
     expression
 }
 
-impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> NodeProcessor for RequirePathProcessor<'a, 'b, 'resources, 'code, T> {
+impl<'a, 'b, 'resources, 'code, T: RequirePathLocatorMode> NodeProcessor
+    for RequirePathProcessor<'a, 'b, 'resources, 'code, T>
+{
     fn process_expression(&mut self, expression: &mut Expression) {
         if let Expression::Call(call) = expression {
             if let Some(replace_with) = self.try_inline_call(call) {

diff --git a/src/rules/bundle/require_mode.rs b/src/rules/bundle/require_mode.rs
@@ -2,10 +2,13 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 
-use crate::rules::{require::{HybridRequireMode, PathRequireMode}, RuleProcessResult};
+use crate::rules::{
+    require::{HybridRequireMode, PathRequireMode},
+    RuleProcessResult,
+};
 use crate::{nodes::Block, rules::Context};
 
-use super::{path_require_mode, hybrid_require_mode, BundleOptions};
+use super::{hybrid_require_mode, path_require_mode, BundleOptions};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(deny_unknown_fields, rename_all = "snake_case", tag = "name")]
@@ -54,10 +57,10 @@ impl BundleRequireMode {
         match self {
             Self::Path(path_require_mode) => {
                 path_require_mode::process_block(block, context, options, path_require_mode)
-            },
+            }
             Self::Hybrid(hybrid_require_mode) => {
                 hybrid_require_mode::process_block(block, context, options, hybrid_require_mode)
-            },
+            }
         }
     }
 }
diff --git a/src/rules/convert_require/mod.rs b/src/rules/convert_require/mod.rs
@@ -13,7 +13,7 @@ use crate::rules::{Context, RuleConfiguration, RuleConfigurationError, RulePrope
 
 use instance_path::InstancePath;
 pub use roblox_index_style::RobloxIndexStyle;
-pub use roblox_require_mode::{RobloxRequireMode, parse_roblox};
+pub use roblox_require_mode::{parse_roblox, RobloxRequireMode};
 
 use super::{verify_required_properties, Rule, RuleProcessResult};
 

diff --git a/src/rules/convert_require/roblox_require_mode.rs b/src/rules/convert_require/roblox_require_mode.rs
@@ -7,7 +7,10 @@ use crate::{
     utils, DarkluaError,
 };
 
-use std::{collections::VecDeque, path::{Component, Path, PathBuf}};
+use std::{
+    collections::VecDeque,
+    path::{Component, Path, PathBuf},
+};
 
 use super::{
     instance_path::{get_parent_instance, script_identifier},
@@ -244,15 +247,17 @@ fn get_relative_parent_path(path: &Path) -> &Path {
 
 pub fn parse_roblox(call: &FunctionCall, current_path: &Path) -> DarkluaResult<Option<PathBuf>> {
     let Arguments::Tuple(args) = call.get_arguments() else {
-            Err(DarkluaError::custom("unexpected require call, only accepts tuples")
-            .context("while finding roblox requires")
+        Err(
+            DarkluaError::custom("unexpected require call, only accepts tuples")
+                .context("while finding roblox requires"),
         )?
     };
-    
+
     let mut path_builder = VecDeque::<String>::new();
     let Some(Expression::Field(field)) = args.iter_values().next() else {
-        Err(DarkluaError::custom("unexpected require argument, only accepts fields")
-            .context("while getting roblox path")
+        Err(
+            DarkluaError::custom("unexpected require argument, only accepts fields")
+                .context("while getting roblox path"),
         )?
     };
 
@@ -265,49 +270,86 @@ pub fn parse_roblox(call: &FunctionCall, current_path: &Path) -> DarkluaResult<O
     Ok(Some(current_path))
 }
 
-fn parse_roblox_prefix(prefix: &Prefix, path_builder: &mut VecDeque<String>, current_path: &mut PathBuf) -> DarkluaResult<()> {
+fn parse_roblox_prefix(
+    prefix: &Prefix,
+    path_builder: &mut VecDeque<String>,
+    current_path: &mut PathBuf,
+) -> DarkluaResult<()> {
     match prefix {
         Prefix::Field(x) => parse_roblox_field(&x, path_builder, current_path)?,
         Prefix::Index(x) => parse_roblox_index(&x, path_builder, current_path)?,
-        Prefix::Identifier(x) => handle_roblox_script_parent(&x.get_name(), path_builder, current_path)?,
-        _ => Err(DarkluaError::custom("unexpected prefix, only constants accepted").context("while parsing roblox require"))?
+        Prefix::Identifier(x) => {
+            handle_roblox_script_parent(&x.get_name(), path_builder, current_path)?
+        }
+        _ => Err(
+            DarkluaError::custom("unexpected prefix, only constants accepted")
+                .context("while parsing roblox require"),
+        )?,
     };
     Ok(())
 }
 
-fn parse_roblox_expression(expression: &Expression, path_builder: &mut VecDeque<String>, current_path: &mut PathBuf) -> DarkluaResult<()> {
+fn parse_roblox_expression(
+    expression: &Expression,
+    path_builder: &mut VecDeque<String>,
+    current_path: &mut PathBuf,
+) -> DarkluaResult<()> {
     match expression {
         Expression::Field(x) => parse_roblox_field(x, path_builder, current_path)?,
         Expression::Index(x) => parse_roblox_index(x, path_builder, current_path)?,
-        Expression::Identifier(x) => handle_roblox_script_parent(&x.get_name(), path_builder, current_path)?,
-        Expression::String(x) => handle_roblox_script_parent(x.get_value(), path_builder, current_path)?,
-        _ => Err(DarkluaError::custom("unexpected expression, only constants accepted").context("while parsing roblox require"))?,
+        Expression::Identifier(x) => {
+            handle_roblox_script_parent(&x.get_name(), path_builder, current_path)?
+        }
+        Expression::String(x) => {
+            handle_roblox_script_parent(x.get_value(), path_builder, current_path)?
+        }
+        _ => Err(
+            DarkluaError::custom("unexpected expression, only constants accepted")
+                .context("while parsing roblox require"),
+        )?,
     };
     Ok(())
 }
 
-fn parse_roblox_field(field: &Box<FieldExpression>, path_builder: &mut VecDeque<String>, current_path: &mut PathBuf) -> DarkluaResult<()> {
+fn parse_roblox_field(
+    field: &Box<FieldExpression>,
+    path_builder: &mut VecDeque<String>,
+    current_path: &mut PathBuf,
+) -> DarkluaResult<()> {
     handle_roblox_script_parent(&field.get_field().get_name(), path_builder, current_path)?;
     parse_roblox_prefix(field.get_prefix(), path_builder, current_path)
 }
 
-fn parse_roblox_index(index: &Box<IndexExpression>, path_builder: &mut VecDeque<String>, current_path: &mut PathBuf) -> DarkluaResult<()> {
+fn parse_roblox_index(
+    index: &Box<IndexExpression>,
+    path_builder: &mut VecDeque<String>,
+    current_path: &mut PathBuf,
+) -> DarkluaResult<()> {
     parse_roblox_expression(index.get_index(), path_builder, current_path)?;
     parse_roblox_prefix(index.get_prefix(), path_builder, current_path)
 }
 
-fn handle_roblox_script_parent(str: &str, path_builder: &mut VecDeque<String>, current_path: &mut PathBuf) -> DarkluaResult<()> {
+fn handle_roblox_script_parent(
+    str: &str,
+    path_builder: &mut VecDeque<String>,
+    current_path: &mut PathBuf,
+) -> DarkluaResult<()> {
     match str {
         "script" => {
-            if path_builder.front().map(|x| x != "Parent").unwrap_or_default() {
-                Err(DarkluaError::custom("expected .Parent after script").context("while parsing roblox require"))?
+            if path_builder
+                .front()
+                .map(|x| x != "Parent")
+                .unwrap_or_default()
+            {
+                Err(DarkluaError::custom("expected .Parent after script")
+                    .context("while parsing roblox require"))?
             }
             path_builder.pop_front();
-        },
+        }
         x @ "Parent" => {
             current_path.pop();
             path_builder.push_front(x.to_string());
-        },
+        }
         x => path_builder.push_front(x.to_string()),
     };
     Ok(())