prettier 0.15.1 → 0.16.0

data/src/haml/print.js

@@ -0,0 +1,38 @@
+const { concat, hardline, join, markAsRoot } = require("../prettier");
+
+const comment = require("./nodes/comment");
+const doctype = require("./nodes/doctype");
+const filter = require("./nodes/filter");
+const hamlComment = require("./nodes/hamlComment");
+const script = require("./nodes/script");
+const silentScript = require("./nodes/silentScript");
+const tag = require("./nodes/tag");
+
+const nodes = {
+  comment,
+  doctype,
+  filter,
+  haml_comment: hamlComment,
+  plain: (path, _opts, _print) => {
+    const { value } = path.getValue();
+
+    return value.text.startsWith("=") ? `\\${value.text}` : value.text;
+  },
+  root: (path, opts, print) =>
+    markAsRoot(concat([join(hardline, path.map(print, "children")), hardline])),
+  script,
+  silent_script: silentScript,
+  tag
+};
+
+const genericPrint = (path, opts, print) => {
+  const { type } = path.getValue();
+
+  if (!(type in nodes)) {
+    throw new Error(`Unsupported node encountered: ${type}`);
+  }
+
+  return nodes[type](path, opts, print);
+};
+
+module.exports = genericPrint;

data/src/nodes.js

