feat: merge my pg_interval_2 fork into mainline

.github/workflows/ci.yml

@@ -14,57 +14,42 @@ env:
 
 jobs:
   test:
-    name: Build, Lint, and Test
-    runs-on: ubuntu-latest
-    container:
-      image: rust:alpine
-    steps:
-      - name: Install Alpine dependencies
-        run: apk add --no-cache git musl-dev
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust components
-        run: rustup component add clippy rustfmt
+    name: test - ${{ matrix.target }}
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            runner: ubuntu-latest
+            os: ubuntu
+          - target: aarch64-unknown-linux-gnu
+            runner: ubuntu-24.04-arm
+            os: ubuntu
+          - target: aarch64-apple-darwin
+            runner: macos-latest
+            os: macos
+    runs-on: ${{ matrix.runner }}
 
-      - name: Cache Cargo dependencies
-        uses: actions/cache@v3
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-alpine-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Check formatting
-        run: cargo fmt -- --check
-
-      - name: Lint with Clippy
-        run: cargo clippy -- -D warnings
-
-      - name: Run Tests
-        run: cargo test --verbose
-
-  publish:
-    name: Publish to Crates.io
+          target: ${{ matrix.target }}
+          rustflags: ""
+      - name: run test
+        run: |
+          cargo test --verbose
+
+  # Check formatting with rustfmt
+  formatting:
+    name: cargo fmt
     runs-on: ubuntu-latest
-    needs: test
-    environment: master
-    if: github.ref == 'refs/heads/master'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Build Release
-        run: cargo build --release
-
-      - name: Publish to Crates.io
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-        run: cargo publish --token $CARGO_REGISTRY_TOKEN
+      - uses: actions/checkout@v4
+      # Ensure rustfmt is installed and setup problem matcher
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: rustfmt
+          rustflags: ""
+      - name: Rustfmt Check
+        uses: actions-rust-lang/rustfmt@v1

Cargo.toml

@@ -2,7 +2,7 @@
 name = "pg_interval"
 version = "0.4.3"
 edition = "2018"
-authors = ["Ryan Piper <piper.ryan235@gmail.com>"]
+authors = ["Ryan Piper <piper.ryan235@gmail.com>", "Ning Sun <n@sunng.info>"]
 license = "MIT"
 description = "A native PostgreSQL interval type"
 repository = "https://github.com/piperRyan/rust-postgres-interval"

README.md

