fix: try to fix ci

Author: blitss

.github/workflows/ci.yaml

@@ -23,6 +23,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          path: typeid
       - name: Install cargo-pgrx
         run: |
           PGRX_VERSION=$(cargo metadata --format-version 1 | jq -r '.packages[]|select(.name=="pgrx")|.version')
@@ -34,6 +36,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          path: typeid
       - name: Install PostgreSQL headers
         run: |
           sudo apt-get update
@@ -43,9 +47,8 @@ jobs:
           PGRX_VERSION=$(cargo metadata --format-version 1 | jq -r '.packages[]|select(.name=="pgrx")|.version')
           cargo install --locked --version=$PGRX_VERSION cargo-pgrx --debug --force
           cargo pgrx init --pg14 $(which pg_config)
-      - name: Install PL/PRQL
+      - name: Install TypeID/PRQL
         run: |
-          cd plprql
           cargo pgrx install --no-default-features --release --sudo
       - name: Start PostgreSQL
         run: |
@@ -63,6 +66,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          path: typeid
       - name: Run rustfmt
         run: cargo fmt -- --check
   rust-clippy:
@@ -73,6 +78,9 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+
+        with:
+          path: typeid
       - name: Install cargo-pgrx
         run: |
           PGRX_VERSION=$(cargo metadata --format-version 1 | jq -r '.packages[]|select(.name=="pgrx")|.version')

src/base32.rs

@@ -9,59 +9,57 @@ pub enum Error {
 }
 
 fn decode_base32_to_u128(id: &str) -> Result<u128, Error> {
-  let mut id: [u8; 26] = id.as_bytes().try_into().map_err(|_| Error::InvalidData)?;
-  let mut max = 0;
-  for b in &mut id {
-      *b = CROCKFORD_INV[*b as usize];
-      max |= *b;
-  }
-  if max > 32 || id[0] > 7 {
-      return Err(Error::InvalidData);
-  }
+    let mut id: [u8; 26] = id.as_bytes().try_into().map_err(|_| Error::InvalidData)?;
+    let mut max = 0;
+    for b in &mut id {
+        *b = CROCKFORD_INV[*b as usize];
+        max |= *b;
+    }
+    if max > 32 || id[0] > 7 {
+        return Err(Error::InvalidData);
+    }
 
-  let mut out = 0u128;
-  for b in id {
-      out <<= 5;
-      out |= b as u128;
-  }
+    let mut out = 0u128;
+    for b in id {
+        out <<= 5;
+        out |= b as u128;
+    }
 
-  Ok(out)
+    Ok(out)
 }
 
 fn encode_u128_to_base32(data: u128) -> String {
-  let mut buf = [0u8; 26];
-  let mut data = data;
-  for i in (0..26).rev() {
-      buf[i] = CROCKFORD[(data & 0x1f) as usize];
-      debug_assert!(buf[i].is_ascii());
-      data >>= 5;
-  }
-  unsafe { String::from_utf8_unchecked(buf.to_vec()) }
+    let mut buf = [0u8; 26];
+    let mut data = data;
+    for i in (0..26).rev() {
+        buf[i] = CROCKFORD[(data & 0x1f) as usize];
+        debug_assert!(buf[i].is_ascii());
+        data >>= 5;
+    }
+    unsafe { String::from_utf8_unchecked(buf.to_vec()) }
 }
 
 const CROCKFORD: &[u8; 32] = b"0123456789abcdefghjkmnpqrstvwxyz";
 const CROCKFORD_INV: &[u8; 256] = &{
-  let mut output = [255; 256];
+    let mut output = [255; 256];
 
-  let mut i = 0;
-  while i < 32 {
-      output[CROCKFORD[i as usize] as usize] = i;
-      i += 1;
-  }
+    let mut i = 0;
+    while i < 32 {
+        output[CROCKFORD[i as usize] as usize] = i;
+        i += 1;
+    }
 
-  output
+    output
 };
 
-
 pub fn encode_base32_uuid(uuid: &Uuid) -> String {
-  encode_u128_to_base32(uuid.as_u128())
+    encode_u128_to_base32(uuid.as_u128())
 }
 
 pub fn decode_base32_uuid(encoded: &str) -> Result<Uuid, Error> {
-  decode_base32_to_u128(encoded).map(|result: u128| Uuid::from_u128(result))
+    decode_base32_to_u128(encoded).map(|result: u128| Uuid::from_u128(result))
 }
 
