sort-comp Allow methods to belong to any matching group.

Author: nosilleg

lib/rules/sort-comp.js

@@ -131,84 +131,91 @@ module.exports = {
      * @returns {Array} The matching patterns indexes. Return [Infinity] if there is no match.
      */
     function getRefPropIndexes(method) {
-      let isRegExp;
-      let matching;
-      let i;
-      let j;
-      const indexes = [];
-
-      if (method.getter) {
-        const getterIndex = methodsOrder.indexOf('getters');
-        if (getterIndex >= 0) {
-          indexes.push(getterIndex);
-        }
-      }
-
-      if (method.setter) {
-        const setterIndex = methodsOrder.indexOf('setters');
-        if (setterIndex >= 0) {
-          indexes.push(setterIndex);
-        }
-      }
-
-      if (method.typeAnnotation) {
-        const annotationIndex = methodsOrder.indexOf('type-annotations');
-        if (annotationIndex >= 0) {
-          indexes.push(annotationIndex);
-        }
-      }
+      const methodGroupIndexes = [];
 
-      if (indexes.length === 0) {
-        for (i = 0, j = methodsOrder.length; i < j; i++) {
-          isRegExp = methodsOrder[i].match(regExpRegExp);
-          if (isRegExp) {
-            matching = new RegExp(isRegExp[1], isRegExp[2]).test(method.name);
-          } else {
-            matching = methodsOrder[i] === method.name;
+      methodsOrder.forEach((currentGroup, groupIndex) => {
+        if (currentGroup === 'getters') {
+          if (method.getter) {
+            methodGroupIndexes.push(groupIndex);
           }
-          if (matching) {
-            indexes.push(i);
+        } else if (currentGroup === 'setters') {
+          if (method.setter) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else if (currentGroup === 'type-annotations') {
+          if (method.typeAnnotation) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else if (currentGroup === 'static-methods') {
+          if (method.static) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else if (currentGroup === 'instance-variables') {
+          if (method.instanceVariable) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else if (currentGroup === 'instance-methods') {
+          if (method.instanceMethod) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else if ([
+          'displayName',
+          'propTypes',
+          'contextTypes',
+          'childContextTypes',
+          'mixins',
+          'statics',
+          'defaultProps',
+          'constructor',
+          'getDefaultProps',
+          'state',
+          'getInitialState',
+          'getChildContext',
+          'getDerivedStateFromProps',
+          'componentWillMount',
+          'UNSAFE_componentWillMount',
+          'componentDidMount',
+          'componentWillReceiveProps',
+          'UNSAFE_componentWillReceiveProps',
+          'shouldComponentUpdate',
+          'componentWillUpdate',
+          'UNSAFE_componentWillUpdate',
+          'getSnapshotBeforeUpdate',
+          'componentDidUpdate',
+          'componentDidCatch',
+          'componentWillUnmount',
+          'render'
+        ].includes(currentGroup)) {
+          if (currentGroup === method.name) {
+            methodGroupIndexes.push(groupIndex);
+          }
+        } else {
+          // Is the group a regex?
+          const isRegExp = currentGroup.match(regExpRegExp);
+          if (isRegExp) {
+            const isMatching = new RegExp(isRegExp[1], isRegExp[2]).test(method.name);
+            if (isMatching) {
+              methodGroupIndexes.push(groupIndex);
+            }
+          } else if (currentGroup === method.name) {
+            methodGroupIndexes.push(groupIndex);
           }
         }
-      }
-
-      if (indexes.length === 0 && method.static) {
-        const staticIndex = methodsOrder.indexOf('static-methods');
-        if (staticIndex >= 0) {
-          indexes.push(staticIndex);
-        }
-      }
-
-      if (indexes.length === 0 && method.instanceVariable) {
-        const annotationIndex = methodsOrder.indexOf('instance-variables');
-        if (annotationIndex >= 0) {
-          indexes.push(annotationIndex);
-        }
-      }
-
-      if (indexes.length === 0 && method.instanceMethod) {
-        const annotationIndex = methodsOrder.indexOf('instance-methods');
-        if (annotationIndex >= 0) {
-          indexes.push(annotationIndex);
-        }
-      }
+      });
 
       // No matching pattern, return 'everything-else' index
-      if (indexes.length === 0) {
-        for (i = 0, j = methodsOrder.length; i < j; i++) {
-          if (methodsOrder[i] === 'everything-else') {
-            indexes.push(i);
-            break;
-          }
-        }
-      }
+      if (methodGroupIndexes.length === 0) {
+        const everythingElseIndex = methodsOrder.indexOf('everything-else');
 
-      // No matching pattern and no 'everything-else' group
-      if (indexes.length === 0) {
-        indexes.push(Infinity);
+        if (everythingElseIndex !== -1) {
+          methodGroupIndexes.push(everythingElseIndex);
+        } else {
+          // No matching pattern and no 'everything-else' group
+          methodGroupIndexes.push(Infinity);
+        }
       }
 
-      return indexes;
+      return methodGroupIndexes;
     }
 
     /**
@@ -409,6 +416,10 @@ module.exports = {
 
         // Loop around the properties a second time (for comparison)
         for (k = 0, l = propertiesInfos.length; k < l; k++) {
+          if (i === k) {
+            continue;
+          }
+
           propB = propertiesInfos[k];
 
           // Compare the properties order