@@ -23,6 +23,7 @@ module.exports = Object.assign(
   require("./nodes/patterns"),
   require("./nodes/regexp"),
   require("./nodes/rescue"),
+  require("./nodes/return"),
   require("./nodes/scopes"),
   require("./nodes/statements"),
   require("./nodes/strings")

data/src/nodes/conditionals.js

@@ -10,34 +10,6 @@ const {
 } = require("../prettier");
 const { containsAssignment } = require("../utils");
 
-const noTernary = [
-  "@comment",
-  "alias",
-  "assign",
-  "break",
-  "command",
-  "command_call",
-  "if_mod",
-  "ifop",
-  "lambda",
-  "massign",
-  "next",
-  "opassign",
-  "rescue_mod",
-  "return",
-  "return0",
-  "super",
-  "undef",
-  "unless_mod",
-  "until_mod",
-  "var_alias",
-  "void_stmt",
-  "while_mod",
-  "yield",
-  "yield0",
-  "zsuper"
-];
-
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([
     `${keyword} `,
@@ -152,11 +124,54 @@ const printSingle = keyword => (path, { inlineConditionals }, print) => {
   return group(ifBreak(multiline, inline));
 };
 
+const noTernary = [
+  "@comment",
+  "alias",
+  "assign",
+  "break",
+  "command",
+  "command_call",
+  "if_mod",
+  "ifop",
+  "lambda",
+  "massign",
+  "next",
+  "opassign",
+  "rescue_mod",
+  "return",
+  "return0",
+  "super",
+  "undef",
+  "unless_mod",
+  "until_mod",
+  "var_alias",
+  "void_stmt",
+  "while_mod",
+  "yield",
+  "yield0",
+  "zsuper"
+];
+
 // Certain expressions cannot be reduced to a ternary without adding parens
 // around them. In this case we say they cannot be ternaried and default instead
 // to breaking them into multiple lines.
-const canTernaryStmts = stmts =>
-  stmts.body.length === 1 && !noTernary.includes(stmts.body[0].type);
+const canTernaryStmts = stmts => {
+  if (stmts.body.length !== 1) {
+    return false;
+  }
+
+  const stmt = stmts.body[0];
+
+  // If the user is using one of the lower precedence "and" or "or" operators,
+  // then we can't use a ternary expression as it would break the flow control.
+  if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+    return false;
+  }
+
+  // Check against the blocklist of statement types that are not allowed to be
+  // a part of a ternary expression.
+  return !noTernary.includes(stmt.type);
+};
 
 // In order for an `if` or `unless` expression to be shortened to a ternary,
 // there has to be one and only one "addition" (another clause attached) which

data/src/nodes/flow.js

@@ -1,11 +1,4 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  softline
-} = require("../prettier");
+const { concat, join } = require("../prettier");
 const { literal } = require("../utils");
 
 module.exports = {
@@ -42,32 +35,6 @@ module.exports = {
 
     return concat(["next ", join(", ", path.call(print, "body", 0))]);
   },
-  return: (path, opts, print) => {
-    const args = path.getValue().body[0].body[0];
-
-    if (!args) {
-      return "return";
-    }
-
-    let value = join(", ", path.call(print, "body", 0));
-
-    // If the body of the return contains parens, then just skip directly to the
-    // content of the parens so that we can skip printing parens if we don't
-    // want them.
-    if (args.body[0] && args.body[0].type === "paren") {
-      value = path.call(print, "body", 0, "body", 0, "body", 0, "body", 0);
-    }
-
-    return group(
-      concat([
-        "return",
-        ifBreak("(", " "),
-        indent(concat([softline, value])),
-        concat([softline, ifBreak(")", "")])
-      ])
-    );
-  },
-  return0: literal("return"),
   yield: (path, opts, print) => {
     if (path.getValue().body[0].type === "paren") {
       return concat(["yield", path.call(print, "body", 0)]);

data/src/nodes/massign.js

@@ -13,12 +13,13 @@ module.exports = {
       right = group(join(concat([",", line]), right));
     }
 
+    const parts = [join(concat([",", line]), path.call(print, "body", 0))];
+    if (path.getValue().body[0].comma) {
+      parts.push(",");
+    }
+
     return group(
-      concat([
-        group(join(concat([",", line]), path.call(print, "body", 0))),
-        " =",
-        indent(concat([line, right]))
-      ])
+      concat([group(concat(parts)), " =", indent(concat([line, right]))])
     );
   },
   mlhs: makeList,
@@ -40,18 +41,16 @@ module.exports = {
       return path.call(print, "body", 0);
     }
 
-    return group(
-      concat([
-        "(",
-        indent(
-          concat([
-            softline,
-            join(concat([",", line]), path.call(print, "body", 0))
-          ])
-        ),
-        concat([softline, ")"])
-      ])
-    );
+    const parts = [
+      softline,
+      join(concat([",", line]), path.call(print, "body", 0))
+    ];
+
+    if (path.getValue().body[0].comma) {
+      parts.push(",");
+    }
+
+    return group(concat(["(", indent(concat(parts)), concat([softline, ")"])]));
   },
   mrhs: makeList,
   mrhs_add_star: (path, opts, print) =>

data/src/nodes/return.js

@@ -0,0 +1,60 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  line,
+  join,
+  softline
+} = require("../prettier");
+const { literal } = require("../utils");
+
+const printReturn = (path, opts, print) => {
+  let args = path.getValue().body[0].body[0];
+  let steps = ["body", 0, "body", 0];
+
+  if (!args) {
+    return "return";
+  }
+
+  // If the body of the return contains parens, then just skip directly to the
+  // content of the parens so that we can skip printing parens if we don't
+  // want them.
+  if (args.body[0] && args.body[0].type === "paren") {
+    args = args.body[0].body[0];
+    steps = steps.concat("body", 0, "body", 0);
+  }
+
+  // If we're returning an array literal that isn't a special array, then we
+  // want to grab the arguments so that we can print them out as if they were
+  // normal return arguments.
+  if (
+    args.body[0] &&
+    args.body[0].type === "array" &&
+    ["args", "args_add_star"].includes(args.body[0].body[0].type)
+  ) {
+    steps = steps.concat("body", 0, "body", 0);
+  }
+
+  // Now that we've established which actual node is the arguments to return,
+  // we grab it out of the path by diving down the steps that we've set up.
+  const parts = path.call.apply(path, [print].concat(steps));
+
+  // If we got the value straight out of the parens, then `parts` would only
+  // be a singular doc as opposed to an array.
+  const value = Array.isArray(parts) ? join(concat([",", line]), parts) : parts;
+
+  return group(
+    concat([
+      "return",
+      ifBreak(parts.length > 1 ? " [" : "(", " "),
+      indent(concat([softline, value])),
+      concat([softline, ifBreak(parts.length > 1 ? "]" : ")", "")])
+    ])
+  );
+};
+
+module.exports = {
+  return: printReturn,
+  return0: literal("return")
+};

data/src/nodes/statements.js

@@ -7,7 +7,6 @@ const {
   join,
   line,
   literalline,
-  markAsRoot,
   softline,
   trim
 } = require("../prettier");
@@ -66,9 +65,7 @@ module.exports = {
     );
   },
   program: (path, opts, print) =>
-    markAsRoot(
-      concat([join(literalline, path.map(print, "body")), literalline])
-    ),
+    concat([join(hardline, path.map(print, "body")), hardline]),
   stmts: (path, opts, print) => {
     const stmts = path.getValue().body;
     const parts = [];

data/src/nodes/strings.js

@@ -4,7 +4,8 @@ const {
   hardline,
   indent,
   literalline,
-  softline
+  softline,
+  join
 } = require("../prettier");
 const { concatBody, empty, makeList, prefix, surround } = require("../utils");
 const escapePattern = require("../escapePattern");
@@ -38,13 +39,14 @@ const getStringQuote = (string, preferSingleQuotes) => {
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-const makeString = (content, enclosingQuote) => {
+const makeString = (content, enclosingQuote, originalQuote) => {
+  const replaceOther = ["'", '"'].includes(originalQuote);
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
   // Escape and unescape single and double quotes as needed to be able to
   // enclose `content` with `enclosingQuote`.
   return content.replace(quotePattern, (match, escaped, quote) => {
-    if (escaped === otherQuote) {
+    if (replaceOther && escaped === otherQuote) {
       return escaped;
     }
 
@@ -60,6 +62,53 @@ const makeString = (content, enclosingQuote) => {
   });
 };
 
+// The `parts` argument that comes into this function is an array of either
+// printed embedded expressions or plain strings (that themselves can contain
+// newlines). What we want to return is an array where each element represents a
+// line in the original text. So we end up tracking every line as we go and
+// pushing onto a `currentLine` variable, then when we hit a new line we push
+// the current line onto the `lines` variable until we've used up every part.
+const makeHeredocLines = parts => {
+  let lines = [];
+  let currentLine = [];
+
+  parts.forEach(part => {
+    if (part.type === "group" || !part.includes("\n")) {
+      // In this case we've either hit an embedded expression or the piece of
+      // the current line that we're looking at is in the middle of two of them,
+      // so we just push onto the current line and continue on.
+      currentLine.push(part);
+      return;
+    }
+
+    let splits = part.split("\n");
+    if (splits[splits.length - 1] === "") {
+      // If a line ends with a newline, then we end up with an empty string at
+      // the end of the splits, we just pop it off here since we'll handle the
+      // newlines later.
+      splits = splits.slice(0, -1);
+    }
+
+    if (currentLine.length > 0) {
+      lines.push(concat(currentLine.concat(splits[0])));
+      currentLine = [];
+    } else {
+      lines.push(splits[0]);
+    }
+
+    if (splits.length > 1) {
+      lines = lines.concat(splits.slice(1, -1));
+      currentLine.push(splits[splits.length - 1]);
+    }
+  });
+
+  if (currentLine.length > 0) {
+    lines = lines.concat(currentLine);
+  }
+
+  return lines;
+};
+
 module.exports = {
   "@CHAR": (path, { preferSingleQuotes }, _print) => {
     const { body } = path.getValue();
@@ -78,10 +127,13 @@ module.exports = {
   },
   heredoc: (path, opts, print) => {
     const { beging, ending } = path.getValue();
+    const lines = makeHeredocLines(path.map(print, "body"));
 
     return concat([
       beging,
-      concat([literalline].concat(path.map(print, "body"))),
+      literalline,
+      join(literalline, lines),
+      literalline,
       ending
     ]);
   },
@@ -130,7 +182,7 @@ module.exports = {
     string.body.forEach((part, index) => {
       if (part.type === "@tstring_content") {
         // In this case, the part of the string is just regular string content
-        parts.push(makeString(part.body, quote));
+        parts.push(makeString(part.body, quote, string.quote));
       } else {
         // In this case, the part of the string is an embedded expression
         parts.push(path.call(print, "body", 0, "body", index));

data/src/ripper.rb

@@ -14,11 +14,12 @@ require 'json' unless defined?(JSON)
 require 'ripper'
 
 class RipperJS < Ripper
-  attr_reader :lines, :__end__
+  attr_reader :source, :lines, :__end__
 
   def initialize(source, *args)
     super(source, *args)
 
+    @source = source
     @lines = source.split("\n")
     @__end__ = nil
   end
@@ -750,6 +751,31 @@ class RipperJS < Ripper
           sexp.merge!(type: :lambda, body: [params, stmts])
         end
       end
+
+      # We need to track for `mlhs_paren` and `massign` nodes whether or not
+      # there was an extra comma at the end of the expression. For some reason
+      # it's not showing up in the AST in an obvious way. In this case we're
+      # just simplifying everything by adding an additional field to `mlhs`
+      # nodes called `comma` that indicates whether or not there was an extra.
+      def on_mlhs_paren(body)
+        super.tap do |node|
+          next unless body[:type] == :mlhs
+
+          ending = source.rindex(')', char_pos)
+          buffer = source[(node[:char_start] + 1)...ending]
+
+          body[:comma] = buffer.strip.end_with?(',')
+        end
+      end
+
+      def on_massign(left, right)
+        super.tap do
+          next unless left[:type] == :mlhs
+
+          range = left[:char_start]..left[:char_end]
+          left[:comma] = source[range].strip.end_with?(',')
+        end
+      end
     end
   )
 end