-
 #[cfg(test)]
 mod tests {
     use uuid::Uuid;
@@ -76,4 +74,4 @@ mod tests {
         let decoded = decode_base32_uuid(&encoded).unwrap();
         assert_eq!(uuid, decoded);
     }
-}
+}

src/lib.rs

@@ -10,7 +10,6 @@ use pgrx::prelude::*;
 
 pgrx::pg_module_magic!();
 
-
 #[pg_extern]
 fn typeid_generate(prefix: &str) -> TypeID {
     TypeID::new(TypeIDPrefix::new(prefix).unwrap(), Uuid::now_v7())
@@ -23,7 +22,10 @@ fn typeid_to_uuid(typeid: TypeID) -> pgrx::Uuid {
 
 #[pg_extern]
 fn uuid_to_typeid(prefix: &str, uuid: pgrx::Uuid) -> TypeID {
-    TypeID::new(TypeIDPrefix::new(prefix).unwrap(), Uuid::from_slice(uuid.as_bytes()).unwrap())
+    TypeID::new(
+        TypeIDPrefix::new(prefix).unwrap(),
+        Uuid::from_slice(uuid.as_bytes()).unwrap(),
+    )
 }
 
 #[pg_extern]
@@ -64,8 +66,8 @@ fn typeid_ne(a: TypeID, b: TypeID) -> bool {
     typeid_cmp(a, b) != 0
 }
 
-extension_sql!{
-  r#"
+extension_sql! {
+r#"
    CREATE OPERATOR < (
         LEFTARG = typeid,
         RIGHTARG = typeid,
@@ -114,14 +116,14 @@ extension_sql!{
         OPERATOR 5 > (typeid, typeid),
         FUNCTION 1 typeid_cmp(typeid, typeid);
     "#,
-    name = "create_typeid_operator_class",
-    finalize,
-  }
+  name = "create_typeid_operator_class",
+  finalize,
+}
 
 /// Generate a UUID v7, producing a Postgres uuid object
 #[pg_extern]
 fn uuid_generate_v7() -> pgrx::Uuid {
-  pgrx::Uuid::from_bytes(*Uuid::now_v7().as_bytes())
+    pgrx::Uuid::from_bytes(*Uuid::now_v7().as_bytes())
 }
 
 #[cfg(any(test, feature = "pg_test"))]
@@ -136,7 +138,6 @@ mod tests {
         assert_eq!(typeid.type_prefix(), "test");
     }
 
-
     #[pg_test]
     fn test_uuid() {
         let uuid: pgrx::Uuid = crate::uuid_generate_v7();
@@ -146,7 +147,6 @@ mod tests {
 
         assert_eq!(converted.get_version_num(), 7);
     }
-
 }
 
 /// This module is required by `cargo pgrx test` invocations.

src/typeid.rs

@@ -2,8 +2,8 @@ use core::fmt;
 use std::borrow::Cow;
 
 use pgrx::prelude::*;
+use serde::{Deserialize, Serialize};
 use uuid::Uuid;
-use serde::{Serialize, Deserialize};
 
 use crate::base32::{decode_base32_uuid, encode_base32_uuid};
 
@@ -36,7 +36,7 @@ impl TypeIDPrefix {
     }
 
     pub fn try_unsafe(tag: &str) -> Self {
-      Self(tag.to_string())
+        Self(tag.to_string())
     }
 
     fn try_from_type_prefix(tag: &str) -> Result<Self, Cow<'static, str>> {
@@ -77,58 +77,62 @@ impl TypeIDPrefix {
 pub struct TypeID(TypeIDPrefix, Uuid);
 
 impl TypeID {
-  pub fn new(type_prefix: TypeIDPrefix, uuid: Uuid) -> Self {
-      TypeID(type_prefix, uuid)
-  }
-
-  pub fn from_string(id: &str) -> Result<Self, Error> {
-      // Split the input string once at the first occurrence of '_'
-      let (tag, id) = match id.rsplit_once('_') {
-        Some(("", _)) => return Err(Error::InvalidType),
-        Some((tag, id)) => (tag, id),
-        None => ("", id),
-      };
-
-      // Decode the UUID part and handle potential errors
-      let uuid = decode_base32_uuid(id).map_err(|_| Error::InvalidData)?;
-
-      let prefix = TypeIDPrefix::new(tag)?;
-
-      // Create and return the TypeID
-      Ok(TypeID(prefix, uuid))
-  }
-
-  pub fn type_prefix(&self) -> &str {
-      &self.0.to_type_prefix()
-  }
-
-  pub fn uuid(&self) -> &Uuid {
-      &self.1
-  }
+    pub fn new(type_prefix: TypeIDPrefix, uuid: Uuid) -> Self {
+        TypeID(type_prefix, uuid)
+    }
+
+    pub fn from_string(id: &str) -> Result<Self, Error> {
+        // Split the input string once at the first occurrence of '_'
+        let (tag, id) = match id.rsplit_once('_') {
+            Some(("", _)) => return Err(Error::InvalidType),
+            Some((tag, id)) => (tag, id),
+            None => ("", id),
+        };
+
+        // Decode the UUID part and handle potential errors
+        let uuid = decode_base32_uuid(id).map_err(|_| Error::InvalidData)?;
+
+        let prefix = TypeIDPrefix::new(tag)?;
+
+        // Create and return the TypeID
+        Ok(TypeID(prefix, uuid))
+    }
+
+    pub fn type_prefix(&self) -> &str {
+        self.0.to_type_prefix()
+    }
+
+    pub fn uuid(&self) -> &Uuid {
+        &self.1
+    }
 }
 
 impl fmt::Display for TypeID {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-      if self.type_prefix().is_empty() {
-          write!(f, "{}", encode_base32_uuid(self.uuid()))
-      } else {
-          write!(f, "{}_{}", self.type_prefix(), encode_base32_uuid(self.uuid()))
-      }
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.type_prefix().is_empty() {
+            write!(f, "{}", encode_base32_uuid(self.uuid()))
+        } else {
+            write!(
+                f,
+                "{}_{}",
+                self.type_prefix(),
+                encode_base32_uuid(self.uuid())
+            )
+        }
+    }
 }
 
-
 impl InOutFuncs for TypeID {
-  fn input(input: &core::ffi::CStr) -> TypeID {
-      // Convert the input to a str and handle potential UTF-8 errors
-      let str_input = input.to_str().expect("text input is not valid UTF8");
-
-      TypeID::from_string(str_input).unwrap()
-  }
-
-  fn output(&self, buffer: &mut pgrx::StringInfo) {
-      // Use write! macro to directly push the string representation into the buffer
-      use std::fmt::Write;
-      write!(buffer, "{}", self).expect("Failed to write to buffer");
-  }
-}
+    fn input(input: &core::ffi::CStr) -> TypeID {
+        // Convert the input to a str and handle potential UTF-8 errors
+        let str_input = input.to_str().expect("text input is not valid UTF8");
+
+        TypeID::from_string(str_input).unwrap()
+    }
+
+    fn output(&self, buffer: &mut pgrx::StringInfo) {
+        // Use write! macro to directly push the string representation into the buffer
+        use std::fmt::Write;
+        write!(buffer, "{}", self).expect("Failed to write to buffer");
+    }
+}

tests/spec.rs

@@ -1,6 +1,6 @@
 use libtest_mimic::{Arguments, Trial};
 use serde::Deserialize;
-use typeid::typeid::{TypeID};
+use typeid::typeid::TypeID;
 use uuid::Uuid;
 
 #[derive(Deserialize)]
@@ -27,8 +27,8 @@ fn main() {
     for test in valid {
         tests.push(Trial::test(format!("valid::{}", test.name), move || {
             let id = match TypeID::from_string(&test.typeid) {
-              Ok(id) => id,
-              Err(e) => return Err(e.to_string().into()),
+                Ok(id) => id,
+                Err(e) => return Err(e.to_string().into()),
             };
 
             if id.uuid().ne(&test.uuid) {
@@ -60,4 +60,4 @@ fn main() {
 
     let args = Arguments::from_args();
     libtest_mimic::run(&args, tests).exit_if_failed();
-}
+}