prettier 0.12.2

data/src/ruby.js

@@ -0,0 +1,127 @@
+const parse = require("./parse");
+const print = require("./print");
+
+const pragmaPattern = /#\s*@(prettier|format)/;
+const hasPragma = text => pragmaPattern.test(text);
+
+/*
+ * metadata mostly pulled from linguist and rubocop:
+ * https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+ * https://github.com/rubocop-hq/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
+ */
+
+module.exports = {
+  languages: [
+    {
+      name: "Ruby",
+      parsers: ["ruby"],
+      extensions: [
+        ".arb",
+        ".axlsx",
+        ".builder",
+        ".eye",
+        ".fcgi",
+        ".gemfile",
+        ".gemspec",
+        ".god",
+        ".jb",
+        ".jbuilder",
+        ".mspec",
+        ".opal",
+        ".pluginspec",
+        ".podspec",
+        ".rabl",
+        ".rake",
+        ".rb",
+        ".rbuild",
+        ".rbw",
+        ".rbx",
+        ".ru",
+        ".ruby",
+        ".thor",
+        ".watchr"
+      ],
+      filenames: [
+        ".irbrc",
+        ".pryrc",
+        "Appraisals",
+        "Berksfile",
+        "Brewfile",
+        "Buildfile",
+        "Capfile",
+        "Cheffile",
+        "Dangerfile",
+        "Deliverfile",
+        "Fastfile",
+        "Gemfile",
+        "Guardfile",
+        "Jarfile",
+        "Mavenfile",
+        "Podfile",
+        "Puppetfile",
+        "Rakefile",
+        "Snapfile",
+        "Thorfile",
+        "Vagabondfile",
+        "Vagrantfile",
+        "buildfile"
+      ],
+      interpreters: ["jruby", "macruby", "rake", "rbx", "ruby"],
+      linguistLanguageId: 326,
+      vscodeLanguageIds: ["ruby"]
+    }
+  ],
+  parsers: {
+    ruby: {
+      parse,
+      astFormat: "ruby",
+      hasPragma
+    }
+  },
+  printers: {
+    ruby: {
+      print
+    }
+  },
+  options: {
+    addTrailingCommas: {
+      type: "boolean",
+      category: "Global",
+      default: false,
+      description:
+        "Adds a trailing comma to array literals, hash literals, and method calls."
+    },
+    inlineConditionals: {
+      type: "boolean",
+      category: "Global",
+      default: true,
+      description:
+        "When it fits on one line, allows if and unless statements to use the modifier form."
+    },
+    inlineLoops: {
+      type: "boolean",
+      category: "Global",
+      default: true,
+      description:
+        "When it fits on one line, allows while and until statements to use the modifier form."
+    },
+    preferHashLabels: {
+      type: "boolean",
+      category: "Global",
+      default: true,
+      description:
+        "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
+    },
+    preferSingleQuotes: {
+      type: "boolean",
+      category: "Global",
+      default: true,
+      description:
+        "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
+    }
+  },
+  defaultOptions: {
+    printWidth: 80,
+    tabWidth: 2
+  }
+};

data/src/toProc.js

@@ -0,0 +1,82 @@
+const isCall = node => ["::", "."].includes(node) || node.type === "@period";
+
+// If you have a simple block that only calls a method on the single required
+// parameter that is passed to it, then you can replace that block with the
+// simpler `Symbol#to_proc`. Meaning, it would go from:
+//
+//     [1, 2, 3].map { |i| i.to_s }
+//
+// to:
+//
+//     [1, 2, 3].map(&:to_s)
+//
+// This works with `do` blocks as well.
+const toProc = node => {
+  if (!node) {
+    return null;
+  }
+
+  const [variables, blockContents] = node.body;
+
+  // Ensure that there are variables being passed to this block.
+  const params = variables && variables.body[0];
+  if (!params || params.type !== "params") {
+    return null;
+  }
+
+  // Ensure there is one and only one parameter, and that it is required.
+  const reqParams = params.body[0];
+  const otherParams = params.body.slice(1);
+  if (
+    !Array.isArray(reqParams) ||
+    reqParams.length !== 1 ||
+    otherParams.some(Boolean)
+  ) {
+    return null;
+  }
+
+  let statements;
+  if (blockContents.type === "bodystmt") {
+    // We’re in a `do` block
+    const blockStatements = blockContents.body[0];
+    const rescueElseEnsure = blockStatements.body.slice(1);
+
+    // You can’t use the to_proc shortcut if you’re rescuing
+    if (rescueElseEnsure.some(Boolean)) {
+      return null;
+    }
+
+    statements = blockStatements;
+  } else {
+    // We’re in a brace block
+    statements = blockContents;
+  }
+
+  // Ensure the block contains only one statement
+  if (statements.body.length !== 1) {
+    return null;
+  }
+
+  // Ensure that statement is a call
+  const [statement] = statements.body;
+  if (statement.type !== "call") {
+    return null;
+  }
+
+  // Ensure the call is a method of the block argument
+  const [varRef, call, method, args] = statement.body;
+
+  if (
+    varRef.type !== "var_ref" ||
+    varRef.body[0].body !== reqParams[0].body ||
+    !isCall(call) ||
+    method.type !== "@ident" ||
+    args
+  ) {
+    return null;
+  }
+
+  return `&:${method.body}`;
+};
+
+module.exports = toProc;

