prettier 1.0.0.pre.rc1 → 1.0.0.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2bdbafe8bc7bd8ebc0f77727584bfa80773721ca5e77f820df84b8e7c7e0951
-  data.tar.gz: 53e157e6880b56e642690fb90f6244ad669739a2e5fb697cde0c8082facc2c20
+  metadata.gz: 305f0248dc0f0b4ab56d698f04858e3d25df0f91888a203f75740ae5a06a7e0d
+  data.tar.gz: 192eaf1d3cd95a9dc3693c0346f636f53ae2baede4cd3de5d827bd671571daf3
 SHA512:
-  metadata.gz: 854c61aa25de0a708606f89cb4bd3dde7dee10ecec89cfc7660bf03722ea12603bbb4dbf5f8d8b25f14359de55b419f2758522198cae9926d03fe77fab7aa001
-  data.tar.gz: d9c821b5367084de39bbe51c60a58642210caa5da04757c6fafbabec6e204adfdd9d7b656e34c3a94e50af26d5c6ceda9236edf68e96c98ed1e941957fe47c4a
+  metadata.gz: 33a09aa76044b30dde5aa1555bfabc8f178607335ca0af9e4709d0f9fbfdc437c986097da85cc2d0c411326cb25d0672587a0253016bc89e71ca1245a5cfd652
+  data.tar.gz: b293f495c164808c4372dc79cfa801fd1603fe4907eafb374b61ba171cffbf1aaa09b6e0b1a427bc949099091db790a79d74d56c50f72c3ba006acc718b0065c

data/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.0.0-rc2] - 2020-12-10
+
+### Changed
+
+- [@kddeisz] - Print hashes with consistent keys (e.g., if one key cannot be a hash label, use all hash rockets).
+- [@kddeisz] - Respect using `o` or not using `o` for octal numbers.
+- [@kddeisz] - Ensure `when` clauses with multiple predicates that can be split into multiple lines are split correctly.
+- [@kddeisz] - Ensure hash literal is split correctly when only its contents would fit on one line.
+- [@kddeisz] - Simplify `toProc` checks by not calling if the option is disabled.
+- [@johncsnyder], [@kddeisz] - Add `method_add_block` to the potential like of method calls that can be chained.
+- [@kddeisz] - Add the `rubyArrayLiteral` option for disabling automatically turning into array literals.
+
 ## [1.0.0-rc1] - 2020-12-09
 
 ### Changed
@@ -928,7 +940,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.0.0-rc1...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.0.0-rc2...HEAD
+[1.0.0-rc2]: https://github.com/prettier/plugin-ruby/compare/v1.0.0-rc1...v1.0.0-rc2
 [1.0.0-rc1]: https://github.com/prettier/plugin-ruby/compare/v0.22.0...v1.0.0-rc1
 [0.22.0]: https://github.com/prettier/plugin-ruby/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/prettier/plugin-ruby/compare/v0.20.1...v0.21.0

data/README.md

@@ -122,16 +122,17 @@ The `prettier` executable is now installed and ready for use:
 
 Below are the options (from [`src/ruby.js`](src/ruby.js)) that `@prettier/plugin-ruby` currently supports:
 
