Javascript, hbs and Ruby syntax support

.github/workflows/polyglot_release.yml

@@ -14,10 +14,11 @@ jobs:
         pip install --upgrade maturin
         maturin build --release -o dist
         maturin build --sdist -o dist
-    - name: Pypi Release for ubuntu-latest
-      run: |
-        pip install twine
-        twine upload --skip-existing -u __token__ -p ${{ secrets.PYPI_TOKEN }} dist/*
+    - name: Archive production artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: polyglot-piranha-package-ubuntu
+        path: dist/*
   build_ubuntu_20:
     runs-on: ubuntu-20.04
     steps:
@@ -29,54 +30,9 @@ jobs:
       run: |
         pip install --upgrade maturin
         maturin build --release -o dist
-        maturin build --sdist -o dist
-    - name: Pypi Release for ubuntu-latest
-      run: |
-        pip install twine
-        twine upload --skip-existing -u __token__ -p ${{ secrets.PYPI_TOKEN }} dist/*
-  macos_build_x86:
-    name: 'macos-x86'
-    runs-on: [macos-12]
-    strategy:
-      matrix:
-        arch: ['x86_64']
-    env:
-      # Polyglot depends on tree-sitter-python which tries to compile c++ files stdlibc++ which is depreciated in newer version of mac.
-      MACOSX_DEPLOYMENT_TARGET: 10.16
-      CXXFLAGS: -stdlib=libc++ -mmacosx-version-min=10.16
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.8
-      - name: Build wheel with Maturin
-        run: |
-          pip install --upgrade maturin
-          maturin build --release -o dist
-      - name: Pypi Release for macos-latest
-        run: |
-          pip install twine
-          twine upload --skip-existing -u __token__ -p ${{ secrets.PYPI_TOKEN }} dist/*
-  macos_build_arm:
-    name: 'macos-arm64'
-    runs-on: [macos-latest]
-    strategy:
-      matrix:
-        arch: ['arm64']
-    env:
-      # Polyglot depends on tree-sitter-python which tries to compile c++ files stdlibc++ which is depreciated in newer version of mac.
-      CXXFLAGS: -stdlib=libc++
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.8
-      - name: Build wheel with Maturin
-        run: |
-          rustup target add aarch64-apple-darwin
-          pip install --upgrade maturin
-          maturin build --release -o dist --target universal2-apple-darwin
-      - name: Pypi Release for macos-latest
-        run: |
-          pip install twine
-          twine upload --skip-existing -u __token__ -p ${{ secrets.PYPI_TOKEN }} dist/*
+        maturin build --sdist -o dist        
+    - name: Archive production artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: polyglot-piranha-package-ubuntu-20
+        path: dist/*

Cargo.toml

@@ -7,7 +7,7 @@ authors = [
 ]
 name = "piranha"
 description = "Polyglot Piranha is a library for performing structural find and replace with deep cleanup."
-version = "0.3.24"
+version = "0.3.5"
 edition = "2021"
 include = ["pyproject.toml", "src/"]
 exclude = ["legacy"]
@@ -34,7 +34,7 @@ doctest = false
 cc = "1.0.73"
 
 [dependencies]
-tree-sitter = "0.20.6"
+tree-sitter = "0.20.10"
 tree-sitter-traversal = "0.1.2"
 json = "0.12.4"
 toml = "0.8.8"

legacy/javascript/config/properties.json

@@ -14,6 +14,24 @@
             "methodName": "isToggleEnabled",
             "flagType": "treated",
             "argumentIndex": 0
+        },
+        {
+            "methodName": "hasTempFeature",
+            "flagType": "treated",
+            "argumentIndex": 0
+        },
+        {
+            "methodName": "ermFlagEnabled",
+            "flagType": "treated",
+            "argumentIndex": 0
+        }
+    ],
+    "templateHelpers": [
+        {
+            "helperName": "has-temp-feature"
+        },
+        {
+            "helperName": "has-erm-flag"
         }
     ]
 }

legacy/javascript/config/utils.js

@@ -0,0 +1,111 @@
+const babel = require("@babel/core");
+const hasOwn = Object.prototype.hasOwnProperty;
+
+const parseOptions = {
+  parser: {
+    parse: function (source, options) {
+      const babelOptions = getBabelOptions(options);
+      babelOptions.plugins.push("jsx", "flow", "decoratorAutoAccessors");
+      return adjustComments(require("@babel/parser").parse(source, babelOptions));
+      // return require("@babel/parser").parse(source, babelOptions);
+    }
+  }
+}
+
+function getOption(options, key, defaultValue) {
+  if (options && hasOwn.call(options, key)) {
+    return options[key];
+  }
+  return defaultValue;
+}
+
+function getBabelOptions(options) {
+  return {
+    sourceType: getOption(options, "sourceType", "module"),
+    strictMode: getOption(options, "strictMode", false),
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    startLine: 1,
+    tokens: true,
+    plugins: [
+      "asyncGenerators",
+      "bigInt",
+      "classPrivateMethods",
+      "classPrivateProperties",
+      "classProperties",
+      "classStaticBlock",
+      "decimal",
+      "decorators-legacy",
+      "doExpressions",
+      "dynamicImport",
+      "exportDefaultFrom",
+      "exportExtensions",
+      "exportNamespaceFrom",
+      "functionBind",
+      "functionSent",
+      "importAssertions",
+      "importMeta",
+      "nullishCoalescingOperator",
+      "numericSeparator",
+      "objectRestSpread",
+      "optionalCatchBinding",
+      "optionalChaining",
+      [
+        "pipelineOperator",
+        {
+          proposal: "minimal",
+        },
+      ],
+      [
+        "recordAndTuple",
+        {
+          syntaxType: "hash",
+        },
+      ],
+      "throwExpressions",
+      "topLevelAwait",
+      "v8intrinsic",
+    ],
+  };
+}
+
+function adjustComments(node) {
+  const seen = new WeakSet();
+
+  const copy = (from, to, leading, trailing) => {
+    from.forEach(comment => {
+      if (!seen.has(comment)) {
+        comment.leading = leading;
+        comment.trailing = trailing;
+        to.push(comment);
+        seen.add(comment);
+      }
+    })
+  }
+
+  babel.types.traverseFast(node, (node) => {
+    const comments = [];
+    if (node.leadingComments) {
+      copy(node.leadingComments, comments, true, false);
+      delete node.leadingComments;
+    }
+    if (node.innerComments) {
+      copy(node.innerComments, comments, false, false);
+      delete node.innerComments;
+    }
+    node.comments = comments;
+  });
+
+  babel.types.traverseFast(node, (node) => {
+    if (node.trailingComments) {
+      copy(node.trailingComments, node.comments, false, true);
+      delete node.trailingComments;
+    }
+  })
+
+  return node;
+}
+
+module.exports = {
+  parseOptions,
+}

legacy/javascript/index.js

@@ -0,0 +1,156 @@
+const fs = require('fs');
+const path = require('path');
+const fg = require('fast-glob');
+const recast = require("recast");
+const ArgumentParser = require('argparse').ArgumentParser;
+const jsRefactor = require("./src/refactor");
+const { parseOptions } = require("./config/utils");
+const templateRefactor = require("./src/template-refactor");
+const templateRecast = require('ember-template-recast');
+
+const parser = new ArgumentParser();
+const requiredArgs = parser.addArgumentGroup();
+
+requiredArgs.addArgument(['--flag'], {
+  help: 'Name of the stale flag',
+  required: true,
+});
+
+requiredArgs.addArgument(['--path'], {
+  help: 'Absolute directory path  for flag cleanup',
+  require: true
+});
+
+requiredArgs.addArgument(['--output'], {
+  help: 'Absolute destination path of the refactored output files. File is modified in-place by default.'
+});
+
+requiredArgs.addArgument(['--properties'], {
+  help: 'Path of configuration file for Piranha',
+  required: true,
+});
+
+requiredArgs.addArgument(['--enable-log'], {
+  help: 'Print cleanup logs',
+  action: 'storeTrue',
+  defaultValue: false,
+});
+
+const args = parser.parseArgs();
+let flagname = args.flag;
+
+const propertiesInJson = fs.readFileSync(args.properties);
+const properties = JSON.parse(propertiesInJson);
+console.log(JSON.stringify(properties));
+
+let jsFiles = [], templateFiles = [];
+if(args.path.endsWith(".js")) {
+  jsFiles = [args.path];
+} else if(args.path.endsWith(".hbs")) {
+  templateFiles = [args.path];
+} else {
+  const excludeNodeModules = `!${path.join(args.path, 'node_modules/**')}`;
+  const excludeDist = `!${path.join(args.path, 'dist/**')}`;
+  jsFiles = fg.sync([
+    path.join(args.path, '**/*.js'), excludeNodeModules, excludeDist]
+  );
+  templateFiles = fg.sync([path.join(args.path, '**/*.hbs'), excludeNodeModules, excludeDist]);
+}
+console.log("Total JS files in frontend/app: ", jsFiles.length);
+console.log("Total Templates files in frontend/app: ", templateFiles.length, "\n");
+
+if(args.output) {
+  fs.rmdirSync(args.output, { recursive: true })
+}
+
+const filesHavingFlagKeyword = [], allModifiedFiles = [], templateToCleanupInfoMap = {};
+
+//cleanup js files
+for (let filename of jsFiles) {
+  const content = fs.readFileSync(filename, 'utf-8');
+  if(!content.includes(flagname)) continue;
+  const ast = recast.parse(content, parseOptions);
+
+  const engine = new jsRefactor.RefactorEngine(
+    ast,
+    properties,
+    true,
+    flagname,
+    15,
+    args.enable_log,
+    false,
+    filename,
+  );
+  const { changed, hasFlagKeywordInFile, templateCleanupInfo } = engine.refactorPipeline();
+  if (path.parse(filename).base === 'component.js') {
+    const templatePath = path.join(filename, "..", "template.hbs");
+    templateToCleanupInfoMap[templatePath] = templateCleanupInfo;
+  }
+
+  if (hasFlagKeywordInFile) filesHavingFlagKeyword.push(filename);
+  if (changed) {
+    allModifiedFiles.push(filename);
+  } else {
+    continue;
+  }
+
+  const output = recast.print(ast).code;
+  writeOutput(filename, output);
+}
+
+//cleanup templates
+for (let filename of templateFiles) {
+  const content = fs.readFileSync(filename, 'utf8');
+
+  const cleanupInfo = templateToCleanupInfoMap[filename] || { properties: [] };
+  let hasFlagOrProperty = content.includes(flagname) || cleanupInfo.properties.some((prop) => content.includes(prop));
+  if(!hasFlagOrProperty) continue;
+
+  const ast = templateRecast.parse(content);
+
+  const engine = new templateRefactor.TemplateRefactorEngine({
+    ast,
+    properties,
+    flagname,
+    filename,
+    cleanupInfo,
+    print_to_console: args.enable_log,
+  });
+
+  const { changed, hasFlagKeywordInFile } = engine.refactorPipeline();
+
+  if (hasFlagKeywordInFile) filesHavingFlagKeyword.push(filename);
+  if (changed) {
+    allModifiedFiles.push(filename);
+  } else {
+    continue;
+  }
+
+  const output = templateRecast.print(ast);
+  writeOutput(filename, output);
+}
+
+function writeOutput(filename, output) {
+  const { base, dir } = path.parse(filename);
+  let outputDir = args.output ? path.join(args.output, dir) : dir;
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  const outputpath = path.join(outputDir, base);
+  fs.writeFileSync(outputpath, output, function (err) {
+    if (err) {
+      return console.log(err);
+    }
+    console.log(`Output written to ${outputpath}`);
+  });
+}
+
+const diff1 = filesHavingFlagKeyword.filter(filename => !allModifiedFiles.includes(filename));
+const diff2 = allModifiedFiles.filter(filename => !filesHavingFlagKeyword.includes(filename));
+if (diff1.length) {
+  console.log("Attention: These files might need modification, please check them manually", diff1);
+}
+if (diff2.length) {
+  console.log("Attention: These files might not need modification, please check them manually", diff2);
+}
+console.log(`Total ${allModifiedFiles.length} files are modified by tool cleanup`)