immosquare-cleaner 0.1.36 → 0.1.37

data/node_modules/eslint-plugin-align-assignments/README.md

@@ -0,0 +1,49 @@
+# eslint-plugin-align-assignments 
+
+ESLint rule to enforce alignment of assignment declarations in a group. 
+
+[![Build Status](https://travis-ci.org/lucasefe/eslint-plugin-align-assignments.svg?branch=master)](https://travis-ci.org/lucasefe/eslint-plugin-align-assignments)
+
+## Installation
+
+You'll first need to install [ESLint](http://eslint.org):
+
+```
+$ npm install eslint --save-dev
+```
+
+Next, install `eslint-plugin-align-assignments`:
+
+```
+$ npm install eslint-plugin-align-assignments --save-dev
+```
+
+**Note:** If you installed ESLint globally (using the `-g` flag) then you must
+also install `eslint-plugin-align-assignmentss` globally.
+
+## Usage
+
+Add `align-assignments` to the plugins section of your `.eslintrc` configuration
+file. You can omit the `eslint-plugin-` prefix:
+
+```json
+{
+  "plugins": [
+    "align-assignments"
+  ]
+}
+```
+
+
+Then configure the rules you want to use under the rules section.
+
+```json
+{
+  "rules": {
+    "align-assignments/align-assignments": [2, { "requiresOnly": false } ]
+  }
+}
+```
+
+
+

data/node_modules/eslint-plugin-align-assignments/docs/rules/align-assignment.md

@@ -0,0 +1,36 @@
+# align-assignment (align-assignment)
+
+Please describe the origin of the rule here.
+
+
+## Rule Details
+
+This rule aims to...
+
+Examples of **incorrect** code for this rule:
+
+```js
+
+// fill me in
+
+```
+
+Examples of **correct** code for this rule:
+
+```js
+
+// fill me in
+
+```
+
+### Options
+
+If there are any options, describe them here. Otherwise, delete this section.
+
+## When Not To Use It
+
+Give a short description of when it would be appropriate to turn off this rule.
+
+## Further Reading
+
+If there are other links that describe the issue this rule addresses, please include them here in a bulleted list.

data/node_modules/eslint-plugin-align-assignments/lib/index.js

@@ -0,0 +1,5 @@
+const alignAssignments = require('./rules/align-assignments');
+
+exports.rules = {
+  'align-assignments': alignAssignments
+};

data/node_modules/eslint-plugin-align-assignments/lib/rules/align-assignments.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview align-assignments
+ * @author Lucas Florio
+ */
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const hasRequire   = /require\(/;
+const spaceMatcher = /(\s*)((?:\+|-|\*|\/|%|&|\^|\||<<|>>|\*\*|>>>)?=)/;
+
+module.exports = {
+  meta: {
+    fixable: 'code'
+  },
+
+  create(context) {
+    const { options }  = context;
+    const requiresOnly = options && options.length > 0 && options[0].requiresOnly;
+    const sourceCode   = context.getSourceCode();
+    const groups       = [];
+    let previousNode;
+
+    return {
+      VariableDeclaration(node) {
+        const source = sourceCode.getText(node);
+        if (requiresOnly && !hasRequire.test(source))
+          return;
+
+        addNode(node, node);
+      },
+
+      ExpressionStatement(node) {
+        // Does it contain an assignment expression?
+        const hasAssignmentExpression = node.expression.type === 'AssignmentExpression';
+        if (!hasAssignmentExpression)
+          return;
+
+        addNode(node, node.expression);
+      },
+      'Program:exit': checkAll
+    };
+
+    function checkAll() {
+      groups.forEach(check);
+    }
+
+    function isAssignmentExpression(node) {
+      return node.type === 'AssignmentExpression';
+    }
+
+    function addNode(groupNode, node) {
+      if (shouldStartNewGroup(groupNode, previousNode))
+        groups.push([ node ]);
+      else
+        getLast(groups).push(node);
+
+      previousNode = groupNode;
+    }
+
+    function shouldStartNewGroup(node) {
+      // first line of all
+      if (!previousNode) return true;
+
+      // switching parent nodes
+      if (node.parent !== previousNode.parent)
+        return true;
+
+      // If previous node was a for and included the declarations, new group
+      if (previousNode.parent.type === 'ForStatement' && previousNode.declarations)
+        return true;
+
+      // previous line was blank.
+      const lineOfNode = sourceCode.getFirstToken(node).loc.start.line;
+      const lineOfPrev = sourceCode.getLastToken(previousNode).loc.start.line;
+      return lineOfNode - lineOfPrev !== 1;
+    }
+
+    function check(group) {
+      const maxPos = getMaxPos(group);
+
+      if (!areAligned(maxPos, group)) {
+        context.report({
+          loc: {
+            start: group[0].loc.start,
+            end:   getLast(group).loc.end
+          },
+          message: 'This group of assignments is not aligned',
+          fix:     fixer =>  {
+            const fixings = group.map(function(node) {
+              const tokens           = sourceCode.getTokens(node);
+              const firstToken       = tokens[0];
+              const assignmentToken  = tokens.find(token => [ '=', '+=', '-=', '*=', '/=', '%=', '&=', '^=', '|=', '<<=', '>>=', '**=', '>>>=' ].includes(token.value));
+              const line             = sourceCode.getText(node);
+              const lineIsAligned    = line.charAt(maxPos) === '=';
+              if (lineIsAligned || !assignmentToken || isMultiline(firstToken, assignmentToken))
+                return fixer.replaceText(node, line);
+              else {
+                // source line may include spaces, we need to accomodate for that.
+                const spacePrefix    = firstToken.loc.start.column;
+                const startDelimiter = assignmentToken.loc.start.column - spacePrefix;
+                const endDelimiter   = assignmentToken.loc.end.column - spacePrefix;
+                const start          = line.slice(0, startDelimiter).replace(/\s+$/m, '');
+                const ending         = line.slice(endDelimiter).replace(/^\s+/m, '');
+                const spacesRequired = maxPos - start.length - assignmentToken.value.length + 1;
+                const spaces         = ' '.repeat(spacesRequired);
+                const fixedText      = `${start}${spaces}${assignmentToken.value} ${ending}`;
+                return fixer.replaceText(node, fixedText);
+              }
+            });
+
+            return fixings.filter(fix => fix);
+          }
+        });
+      }
+    }
+
+    function isMultiline(firstToken, assignmentToken) {
+      return firstToken.loc.start.line !== assignmentToken.loc.start.line;
+    }
+
+    function findAssigment(node) {
+      const prefix   = getPrefix(node);
+      const source   = sourceCode.getText(node);
+      const match    = source.substr(prefix).match(spaceMatcher);
+      const position = match ? match.index + prefix + match[2].length : null;
+      return position;
+    }
+
+    function getPrefix(node) {
+      const nodeBefore = isAssignmentExpression(node) ?
+        node.left :
+        node.declarations.find(dcl => dcl.type === 'VariableDeclarator').id;
+
+      const prefix = nodeBefore.loc.end.column - nodeBefore.loc.start.column;
+      return prefix;
+    }
+
+    function areAligned(maxPos, nodes) {
+      return nodes
+        .filter(assignmentOnFirstLine)
+        .map(node => sourceCode.getText(node))
+        .every(source => source.charAt(maxPos) === '=');
+    }
+
+    function getMaxPos(nodes) {
+      return nodes
+        .filter(assignmentOnFirstLine)
+        .map(findAssigment)
+        .reduce((last, current) => Math.max(last, current), []);
+    }
+
+    function assignmentOnFirstLine(node) {
+      if (isAssignmentExpression(node)) {
+        const onFirstLine = node.left.loc.start.line === node.right.loc.start.line;
+        return onFirstLine;
+      } else {
+        const source = sourceCode.getText(node);
+        const lines  = source.split('\n');
+        return lines[0].includes('=');
+      }
+    }
+
+    function getLast(ary) {
+      return ary[ary.length - 1];
+    }
+  }
+};

data/node_modules/eslint-plugin-align-assignments/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "eslint-plugin-align-assignments",
+  "version": "1.1.2",
+  "author": "Lucas Florio <lucasefe@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/lucasefe/eslint-plugin-align-assignments",
+  "main": "lib/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lucasefe/eslint-plugin-sort-align-assignments"
+  },
+  "scripts": {
+    "test": "mocha tests/lib/rules/align-assignments_test.js"
+  },
+  "devDependencies": {
+    "eslint": "^5.9.0",
+    "mocha": "^5.2.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=0.8.0"
+  }
+}