-| API Option        | CLI Option            | Default | Description                                                                                                                          |
-| ----------------- | --------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `printWidth`      | `--print-width`       |  `80`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width)).                                     |
-| `requirePragma`   | `--require-pragma`    | `false` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma)).                                  |
-| `rubyHashLabel`   | `--ruby-hash-label`   | `true`  | When possible, uses the shortened hash key syntax, as opposed to hash rockets.                                                       |
-| `rubyModifier`    | `--ruby-modifier`     | `true`  | When it fits on one line, allows while and until statements to use the modifier form.                                                |
-| `rubySingleQuote` | `--ruby-single-quote` | `true`  | When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.                        |
-| `rubyToProc`      | `--ruby-to-proc`      | `false` | When possible, convert blocks to the more concise `Symbol#to_proc` syntax.                                                           |
-| `tabWidth`        | `--tab-width`         |   `2`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                                       |
-| `trailingComma`   | `--trailing-comma`    | `"es5"` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
+| API Option         | CLI Option             | Default | Description                                                                                                                          |
+| ------------------ | ---------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------ |
+| `printWidth`       | `--print-width`        |  `80`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width)).                                     |
+| `requirePragma`    | `--require-pragma`     | `false` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma)).                                  |
+| `rubyArrayLiteral` | `--ruby-array-literal` | `true`  | When possible, favor the use of string and symbol array literals.                                                                    |
+| `rubyHashLabel`    | `--ruby-hash-label`    | `true`  | When possible, uses the shortened hash key syntax, as opposed to hash rockets.                                                       |
+| `rubyModifier`     | `--ruby-modifier`      | `true`  | When it fits on one line, allows while and until statements to use the modifier form.                                                |
+| `rubySingleQuote`  | `--ruby-single-quote`  | `true`  | When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.                        |
+| `rubyToProc`       | `--ruby-to-proc`       | `false` | When possible, convert blocks to the more concise `Symbol#to_proc` syntax.                                                           |
+| `tabWidth`         | `--tab-width`          |   `2`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                                       |
+| `trailingComma`    | `--trailing-comma`     | `"es5"` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.0.0-rc1",
+  "version": "1.0.0-rc2",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {

data/src/embed.js

@@ -67,7 +67,11 @@ const embed = (path, print, textToDoc, _opts) => {
       path.call(print, "beging"),
       lineSuffix(
         group(
-          concat([indent(markAsRoot(formatted)), literalLineNoBreak, ending])
+          concat([
+            indent(markAsRoot(formatted)),
+            literalLineNoBreak,
+            ending.trim()
+          ])
         )
       )
     ]);
@@ -78,7 +82,7 @@ const embed = (path, print, textToDoc, _opts) => {
   return markAsRoot(
     concat([
       path.call(print, "beging"),
-      lineSuffix(group(concat([formatted, literalLineNoBreak, ending])))
+      lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
     ])
   );
 };

data/src/nodes/args.js

@@ -9,80 +9,56 @@ const {
 } = require("../prettier");
 
 const toProc = require("../toProc");
