merge

Author: juleswritescode

.github/workflows/publish.reusable.yml

@@ -16,7 +16,6 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-      # ? what's this?! required for executing the node script?
       id-token: write
     steps:
       - uses: actions/checkout@v4

.github/workflows/pull_request.yml

@@ -102,20 +102,20 @@ jobs:
           version: latest
       - name: Run Lints
         run: |
+          cargo sqlx prepare --check --workspace
           cargo clippy
           cargo run -p rules_check
           biome lint
-          cargo sqlx prepare --check --workspace
 
   test:
     name: Test
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         include:
-          # reactive once we upgrade to the latest version of pg_query that is windows-compatible
-          - os: windows-latest
-          - os: ubuntu-latest
+          # use the same images we use for compiling
+          - os: windows-2022
+          - os: ubuntu-22.04
     steps:
       - name: Checkout PR branch
         uses: actions/checkout@v4
@@ -138,8 +138,10 @@ jobs:
         run: cargo test --workspace
 
   test-js-bindings:
-    name: Test JS Bindings
-    runs-on: ubuntu-latest
+    name:
+      Test JS Bindings
+      # use the same image we use for compiling
+    runs-on: ubuntu-22.04
     services:
       postgres:
         image: postgres:latest
@@ -173,7 +175,7 @@ jobs:
 
   codegen:
     name: Check Codegen
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     services:
       postgres:
         image: postgres:latest

.github/workflows/release.yml

@@ -37,12 +37,12 @@ jobs:
     strategy:
       matrix:
         config:
-          - { os: ubuntu-latest, target: x86_64-unknown-linux-gnu }
-          - { os: ubuntu-latest, target: aarch64-unknown-linux-gnu }
-          - { os: macos-latest, target: x86_64-apple-darwin }
-          - { os: macos-latest, target: aarch64-apple-darwin }
-          - { os: windows-latest, target: x86_64-pc-windows-msvc }
-          - { os: windows-latest, target: aarch64-pc-windows-msvc }
+          - { os: ubuntu-22.04, target: x86_64-unknown-linux-gnu }
+          - { os: ubuntu-22.04, target: aarch64-unknown-linux-gnu }
+          - { os: macos-14, target: x86_64-apple-darwin }
+          - { os: macos-14, target: aarch64-apple-darwin }
+          - { os: windows-2022, target: x86_64-pc-windows-msvc }
+          - { os: windows-2022, target: aarch64-pc-windows-msvc }
 
     runs-on: ${{ matrix.config.os }}
 
@@ -87,12 +87,12 @@ jobs:
 
       # windows is a special snowflake too, it saves binaries as .exe
       - name: 👦 Name the Binary
-        if: matrix.config.os == 'windows-latest'
+        if: matrix.config.os == 'windows-2022'
         run: |
           mkdir dist
           cp target/${{ matrix.config.target }}/release/postgrestools.exe ./dist/postgrestools_${{ matrix.config.target }}
       - name: 👦 Name the Binary
-        if: matrix.config.os != 'windows-latest'
+        if: matrix.config.os != 'windows-2022'
         run: |
           mkdir dist
           cp target/${{ matrix.config.target }}/release/postgrestools ./dist/postgrestools_${{ matrix.config.target }}

crates/pgt_workspace/src/workspace/server/change.rs

@@ -140,6 +140,8 @@ impl Document {
         let mut start = change_range.start();
         let mut end = change_range.end().min(content_size);
 
+        let is_trim = change_range.start() >= content_size;
+
         let mut affected_indices = Vec::new();
         let mut prev_index = None;
         let mut next_index = None;
@@ -157,23 +159,20 @@ impl Document {
             }
         }
 
-        let start_incl = prev_index
+        let first_affected_stmt_start = prev_index
             .map(|i| self.positions[i].1.start())
             .unwrap_or(start);
-        let end_incl = next_index
+
+        let mut last_affected_stmt_end = next_index
             .map(|i| self.positions[i].1.end())
             .unwrap_or_else(|| end);
 
