@futdevpro/dynamo-eslint 1.14.25 → 1.14.27

package/src/plugin/rules/require-jsdoc-description.spec.ts

@@ -539,4 +539,115 @@ describe('| require-jsdoc-description', () => {
 
     rule.FunctionDeclaration(mockNode);
   });
+
+  it('| should handle abstract class with multiline JSDoc', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when abstract class has multiline JSDoc');
+      },
+      options: [{ scope: 'public' }],
+      sourceCode: {
+        getCommentsBefore: () => [{
+          type: 'Block',
+          value: '* Abstract data service osztály a user műveletek kezeléséhez.\n* Kezeli a login, register, validation és egyéb user-rel kapcsolatos műveleteket.',
+          loc: { end: { line: 3 } },
+        }],
+      },
+    } as any;
+
+    const rule = requireJSDocRule.create(mockContext);
+
+    const mockNode = {
+      type: 'ClassDeclaration',
+      id: { name: 'FDPNTS_User_DataService' },
+      loc: { start: { line: 4 } },
+      parent: {
+        type: 'ExportNamedDeclaration',
+      },
+    } as any;
+
+    rule.ClassDeclaration(mockNode);
+  });
+
+  it('| should handle multiline JSDoc with empty lines', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when JSDoc has multiline description with empty lines');
+      },
+      options: [{ scope: 'public' }],
+      sourceCode: {
+        getCommentsBefore: () => [{
+          type: 'Block',
+          value: '* This is a multiline description\n*\n* with empty lines in between\n* that should still be valid',
+          loc: { end: { line: 4 } },
+        }],
+      },
+    } as any;
+
+    const rule = requireJSDocRule.create(mockContext);
+
+    const mockNode = {
+      type: 'FunctionDeclaration',
+      id: { name: 'testFunction' },
+      loc: { start: { line: 5 } },
+    } as any;
+
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should handle multiline JSDoc followed by @tags', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when JSDoc has description before @tags');
+      },
+      options: [{ scope: 'public' }],
+      sourceCode: {
+        getCommentsBefore: () => [{
+          type: 'Block',
+          value: '* This is a description\n* that spans multiple lines\n* @param {string} name The name parameter',
+          loc: { end: { line: 2 } },
+        }],
+      },
+    } as any;
+
+    const rule = requireJSDocRule.create(mockContext);
+
+    const mockNode = {
+      type: 'FunctionDeclaration',
+      id: { name: 'testFunction' },
+      loc: { start: { line: 3 } },
+    } as any;
+
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should report when abstract class is missing JSDoc', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.type).toBe('Class');
+        expect(options.data.name).toBe('AbstractClass');
+      },
+      options: [{ scope: 'public' }],
+      sourceCode: {
+        getCommentsBefore: () => [],
+      },
+    } as any;
+
+    const rule = requireJSDocRule.create(mockContext);
+
+    const mockNode = {
+      type: 'ClassDeclaration',
+      id: { name: 'AbstractClass' },
+      loc: { start: { line: 1 } },
+      parent: {
+        type: 'ExportNamedDeclaration',
+      },
+    } as any;
+
+    rule.ClassDeclaration(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
 });

package/src/plugin/rules/require-jsdoc-description.ts

@@ -125,6 +125,7 @@ const rule: Rule.RuleModule = {
         }
 
         // JSDoc should be on the line immediately before (no blank lines)
+        // For multi-line comments, check if the last line of the comment is immediately before the node
         return commentEnd === nodeStart - 1;
       } catch (error) {
         console.error('[require-jsdoc-description] Error in isJSDocOnPreviousLine:', error);
@@ -142,24 +143,27 @@ const rule: Rule.RuleModule = {
           return '';
         }
 
+        // The comment.value contains the text between /** and */
+        // It may start with * and include newlines with * at the beginning of each line
         const lines = jsdocComment.value.split('\n');
         let description = '';
 
         for (const line of lines) {
-          // Remove leading * and whitespace
-          const cleanLine = line.replace(/^\s*\*\s?/, '').trim();
+          // Remove leading whitespace and * character (JSDoc format: " * text" or "* text")
+          // Handle both formats: " * text" and "* text" and " *text"
+          const cleanLine = line.replace(/^\s*\*+\s?/, '').trim();
           
-          // Skip empty lines
+          // Skip empty lines (after removing * and whitespace)
           if (!cleanLine) {
             continue;
           }
 
-          // Stop at @tags
+          // Stop at @tags (JSDoc tags like @param, @returns, etc.)
           if (cleanLine.startsWith('@')) {
             break;
           }
 
-          // Add to description
+          // Add to description with space separator
           if (description) {
             description += ' ';
           }
@@ -182,10 +186,18 @@ const rule: Rule.RuleModule = {
         const comments = sourceCode.getCommentsBefore(node);
         
         // Find JSDoc comment (/** ... */)
-        const jsdocComment = comments.find((comment: any) => 
-          comment.type === 'Block' && 
-          comment.value.startsWith('*')
-        );
+        // JSDoc comments are Block comments where the value (content between /** and */) starts with *
+        const jsdocComment = comments.find((comment: any) => {
+          if (comment.type !== 'Block') {
+            return false;
+          }
+          
+          const value = comment.value || '';
+          
+          // JSDoc comment value should start with * (the first character after /**)
+          // Handle cases where there might be whitespace before the *
+          return value.trim().startsWith('*');
+        });
 
         if (!jsdocComment) {
           return { hasJSDoc: false, isValid: false, isOnPreviousLine: false };
@@ -228,6 +240,39 @@ const rule: Rule.RuleModule = {
       }
     }
 
+    /**
+     * Get node name location for error reporting
+     */
+    function getNodeNameLoc(node: any): { start: { line: number; column: number }; end: { line: number; column: number } } | null {
+      try {
+        // For MethodDefinition, use key.loc
+        if (node.key && node.key.loc) {
+          return node.key.loc;
+        }
+
+        // For declarations with id (FunctionDeclaration, ClassDeclaration, etc.)
+        if (node.id && node.id.loc) {
+          return node.id.loc;
+        }
+
+        // For VariableDeclarator
+        if (node.id && node.id.loc) {
+          return node.id.loc;
+        }
+
+        // Fallback to node location if name location not found
+        if (node.loc) {
+          return node.loc;
+        }
+
+        return null;
+      } catch (error) {
+        console.error('[require-jsdoc-description] Error in getNodeNameLoc:', error);
+
+        return null;
+      }
+    }
+
     /**
      * Get node type for error messages
      */
@@ -299,22 +344,26 @@ const rule: Rule.RuleModule = {
       try {
         const name = getNodeName(node);
         const type = getNodeType(node);
+        const nameLoc = getNodeNameLoc(node);
+
+        // Fallback to node location if name location not found
+        const reportLoc = nameLoc || node.loc;
 
         if (!jsdocResult.hasJSDoc) {
           context.report({
-            node,
+            loc: reportLoc,
             messageId: 'missingJSDoc',
             data: { type, name },
           });
         } else if (!jsdocResult.isOnPreviousLine) {
           context.report({
-            node,
+            loc: reportLoc,
             messageId: 'invalidJSDocPosition',
             data: { type, name },
           });
         } else if (!jsdocResult.isValid) {
           context.report({
-            node,
+            loc: reportLoc,
             messageId: 'emptyJSDoc',
             data: { type, name },
           });