refactor

Author: belchior

src/behavior.rs

@@ -1,5 +1,12 @@
 use crate::fmt;
 
+pub fn push_unique<T: Eq>(list: &mut Vec<T>, value: T) {
+  let prev_item = list.iter().find(|&item| *item == value);
+  if prev_item.is_none() {
+    list.push(value);
+  }
+}
+
 pub fn raw_queries<'a, T>(raw_list: &'a Vec<(T, String)>, clause: &'a T) -> Vec<String>
 where
   T: PartialEq,
@@ -11,29 +18,21 @@ where
     .collect::<Vec<_>>()
 }
 
-pub fn push_unique<'a>(list: &mut Vec<String>, value: String) {
-  let prev_item = list.iter().find(|&item| *item == value);
-
-  if prev_item.is_none() {
-    list.push(value);
-  }
-}
-
 pub trait BuilderInner<'a, T> {
   fn concat(&self, fmts: &fmt::Formatter) -> String;
 
-  fn raws(&self) -> &Vec<String>;
+  fn _raw(&self) -> &Vec<String>;
 
-  fn raw_before(&self) -> &Vec<(T, String)>;
+  fn _raw_before(&self) -> &Vec<(T, String)>;
 
-  fn raw_after(&self) -> &Vec<(T, String)>;
+  fn _raw_after(&self) -> &Vec<(T, String)>;
 
   fn concat_raw(&self, query: String, fmts: &fmt::Formatter) -> String {
-    if self.raws().is_empty() {
+    if self._raw().is_empty() {
       return query;
     }
     let fmt::Formatter { lb, space, .. } = fmts;
-    let raw_sql = self.raws().join(space);
+    let raw_sql = self._raw().join(space);
 
     format!("{query}{raw_sql}{space}{lb}")
   }
@@ -43,8 +42,8 @@ pub trait BuilderInner<'a, T> {
     T: PartialEq,
   {
     let fmt::Formatter { space, .. } = fmts;
-    let raw_before = raw_queries(self.raw_before(), &clause).join(space);
-    let raw_after = raw_queries(self.raw_after(), &clause).join(space);
+    let raw_before = raw_queries(self._raw_before(), &clause).join(space);
+    let raw_after = raw_queries(self._raw_after(), &clause).join(space);
     let space_after = if raw_after.is_empty() == false { space } else { "" };
     let space_before = if raw_before.is_empty() == false { space } else { "" };
 

src/delete.rs

@@ -36,6 +36,23 @@ impl<'a> DeleteBuilder<'a> {
     self
   }
 
+  /// The delete clause. This method overrides the previous value
+  ///
+  /// ```
+  /// use sql_query_builder::DeleteBuilder;
+  ///
+  /// let delete = DeleteBuilder::new()
+  ///   .delete_from("orders");
+  ///
+  /// let delete = DeleteBuilder::new()
+  ///   .delete_from("address")
+  ///   .delete_from("orders");
+  /// ```
+  pub fn delete_from(mut self, table_name: &'a str) -> Self {
+    self._delete_from = table_name.trim();
+    self
+  }
+
   /// Create DeleteBuilder's instance
   pub fn new() -> Self {
     Self::default()
@@ -118,23 +135,6 @@ impl<'a> DeleteBuilder<'a> {
     self
   }
 
-  /// The delete clause. This method overrides the previous value
-  ///
-  /// ```
-  /// use sql_query_builder::DeleteBuilder;
-  ///
-  /// let delete = DeleteBuilder::new()
-  ///   .delete_from("orders");
-  ///
-  /// let delete = DeleteBuilder::new()
-  ///   .delete_from("address")
-  ///   .delete_from("orders");
-  /// ```
-  pub fn delete_from(mut self, table_name: &'a str) -> Self {
-    self._delete_from = table_name.trim();
-    self
-  }
-
   /// The where clause
   pub fn where_clause(mut self, condition: &'a str) -> Self {
     push_unique(&mut self._where, condition.trim().to_owned());
@@ -153,15 +153,15 @@ impl BuilderInner<'_, DeleteClause> for DeleteBuilder<'_> {
     query.trim_end().to_owned()
   }
 
-  fn raws(&self) -> &Vec<String> {
+  fn _raw(&self) -> &Vec<String> {
     &self._raw
   }
 
-  fn raw_after(&self) -> &Vec<(DeleteClause, String)> {
+  fn _raw_after(&self) -> &Vec<(DeleteClause, String)> {
     &self._raw_after
   }
 
-  fn raw_before(&self) -> &Vec<(DeleteClause, String)> {
+  fn _raw_before(&self) -> &Vec<(DeleteClause, String)> {
     &self._raw_before
   }
 }

src/insert.rs

@@ -190,15 +190,15 @@ impl BuilderInner<'_, InsertClause> for InsertBuilder<'_> {
     query.trim_end().to_owned()
   }
 
-  fn raws(&self) -> &Vec<String> {
+  fn _raw(&self) -> &Vec<String> {
     &self._raw
   }
 
-  fn raw_after(&self) -> &Vec<(InsertClause, String)> {
+  fn _raw_after(&self) -> &Vec<(InsertClause, String)> {
     &self._raw_after
   }
 
-  fn raw_before(&self) -> &Vec<(InsertClause, String)> {
+  fn _raw_before(&self) -> &Vec<(InsertClause, String)> {
     &self._raw_before
   }
 }

src/select.rs

@@ -307,15 +307,15 @@ impl BuilderInner<'_, SelectClause> for SelectBuilder<'_> {
     query.trim_end().to_owned()
   }
 
-  fn raws(&self) -> &Vec<String> {
+  fn _raw(&self) -> &Vec<String> {
     &self._raw
   }
 
-  fn raw_after(&self) -> &Vec<(SelectClause, String)> {
+  fn _raw_after(&self) -> &Vec<(SelectClause, String)> {
     &self._raw_after
   }
 
-  fn raw_before(&self) -> &Vec<(SelectClause, String)> {
+  fn _raw_before(&self) -> &Vec<(SelectClause, String)> {
     &self._raw_before
   }
 }

src/update.rs

@@ -160,15 +160,15 @@ impl BuilderInner<'_, UpdateClause> for UpdateBuilder<'_> {
     query.trim_end().to_owned()
   }
 
-  fn raws(&self) -> &Vec<String> {
+  fn _raw(&self) -> &Vec<String> {
     &self._raw
   }
 
-  fn raw_after(&self) -> &Vec<(UpdateClause, String)> {
+  fn _raw_after(&self) -> &Vec<(UpdateClause, String)> {
     &self._raw_after
   }
 
-  fn raw_before(&self) -> &Vec<(UpdateClause, String)> {
+  fn _raw_before(&self) -> &Vec<(UpdateClause, String)> {
     &self._raw_before
   }
 }