-        let end_incl = if is_addition {
-            end_incl.add(diff_size)
-        } else {
-            end_incl.sub(diff_size)
-        };
-
-        let end = if is_addition {
-            end.add(diff_size)
-        } else {
-            end.sub(diff_size)
+        if is_addition {
+            end = end.add(diff_size);
+            last_affected_stmt_end = last_affected_stmt_end.add(diff_size);
+        } else if !is_trim {
+            end = end.sub(diff_size);
+            last_affected_stmt_end = last_affected_stmt_end.sub(diff_size)
         };
 
         Affected {
@@ -185,8 +184,10 @@ impl Document {
             prev_index,
             next_index,
             full_affected_range: TextRange::new(
-                start_incl,
-                end_incl.min(content_size).max(start_incl),
+                first_affected_stmt_start,
+                last_affected_stmt_end
+                    .min(content_size)
+                    .max(first_affected_stmt_start),
             ),
         }
     }
@@ -221,6 +222,7 @@ impl Document {
         let mut changed: Vec<StatementChange> = Vec::with_capacity(self.positions.len());
 
         let change_range = change.range.unwrap();
+        let previous_content = self.content.clone();
         let new_content = change.apply_to_text(&self.content);
 
         // we first need to determine the affected range and all affected statements, as well as
@@ -261,15 +263,15 @@ impl Document {
                 let new_range = new_ranges[0].add(affected_range.start());
                 let (old_id, old_range) = self.positions[affected_idx].clone();
 
-                // move all statements after the afffected range
+                // move all statements after the affected range
                 self.move_ranges(old_range.end(), change.diff_size(), change.is_addition());
 
                 let new_id = self.id_generator.next();
                 self.positions[affected_idx] = (new_id.clone(), new_range);
 
                 changed.push(StatementChange::Modified(ModifiedStatement {
                     old_stmt: old_id.clone(),
-                    old_stmt_text: self.content[old_range].to_string(),
+                    old_stmt_text: previous_content[old_range].to_string(),
 
                     new_stmt: new_id,
                     new_stmt_text: changed_content[new_ranges[0]].to_string(),
@@ -1285,4 +1287,139 @@ mod tests {
 
         assert_document_integrity(&d);
     }
+
+    #[test]
+    fn remove_trailing_whitespace() {
+        let path = PgTPath::new("test.sql");
+
+        let mut doc = Document::new(path.clone(), "select * from ".to_string(), 0);
+
+        let change = ChangeFileParams {
+            path: path.clone(),
+            version: 1,
+            changes: vec![ChangeParams {
+                text: "".to_string(),
+                range: Some(TextRange::new(13.into(), 14.into())),
+            }],
+        };
+
+        let changed = doc.apply_file_change(&change);
+
+        assert_eq!(doc.content, "select * from");
+
+        assert_eq!(changed.len(), 1);
+
+        match &changed[0] {
+            StatementChange::Modified(stmt) => {
+                let ModifiedStatement {
+                    change_range,
+                    change_text,
+                    new_stmt_text,
+                    old_stmt_text,
+                    ..
+                } = stmt;
+
+                assert_eq!(change_range, &TextRange::new(13.into(), 14.into()));
+                assert_eq!(change_text, "");
+                assert_eq!(new_stmt_text, "select * from");
+
+                // the whitespace was not considered
+                // to be a part of the statement
+                assert_eq!(old_stmt_text, "select * from");
+            }
+
+            _ => assert!(false, "Did not yield a modified statement."),
+        }
+
+        assert_document_integrity(&doc);
+    }
+
+    #[test]
+    fn remove_trailing_whitespace_and_last_char() {
+        let path = PgTPath::new("test.sql");
+
+        let mut doc = Document::new(path.clone(), "select * from ".to_string(), 0);
+
+        let change = ChangeFileParams {
+            path: path.clone(),
+            version: 1,
+            changes: vec![ChangeParams {
+                text: "".to_string(),
+                range: Some(TextRange::new(12.into(), 14.into())),
+            }],
+        };
+
+        let changed = doc.apply_file_change(&change);
+
+        assert_eq!(doc.content, "select * fro");
+
+        assert_eq!(changed.len(), 1);
+
+        match &changed[0] {
+            StatementChange::Modified(stmt) => {
+                let ModifiedStatement {
+                    change_range,
+                    change_text,
+                    new_stmt_text,
+                    old_stmt_text,
+                    ..
+                } = stmt;
+
+                assert_eq!(change_range, &TextRange::new(12.into(), 14.into()));
+                assert_eq!(change_text, "");
+                assert_eq!(new_stmt_text, "select * fro");
+
+                // the whitespace was not considered
+                // to be a part of the statement
+                assert_eq!(old_stmt_text, "select * from");
+            }
+
+            _ => assert!(false, "Did not yield a modified statement."),
+        }
+
+        assert_document_integrity(&doc);
+    }
+
+    #[test]
+    fn remove_inbetween_whitespace() {
+        let path = PgTPath::new("test.sql");
+
+        let mut doc = Document::new(path.clone(), "select *   from users".to_string(), 0);
+
+        let change = ChangeFileParams {
+            path: path.clone(),
+            version: 1,
+            changes: vec![ChangeParams {
+                text: "".to_string(),
+                range: Some(TextRange::new(9.into(), 11.into())),
+            }],
+        };
+
+        let changed = doc.apply_file_change(&change);
+
+        assert_eq!(doc.content, "select * from users");
+
+        assert_eq!(changed.len(), 1);
+
+        match &changed[0] {
+            StatementChange::Modified(stmt) => {
+                let ModifiedStatement {
+                    change_range,
+                    change_text,
+                    new_stmt_text,
+                    old_stmt_text,
+                    ..
+                } = stmt;
+
+                assert_eq!(change_range, &TextRange::new(9.into(), 11.into()));
+                assert_eq!(change_text, "");
+                assert_eq!(old_stmt_text, "select *   from users");
+                assert_eq!(new_stmt_text, "select * from users");
+            }
+
+            _ => assert!(false, "Did not yield a modified statement."),
+        }
+
+        assert_document_integrity(&doc);
+    }
 }