prettier 0.15.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4601f1c4bcd732027d5e7077aeece6ce80485b33f6d6122149903a3b768bae01
-  data.tar.gz: 7b8934c54be0b0125b25325d45a82d801314c9a4f6074033f9e719db8e873ffc
+  metadata.gz: b3562a5d108cf70183f77a181bc6d2370c28119596741bfedaf0f40b17062098
+  data.tar.gz: ecafaf2f71979173250bf03aabe13c7d6fa5d6fe4f7373042405c81bdc6a3b60
 SHA512:
-  metadata.gz: 5b9adb4c97a45dd1323cd36af7e8fbd6b542a5bb15f9c5c5824155ee09ea2c6cd2d4b0e27eedcfb4c3d79b1045fa7454cfba3ead575262a1740352a74f47798d
-  data.tar.gz: 3e6bd216100a983f702ca001c1f2578609361fe11e7e7a3ffa70da6b8a0db988d23afd3d7ba5328dfea8f0b1fe5d124bd9767f498708c931aef27e6f05994c40
+  metadata.gz: fc85edcee8ac7892a6d3b0e727abff488d72a5ecfa717383229774f24faae4bf0384f77e1c5c459586b363dc8822968413c1e0aa8da8f998ca46ccf986a3344b
+  data.tar.gz: 79f754fd9fa9a46171e9c8a6871d4b487fd4cc19a8cb21527b5a0d322761771d3339e28bdc4128ab044240d5a7c149a9ea6c40d8acb1db036ecdea7163419af0

data/CHANGELOG.md

@@ -6,6 +6,72 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.15.1] - 2019-11-05
+
+### Changed
+
+- [INTERNAL] Add `bin/lex` for viewing the tokenized result of Ripper on Ruby code (Thanks to @AlanFoster.)
+- When predicates from within an `if`, `unless`, `while`, or `until` loop break the line, they should be aligned together. For example,
+
+<!-- prettier-ignore -->
+```ruby
+if foooooo || barrrrrr
+  baz
+end
+```
+
+If the line was set to very short, the binary node should be aligned to 3 spaces from the left of the file (which aligns with the `if`, it would be more for `unless`). So it would look like:
+
+<!-- prettier-ignore -->
+```ruby
+if foooooo ||
+     barrrrrr
+  baz
+end
+```
+
+(Thanks to @jakeprime for the report.)
+
+- Empty `if`, and `unless` conditionals are now handled gracefully:
+
+<!-- prettier-ignore -->
+```ruby
+if foo?
+end
+```
+
+(Thanks to @AlanFoster for the fix, and @jamescostian for the report.)
+
+- Hash keys are not converted to keyword syntax if they would make invalid symbols. For example,
+
+<!-- prettier-ignore -->
+```ruby
+{ :[] => nil }
+```
+
+cannot be translated into `[]:` as that is an invalid symbol. Instead, it stays with the hash rocket syntax. (Thanks to @mmainz for the report.)
+
+- Do not attempt to format the insides of xstring literals (string that get sent to the command line surrounded by backticks or `%x`). (Thanks to @cldevs for the report.)
+- When predicates for `if`, `unless`, `while`, or `until` nodes contain an assignment, we can't know for sure that it doesn't modify the body. In this case we need to always break and form a multi-line block. (Thanks to @cldevs for the report.)
+- When the return value of `if`, `unless`, `while`, or `until` nodes are assigned to anything other than a local variable, we need to wrap them in parentheses if we're changing to the modifier form. This is because the following expressions have different semantic meaning:
+
+<!-- prettier-ignore -->
+```ruby
+hash[:key] = break :value while false
+hash[:key] = while false do break :value end
+```
+
+The first one will not result in an empty hash, whereas the second one will result in `{ key: nil }`. In this case what we need to do for the first expression to align is wrap it in parens, as in:
+
+<!-- prettier-ignore -->
+```ruby
+hash[:key] = (break :value while false)
+```
+
+That will guarantee that the expressions are equivalent. (Thanks to @MarcManiez for the report.)
+
+- Fix crashes that were happening with `ignored_nl` nodes. (Thanks to @AlanFoster.)
+
 ## [0.15.0] - 2019-08-06
 
 ### Changed
@@ -545,7 +611,8 @@ would previously result in `array[]`, but now prints properly. (Thanks to @xipgr
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v0.15.0...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v0.15.1...HEAD
+[0.15.1]: https://github.com/prettier/plugin-ruby/compare/v0.15.0...v0.15.1
 [0.15.0]: https://github.com/prettier/plugin-ruby/compare/v0.14.0...v0.15.0
 [0.14.0]: https://github.com/prettier/plugin-ruby/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/prettier/plugin-ruby/compare/v0.12.3...v0.13.0

data/CONTRIBUTING.md

@@ -118,6 +118,18 @@ yarn run test
 yarn run test -u
 ```
 
+**Viewing the tokenized result of Ripper on code**
+
+```
+bin/lex 'your_ruby_code(1, 2, 3)'
+```
+
+**Viewing the tokenized result of Ripper on a file**
+
+```
+bin/lex file.rb
+```
+
 **Viewing the output of RipperJS on a file**
 
 ```

data/README.md

@@ -191,6 +191,8 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/jakeprime"><img src="https://avatars1.githubusercontent.com/u/1019036?v=4" width="100px;" alt="jakeprime"/><br /><sub><b>jakeprime</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Ajakeprime" title="Bug reports">🐛</a></td>
+    <td align="center"><a href="http://mmainz.github.io"><img src="https://avatars2.githubusercontent.com/u/5417714?v=4" width="100px;" alt="Mario Mainz"/><br /><sub><b>Mario Mainz</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Ammainz" title="Bug reports">🐛</a></td>
+    <td align="center"><a href="http://www.cldevs.com"><img src="https://avatars3.githubusercontent.com/u/38632061?v=4" width="100px;" alt="CL Web Developers"/><br /><sub><b>CL Web Developers</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Acldevs" title="Bug reports">🐛</a></td>
   </tr>
 </table>
 

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -24,7 +24,7 @@
   "devDependencies": {
     "all-contributors-cli": "^6.1.2",
     "eslint": "^6.0.1",
-    "eslint-config-airbnb-base": "^13.1.0",
+    "eslint-config-airbnb-base": "^14.0.0",
     "eslint-config-prettier": "^6.0.0",
     "eslint-plugin-import": "^2.16.0",
     "jest": "^24.0.0"

data/src/nodes/conditionals.js

@@ -8,6 +8,7 @@ const {
   indent,
   softline
 } = require("../prettier");
+const { containsAssignment } = require("../utils");
 
 const noTernary = [
   "@comment",
@@ -40,7 +41,7 @@ const noTernary = [
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([
     `${keyword} `,
-    align(keyword.length - 1, path.call(print, "body", 0)),
+    align(keyword.length + 1, path.call(print, "body", 0)),
     indent(concat([softline, path.call(print, "body", 1)])),
     concat([softline, path.call(print, "body", 2)]),
     concat([softline, "end"]),
@@ -91,7 +92,7 @@ const printTernary = (path, _opts, print) => {
     ifBreak(
       concat([
         "if ",
-        predicate,
+        align(3, predicate),
         indent(concat([softline, truthyClause])),
         concat([softline, "else"]),
         indent(concat([softline, falsyClause])),
@@ -102,31 +103,52 @@ const printTernary = (path, _opts, print) => {
   );
 };
 
-// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
-// modifier form, we're guaranteed to not have an additional node, so we can
-// just work with the predicate and the body.
-const printSingle = keyword => (path, { inlineConditionals }, print) => {
-  const multiline = concat([
+const makeSingleBlockForm = (keyword, path, print) =>
+  concat([
     `${keyword} `,
-    align(keyword.length - 1, path.call(print, "body", 0)),
+    align(keyword.length + 1, path.call(print, "body", 0)),
     indent(concat([softline, path.call(print, "body", 1)])),
     concat([softline, "end"])
   ]);
 
-  const [predicate, stmts] = path.getValue().body;
+// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
+// modifier form, we're guaranteed to not have an additional node, so we can
+// just work with the predicate and the body.
+const printSingle = keyword => (path, { inlineConditionals }, print) => {
+  const multiline = makeSingleBlockForm(keyword, path, print);
+
+  const [_predicate, stmts] = path.getValue().body;
   const hasComments =
     stmts.type === "stmts" && stmts.body.some(stmt => stmt.type === "@comment");
 
-  if (!inlineConditionals || hasComments || predicate.type === "assign") {
+  if (!inlineConditionals || hasComments) {
     return multiline;
   }
 
-  const inline = concat([
+  let inlineParts = [
     path.call(print, "body", 1),
     ` ${keyword} `,
     path.call(print, "body", 0)
-  ]);
+  ];
+
+  // If the return value of this conditional expression is being assigned to
+  // anything besides a local variable then we can't inline the entire
+  // expression without wrapping it in parentheses. This is because the
+  // following expressions have different semantic meaning:
+  //
+  //     hash[:key] = :value if false
+  //     hash[:key] = if false then :value end
+  //
+  // The first one will not result in an empty hash, whereas the second one
+  // will result in `{ key: nil }`. In this case what we need to do for the
+  // first expression to align is wrap it in parens, as in:
+  //
+  //     hash[:key] = (:value if false)
+  if (["assign", "massign"].includes(path.getParentNode().type)) {
+    inlineParts = ["("].concat(inlineParts).concat(")");
+  }
 
+  const inline = concat(inlineParts);
   return group(ifBreak(multiline, inline));
 };
 
@@ -171,12 +193,31 @@ const printConditional = keyword => (path, { inlineConditionals }, print) => {
     );
   }
 
+  const [predicate, statements, addition] = path.getValue().body;
+
   // If there's an additional clause that wasn't matched earlier, we know we
   // can't go for the inline option.
-  if (path.getValue().body[2]) {
+  if (addition) {
     return group(printWithAddition(keyword, path, print, { breaking: true }));
   }
 
+  // If the body of the conditional is empty, then we explicitly have to use the
+  // block form.
+  if (statements.type === "stmts" && statements.body[0].type === "void_stmt") {
+    return concat([
+      `${keyword} `,
+      align(keyword.length + 1, path.call(print, "body", 0)),
+      concat([hardline, "end"])
+    ]);
+  }
+
+  // If the predicate of the conditional contains an assignment, then we can't
+  // know for sure that it doesn't impact the body of the conditional, so we
+  // have to default to the block form.
+  if (containsAssignment(predicate)) {
+    return makeSingleBlockForm(keyword, path, print);
+  }
+
   return printSingle(keyword)(path, { inlineConditionals }, print);
 };
 

data/src/nodes/hashes.js

@@ -19,6 +19,21 @@ const nodeDive = (node, steps) => {
   return current;
 };
 
+// When attempting to convert a hash rocket into a hash label, you need to take
+// care because only certain patterns are allowed. Ruby source says that they
+// have to match keyword arguments to methods, but don't specify what that is.
+// After some experimentation, it looks like it's:
+//
+// * Starts with a letter (either case) or an underscore
+// * Does not end in equal
+//
+// This function represents that check, as it determines if it can convert the
+// symbol node into a hash label.
+const isValidHashLabel = symbolLiteral => {
+  const label = symbolLiteral.body[0].body[0].body;
+  return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
+};
+
 const makeLabel = (path, { preferHashLabels }, print, steps) => {
   const labelNode = nodeDive(path.getValue(), steps);
   const labelDoc = path.call.apply(path, [print].concat(steps));
@@ -30,11 +45,7 @@ const makeLabel = (path, { preferHashLabels }, print, steps) => {
       }
       return `:${labelDoc.slice(0, labelDoc.length - 1)} =>`;
     case "symbol_literal": {
-      // You can have a symbol literal as a key in a hash that ends with an =
-      // character, which breaks when you use hash labels.
-      const endsInEquals = labelNode.body[0].body[0].body.endsWith("=");
-
-      if (preferHashLabels && labelNode.body.length === 1 && !endsInEquals) {
+      if (preferHashLabels && isValidHashLabel(labelNode)) {
         const symbolSteps = steps.concat("body", 0, "body", 0);
 
         return concat([

data/src/nodes/loops.js

@@ -1,4 +1,5 @@
 const {
+  align,
   concat,
   group,
   hardline,
@@ -6,13 +7,33 @@ const {
   indent,
   softline
 } = require("../prettier");
+const { containsAssignment } = require("../utils");
 
 const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
-  const inlineLoop = concat([
+  let inlineParts = [
     path.call(print, "body", 1),
     ` ${keyword} `,
     path.call(print, "body", 0)
-  ]);
+  ];
+
+  // If the return value of this loop expression is being assigned to anything
+  // besides a local variable then we can't inline the entire expression
+  // without wrapping it in parentheses. This is because the following
+  // expressions have different semantic meaning:
+  //
+  //     hash[:key] = break :value while false
+  //     hash[:key] = while false do break :value end
+  //
+  // The first one will not result in an empty hash, whereas the second one
+  // will result in `{ key: nil }`. In this case what we need to do for the
+  // first expression to align is wrap it in parens, as in:
+  //
+  //     hash[:key] = (break :value while false)
+  if (["assign", "massign"].includes(path.getParentNode().type)) {
+    inlineParts = ["("].concat(inlineParts).concat(")");
+  }
+
+  const inlineLoop = concat(inlineParts);
 
   // If we're in the modifier form and we're modifying a `begin`, then this is a
   // special case where we need to explicitly use the modifier form because
@@ -28,12 +49,19 @@ const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
   }
 
   const blockLoop = concat([
-    concat([`${keyword} `, path.call(print, "body", 0)]),
+    concat([
+      `${keyword} `,
+      align(keyword.length + 1, path.call(print, "body", 0))
+    ]),
     indent(concat([softline, path.call(print, "body", 1)])),
     concat([softline, "end"])
   ]);
 
-  if (!inlineLoops) {
+  // If we're disallowing inline loops or if the predicate of the loop contains
+  // an assignment (in which case we can't know for certain that that
+  // assignment doesn't impact the statements inside the loop) then we can't
+  // use the modifier form and we must use the block form.
+  if (!inlineLoops || containsAssignment(path.getValue().body[0])) {
     return blockLoop;
   }
 

data/src/nodes/strings.js

@@ -3,7 +3,6 @@ const {
   group,
   hardline,
   indent,
-  join,
   literalline,
   softline
 } = require("../prettier");
@@ -96,14 +95,20 @@ module.exports = {
       ])
     ),
   string_dvar: surround("#{", "}"),
-  string_embexpr: (path, opts, print) =>
-    group(
-      concat([
-        "#{",
-        indent(concat([softline, path.call(print, "body", 0)])),
-        concat([softline, "}"])
-      ])
-    ),
+  string_embexpr: (path, opts, print) => {
+    const parts = path.call(print, "body", 0);
+
+    // If the interpolated expression is inside of an xstring literal (a string
+    // that gets sent to the command line) then we don't want to automatically
+    // indent, as this can lead to some very odd looking expressions
+    if (path.getParentNode().type === "xstring") {
+      return concat(["#{", parts, "}"]);
+    }
+
+    return group(
+      concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
+    );
+  },
   string_literal: (path, { preferSingleQuotes }, print) => {
     const string = path.getValue().body[0];
 
@@ -142,21 +147,6 @@ module.exports = {
   xstring_literal: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 
-    if (typeof parts[0] === "string") {
-      parts[0] = parts[0].replace(/^\s+/, "");
-    }
-
-    const lastIndex = parts.length - 1;
-    if (typeof parts[lastIndex] === "string") {
-      parts[lastIndex] = parts[lastIndex].replace(/\s+$/, "");
-    }
-
-    return group(
-      concat([
-        "`",
-        indent(concat([softline, join(softline, parts)])),
-        concat([softline, "`"])
-      ])
-    );
+    return concat(["`"].concat(parts).concat("`"));
   }
 };

data/src/ripper.rb

@@ -340,7 +340,8 @@ class RipperJS < Ripper
       (SCANNER_EVENTS - defined).each do |event|
         define_method(:"on_#{event}") do |body|
           super(body).tap do |node|
-            node.merge!(char_start: char_pos, char_end: char_pos + body.size)
+            char_end = char_pos + (body ? body.size : 0)
+            node.merge!(char_start: char_pos, char_end: char_end)
 
             scanner_events << node
           end
@@ -678,7 +679,7 @@ class RipperJS < Ripper
 
         super(ident).tap do |node|
           if !@access_controls.include?(ident[:body]) ||
-             ident[:body] != lines[lineno - 1].strip
+               ident[:body] != lines[lineno - 1].strip
             next
           end
 
@@ -713,7 +714,7 @@ class RipperJS < Ripper
         stmts, *other_parts = bodystmt[:body]
 
         if !other_parts.any? && stmts[:body].length == 1 &&
-           stmts.dig(:body, 0, :type) == :begin
+             stmts.dig(:body, 0, :type) == :begin
           def_bodystmt = stmts.dig(:body, 0, :body, 0)
         end
 

data/src/utils.js

@@ -8,6 +8,12 @@ const {
 
 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 =>
+  ["assign", "massign"].includes(node.type) ||
+  (node.type === "paren" && node.body[0].body.some(containsAssignment));
+
 const docLength = doc => {
   if (doc.length) {
     return doc.length;
@@ -135,6 +141,7 @@ const surround = (left, right) => (path, opts, print) =>
 
 module.exports = {
   concatBody,
+  containsAssignment,
   docLength,
   empty,
   first,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2019-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: prettier plugin for the Ruby programming language