From 0908e81f3857179d5fbfce4faa845d6cedf83977 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Thu, 9 Sep 2021 10:59:33 -0500
Subject: [PATCH] refactor(de): Consolidate array logic (#182)

---
 src/easy/de/array.rs           | 14 +++++++++++---
 src/easy/de/array_of_tables.rs | 29 -----------------------------
 src/easy/de/item.rs            |  2 +-
 src/easy/de/mod.rs             |  2 --
 src/easy/de/table.rs           | 28 ----------------------------
 src/easy/de/value.rs           |  4 +++-
 6 files changed, 15 insertions(+), 64 deletions(-)
 delete mode 100644 src/easy/de/array_of_tables.rs

diff --git a/src/easy/de/array.rs b/src/easy/de/array.rs
index ea403e5a..f545d2fa 100644
--- a/src/easy/de/array.rs
+++ b/src/easy/de/array.rs
@@ -1,15 +1,23 @@
 use crate::easy::de::Error;
 
 pub(crate) struct ArraySeqAccess {
-    iter: crate::ArrayIntoIter,
+    iter: std::vec::IntoIter<crate::Item>,
 }
 
 impl ArraySeqAccess {
-    pub(crate) fn new(input: crate::Array) -> Self {
+    pub(crate) fn new(input: Vec<crate::Item>) -> Self {
         Self {
             iter: input.into_iter(),
         }
     }
+
+    pub(crate) fn with_array(input: crate::Array) -> Self {
+        Self::new(input.values)
+    }
+
+    pub(crate) fn with_array_of_tables(input: crate::ArrayOfTables) -> Self {
+        Self::new(input.values)
+    }
 }
 
 impl<'de> serde::de::SeqAccess<'de> for ArraySeqAccess {
@@ -21,7 +29,7 @@ impl<'de> serde::de::SeqAccess<'de> for ArraySeqAccess {
     {
         match self.iter.next() {
             Some(v) => seed
-                .deserialize(&mut crate::easy::de::ValueDeserializer::new(v))
+                .deserialize(&mut crate::easy::de::ItemDeserializer::new(v))
                 .map(Some),
             None => Ok(None),
         }
diff --git a/src/easy/de/array_of_tables.rs b/src/easy/de/array_of_tables.rs
deleted file mode 100644
index 60db5250..00000000
--- a/src/easy/de/array_of_tables.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use crate::easy::de::Error;
-
-pub(crate) struct ArrayOfTablesSeqAccess {
-    iter: crate::ArrayOfTablesIntoIter,
-}
-
-impl<'de> ArrayOfTablesSeqAccess {
-    pub(crate) fn new(input: crate::ArrayOfTables) -> Self {
-        Self {
-            iter: input.into_iter(),
-        }
-    }
-}
-
-impl<'de> serde::de::SeqAccess<'de> for ArrayOfTablesSeqAccess {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: serde::de::DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(v) => seed
-                .deserialize(&mut crate::easy::de::TableDeserializer::new(v))
-                .map(Some),
-            None => Ok(None),
-        }
-    }
-}
diff --git a/src/easy/de/item.rs b/src/easy/de/item.rs
index b813f978..cee30639 100644
--- a/src/easy/de/item.rs
+++ b/src/easy/de/item.rs
@@ -26,7 +26,7 @@ impl<'de, 'a> serde::Deserializer<'de> for &'a mut ItemDeserializer {
             }
             crate::Item::Table(v) => visitor.visit_map(crate::easy::de::TableMapAccess::new(v)),
             crate::Item::ArrayOfTables(v) => {
-                visitor.visit_seq(crate::easy::de::ArrayOfTablesSeqAccess::new(v))
+                visitor.visit_seq(crate::easy::de::ArraySeqAccess::with_array_of_tables(v))
             }
         }
     }
diff --git a/src/easy/de/mod.rs b/src/easy/de/mod.rs
index 7a4a3e0c..1618cf9e 100644
--- a/src/easy/de/mod.rs
+++ b/src/easy/de/mod.rs
@@ -5,14 +5,12 @@
 use serde::Deserialize;
 
 mod array;
-mod array_of_tables;
 mod inline_table;
 mod item;
 mod table;
 mod value;
 
 use array::*;
-use array_of_tables::*;
 use inline_table::*;
 use item::*;
 use table::*;
diff --git a/src/easy/de/table.rs b/src/easy/de/table.rs
index e0dfe0d9..a9dcaa47 100644
--- a/src/easy/de/table.rs
+++ b/src/easy/de/table.rs
@@ -2,34 +2,6 @@ use serde::de::IntoDeserializer;
 
 use crate::easy::de::Error;
 
-pub(crate) struct TableDeserializer {
-    input: crate::Table,
-}
-
-impl TableDeserializer {
-    pub(crate) fn new(input: crate::Table) -> Self {
-        Self { input }
-    }
-}
-
-impl<'de, 'a> serde::Deserializer<'de> for &'a mut TableDeserializer {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let mut input = crate::Table::new();
-        std::mem::swap(&mut input, &mut self.input);
-        visitor.visit_map(TableMapAccess::new(input))
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map option unit newtype_struct
-        ignored_any unit_struct tuple_struct tuple enum identifier struct
-    }
-}
 pub(crate) struct TableMapAccess {
     iter: linked_hash_map::IntoIter<crate::repr::InternalString, crate::table::TableKeyValue>,
     value: Option<crate::Item>,
diff --git a/src/easy/de/value.rs b/src/easy/de/value.rs
index 4fb427f7..c380a4d4 100644
--- a/src/easy/de/value.rs
+++ b/src/easy/de/value.rs
@@ -28,7 +28,9 @@ impl<'de, 'a> serde::Deserializer<'de> for &'a mut ValueDeserializer {
             crate::Value::LocalDateTime(v) => visitor.visit_string(v.into_value().to_string()),
             crate::Value::LocalDate(v) => visitor.visit_string(v.into_value().to_string()),
             crate::Value::LocalTime(v) => visitor.visit_string(v.into_value().to_string()),
-            crate::Value::Array(v) => visitor.visit_seq(crate::easy::de::ArraySeqAccess::new(v)),
+            crate::Value::Array(v) => {
+                visitor.visit_seq(crate::easy::de::ArraySeqAccess::with_array(v))
+            }
             crate::Value::InlineTable(v) => {
                 visitor.visit_map(crate::easy::de::InlineTableMapAccess::new(v))
             }