refactor(*): split formatting code into seperate modules

Author: piperRyan

src/integrations/mod.rs

@@ -1 +1 @@
-mod rust_postgres;
+mod rust_postgres;

src/integrations/rust_postgres.rs

@@ -1,18 +1,19 @@
-use std::error::Error;
-use postgres::types::{FromSql, IsNull, ToSql, Type, INTERVAL};
-use ::Interval;
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-
+use postgres::types::{FromSql, IsNull, ToSql, Type, INTERVAL};
+use std::error::Error;
+use Interval;
 
 impl FromSql for Interval {
-    fn from_sql(_: &Type, mut raw: &[u8]) 
-            -> Result<Interval, Box<Error + Sync + Send>> {
-
+    fn from_sql(_: &Type, mut raw: &[u8]) -> Result<Interval, Box<Error + Sync + Send>> {
         let microseconds: i64 = raw.read_i64::<BigEndian>()?;
         let days: i32 = raw.read_i32::<BigEndian>()?;
         let months: i32 = raw.read_i32::<BigEndian>()?;
 
-        Ok(Interval{months, days, microseconds})
+        Ok(Interval {
+            months,
+            days,
+            microseconds,
+        })
     }
 
     fn accepts(ty: &Type) -> bool {
@@ -24,9 +25,7 @@ impl FromSql for Interval {
 }
 
 impl ToSql for Interval {
-    fn to_sql(&self, _: &Type, out: &mut Vec<u8>) 
-            -> Result<IsNull, Box<Error + Sync + Send>> {
-
+    fn to_sql(&self, _: &Type, out: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
         out.write_i64::<BigEndian>(self.microseconds)?;
         out.write_i32::<BigEndian>(self.days)?;
         out.write_i32::<BigEndian>(self.months)?;

src/interval_fmt/iso_8601.rs

@@ -0,0 +1,43 @@
+use interval_norm::IntervalNorm;
+
+impl IntervalNorm {
+    /// Produces a iso 8601 compliant interval string.
+    pub fn into_iso_8601(self) -> String {
+        if self.is_zeroed() {
+            return "PT0S".to_owned();
+        }
+        let mut year_interval = "P".to_owned();
+        let mut day_interval = "".to_owned();
+        let mut time_interval;
+        if self.is_time_present() {
+            time_interval = "T".to_owned();
+            if self.hours != 0 {
+                time_interval.push_str(&format!("{}H", self.hours));
+            }
+            if self.minutes != 0 {
+                time_interval.push_str(&format!("{}M", self.minutes));
+            }
+            if self.seconds != 0 {
+                time_interval.push_str(&format!("{}S", self.seconds));
+            }
+            if self.microseconds != 0 {
+                let ms = super::safe_abs_u64(self.microseconds);
+                time_interval.push_str(&format!(".{:06}", ms));
+            }
+        } else {
+            time_interval = "".to_owned();
+        }
+        if self.years != 0 {
+            year_interval.push_str(&format!("{}Y", self.years));
+        }
+        if self.months != 0 {
+            year_interval.push_str(&format!("{}M", self.months));
+        }
+        if self.days != 0 {
+            day_interval.push_str(&format!("{}D", self.days));
+        }
+        year_interval.push_str(&*day_interval);
+        year_interval.push_str(&*time_interval);
+        year_interval
+    }
+}

src/interval_fmt/mod.rs

@@ -0,0 +1,45 @@
+mod iso_8601;
+mod postgres;
+mod sql;
+
+use std::ops::Neg;
+
+/// Safely maps a i64 value to a unsigned number
+/// without any overflow issues.
+fn safe_abs_u64(mut num: i64) -> u64 {
+    let max = i64::max_value();
+    let max_min = max.neg();
+    if num <= max_min {
+        let result = max as u64;
+        num += max;
+        num *= -1;
+        result + num as u64
+    } else {
+        num.abs() as u64
+    }
+}
+
+/// Safely maps a i32 value to a unsigned number
+/// without any overflow issues.
+fn safe_abs_u32(mut num: i32) -> u32 {
+    let max = i32::max_value();
+    let max_min = max.neg();
+    if num <= max_min {
+        let result = max as u32;
+        num += max;
+        num *= -1;
+        result + num as u32
+    } else {
+        num.abs() as u32
+    }
+}
+
+/// Pads a i64 value with a width of 2.
+fn pad_i64(val: i64) -> String {
+    let num = if val < 0 {
+        safe_abs_u64(val)
+    } else {
+        val as u64
+    };
+    return format!("{:02}", num);
+}

src/interval_fmt/postgres.rs

@@ -0,0 +1,51 @@
+use interval_norm::IntervalNorm;
+
+impl IntervalNorm {
+    /// Produces a postgres compliant interval string.
+    pub fn into_postgres(self) -> String {
+        if self.is_zeroed() {
+            return "00:00:00".to_owned();
+        }
+        let mut year_interval = "".to_owned();
+        let mut day_interval = "".to_owned();
+        let time_interval = self.get_postgres_time_interval();
+        if self.is_day_present() {
+            day_interval = format!("{:#?} days ", self.days)
+        }
+        if self.is_year_month_present() {
+            if self.years != 0 {
+                year_interval.push_str(&*format!("{:#?} year ", self.years))
+            }
+            if self.months != 0 {
+                year_interval.push_str(&*format!("{:#?} mons ", self.months));
+            }
+        }
+        year_interval.push_str(&*day_interval);
+        year_interval.push_str(&*time_interval);
+        year_interval.trim().to_owned()
+    }
+
+    fn get_postgres_time_interval(&self) -> String {
+        let mut time_interval = "".to_owned();
+        if self.is_time_present() {
+            let sign = if !self.is_time_interval_pos() {
+                "-".to_owned()
+            } else {
+                "".to_owned()
+            };
+            let hours = super::pad_i64(self.hours);
+            time_interval.push_str(
+                &*(sign
+                    + &hours
+                    + ":"
+                    + &super::pad_i64(self.minutes)
+                    + ":"
+                    + &super::pad_i64(self.seconds)),
+            );
+            if self.microseconds != 0 {
+                time_interval.push_str(&*format!(".{:06}", super::safe_abs_u64(self.microseconds)))
+            }
+        }
+        time_interval
+    }
+}

src/interval_fmt/sql.rs

@@ -0,0 +1,65 @@
+use interval_norm::IntervalNorm;
+
+impl IntervalNorm {
+    pub fn into_sql(self) -> String {
+        if self.is_zeroed() {
+            return "0".to_owned();
+        } else if !self.is_time_present() && !self.is_day_present() {
+            get_year_month(self.months, self.years, true)
+        } else if !self.is_time_present() && !self.is_year_month_present() {
+            format!("{} 0:00:00", self.days)
+        } else if !self.is_year_month_present() && !self.is_day_present() {
+            get_time_interval(
+                self.hours,
+                self.minutes,
+                self.seconds,
+                self.microseconds,
+                self.is_time_interval_pos(),
+                true,
+            )
+        } else {
+            let year_month = get_year_month(self.months, self.years, false);
+            let time_interval = get_time_interval(
+                self.hours,
+                self.minutes,
+                self.seconds,
+                self.microseconds,
+                self.is_time_interval_pos(),
+                false,
+            );
+            format!("{} {:+} {}", year_month, self.days, time_interval)
+        }
+    }
+}
+
+fn get_year_month(mons: i32, years: i32, is_only_year_month: bool) -> String {
+    let months = super::safe_abs_u32(mons);
+    if years == 0 || is_only_year_month {
+        format!("{}-{}", years, months)
+    } else {
+        format!("{:+}-{}", years, months)
+    }
+}
+
+fn get_time_interval(
+    hours: i64,
+    mins: i64,
+    secs: i64,
+    micros: i64,
+    is_time_interval_pos: bool,
+    is_only_time: bool,
+) -> String {
+    let mut interval = "".to_owned();
+    if is_time_interval_pos && is_only_time {
+        interval.push_str(&format!("{}:{:02}:{:02}", hours, mins, secs));
+    } else {
+        let minutes = super::safe_abs_u64(mins);
+        let seconds = super::safe_abs_u64(secs);
+        interval.push_str(&format!("{:+}:{:02}:{:02}", hours, minutes, seconds));
+    }
+    if micros != 0 {
+        let microseconds = format!(".{:06}", super::safe_abs_u64(micros));
+        interval.push_str(&microseconds);
+    }
+    interval
+}

src/interval_norm.rs

@@ -0,0 +1,77 @@
+use pg_interval::Interval;
+
+pub struct IntervalNorm {
+    pub years: i32,
+    pub months: i32,
+    pub days: i32,
+    pub hours: i64,
+    pub minutes: i64,
+    pub seconds: i64,
+    pub microseconds: i64,
+}
+
+impl<'a> From<&'a Interval> for IntervalNorm {
+    fn from(val: &Interval) -> IntervalNorm {
+        // grab the base values from the interval
+        let months = val.months;
+        let days = val.days;
+        let microseconds = val.microseconds;
+        // calc the year and get the remaining months
+        let years = (months - (months % 12)) / 12;
+        let months = months - years * 12;
+        // calc the hours from the microseconds and update
+        // the remaining microseconds.
+        let hours = (microseconds - (microseconds % 3_600_000_000)) / 3_600_000_000;
+        let microseconds = microseconds - hours * 3_600_000_000;
+        // calc the minutes from remaining microseconds and
+        // update the remaining microseconds.
+        let minutes = (microseconds - (microseconds % 60_000_000)) / 60_000_000;
+        let microseconds = microseconds - minutes * 60_000_000;
+        // calc the seconds and update the remaining microseconds.
+        let seconds = (microseconds - (microseconds % 1_000_000)) / 1_000_000;
+        let microseconds = microseconds - seconds * 1_000_000;
+        IntervalNorm {
+            years,
+            months,
+            days,
+            hours,
+            minutes,
+            seconds,
+            microseconds,
+        }
+    }
+}
+
+impl IntervalNorm {
+    /// Is all the values in the interval set to 0?
+    pub fn is_zeroed(&self) -> bool {
+        self.years == 0
+            && self.months == 0
+            && self.hours == 0
+            && self.minutes == 0
+            && self.seconds == 0
+            && self.microseconds == 0
+    }
+
+    /// Is the years or month value set?
+    pub fn is_year_month_present(&self) -> bool {
+        self.years != 0 || self.months != 0
+    }
+
+    /// Is the day value set?
+    pub fn is_day_present(&self) -> bool {
+        self.days != 0
+    }
+
+    /// Is at least one of hours,minutes,seconds,microseconds values
+    /// postive. There are no mixed intervals so we can assume that
+    /// if one value is postive the rest are at least >= 0
+    pub fn is_time_interval_pos(&self) -> bool {
+        self.hours > 0 || self.minutes > 0 || self.seconds > 0 || self.microseconds > 0
+    }
+
+    /// Is the hours,minutes, seconds, microseconds values set?
+    pub fn is_time_present(&self) -> bool {
+        self.hours != 0 || self.minutes != 0 || self.seconds != 0 || self.microseconds != 0
+    }
+}

src/lib.rs

@@ -7,9 +7,9 @@ extern crate byteorder;
 #[cfg(feature = "postgres")]
 mod integrations;
 
-mod pg_formatter;
+mod interval_fmt;
+mod interval_norm;
 mod pg_interval;
 mod pg_interval_add;
 mod pg_interval_sub;
-
 pub use pg_interval::Interval;