@@ -1,5 +1,3 @@
-[![Build Status](https://travis-ci.org/piperRyan/rust-postgres-interval.svg?branch=master)](https://travis-ci.org/piperRyan/rust-postgres-interval) [![codecov](https://codecov.io/gh/piperRyan/rust-postgres-interval/branch/master/graph/badge.svg)](https://codecov.io/gh/piperRyan/rust-postgres-interval)
-
 # Rust-Postgres-Interval
 A interval type for the postgres driver.
 
@@ -23,18 +21,3 @@ fn main() {
     assert_eq!(String::from("P1Y1M1DT1H"), output);
 }
 ```
-
-## Requirements
-- rust 1.22
-
-## Roadmap to 1.0.0
-
-- [x] Convert Interval Into Formated String
-    - [x] Iso 8601
-    - [x] Postgres
-    - [x] Sql
-- [ ] Parse Formated Strings Into The Interval Type
-    - [x] Iso 8601
-    - [x] Postgres
-    - [ ] Sql
-- [x] Chrono Integrations

src/integrations/duration.rs

@@ -12,9 +12,9 @@ impl Interval {
         let mut days = duration.num_days();
         let mut new_dur = duration - Duration::days(days);
         let mut hours = duration.num_hours();
-        new_dur -= Duration::hours(hours);
+        new_dur = new_dur - Duration::hours(hours);
         let minutes = new_dur.num_minutes();
-        new_dur -= Duration::minutes(minutes);
+        new_dur = new_dur - Duration::minutes(minutes);
         let nano_secs = new_dur.num_nanoseconds()?;
         if days > (i32::MAX as i64) {
             let overflow_days = days - (i32::MAX as i64);

src/interval_fmt/iso_8601.rs

@@ -17,12 +17,19 @@ impl IntervalNorm {
             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));
+            if self.seconds != 0 || self.microseconds != 0 {
+                let secs_with_micros = if self.seconds != 0 && self.microseconds != 0 {
+                    format!(
+                        "{}.{:06}",
+                        self.seconds,
+                        super::safe_abs_u64(self.microseconds)
+                    )
+                } else if self.microseconds != 0 {
+                    format!(".{:06}", super::safe_abs_u64(self.microseconds))
+                } else {
+                    format!("{}", self.seconds)
+                };
+                time_interval.push_str(&format!("{}S", secs_with_micros));
             }
         } else {
             time_interval = "".to_owned();

src/interval_fmt/postgres.rs

@@ -1,5 +1,53 @@
 use crate::interval_norm::IntervalNorm;
 
+fn get_year_suffix(value: i32) -> &'static str {
+    if value == 1 {
+        "year"
+    } else {
+        "years"
+    }
+}
+
+fn get_mon_suffix(value: i32) -> &'static str {
+    if value == 1 {
+        "mon"
+    } else {
+        "mons"
+    }
+}
+
+fn get_day_suffix(value: i32) -> &'static str {
+    if value == 1 {
+        "day"
+    } else {
+        "days"
+    }
+}
+
+fn get_hour_suffix(value: i64) -> &'static str {
+    if value == 1 {
+        "hour"
+    } else {
+        "hours"
+    }
+}
+
+fn get_min_suffix(value: i64) -> &'static str {
+    if value == 1 {
+        "min"
+    } else {
+        "mins"
+    }
+}
+
+fn get_sec_suffix(seconds: i64, microseconds: i64) -> &'static str {
+    if seconds == 1 && microseconds == 0 {
+        "sec"
+    } else {
+        "secs"
+    }
+}
+
 impl IntervalNorm {
     /// Produces a postgres compliant interval string.
     pub fn into_postgres(self) -> String {
@@ -10,14 +58,18 @@ impl IntervalNorm {
         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)
+            day_interval = format!("{} {} ", self.days, get_day_suffix(self.days))
         }
         if self.is_year_month_present() {
             if self.years != 0 {
-                year_interval.push_str(&format!("{:#?} year ", self.years))
+                year_interval.push_str(&*format!("{} {} ", self.years, get_year_suffix(self.years)))
             }
             if self.months != 0 {
-                year_interval.push_str(&format!("{:#?} mons ", self.months));
+                year_interval.push_str(&*format!(
+                    "{} {} ",
+                    self.months,
+                    get_mon_suffix(self.months)
+                ));
             }
         }
         year_interval.push_str(&day_interval);
@@ -48,4 +100,97 @@ impl IntervalNorm {
         }
         time_interval
     }
+
+    /// Produces a postgres_verbose compliant interval string.
+    pub fn into_postgres_verbose(self) -> String {
+        let is_negative = !self.is_time_interval_pos()
+            && (self.years < 0
+                || self.months < 0
+                || self.days < 0
+                || self.hours < 0
+                || self.minutes < 0
+                || self.seconds < 0
+                || self.microseconds < 0);
+
+        let mut parts = Vec::new();
+
+        if self.years != 0 {
+            let abs_years = if self.years < 0 {
+                -self.years
+            } else {
+                self.years
+            };
+            parts.push(format!("{} {}", abs_years, get_year_suffix(abs_years)));
+        }
+
+        if self.months != 0 {
+            let abs_months = if self.months < 0 {
+                -self.months
+            } else {
+                self.months
+            };
+            parts.push(format!("{} {}", abs_months, get_mon_suffix(abs_months)));
+        }
+
+        if self.days != 0 {
+            let abs_days = if self.days < 0 { -self.days } else { self.days };
+            parts.push(format!("{} {}", abs_days, get_day_suffix(abs_days)));
+        }
+
+        if self.hours != 0 {
+            let abs_hours = if self.hours < 0 {
+                -self.hours
+            } else {
+                self.hours
+            };
+            parts.push(format!("{} {}", abs_hours, get_hour_suffix(abs_hours)));
+        }
+
+        if self.minutes != 0 {
+            let abs_minutes = if self.minutes < 0 {
+                -self.minutes
+            } else {
+                self.minutes
+            };
+            parts.push(format!("{} {}", abs_minutes, get_min_suffix(abs_minutes)));
+        }
+
+        if self.seconds != 0 || self.microseconds != 0 {
+            let abs_seconds = if self.seconds < 0 {
+                -self.seconds
+            } else {
+                self.seconds
+            };
+            let abs_micros = if self.microseconds < 0 {
+                -self.microseconds
+            } else {
+                self.microseconds
+            };
+            if abs_micros != 0 {
+                let secs_with_micros = abs_seconds as f64 + abs_micros as f64 / 1_000_000.0;
+                parts.push(format!(
+                    "{} {}",
+                    secs_with_micros,
+                    get_sec_suffix(abs_seconds, abs_micros)
+                ));
+            } else {
+                parts.push(format!(
+                    "{} {}",
+                    abs_seconds,
+                    get_sec_suffix(abs_seconds, abs_micros)
+                ));
+            }
+        }
+
+        if parts.is_empty() {
+            return "@ 0".to_owned();
+        }
+
+        let result = format!("@ {}", parts.join(" "));
+        if is_negative {
+            format!("{} ago", result)
+        } else {
+            result
+        }
+    }
 }