Merge pull request #2649 from codefori/fix/searchCommaMembers

Fixed member search path parsing

Author: sebjulliand

src/api/Search.ts

@@ -1,30 +1,43 @@
-import * as path from 'path';
 import { GetMemberInfo } from './components/getMemberInfo';
-import { IBMiMember, SearchHit, SearchResults } from './types';
-import { Tools } from './Tools';
 import IBMi from './IBMi';
+import { Tools } from './Tools';
+import { IBMiMember, SearchHit, SearchResults } from './types';
 
 export namespace Search {
-  export async function searchMembers(connection: IBMi, library: string, sourceFile: string, searchTerm: string, members: string|IBMiMember[], readOnly?: boolean,): Promise<SearchResults> {
+
+  function parseHitPath(hit: SearchHit): IBMiMember {
+    const parts = hit.path.split('/');
+    if (parts.length == 4) {
+      parts.shift();
+    }
+    return {
+      library: parts[0],
+      file: parts[1],
+      name: parts[2],
+      extension: ''
+    };
+  }
+
+  export async function searchMembers(connection: IBMi, library: string, sourceFile: string, searchTerm: string, members: string | IBMiMember[], readOnly?: boolean,): Promise<SearchResults> {
     const config = connection.getConfig();
     const content = connection.getContent();
 
     if (connection && config && content) {
-      let detailedMembers: IBMiMember[]|undefined;
-      let memberFilter: string|undefined;
+      let detailedMembers: IBMiMember[] | undefined;
+      let memberFilter: string | undefined;
 
       if (typeof members === `string`) {
         memberFilter = connection.sysNameInAmerican(`${members}.MBR`);
       } else
-      if (Array.isArray(members)) {
-        if (members.length > connection.maximumArgsLength) {
-          detailedMembers = members;
-          memberFilter = "*.MBR";
-        } else {
-          memberFilter = members.map(member => `${member.name}.MBR`).join(` `);
+        if (Array.isArray(members)) {
+          if (members.length > connection.maximumArgsLength) {
+            detailedMembers = members;
+            memberFilter = "*.MBR";
+          } else {
+            memberFilter = members.map(member => `${member.name}.MBR`).join(` `);
+          }
         }
-      }
- 
+
       // First, let's fetch the ASP info
       const asp = await connection.lookupLibraryIAsp(library);
 
@@ -43,38 +56,23 @@ export namespace Search {
         if (detailedMembers) {
           // If the user provided a list of members, we need to filter the results to only include those members
           hits = hits.filter(hit => {
-            const { name, dir } = path.parse(hit.path);
-            const [lib, spf] = dir.split(`/`);
-            return detailedMembers!.some(member => member.name === name && member.library === lib && member.file === spf);
+            const hitMember = parseHitPath(hit);
+            return detailedMembers!.some(member => member.name === hitMember.name && member.library === hitMember.library && member.file === hitMember.file);
           });
 
         } else {
           // Else, we need to fetch the member info for each hit so we can display the correct extension
           const infoComponent = connection?.getComponent<GetMemberInfo>(GetMemberInfo.ID);
-          const memberInfos: IBMiMember[] = hits.map(hit => {
-            const { name, dir } = path.parse(hit.path);
-            const [library, file] = dir.split(`/`);
-
-            return {
-              name,
-              library,
-              file,
-              extension: ``
-            };
-          });
-
-          detailedMembers = await infoComponent?.getMultipleMemberInfo(connection, memberInfos);
+          detailedMembers = await infoComponent?.getMultipleMemberInfo(connection, hits.map(parseHitPath));
         }
 
         // Then fix the extensions in the hit
         for (const hit of hits) {
-          const { name, dir } = path.parse(hit.path);
-          const [lib, spf] = dir.split(`/`);
-
-          const foundMember = detailedMembers?.find(member => member.name === name && member.library === lib && member.file === spf);
+          const hitMember = parseHitPath(hit);
+          const foundMember = detailedMembers?.find(member => member.name === hitMember.name && member.library === hitMember.library && member.file === hitMember.file);
 
           if (foundMember) {
-            hit.path = connection.sysNameInLocal(`${asp ? `${asp}/` : ``}${lib}/${spf}/${name}.${foundMember.extension}`);
+            hit.path = connection.sysNameInLocal(`${asp ? `${asp}/` : ``}${foundMember.library}/${foundMember.file}/${foundMember.name}.${foundMember.extension}`);
           }
         }
 

src/api/tests/suites/search.test.ts

@@ -1,10 +1,12 @@
-import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { parseFilter } from '../../Filter';
-import { Search } from '../../Search';
 import IBMi from '../../IBMi';
-import { newConnection, disposeConnection, CONNECTION_TIMEOUT } from '../connection';
+import { Search } from '../../Search';
+import { Tools } from '../../Tools';
+import { SearchResults } from '../../types';
+import { CONNECTION_TIMEOUT, disposeConnection, newConnection } from '../connection';
 
-describe('Search Tests', {concurrent: true}, () => {
+describe('Search Tests', { concurrent: true }, () => {
   let connection: IBMi
   beforeAll(async () => {
     connection = await newConnection();
@@ -53,5 +55,46 @@ describe('Search Tests', {concurrent: true}, () => {
     expect(result.hits.length).toBe(6);
     expect(checkNames(result.hits.map(hit => hit.path.split("/").at(-1)!))).toBe(true);
     expect(result.hits.every(hit => !hit.path.endsWith(`MBR`))).toBe(true);
-  });
+  }),
+
+    it('Member with `.` in name search', async () => {
+      const library = connection.getConfig().tempLibrary;
+      const file = `ZZ${Tools.makeid(6)}`;
+      const crtsrcpf = await connection.runCommand({ command: `CRTSRCPF FILE(${library}/${file}) RCDLEN(112)`, noLibList: true });
+      if (crtsrcpf.code !== 0) {
+        throw new Error(`Failed to create test source file: ${crtsrcpf.stderr}`);
+      }
+      try {
+        const members = [
+          { name: "AN.RPGLE", type: "RPGLE", content: ["Some random text", "nobody will read", "but that's for testing"] },
+          { name: "A.CLLE", type: "CLLE", content: ["More random text", "testing is fun", "or so they say"] },
+          { name: "A.CMD", type: "CMD", content: ["This is not valid for a command", "this is for a test", "so I guess it's fine"] }
+        ];
+
+        for (const member of members) {
+          const addpfm = await connection.runCommand({ command: `ADDPFM FILE(${library}/${file}) MBR(${member.name}) SRCTYPE(${member.type})`, noLibList: true });
+          if (addpfm.code !== 0) {
+            throw new Error(`Failed to add test member: ${addpfm.stderr}`);
+          }
+          await connection.getContent().uploadMemberContent(library, file, member.name, member.content.join("\n"));
+        }
+
+        const hasMember = (results: SearchResults, member: string) => results.hits.map(hit => hit.path.split('/').pop()).includes(member);
+
+        const searchTest = await Search.searchMembers(connection, library, file, "test", '*');
+        expect(searchTest.hits.length).toBe(3);
+        expect(hasMember(searchTest, "AN.RPGLE")).toBe(true);
+        expect(hasMember(searchTest, "A.CLLE")).toBe(true);
+        expect(hasMember(searchTest, "A.CMD")).toBe(true);
+
+        const searchTesting = await Search.searchMembers(connection, library, file, "testing", '*');
+        expect(searchTesting.hits.length).toBe(2);
+        expect(hasMember(searchTesting, "AN.RPGLE")).toBe(true);
+        expect(hasMember(searchTesting, "A.CLLE")).toBe(true);
+        expect(hasMember(searchTesting, "A.CMD")).toBe(false);
+      }
+      finally {
+        await connection.runCommand({ command: `DLTF FILE(${library} / ${file})`, noLibList: true });
+      }
+    });
 });