data/src/utils.js

@@ -0,0 +1,150 @@
+const {
+  breakParent,
+  concat,
+  hardline,
+  lineSuffix,
+  literalline
+} = require("./builders");
+
+const concatBody = (path, opts, print) => concat(path.map(print, "body"));
+
+const docLength = doc => {
+  if (doc.length) {
+    return doc.length;
+  }
+
+  if (doc.parts) {
+    return doc.parts.reduce((sum, child) => sum + docLength(child), 0);
+  }
+
+  if (doc.contents) {
+    return docLength(doc.contents);
+  }
+
+  return 0;
+};
+
+const empty = () => "";
+
+const first = (path, opts, print) => path.call(print, "body", 0);
+
+const hasAncestor = (path, types) => {
+  let parent = 0;
+  let parentNode = path.getParentNode();
+
+  while (parentNode) {
+    if (types.includes(parentNode.type)) {
+      return true;
+    }
+
+    parent += 1;
+    parentNode = path.getParentNode(parent);
+  }
+
+  return false;
+};
+
+const literal = value => () => value;
+
+const makeArgs = (path, opts, print, argsIndex) => {
+  let argNodes = path.getValue().body[argsIndex];
+  const argPattern = [print, "body", argsIndex, "body"];
+
+  if (argNodes.type === "args_add_block") {
+    [argNodes] = argNodes.body;
+    argPattern.push(0, "body");
+  }
+
+  const args = path.call(print, "body", argsIndex);
+  const heredocs = [];
+
+  argNodes.body.forEach((argNode, index) => {
+    let pattern;
+    let heredoc;
+
+    if (argNode.type === "heredoc") {
+      pattern = [index, "body"];
+      heredoc = argNode;
+    } else if (
+      argNode.type === "string_literal" &&
+      argNode.body[0].type === "heredoc"
+    ) {
+      pattern = [index, "body", 0, "body"];
+      [heredoc] = argNode.body;
+    } else {
+      return;
+    }
+
+    const content = path.map.apply(path, argPattern.slice().concat(pattern));
+    heredocs.push(
+      concat([literalline].concat(content).concat([heredoc.ending]))
+    );
+    args[index] = heredoc.beging;
+  });
+
+  return { args, heredocs };
+};
+
+const makeCall = (path, opts, print) => {
+  const operation = path.getValue().body[1];
+
+  if ([".", "&."].includes(operation)) {
+    return operation;
+  }
+
+  return operation === "::" ? "." : path.call(print, "body", 1);
+};
+
+const makeList = (path, opts, print) => path.map(print, "body");
+
+const prefix = value => (path, opts, print) =>
+  concat([value, path.call(print, "body", 0)]);
+
+const printComments = (printed, start, comments) => {
+  let node = printed;
+
+  comments.forEach(comment => {
+    if (comment.start < start) {
+      node = concat([
+        comment.break ? breakParent : "",
+        comment.body,
+        hardline,
+        node
+      ]);
+    } else {
+      node = concat([
+        node,
+        comment.break ? breakParent : "",
+        lineSuffix(` ${comment.body}`)
+      ]);
+    }
+  });
+
+  return node;
+};
+
+const skipAssignIndent = node =>
+  ["array", "hash", "heredoc", "lambda", "regexp_literal"].includes(
+    node.type
+  ) ||
+  (node.type === "call" && skipAssignIndent(node.body[0])) ||
+  (node.type === "string_literal" && node.body[0].type === "heredoc");
+
+const surround = (left, right) => (path, opts, print) =>
+  concat([left, path.call(print, "body", 0), right]);
+
+module.exports = {
+  concatBody,
+  docLength,
+  empty,
+  first,
+  hasAncestor,
+  literal,
+  makeArgs,
+  makeCall,
+  makeList,
+  prefix,
+  printComments,
+  skipAssignIndent,
+  surround
+};

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: prettier
+version: !ruby/object:Gem::Version
+  version: 0.12.2
+platform: ruby
+authors:
+- Kevin Deisz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: 
+email: 
+executables:
+- rbprettier
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- bin/console
+- exe/rbprettier
+- lib/prettier.rb
+- lib/prettier/rake/task.rb
+- node_modules/prettier/bin-prettier.js
+- node_modules/prettier/index.js
+- node_modules/prettier/third-party.js
+- package.json
+- src/builders.js
+- src/escapePattern.js
+- src/nodes.js
+- src/nodes/alias.js
+- src/nodes/arrays.js
+- src/nodes/blocks.js
+- src/nodes/calls.js
+- src/nodes/case.js
+- src/nodes/commands.js
+- src/nodes/conditionals.js
+- src/nodes/hashes.js
+- src/nodes/hooks.js
+- src/nodes/lambdas.js
+- src/nodes/loops.js
+- src/nodes/methods.js
+- src/nodes/params.js
+- src/nodes/regexp.js
+- src/nodes/rescue.js
+- src/nodes/strings.js
+- src/parse.js
+- src/print.js
+- src/ripper.rb
+- src/ruby.js
+- src/toProc.js
+- src/utils.js
+homepage: https://github.com/prettier/plugin-ruby#readme
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: prettier plugin for the Ruby programming language
+test_files: []