Sha256: 1afd45ca463cda2ce9cb0e81a57f8c02af9de3698948779e19f9d1fe9699906b
Contents?: true
Size: 1.61 KB
Versions: 5
Compression:
Stored size: 1.61 KB
Contents
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const needsParens = [
"args",
"assign",
"assoc_new",
"binary",
"call",
"massign",
"opassign"
];
// If you have a modifier statement (for instance an inline if statement or an
// inline while loop) there are times when you need to wrap the entire statement
// in parentheses. This occurs when you have something like:
//
// foo[:foo] =
// if bar?
// baz
// end
//
// Normally we would shorten this to an inline version, which would result in:
//
// foo[:foo] = baz if bar?
//
// but this actually has different semantic meaning. The first example will
// result in a nil being inserted into the hash for the :foo key, whereas the
// second example will result in an empty hash because the if statement applies
// to the entire assignment.
//
// We can fix this in a couple of ways. We can use the then keyword, as in:
//
// foo[:foo] = if bar? then baz end
//
// but I haven't actually seen this anywhere. We can also just leave it as is
// with the multi-line version, but for a short predicate and short value it
// looks pretty silly. The last option and the one I've selected here is to add
// parentheses on both sides of the expression, as in:
//
// foo[:foo] = (baz if bar?)
//
// This approach maintains the nice conciseness of the inline version, while
// keeping the correct semantic meaning.
function inlineEnsureParens(path, parts) {
if (needsParens.includes(path.getParentNode().type)) {
return ["(", ...parts, ")"];
}
return parts;
}
exports.default = inlineEnsureParens;
Version data entries
5 entries across 5 versions & 1 rubygems