codemods

_codemods

This is a set of codemods

add-build-script.js

var source = `var stealTools = require("steal-tools");

stealTools.export({
	steal: {
		config: __dirname + "/package.json!npm"
	},
	outputs: {
		"+cjs": {},
		"+amd": {},
		"+global-js": {}
	}
}).catch(function(e){
	
	setTimeout(function(){
		throw e;
	},1);
	
});
`;

var fs = require('fs')
var path = require('path')

module.exports = {  
  getOptions() { return []; },

  run: function (directory, options) {
    var text = options.content
    var filepath = path.join(directory, 'build.js')
    return new Promise(function (resolve, reject) {
      fs.writeFile(filepath, source, function (error) {
        error ? reject(error) : resolve()
      })
    })
  }
}

add-release-scripts.js

module.exports = function transformer(file, api) {
  var src = file.source;
  
  try {
    src = JSON.parse(src);

    // add scripts
   Object.assign(src.scripts, {
    "preversion": "npm test && npm run build",
    "version": "git commit -am \"Update dist for release\" && git checkout -b release && git add -f dist/",
    "postversion": "git push --tags && git checkout master && git branch -D release && git push",
    "release:pre": "npm version prerelease && npm publish --tag=pre",
    "release:patch": "npm version patch && npm publish",
    "release:minor": "npm version minor && npm publish",
    "release:major": "npm version major && npm publish"
    });

    // print result with 2-space indentation
    src = JSON.stringify(src, null, 2) + '\n';
  } catch(e) {
    console.error(e);
  }
  
  return src;
};

bump-can-stache-key.js

module.exports = function transformer(file, api) {
  var src = file.source;
  
  try {
    src = JSON.parse(src);

    Object.assign(src.dependencies, {
      "can-stache-key": "0.0.4"
    });

    // print result with 2-space indentation
    src = JSON.stringify(src, null, 2) + '\n';
  } catch(e) {
    console.error(e);
  }
  
  return src;
};

canjs-canjs-deps.js

// latest versions from canjs/canjs 3.8.2 package.json
const canjsCanjsDeps = {
    "can-cid": "1.0.3",
    "can-component": "3.0.7",
    "can-compute": "3.0.10",
    "can-connect": "1.3.11",
    "can-connect-feathers": "3.5.5",
    "can-connect-cloneable": "0.1.3",
    "can-connect-signalr": "0.1.0",
    "can-construct": "3.1.1",
    "can-construct-super": "3.0.3",
    "can-control": "3.0.10",
    "can-define": "1.0.26",
    "can-define-stream": "0.1.1",
    "can-define-stream-kefir": "0.0.9",
    "can-define-validate-validatejs": "0.0.5",
    "can-deparam": "1.0.1",
    "can-ejs": "3.0.7",
    "can-event": "3.4.0",
    "can-fixture": "1.0.14",
    "can-fixture-socket": "0.6.2",
    "can-jquery": "3.0.7",
    "can-list": "3.0.5",
    "can-map": "3.0.7",
    "can-map-backup": "3.0.3",
    "can-map-define": "3.0.9",
    "can-namespace": "1.0.0",
    "can-observation": "3.1.5",
    "can-param": "1.0.1",
    "can-route": "3.0.11",
    "can-route-pushstate": "3.0.3",
    "can-set": "1.2.0",
    "can-simple-dom": "1.0.8",
    "can-simple-map": "3.1.4",
    "can-stache": "3.0.24",
    "can-stache-bindings": "3.1.5",
    "can-stache-converters": "3.1.0",
    "can-stream": "0.2.3",
    "can-stream-kefir": "0.2.3",
    "can-types": "1.0.4",
    "can-util": "3.7.0",
    "can-validate": "1.0.2",
    "can-validate-legacy": "1.0.2",
    "can-validate-validatejs": "0.0.6",
    "can-vdom": "3.0.3",
    "can-view-autorender": "3.0.4",
    "can-view-callbacks": "3.0.6",
    "can-view-href": "3.0.4",
    "can-view-import": "3.0.7",
    "can-view-live": "3.0.7",
    "can-view-model": "3.1.3",
    "can-view-nodelist": "3.0.4",
    "can-view-parser": "3.1.0",
    "can-view-scope": "3.1.4",
    "can-view-target": "3.0.7",
    "can-zone": "0.6.7",
    "steal-stache": "3.0.7"
};

// these depend on can-types, so must be updated in order to avoid
// "cannot have two versions of can-types" errors
const requiredDeps = [
    "can-component",
    "can-compute",
    "can-connect",
    "can-construct",
    "can-control",
    "can-define",
    "can-event",
    "can-event-radiochange",
    "can-list",
    "can-make-rest",
    "can-map",
    "can-map-define",
    "can-observation",
    "can-reflect",
    "can-route",
    "can-route-pushstate",
    "can-set",
    "can-simple-map",
    "can-stache",
    "can-stache-bindings",
    "can-symbol",
    "can-types",
    "can-util",
    "can-vdom",
    "can-view-autorender",
    "can-view-callbacks",
    "can-view-href",
    "can-view-import",
    "can-view-live",
    "can-view-model",
    "can-view-nodelist",
    "can-view-parser",
    "can-view-scope",
    "can-view-target",
    "steal-stache"
];

function updateVersions(deps) {
    const newDeps = {};
    
    Object.keys(deps).forEach((dep) => {
        // if dep exists in canjsDeps, set it to that version
        // otherwise, keep existing version
        newDeps[dep] = canjsCanjsDeps[dep] || deps[dep];
    });
    
    return newDeps;
}

function addMissingRequiredDependencies(deps) {
    const newDeps = Object.assign({}, deps);
    
    // make sure all required deps are added
    requiredDeps.forEach((dep) => {
        newDeps[dep] = canjsCanjsDeps[dep];
    });
    
    return newDeps;
}

module.exports = function transformer(file, api) {
  let src = file.source;
  
  try {
    src = JSON.parse(src);
      
    src.dependencies = updateVersions(src.dependencies);
    src.devDependencies = updateVersions(src.devDependencies);
    
    src.dependencies = addMissingRequiredDependencies(src.dependencies);
      
    // print result with 2-space indentation
    src = JSON.stringify(src, null, 2) + '\n';
  } catch(e) {
    console.error(e);
  }
  
  return src;
};

colon-bindings-simple.js

module.exports = function transformer(file) {
  var src = file.source;
  
  src = src.replace(/\{\^\$?([^}\n]+)\}=/g, "$1:to=");
  src = src.replace(/\{\(\$?([^)\n]+)\)\}=/g, "$1:bind=");
  src = src.replace(/\{\$?([^}\n]+)\}=/g, "$1:from=");
  src = src.replace(/\(\$?([^)\n]+)\)=/g, "on:$1=");
  
  return src;
};

colon-bindings.js

var kebabToCamel = function (kebab) {
  return kebab.replace(/-(.)/g, function (x, $1) {
    return $1.toUpperCase();
  });
};


var transformStache = function (src) {
  src = src.replace(/\{\^\$?([^}\n]+)\}=/g, function (x, $1) {
    return kebabToCamel($1) + ":to=";
  });
  src = src.replace(/\{\(\$?([^)\n]+)\)\}=/g, function (x, $1) {
    return kebabToCamel($1) + ":bind=";
  });
  src = src.replace(/\{\$?([^}\n]+)\}=/g, function (x, $1) {
    return kebabToCamel($1) + ":from=";
  });
  src = src.replace(/\(\$?([^)\n]+)\)=/g, function (x, $1) {
    return "on:" + kebabToCamel($1) + "=";
  });
  
  return src;
};


var transformJs = function (src) {
  //find call to stache with a template passed in
  //note: only catches the call if a string is passed in and maynot work well if it's not one full string
  return src.replace(/(\bstache\(\s*(["'`]))((?:[^\\\2]|\\[\s\S])*?)(\2\s*\))/g, function (fullStr, $1, quoteType, $3, $4) {
    return $1 + transformStache($3) + $4;
  });
};


var transformHtml = function (src) {
  //find script tag with type text/stache
  return src.replace(/(<script[^>]*type=("|')text\/stache\2[^>]*>)([\s\S]+?)(<\/script>)/g, function (fullStr, $1, quoteType, $3, $4) {
    return $1 + transformStache($3) + $4;
  })
  // find steal.js script tag
  .replace(/(<script[^>]*src=("|').*steal\/steal\.js\2[^>]*>)([\s\S]+?)(<\/script>)/g, function (fullStr, $1, quoteType, $3, $4) {
    return $1 + transformJs($3) + $4;
  })
};

var transformMd = function (src) {
  //find ```html code blocks and treat it as stache
  //find ```js code blocks and treat them as js
  return src.replace(/(```)(js|html)?((?:[\s\S])+?)\1/g, function (fullStr, ticks, codeBlockType, codeBlock) {
    codeBlockType = codeBlockType || "";
    var output = ticks + codeBlockType;

    if (codeBlockType === "html") {
      output += transformStache(codeBlock);
    } else if (codeBlockType === "js") {
      output += transformJs(codeBlock);
    } else {
      output += codeBlock;
    }
    return output + ticks;
  });
};


module.exports = function transformer(file) {
  var src = file.source;
  var path = file.path;
  var type = path.slice(path.lastIndexOf('.') + 1);
   
  if (type === "js") {
    src = transformJs(src);
  } else if (type === "md") {
    src = transformMd(src);
  } else if (type === "html") {
    src = transformHtml(src);
  } else if (type === "stache") {
    src = transformStache(src);
  }
  
  return src;
};

remove-pre-release-deps.js

function removePreReleases(deps) {
  var newDeps = {};
  
  Object.keys(deps).forEach((dep) => {
    newDeps[dep] = deps[dep].replace(/-pre.*/, '');
  });
  
  return newDeps;
}

module.exports = function transformer(file, api) {
  var src = file.source;
  
  try {
    src = JSON.parse(src);
    
    // remove -pre... from dependencies/devDependencies
    src.dependencies = removePreReleases(src.dependencies);
    src.devDependencies = removePreReleases(src.devDependencies);
    
    // print result with 2-space indentation
    src = JSON.stringify(src, null, 2) + '\n';
  } catch(e) {
    console.error(e);
  }
  
  return src;
};