prettier 0.20.1 → 0.21.0

data/node_modules/prettier/third-party.js

@@ -2,36 +2,28 @@
 
 var os = require('os');
 var path = require('path');
-var module$1 = require('module');
+var Module = require('module');
 var fs = require('fs');
 var util = require('util');
-var buffer$1 = require('buffer');
-var stream = require('stream');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var module__default = /*#__PURE__*/_interopDefaultLegacy(module$1);
+var Module__default = /*#__PURE__*/_interopDefaultLegacy(Module);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
-var buffer__default = /*#__PURE__*/_interopDefaultLegacy(buffer$1);
-var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream);
 
 function createCommonjsModule(fn, basedir, module) {
 	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
 	}, fn(module, module.exports), module.exports;
 }
 
-function getCjsExportFromNamespace (n) {
-	return n && n['default'] || n;
-}
-
 function commonjsRequire () {
 	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
 }
@@ -59,10 +51,10 @@ const resolveFrom = (fromDir, moduleId, silent) => {
 
   const fromFile = path__default['default'].join(fromDir, 'noop.js');
 
-  const resolveFileName = () => module__default['default']._resolveFilename(moduleId, {
+  const resolveFileName = () => Module__default['default']._resolveFilename(moduleId, {
     id: fromFile,
     filename: fromFile,
-    paths: module__default['default']._nodeModulePaths(fromDir)
+    paths: Module__default['default']._nodeModulePaths(fromDir)
   });
 
   if (silent) {
@@ -10164,133 +10156,41 @@ var findParentDir = createCommonjsModule(function (module, exports) {
 });
 
 const {
-  PassThrough: PassThroughStream
-} = stream__default['default'];
+  stdin
+} = process;
 
-var bufferStream = options => {
-  options = Object.assign({}, options);
-  const {
-    array
-  } = options;
-  let {
-    encoding
-  } = options;
-  const isBuffer = encoding === 'buffer';
-  let objectMode = false;
+var getStdin = async () => {
+  let result = '';
 
-  if (array) {
-    objectMode = !(encoding || isBuffer);
-  } else {
-    encoding = encoding || 'utf8';
-  }
-
-  if (isBuffer) {
-    encoding = null;
+  if (stdin.isTTY) {
+    return result;
   }
 
-  const stream = new PassThroughStream({
-    objectMode
-  });
+  stdin.setEncoding('utf8');
 
-  if (encoding) {
-    stream.setEncoding(encoding);
+  for await (const chunk of stdin) {
+    result += chunk;
   }
 
-  let length = 0;
-  const chunks = [];
-  stream.on('data', chunk => {
-    chunks.push(chunk);
-
-    if (objectMode) {
-      length = chunks.length;
-    } else {
-      length += chunk.length;
-    }
-  });
-
-  stream.getBufferedValue = () => {
-    if (array) {
-      return chunks;
-    }
-
-    return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-  };
-
-  stream.getBufferedLength = () => length;
-
-  return stream;
+  return result;
 };
 
-const {
-  constants: BufferConstants
-} = buffer__default['default'];
-const {
-  promisify: promisify$1
-} = util__default['default'];
-const streamPipelinePromisified = promisify$1(stream__default['default'].pipeline);
+var buffer = async () => {
+  const result = [];
+  let length = 0;
 
-class MaxBufferError extends Error {
-  constructor() {
-    super('maxBuffer exceeded');
-    this.name = 'MaxBufferError';
+  if (stdin.isTTY) {
+    return Buffer.concat([]);
   }
 
-}
-
-async function getStream(inputStream, options) {
-  if (!inputStream) {
-    throw new Error('Expected a stream');
+  for await (const chunk of stdin) {
+    result.push(chunk);
+    length += chunk.length;
   }
 
-  options = Object.assign({
-    maxBuffer: Infinity
-  }, options);
-  const {
-    maxBuffer
-  } = options;
-  const stream = bufferStream(options);
-  await new Promise((resolve, reject) => {
-    const rejectPromise = error => {
-      // Don't retrieve an oversized buffer.
-      if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-        error.bufferedData = stream.getBufferedValue();
-      }
-
-      reject(error);
-    };
-
-    (async () => {
-      try {
-        await streamPipelinePromisified(inputStream, stream);
-        resolve();
-      } catch (error) {
-        rejectPromise(error);
-      }
-    })();
-
-    stream.on('data', () => {
-      if (stream.getBufferedLength() > maxBuffer) {
-        rejectPromise(new MaxBufferError());
-      }
-    });
-  });
-  return stream.getBufferedValue();
-}
-
-var getStream_1 = getStream;
-
-var buffer = (stream, options) => getStream(stream, Object.assign({}, options, {
-  encoding: 'buffer'
-}));
-
-var array = (stream, options) => getStream(stream, Object.assign({}, options, {
-  array: true
-}));
-
-var MaxBufferError_1 = MaxBufferError;
-getStream_1.buffer = buffer;
-getStream_1.array = array;
-getStream_1.MaxBufferError = MaxBufferError_1;
+  return Buffer.concat(result, length);
+};
+getStdin.buffer = buffer;
 
 var vendors = [
 	{
@@ -10502,25 +10402,18 @@ var vendors = [
 	}
 ];
 
-var vendors$1 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	'default': vendors
-});
-
-var vendors$2 = getCjsExportFromNamespace(vendors$1);
-
 var ciInfo = createCommonjsModule(function (module, exports) {
 
   var env = process.env; // Used for testing only
 
   Object.defineProperty(exports, '_vendors', {
-    value: vendors$2.map(function (v) {
+    value: vendors.map(function (v) {
       return v.constant;
     })
   });
   exports.name = null;
   exports.isPR = null;
-  vendors$2.forEach(function (vendor) {
+  vendors.forEach(function (vendor) {
     var envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
     var isCI = envs.every(function (obj) {
       return checkEnv(obj);
@@ -10576,7 +10469,7 @@ var thirdParty = {
   cosmiconfig: dist$2.cosmiconfig,
   cosmiconfigSync: dist$2.cosmiconfigSync,
   findParentDir: findParentDir.sync,
-  getStream: getStream_1,
+  getStdin: getStdin,
   isCI: () => ciInfo.isCI
 };
 

data/package.json

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

data/src/nodes.js

@@ -1,6 +1,7 @@
 module.exports = Object.assign(
   {},
   require("./nodes/alias"),
+  require("./nodes/aref"),
   require("./nodes/args"),
   require("./nodes/arrays"),
   require("./nodes/assign"),

data/src/nodes/alias.js

@@ -1,32 +1,75 @@
-const { concat, join } = require("../prettier");
+const {
+  addTrailingComment,
+  align,
+  concat,
+  group,
+  hardline,
+  line
+} = require("../prettier");
 
-const usingSymbols = (path) => {
-  const [left, right] = path.getValue().body.map((node) => node.body[0].type);
-  return left === "symbol" && right === "symbol";
-};
-
-const identFromSymbol = (path, print, index) =>
-  path.call(print, "body", index, "body", 0, "body", 0);
+/* In general, return the printed doc of the argument at the provided index.
+ * Special handling is given for symbol literals that are not bare words, as we
+ * convert those into bare words by just pulling out the ident node.
+ */
+function printAliasArgument(path, _opts, print, argIndex) {
+  const node = path.getValue().body[argIndex];
 
-const aliasError = (_path, _opts, _print) => {
-  throw new Error("can't make alias for the number variables");
-};
+  if (node.type === "symbol_literal" && node.body[0].type === "symbol") {
+    // If we're going to descend into the symbol literal to grab out the ident
+    // node, then we need to make sure we copy over any comments as well,
+    // otherwise we could accidentally skip printing them.
+    if (node.comments) {
+      node.comments.forEach((comment) => {
+        addTrailingComment(node.body[0].body[0], comment);
+      });
+    }
 
-const aliasVars = (path, opts, print) => {
-  if (usingSymbols(path)) {
-    return join(" ", [
-      identFromSymbol(path, print, 0),
-      identFromSymbol(path, print, 1)
-    ]);
+    return path.call(print, "body", argIndex, "body", 0, "body", 0);
   }
-  return join(" ", path.map(print, "body"));
-};
 
-const alias = (path, opts, print) =>
-  concat(["alias ", aliasVars(path, opts, print)]);
+  return path.call(print, "body", argIndex);
+}
+
+/* The `alias` keyword is used to make a method respond to another name as well
+ * as the current one. For example, to get the method `foo` to also respond to
+ * `bar`, you would:
+ *
+ *     alias bar foo
+ *
+ * Now, in the current context you can call `bar` and it will execute the `foo`
+ * method.
+ *
+ * When you're aliasing two methods, you can either provide bare words (like the
+ * example above) or you can provide symbols (note that this includes dynamic
+ * symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
+ * style guide, we prefer bare words:
+ *
+ *     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
+ *
+ * The `alias` node contains two children. The left and right align with the
+ * arguments passed to the keyword. So, for the above example the left would be
+ * the symbol literal `bar` and the right could be the symbol literal `foo`.
+ */
+function printAlias(path, opts, print) {
+  const keyword = "alias ";
+
+  const rightSide = concat([
+    // If the left child has any comments, then we need to explicitly break this
+    // into two lines
+    path.getValue().body[0].comments ? hardline : line,
+    printAliasArgument(path, opts, print, 1)
+  ]);
+
+  return group(
+    concat([
+      keyword,
+      printAliasArgument(path, opts, print, 0),
+      group(align(keyword, rightSide))
+    ])
+  );
+}
 
 module.exports = {
-  alias,
-  alias_error: aliasError,
-  var_alias: alias
+  alias: printAlias,
+  var_alias: printAlias
 };

data/src/nodes/aref.js

@@ -0,0 +1,55 @@
+const { concat, group, indent, join, line, softline } = require("../prettier");
+
+/* `aref` nodes are when you're pulling a value out of a collection at a
+ * specific index. Put another way, it's any time you're calling the method
+ * `#[]`.
+ *
+ * The nodes usually contains two children, details below in the
+ * `printArefField` function. In some cases, you don't necessarily have the
+ * second child node, because you can call procs with a pretty esoteric syntax.
+ * In the following example, you wouldn't have a second child, and `"foo"` would
+ * be the first child.
+ *
+ *     foo[]
+ */
+function printAref(path, opts, print) {
+  const indexNode = path.getValue().body[1];
+
+  if (!indexNode) {
+    return concat([path.call(print, "body", 0), "[]"]);
+  }
+
+  return printArefField(path, opts, print);
+}
+
+/* `aref_field` nodes are for assigning values into collections at specific
+ * indices. Put another way, it's any time you're calling the method `#[]=`.
+ * The `aref_field` node itself is just the left side of the assignment, and
+ * they're always wrapped in `assign` nodes.
+ *
+ * The nodes always contain two children, the name of the array (usually a
+ * `vcall` node and the index (usually an `args_add_block` node). The
+ * `args_add_block` is one of a couple nodes that has special handling where its
+ * printed form is actually an array to make joining easier.
+ *
+ * So in the following example, `"foo"` is the array and `["bar"]` is the index.
+ *
+ *     foo[bar] = baz
+ */
+function printArefField(path, opts, print) {
+  const [printedArray, printedIndex] = path.map(print, "body");
+
+  return group(
+    concat([
+      printedArray,
+      "[",
+      indent(concat([softline, join(concat([",", line]), printedIndex)])),
+      concat([softline, "]"])
+    ])
+  );
+}
+
+module.exports = {
+  aref: printAref,
+  aref_field: printArefField
+};

data/src/nodes/arrays.js

@@ -33,21 +33,6 @@ const getSpecialArrayParts = (path, print, args) =>
     path.call(print, "body", 0, "body", index, "body", 0, "body", 0)
   );
 
-const printAref = (path, opts, print) =>
-  group(
-    concat([
-      path.call(print, "body", 0),
-      "[",
-      indent(
-        concat([
-          softline,
-          join(concat([",", line]), path.call(print, "body", 1))
-        ])
-      ),
-      concat([softline, "]"])
-    ])
-  );
-
 const printSpecialArray = (parts) =>
   group(
     concat([
@@ -78,14 +63,6 @@ const getElements = (node, elementPath) => {
 };
 
 module.exports = {
-  aref: (path, opts, print) => {
-    if (!path.getValue().body[1]) {
-      return concat([path.call(print, "body", 0), "[]"]);
-    }
-
-    return printAref(path, opts, print);
-  },
-  aref_field: printAref,
   array: (path, { addTrailingCommas }, print) => {
     const args = path.getValue().body[0];
 
@@ -120,24 +97,15 @@ module.exports = {
     elements.forEach(({ element, elementPath }, index) => {
       const isInner = index !== elements.length - 1;
 
-      const isStraightHeredoc = element.type === "heredoc";
-      const isSquigglyHeredoc =
-        element.type === "string_literal" && element.body[0].type === "heredoc";
-
-      if (isStraightHeredoc || isSquigglyHeredoc) {
-        const heredocNode = isStraightHeredoc ? element : element.body[0];
-        const heredocPath = [print].concat(elementPath);
-
-        if (isSquigglyHeredoc) {
-          heredocPath.push("body", 0);
-        }
-
+      if (element.type === "heredoc") {
         normalDocs.push(
-          heredocNode.beging,
+          element.beging,
           isInner || addTrailingCommas ? "," : "",
           literalline,
-          concat(path.map.apply(path, heredocPath.concat("body"))),
-          heredocNode.ending,
+          concat(
+            path.map.apply(path, [print].concat(elementPath).concat("body"))
+          ),
+          element.ending,
           isInner ? line : ""
         );
       } else {