-const { docLength, getTrailingComma } = require("../utils");
-
-module.exports = {
-  arg_paren: (path, opts, print) => {
-    const argsNode = path.getValue().body[0];
-
-    if (argsNode === null) {
-      return "";
-    }
-
-    // Here we can skip the entire rest of the method by just checking if it's
-    // an args_forward node, as we're guaranteed that there are no other arg
-    // nodes.
-    if (argsNode.type === "args_forward") {
-      return group(
+const { getTrailingComma } = require("../utils");
+
+function printArgParen(path, opts, print) {
+  const argsNode = path.getValue().body[0];
+
+  if (argsNode === null) {
+    return "";
+  }
+
+  // Here we can skip the entire rest of the method by just checking if it's
+  // an args_forward node, as we're guaranteed that there are no other arg
+  // nodes.
+  if (argsNode.type === "args_forward") {
+    return group(
+      concat([
+        "(",
+        indent(concat([softline, path.call(print, "body", 0)])),
+        softline,
+        ")"
+      ])
+    );
+  }
+
+  const args = path.call(print, "body", 0);
+  const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
+
+  // Now here we return a doc that represents the whole grouped expression,
+  // including the surrouding parentheses.
+  return group(
+    concat([
+      "(",
+      indent(
         concat([
-          "(",
-          indent(concat([softline, path.call(print, "body", 0)])),
           softline,
-          ")"
+          join(concat([",", line]), args),
+          getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
         ])
-      );
-    }
-
-    const args = path.call(print, "body", 0);
-    const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
-
-    // These are the docs representing the actual arguments, without any
-    // parentheses or surrounding lines yet added.
-    let argsDocs = [
-      join(concat([",", line]), args),
-      getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
-    ];
-
-    // Here we're going to make a determination on whether or not we should put
-    // a newline before the first argument. In some cases this makes the
-    // appearance a little better. For example, instead of taking this input:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2).baz(arg1)
-    //
-    // and transforming it into this:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2).baz(
-    //       arg1
-    //     )
-    //
-    // it instead gets transformed into this:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2)
-    //       .baz(arg1)
-    //
-    const maxDocLength = 15;
-    const firstArgDoc = args[0];
-
-    // prettier-ignore
-    const shouldWrapLine =
-      (args.reduce((sum, arg) => sum + docLength(arg), 0) > maxDocLength) ||
-      (args.length == 1 && firstArgDoc.type === "group" && docLength(firstArgDoc) > maxDocLength) ||
-      (firstArgDoc.type === "concat" && firstArgDoc.parts.some((part) => part.type === "group"));
-
-    // Here we're going to get all of the docs representing the doc that's
-    // inside the parentheses.
-    if (shouldWrapLine) {
-      argsDocs = [indent(concat([softline].concat(argsDocs))), softline];
-    } else {
-      argsDocs = [indent(concat(argsDocs))];
-    }
-
-    // Now here we return a doc that represents the whole grouped expression,
-    // including the surrouding parentheses.
-    return group(concat(["("].concat(argsDocs).concat(")")));
-  },
-  args: (path, opts, print) => {
-    const args = path.map(print, "body");
+      ),
+      softline,
+      ")"
+    ])
+  );
+}
+
+function printArgs(path, { rubyToProc }, print) {
+  const args = path.map(print, "body");
+
+  // Don't bother trying to do any kind of fancy toProc transform if the
+  // option is disabled.
+  if (rubyToProc) {
     let blockNode = null;
 
     // Look up the chain to see if these arguments are contained within a
@@ -99,21 +75,26 @@ module.exports = {
       return blockNode;
     });
 
-    const proc = blockNode && toProc(path, opts, blockNode);
+    const proc = blockNode && toProc(path, blockNode);
 
-    // If we have a successful to_proc transformation, but we're part of an aref
-    // node, that means it's something to the effect of
+    // If we have a successful to_proc transformation, but we're part of an
+    // aref node, that means it's something to the effect of
     //
     //     foo[:bar].each(&:to_s)
     //
-    // In this case we need to just return regular arguments, otherwise we would
-    // end up putting &:to_s inside the brackets accidentally.
+    // In this case we need to just return regular arguments, otherwise we
+    // would end up putting &:to_s inside the brackets accidentally.
     if (proc && path.getParentNode(1).type !== "aref") {
       args.push(proc);
     }
+  }
 
-    return args;
-  },
+  return args;
+}
+
+module.exports = {
+  arg_paren: printArgParen,
+  args: printArgs,
   args_add_block: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 

data/src/nodes/arrays.js

@@ -18,32 +18,35 @@ const { getTrailingComma } = require("../utils");
 //     ['a', 'b', 'c']
 //
 function isStringArray(args) {
-  return args.body.every((arg) => {
-    // We want to verify that every node inside of this array is a string
-    // literal. We also want to make sure none of them have comments attached.
-    if (arg.type !== "string_literal" || arg.comments) {
-      return false;
-    }
-
-    // If the string has multiple parts (meaning plain string content but also
-    // interpolated content) then we know it's not a simple string.
-    if (arg.body.length !== 1) {
-      return false;
-    }
-
-    const part = arg.body[0];
-
-    // If the only part of this string is not @tstring_content then it's
-    // interpolated, so again we can return false.
-    if (part.type !== "@tstring_content") {
-      return false;
-    }
-
-    // Finally, verify that the string doesn't contain a space, an escape
-    // character, or brackets so that we know it can be put into a string
-    // literal array.
-    return !/[\s\\[\]]/.test(part.body);
-  });
+  return (
+    args.body.length > 1 &&
+    args.body.every((arg) => {
+      // We want to verify that every node inside of this array is a string
+      // literal. We also want to make sure none of them have comments attached.
+      if (arg.type !== "string_literal" || arg.comments) {
+        return false;
+      }
+
+      // If the string has multiple parts (meaning plain string content but also
+      // interpolated content) then we know it's not a simple string.
+      if (arg.body.length !== 1) {
+        return false;
+      }
+
+      const part = arg.body[0];
+
+      // If the only part of this string is not @tstring_content then it's
+      // interpolated, so again we can return false.
+      if (part.type !== "@tstring_content") {
+        return false;
+      }
+
+      // Finally, verify that the string doesn't contain a space, an escape
+      // character, or brackets so that we know it can be put into a string
+      // literal array.
+      return !/[\s\\[\]]/.test(part.body);
+    })
+  );
 }
 
 // Checks that every argument within this args node is a symbol_literal node (as
@@ -53,8 +56,9 @@ function isStringArray(args) {
 //     [:a, :b, :c]
 //
 function isSymbolArray(args) {
-  return args.body.every(
-    (arg) => arg.type === "symbol_literal" && !arg.comments
+  return (
+    args.body.length > 1 &&
+    args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments)
   );
 }
 
@@ -123,7 +127,7 @@ function printArray(path, opts, print) {
 
   // If we have an array that contains only simple string literals with no
   // spaces or interpolation, then we're going to print a %w array.
-  if (isStringArray(args)) {
+  if (opts.rubyArrayLiteral && isStringArray(args)) {
     const printString = (stringPath) => stringPath.call(print, "body", 0);
     const parts = path.map(printString, "body", 0, "body");
 
@@ -132,7 +136,7 @@ function printArray(path, opts, print) {
 
   // If we have an array that contains only simple symbol literals with no
   // interpolation, then we're going to print a %i array.
-  if (isSymbolArray(args)) {
+  if (opts.rubyArrayLiteral && isSymbolArray(args)) {
     const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
     const parts = path.map(printSymbol, "body", 0, "body");
 

data/src/nodes/assign.js

@@ -1,5 +1,5 @@
 const { concat, group, indent, join, line } = require("../prettier");
-const { concatBody, first, skipAssignIndent } = require("../utils");
+const { first, skipAssignIndent } = require("../utils");
 
 function printAssign(path, opts, print) {
   const [_targetNode, valueNode] = path.getValue().body;
@@ -34,6 +34,6 @@ function printOpAssign(path, opts, print) {
 module.exports = {
   assign: printAssign,
   opassign: printOpAssign,
-  var_field: concatBody,
+  var_field: first,
   var_ref: first
 };

data/src/nodes/calls.js

@@ -6,15 +6,15 @@ const {
   indent,
   softline
 } = require("../prettier");
-const { concatBody, first, makeCall, noIndent } = require("../utils");
+const { first, makeCall, noIndent } = require("../utils");
 
 const toProc = require("../toProc");
 
-const chained = ["call", "method_add_arg"];
+const chained = ["call", "method_add_arg", "method_add_block"];
 
 function printCall(path, opts, print) {
-  const callNode = path.getValue();
-  const [receiverNode, _operatorNode, messageNode] = callNode.body;
+  const node = path.getValue();
+  const [receiverNode, _operatorNode, messageNode] = node.body;
 
   const receiverDoc = path.call(print, "body", 0);
   const operatorDoc = makeCall(path, opts, print);
@@ -24,21 +24,13 @@ function printCall(path, opts, print) {
   // call syntax so if `call` is implicit, we don't print it out.
   const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
 
-  // For certain left sides of the call nodes, we want to attach directly to
-  // the } or end.
-  if (noIndent.includes(receiverNode.type)) {
-    return concat([receiverDoc, operatorDoc, messageDoc]);
-  }
-
   // The right side of the call node, as in everything including the operator
   // and beyond.
-  const rightSideDoc = indent(
-    concat([
-      receiverNode.comments ? hardline : softline,
-      operatorDoc,
-      messageDoc
-    ])
-  );
+  const rightSideDoc = concat([
+    receiverNode.comments ? hardline : softline,
+    operatorDoc,
+    messageDoc
+  ]);
 
   // Get a reference to the parent node so we can check if we're inside a chain
   const parentNode = path.getParentNode();
@@ -46,27 +38,31 @@ function printCall(path, opts, print) {
   // If our parent node is a chained node then we're not going to group the
   // right side of the expression, as we want to have a nice multi-line layout.
   if (chained.includes(parentNode.type)) {
-    parentNode.chain = (callNode.chain || 0) + 1;
-    parentNode.breakDoc = (callNode.breakDoc || [receiverDoc]).concat(
-      rightSideDoc
-    );
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
   }
 
   // If we're at the top of a chain, then we're going to print out a nice
   // multi-line layout if this doesn't break into multiple lines.
-  if (!chained.includes(parentNode.type) && (callNode.chain || 0) >= 3) {
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
     return ifBreak(
-      group(concat(callNode.breakDoc.concat(rightSideDoc))),
+      group(indent(concat(node.breakDoc.concat(rightSideDoc)))),
       concat([receiverDoc, group(rightSideDoc)])
     );
   }
 
-  return group(concat([receiverDoc, group(rightSideDoc)]));
+  // For certain left sides of the call nodes, we want to attach directly to
+  // the } or end.
+  if (noIndent.includes(receiverNode.type)) {
+    return concat([receiverDoc, operatorDoc, messageDoc]);
+  }
+
+  return group(concat([receiverDoc, group(indent(rightSideDoc))]));
 }
 
 function printMethodAddArg(path, opts, print) {
-  const methodAddArgNode = path.getValue();
-  const argNode = methodAddArgNode.body[1];
+  const node = path.getValue();
+  const argNode = node.body[1];
 
   const [methodDoc, argsDoc] = path.map(print, "body");
 
@@ -88,20 +84,15 @@ function printMethodAddArg(path, opts, print) {
   // If our parent node is a chained node then we're not going to group the
   // right side of the expression, as we want to have a nice multi-line layout.
   if (chained.includes(parentNode.type)) {
-    parentNode.chain = (methodAddArgNode.chain || 0) + 1;
-    parentNode.breakDoc = (methodAddArgNode.breakDoc || [methodDoc]).concat(
-      argsDoc
-    );
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
   }
 
   // If we're at the top of a chain, then we're going to print out a nice
   // multi-line layout if this doesn't break into multiple lines.
-  if (
-    !chained.includes(parentNode.type) &&
-    (methodAddArgNode.chain || 0) >= 3
-  ) {
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
     return ifBreak(
-      group(concat(methodAddArgNode.breakDoc.concat(argsDoc))),
+      group(indent(concat(node.breakDoc.concat(argsDoc)))),
       concat([methodDoc, argsDoc])
     );
   }
@@ -109,15 +100,18 @@ function printMethodAddArg(path, opts, print) {
   return concat([methodDoc, argsDoc]);
 }
 
-module.exports = {
-  call: printCall,
-  fcall: concatBody,
-  method_add_arg: printMethodAddArg,
-  method_add_block: (path, opts, print) => {
-    const [method, block] = path.getValue().body;
-    const proc = toProc(path, opts, block);
+function printMethodAddBlock(path, { rubyToProc }, print) {
+  const node = path.getValue();
+
+  const [callNode, blockNode] = node.body;
+  const [callDoc, blockDoc] = path.map(print, "body");
 
-    if (proc && method.type === "call") {
+  // Don't bother trying to do any kind of fancy toProc transform if the option
+  // is disabled.
+  if (rubyToProc) {
+    const proc = toProc(path, blockNode);
+
+    if (proc && callNode.type === "call") {
       return group(
         concat([
           path.call(print, "body", 0),
@@ -131,8 +125,34 @@ module.exports = {
     if (proc) {
       return path.call(print, "body", 0);
     }
+  }
 
-    return concat(path.map(print, "body"));
-  },
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
+
+  // If our parent node is a chained node then we're not going to group the
+  // right side of the expression, as we want to have a nice multi-line layout.
+  if (chained.includes(parentNode.type)) {
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [callDoc]).concat(blockDoc);
+  }
+
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
+    return ifBreak(
+      group(indent(concat(node.breakDoc.concat(blockDoc)))),
+      concat([callDoc, blockDoc])
+    );
+  }
+
+  return concat([callDoc, blockDoc]);
+}
+
+module.exports = {
+  call: printCall,
+  fcall: first,
+  method_add_arg: printMethodAddArg,
+  method_add_block: printMethodAddBlock,
   vcall: first
 };

data/src/nodes/case.js

@@ -28,13 +28,17 @@ module.exports = {
     // The `fill` builder command expects an array of docs alternating with
     // line breaks. This is so it can loop through and determine where to break.
     const preds = fill(
-      path
-        .call(print, "body", 0)
-        .reduce(
-          (accum, pred, index) =>
-            index === 0 ? [pred] : accum.concat([",", line, pred]),
-          null
-        )
+      path.call(print, "body", 0).reduce((accum, pred, index) => {
+        if (index === 0) {
+          return [pred];
+        }
+
+        // Pull off the last element and make it concat with a comma so that
+        // we can maintain alternating lines and docs.
+        return accum
+          .slice(0, -1)
+          .concat([concat([accum[accum.length - 1], ","]), line, pred]);
+      }, null)
     );
 
     const stmts = path.call(print, "body", 1);

data/src/nodes/hashes.js

@@ -25,35 +25,54 @@ function isValidHashLabel(symbolLiteral) {
   return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
 }
 
-function printHashKey(path, { rubyHashLabel }, print) {
-  const labelNode = path.getValue().body[0];
-  const labelDoc = path.call(print, "body", 0);
+function canUseHashLabels(contentsNode) {
+  return contentsNode.body.every((assocNode) => {
+    if (assocNode.type === "assoc_splat") {
+      return true;
+    }
 
-  switch (labelNode.type) {
-    case "@label":
-      if (rubyHashLabel) {
-        return labelDoc;
-      }
-      return `:${labelDoc.slice(0, labelDoc.length - 1)} =>`;
-    case "symbol_literal": {
-      if (rubyHashLabel && isValidHashLabel(labelNode)) {
-        return concat([path.call(print, "body", 0, "body", 0), ":"]);
-      }
-      return concat([labelDoc, " =>"]);
+    switch (assocNode.body[0].type) {
+      case "@label":
+        return true;
+      case "symbol_literal":
+        return isValidHashLabel(assocNode.body[0]);
+      case "dyna_symbol":
+        return true;
+      default:
+        return false;
     }
+  });
+}
+
+function printHashKeyLabel(path, print) {
+  const node = path.getValue();
+
+  switch (node.type) {
+    case "@label":
+      return print(path);
+    case "symbol_literal":
+      return concat([path.call(print, "body", 0), ":"]);
     case "dyna_symbol":
-      if (rubyHashLabel) {
-        return concat(labelDoc.parts.slice(1).concat(":"));
-      }
-      return concat([labelDoc, " =>"]);
-    default:
-      return concat([labelDoc, " =>"]);
+      return concat(print(path).parts.slice(1).concat(":"));
   }
 }
 
+function printHashKeyRocket(path, print) {
+  const node = path.getValue();
+  const doc = print(path);
+
+  if (node.type === "@label") {
+    return `:${doc.slice(0, doc.length - 1)} =>`;
+  }
+
+  return concat([doc, " =>"]);
+}
+
 function printAssocNew(path, opts, print) {
+  const { keyPrinter } = path.getParentNode();
+
+  const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
-  const parts = [printHashKey(path, opts, print)];
 
   if (skipAssignIndent(path.getValue().body[1])) {
     parts.push(" ", valueDoc);
@@ -64,6 +83,44 @@ function printAssocNew(path, opts, print) {
   return group(concat(parts));
 }
 
+function printHashContents(path, opts, print) {
+  const node = path.getValue();
+
+  // First determine which key printer we're going to use, so that the child
+  // nodes can reference it when they go to get printed.
+  node.keyPrinter =
+    opts.rubyHashLabel && canUseHashLabels(path.getValue())
+      ? printHashKeyLabel
+      : printHashKeyRocket;
+
+  const contents = join(concat([",", line]), path.map(print, "body"));
+
+  // If we're inside a hash literal, then we want to add the braces at this
+  // level so that the grouping is correct. Otherwise you could end up with
+  // opening and closing braces being split up, but the contents not being split
+  // correctly.
+  if (path.getParentNode().type === "hash") {
+    return group(
+      concat([
+        "{",
+        indent(
+          concat([
+            line,
+            contents,
+            getTrailingComma(opts) ? ifBreak(",", "") : ""
+          ])
+        ),
+        line,
+        "}"
+      ])
+    );
+  }
+
+  // Otherwise, we're inside a bare_assoc_hash, so we don't want to print
+  // braces at all.
+  return group(contents);
+}
+
 function printEmptyHashWithComments(path, opts) {
   const hashNode = path.getValue();
 
@@ -92,24 +149,7 @@ function printHash(path, opts, print) {
     return hashNode.comments ? printEmptyHashWithComments(path, opts) : "{}";
   }
 
-  return group(
-    concat([
-      "{",
-      indent(
-        concat([
-          line,
-          path.call(print, "body", 0),
-          getTrailingComma(opts) ? ifBreak(",", "") : ""
-        ])
-      ),
-      line,
-      "}"
-    ])
-  );
-}
-
-function printHashContents(path, opts, print) {
-  return group(join(concat([",", line]), path.map(print, "body")));
+  return path.call(print, "body", 0);
 }
 
 module.exports = {

data/src/nodes/ints.js

@@ -12,12 +12,6 @@
 function printInt(path, _opts, _print) {
   const { body } = path.getValue();
 
-  // If the number is octal and does not contain the optional "o" character
-  // after the leading 0, add it in.
-  if (/^0[0-9]/.test(body)) {
-    return `0o${body.slice(1)}`;
-  }
-
   // If the number is a base 10 number, is sufficiently large, and is not
   // already formatted with underscores, then add them in in between the
   // numbers every three characters starting from the right.

data/src/nodes/lambdas.js

@@ -1,11 +1,4 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  line,
-  softline
-} = require("../prettier");
+const { concat, group, ifBreak, indent, line } = require("../prettier");
 const { hasAncestor } = require("../utils");
 
 // We can have our params coming in as the first child of the main lambda node,
@@ -13,31 +6,22 @@ const { hasAncestor } = require("../utils");
 // though it's possible to omit the parens if you only have one argument, we're
 // going to keep them in no matter what for consistency.
 function printLambdaParams(path, print) {
-  const paramsPath = [print, "body", 0];
-  let paramsNode = path.getValue().body[0];
+  let node = path.getValue().body[0];
 
   // In this case we had something like -> (foo) { bar } which would mean that
   // we're looking at a paren node, so we'll descend one level deeper to get at
   // the actual params node.
-  if (paramsNode.type !== "params") {
-    paramsPath.push("body", 0);
-    paramsNode = paramsNode.body[0];
+  if (node.type !== "params") {
+    node = node.body[0];
   }
 
   // If we don't have any params at all, then we're just going to bail out and
   // print nothing. This is to avoid printing an empty set of parentheses.
-  if (paramsNode.body.every((type) => !type)) {
+  if (node.body.every((type) => !type)) {
     return "";
   }
 
-  return group(
-    concat([
-      "(",
-      indent(concat([softline, path.call.apply(path, paramsPath)])),
-      softline,
-      ")"
-    ])
-  );
+  return path.call(print, "body", 0);
 }
 
 // Lambda nodes represent stabby lambda literals, which can come in a couple of

data/src/nodes/params.js

@@ -1,4 +1,4 @@
-const { concat, group, join, line } = require("../prettier");
+const { concat, group, join, indent, line, softline } = require("../prettier");
 const { literal } = require("../utils");
 
 function printRestParam(symbol) {
@@ -64,6 +64,8 @@ function printParams(path, opts, print) {
     parts.push(path.call(print, "body", 6));
   }
 
+  const contents = [join(concat([",", line]), parts)];
+
   // You can put an extra comma at the end of block args between pipes to
   // change what it does. Below is the difference:
   //
@@ -73,9 +75,19 @@ function printParams(path, opts, print) {
   // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
   // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
   // node in the rest position. Seems odd, but it's true.
-  const comma = rest === 0 || (rest && rest.type === "excessed_comma");
+  if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+    contents.push(",");
+  }
+
+  // If the parent node is a paren then we skipped printing the parentheses so
+  // that we could handle them here and get nicer formatting.
+  if (["lambda", "paren"].includes(path.getParentNode().type)) {
+    return group(
+      concat(["(", indent(concat([softline].concat(contents))), softline, ")"])
+    );
+  }
 
-  return group(concat([join(concat([",", line]), parts), comma ? "," : ""]));
+  return group(concat(contents));
 }
 
 module.exports = {

data/src/nodes/statements.js

@@ -45,35 +45,45 @@ function printBodyStmt(path, opts, print) {
   return group(concat(parts));
 }
 
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+
+function printParen(path, opts, print) {
+  const contentNode = path.getValue().body[0];
+
+  if (!contentNode) {
+    return "()";
+  }
+
+  let contentDoc = path.call(print, "body", 0);
+
+  // If the content is params, we're going to let it handle its own parentheses
+  // so that it breaks nicely.
+  if (contentNode.type === "params") {
+    return contentDoc;
+  }
+
+  // If we have an arg type node as the contents, then it's going to return an
+  // array, so we need to explicitly join that content here.
+  if (argNodeTypes.includes(contentNode.type)) {
+    contentDoc = join(concat([",", line]), contentDoc);
+  }
+
+  return group(
+    concat([
+      "(",
+      indent(concat([softline, contentDoc])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
 module.exports = {
   "@__end__": (path, _opts, _print) => {
     const { body } = path.getValue();
     return concat([trim, "__END__", literalline, body]);
   },
   bodystmt: printBodyStmt,
-  paren: (path, opts, print) => {
-    if (!path.getValue().body[0]) {
-      return "()";
-    }
-
-    let content = path.call(print, "body", 0);
-
-    if (
-      ["args", "args_add_star", "args_add_block"].includes(
-        path.getValue().body[0].type
-      )
-    ) {
-      content = join(concat([",", line]), content);
-    }
-
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, content])),
-        concat([softline, ")"])
-      ])
-    );
-  },
+  paren: printParen,
   program: (path, opts, print) =>
     concat([join(hardline, path.map(print, "body")), hardline]),
   stmts: (path, opts, print) => {

data/src/parser.rb

@@ -566,8 +566,10 @@ class Prettier::Parser < Ripper
 
       # Here we're going to determine the bounds for the stmts
       consequent = parts[1..-1].compact.first
-      self[:body][0].bind(char_start,
-        consequent ? consequent[:char_start] : char_end)
+      self[:body][0].bind(
+        char_start,
+        consequent ? consequent[:char_start] : char_end
+      )
 
       # Next we're going to determine the rescue clause if there is one
       if parts[1]
@@ -1064,7 +1066,10 @@ class Prettier::Parser < Ripper
   # event, so here we'll initialize the current embdoc.
   def on_embdoc_beg(value)
     @embdoc = {
-      type: :@embdoc, value: value, start: lineno, char_start: char_pos
+      type: :@embdoc,
+      value: value,
+      start: lineno,
+      char_start: char_pos
     }
   end
 
@@ -1211,9 +1216,12 @@ class Prettier::Parser < Ripper
 
     # Here we're going to artificially create an extra node type so that if
     # there are comments after the declaration of a heredoc, they get printed.
-    location.merge(
-      type: :heredoc, beging: location.merge(type: :@heredoc_beg, body: beging)
-    ).tap { |node| @heredocs << node }
+    location
+      .merge(
+        type: :heredoc,
+        beging: location.merge(type: :@heredoc_beg, body: beging)
+      )
+      .tap { |node| @heredocs << node }
   end
 
   # This is a parser event that occurs when you're using a heredoc with a
@@ -1644,7 +1652,10 @@ class Prettier::Parser < Ripper
   # some found at the end of the source string.
   def on_program(stmts)
     range = {
-      start: 1, end: lines.length, char_start: 0, char_end: source.length
+      start: 1,
+      end: lines.length,
+      char_start: 0,
+      char_end: source.length
     }
 
     stmts[:body] << @__end__ if @__end__

data/src/ruby.js

@@ -76,30 +76,37 @@ module.exports = {
     ruby: printer
   },
   options: {
+    rubyArrayLiteral: {
+      type: "boolean",
+      category: "Ruby",
+      default: true,
+      description:
+        "When possible, favor the use of string and symbol array literals."
+    },
     rubyHashLabel: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
     },
     rubyModifier: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When it fits on one line, allows if, unless, while, and until statements to use the modifier form."
     },
     rubySingleQuote: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
     },
     rubyToProc: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: false,
       description:
         "When possible, convert blocks to the more concise Symbol#to_proc syntax."

data/src/toProc.js

@@ -11,8 +11,8 @@ const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 //     [1, 2, 3].map(&:to_s)
 //
 // This works with `do` blocks as well.
-const toProc = (path, opts, node) => {
-  if (!node || !opts.rubyToProc) {
+const toProc = (path, node) => {
+  if (!node) {
     return null;
   }
 

data/src/utils.js

@@ -2,8 +2,6 @@ const { concat } = require("./prettier");
 const isEmptyStmts = require("./utils/isEmptyStmts");
 const literalLineNoBreak = require("./utils/literalLineNoBreak");
 
-const concatBody = (path, opts, print) => concat(path.map(print, "body"));
-
 // If the node is a type of assignment or if the node is a paren and nested
 // inside that paren is a node that is a type of assignment.
 const containsAssignment = (node) =>
@@ -79,7 +77,6 @@ const skipAssignIndent = (node) =>
   (node.type === "call" && skipAssignIndent(node.body[0]));
 
 module.exports = {
-  concatBody,
   containsAssignment,
   docLength,
   empty,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc1
+  version: 1.0.0.pre.rc2
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-09 00:00:00.000000000 Z
+date: 2020-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler