Reorganize to support potentially multiple languages

CONTRIBUTING.md

@@ -22,7 +22,7 @@ In order to get printed, the code goes through a couple of transformations. The
 
 ### Text to AST
 
-When the prettier process first spins up, it examines which files it's going to print and selects an appropriate plugin for each one. Once selected, it runs that plugin's `parse` function, seen [here](src/parser.js). For the case of the Ruby plugin, that entails spawning a Ruby process that runs [parser.rb](src/parser.rb) with the input code preloaded on stdin.
+When the prettier process first spins up, it examines which files it's going to print and selects an appropriate plugin for each one. Once selected, it runs that plugin's `parse` function, seen [here](src/ruby/parser.js). For the case of the Ruby plugin, that entails spawning a Ruby process that runs [parser.rb](src/ruby/parser.rb) with the input code preloaded on stdin.
 
 `parser.rb` will read the text off of stdin and then feed it to a new `Ripper` instance, which is a Ruby standard library recursive-descent parser. Briefly, the way that `Ripper` works is by tokenizing the input and then matching those tokens against a grammar to form s-expressions. To extend `Ripper`, you overwrite the methods that control how those s-expressions are formed, e.g., to modify the s-expression that is formed when `Ripper` encounters a string literal, you would override the `#on_string_literal` method. Below is an example for seeing that in action.
 
@@ -71,7 +71,7 @@ Now that the text has been transformed into an AST that we can work with, `parse
 
 ### AST to Doc
 
-Once prettier has a working AST, it will take it and call the selected plugin's [`printNode` function](src/printer.js), whose purpose is to convert that AST into prettier's intermediate representation called Docs. It does this by handing the print function a `FastPath` object that keeps track of the state of the printing as it goes, and allows accessing various parts of the AST quickly.
+Once prettier has a working AST, it will take it and call the selected plugin's [`printNode` function](src/ruby/printer.js), whose purpose is to convert that AST into prettier's intermediate representation called Docs. It does this by handing the print function a `FastPath` object that keeps track of the state of the printing as it goes, and allows accessing various parts of the AST quickly.
 
 Effectively, it walks the AST in the reverse direction from the way `Ripper` built it (top-down instead of bottom-up). The first node that gets passed into the `print` function is the `program` node as that's always on top. Then it is the `program` node's responsibility to recursively call print on its child nodes as it best sees fit.
 

README.md

@@ -120,7 +120,7 @@ The `prettier` executable is now installed and ready for use:
 
 ## Configuration
 
-Below are the options (from [`src/ruby.js`](src/ruby.js)) that `@prettier/plugin-ruby` currently supports:
+Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/plugin-ruby` currently supports:
 
 | API Option         | CLI Option             | Default | Description                                                                                                                          |
 | ------------------ | ---------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------ |

bin/debug

@@ -7,7 +7,7 @@ gemfile do
   gem 'sinatra', require: 'sinatra/base'
 end
 
-require_relative '../src/parser'
+require_relative '../src/ruby/parser'
 
 class App < Sinatra::Base
   HTML = DATA.read

bin/pragma

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
 const fs = require("fs");
-const { hasPragma } = require("../src/ruby").parsers.ruby;
+const { hasPragma } = require("../src/plugin").parsers.ruby;
 
 console.log(hasPragma(fs.readFileSync(process.argv[2], "utf-8")));

bin/sexp

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join('..', 'src', 'parser.rb'), __dir__)
-
+require_relative '../src/ruby/parser'
 require 'pp'
 
 PP.prepend(

package.json

@@ -2,7 +2,7 @@
   "name": "@prettier/plugin-ruby",
   "version": "1.2.2",
   "description": "prettier plugin for the Ruby programming language",
-  "main": "src/ruby.js",
+  "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",

src/ruby.js → src/plugin.js

@@ -1,5 +1,5 @@
-const printer = require("./printer");
-const parser = require("./parser");
+const printer = require("./ruby/printer");
+const parser = require("./ruby/parser");
 
 /*
  * metadata mostly pulled from linguist and rubocop:

src/embed.js → src/ruby/embed.js

@@ -6,9 +6,9 @@ const {
   mapDoc,
   markAsRoot,
   stripTrailingHardline
-} = require("./prettier");
+} = require("../prettier");
 
-const { literalLineNoBreak } = require("./utils");
+const { literalLineNoBreak } = require("../utils");
 
 const parsers = {
   css: "css",

src/nodes/alias.js → src/ruby/nodes/alias.js

@@ -5,7 +5,7 @@ const {
   group,
   hardline,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 // 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

src/nodes/aref.js → src/ruby/nodes/aref.js

@@ -1,4 +1,11 @@
-const { concat, group, indent, join, line, softline } = require("../prettier");
+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

src/nodes/args.js → src/ruby/nodes/args.js

@@ -6,10 +6,10 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
+} = require("../../prettier");
+const { getTrailingComma } = require("../../utils");
 
 const toProc = require("../toProc");
-const { getTrailingComma } = require("../utils");
 
 function printArgParen(path, opts, print) {
   const argsNode = path.getValue().body[0];

src/nodes/arrays.js → src/ruby/nodes/arrays.js

@@ -6,9 +6,8 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
-
-const { getTrailingComma, printEmptyCollection } = require("../utils");
+} = require("../../prettier");
+const { getTrailingComma, printEmptyCollection } = require("../../utils");
 
 // Checks that every argument within this args node is a string_literal node
 // that has no spaces or interpolations. This means we're dealing with an array

src/nodes/assign.js → src/ruby/nodes/assign.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, line } = require("../prettier");
-const { skipAssignIndent } = require("../utils");
+const { concat, group, indent, join, line } = require("../../prettier");
+const { skipAssignIndent } = require("../../utils");
 
 function printAssign(path, opts, print) {
   const [_targetNode, valueNode] = path.getValue().body;

src/nodes/blocks.js → src/ruby/nodes/blocks.js

@@ -7,8 +7,8 @@ const {
   join,
   removeLines,
   softline
-} = require("../prettier");
-const { hasAncestor } = require("../utils");
+} = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 const printBlock = (braces) => (path, opts, print) => {
   const [variables, statements] = path.getValue().body;

src/nodes/calls.js → src/ruby/nodes/calls.js

@@ -5,8 +5,8 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
-const { makeCall, noIndent } = require("../utils");
+} = require("../../prettier");
+const { makeCall, noIndent } = require("../../utils");
 
 const toProc = require("../toProc");
 

src/nodes/case.js → src/ruby/nodes/case.js

@@ -6,7 +6,7 @@ const {
   hardline,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printCase(path, opts, print) {
   const statement = ["case"];

src/nodes/class.js → src/ruby/nodes/class.js

@@ -5,7 +5,7 @@ const {
   ifBreak,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;

src/nodes/commands.js → src/ruby/nodes/commands.js

@@ -7,8 +7,8 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
-const { makeCall } = require("../utils");
+} = require("../../prettier");
+const { makeCall } = require("../../utils");
 
 function docLength(doc) {
   if (doc.length) {

src/nodes/conditionals.js → src/ruby/nodes/conditionals.js

@@ -7,10 +7,10 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment, isEmptyStmts } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([

src/nodes/constants.js → src/ruby/nodes/constants.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, softline } = require("../prettier");
-const { makeCall } = require("../utils");
+const { concat, group, indent, join, softline } = require("../../prettier");
+const { makeCall } = require("../../utils");
 
 function printConstPath(path, opts, print) {
   return join("::", path.map(print, "body"));

src/nodes/flow.js → src/ruby/nodes/flow.js

@@ -1,5 +1,5 @@
-const { concat, join } = require("../prettier");
-const { literal } = require("../utils");
+const { concat, join } = require("../../prettier");
+const { literal } = require("../../utils");
 
 const nodeDive = (node, steps) => {
   let current = node;

src/nodes/hashes.js → src/ruby/nodes/hashes.js

@@ -1,9 +1,16 @@
-const { concat, group, ifBreak, indent, join, line } = require("../prettier");
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line
+} = require("../../prettier");
 const {
   getTrailingComma,
   printEmptyCollection,
   skipAssignIndent
-} = require("../utils");
+} = require("../../utils");
 
 // 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

src/nodes/heredocs.js → src/ruby/nodes/heredocs.js

@@ -1,5 +1,5 @@
-const { concat, group, lineSuffix, join } = require("../prettier");
-const { literalLineNoBreak } = require("../utils");
+const { concat, group, lineSuffix, join } = require("../../prettier");
+const { literalLineNoBreak } = require("../../utils");
 
 function printHeredoc(path, opts, print) {
   const { body, ending } = path.getValue();

src/nodes/hooks.js → src/ruby/nodes/hooks.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, line } = require("../prettier");
-const { isEmptyStmts } = require("../utils");
+const { concat, group, indent, line } = require("../../prettier");
+const { isEmptyStmts } = require("../../utils");
 
 // The `BEGIN` and `END` keywords are used to hook into the Ruby process. Any
 // `BEGIN` blocks are executed right when the process starts up, and the `END`

src/nodes/lambdas.js → src/ruby/nodes/lambdas.js

@@ -1,5 +1,5 @@
-const { concat, group, ifBreak, indent, line } = require("../prettier");
-const { hasAncestor } = require("../utils");
+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,
 // or if we have them wrapped in parens then they'll be one level deeper. Even

src/nodes/loops.js → src/ruby/nodes/loops.js

@@ -7,10 +7,10 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 function printLoop(keyword, modifier) {
   return function printLoopWithOptions(path, { rubyModifier }, print) {

src/nodes/massign.js → src/ruby/nodes/massign.js

@@ -1,4 +1,11 @@
-const { concat, group, indent, join, line, softline } = require("../prettier");
+const {
+  concat,
+  group,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
 
 function printMAssign(path, opts, print) {
   let right = path.call(print, "body", 1);

src/nodes/methods.js → src/ruby/nodes/methods.js

@@ -1,4 +1,4 @@
-const { concat, group, hardline, indent, line } = require("../prettier");
+const { concat, group, hardline, indent, line } = require("../../prettier");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {

src/nodes/operators.js → src/ruby/nodes/operators.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, line, softline } = require("../prettier");
-const { noIndent } = require("../utils");
+const { concat, group, indent, line, softline } = require("../../prettier");
+const { noIndent } = require("../../utils");
 
 function printBinary(path, opts, print) {
   const [_leftNode, operator, rightNode] = path.getValue().body;

src/nodes/params.js → src/ruby/nodes/params.js

@@ -1,5 +1,12 @@
-const { concat, group, join, indent, line, softline } = require("../prettier");
-const { literal } = require("../utils");
+const {
+  concat,
+  group,
+  join,
+  indent,
+  line,
+  softline
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printRestParam(symbol) {
   return function printRestParamWithSymbol(path, opts, print) {

src/nodes/patterns.js → src/ruby/nodes/patterns.js

@@ -1,4 +1,11 @@
-const { concat, group, hardline, indent, join, line } = require("../prettier");
+const {
+  concat,
+  group,
+  hardline,
+  indent,
+  join,
+  line
+} = require("../../prettier");
 
 const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
 

src/nodes/regexp.js → src/ruby/nodes/regexp.js

@@ -1,5 +1,5 @@
-const { concat } = require("../prettier");
-const { hasAncestor } = require("../utils");
+const { concat } = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 function hasContent(node, pattern) {
   return node.body.some(

src/nodes/rescue.js → src/ruby/nodes/rescue.js

@@ -6,8 +6,8 @@ const {
   indent,
   join,
   line
-} = require("../prettier");
-const { literal } = require("../utils");
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printBegin(path, opts, print) {
   return concat([

src/nodes/return.js → src/ruby/nodes/return.js

@@ -6,8 +6,8 @@ const {
   line,
   join,
   softline
-} = require("../prettier");
-const { literal } = require("../utils");
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 // You can't skip the parentheses if you have the `and` or `or` operator,
 // because they have low enough operator precedence that you need to explicitly

src/nodes/statements.js → src/ruby/nodes/statements.js

@@ -10,7 +10,7 @@ const {
   literalline,
   softline,
   trim
-} = require("../prettier");
+} = require("../../prettier");
 
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;

src/nodes/strings.js → src/ruby/nodes/strings.js

@@ -6,7 +6,7 @@ const {
   literalline,
   softline,
   join
-} = require("../prettier");
+} = require("../../prettier");
 
 // If there is some part of this string that matches an escape sequence or that
 // contains the interpolation pattern ("#{"), then we are locked into whichever

src/nodes/super.js → src/ruby/nodes/super.js

@@ -1,5 +1,5 @@
-const { align, concat, group, join, line } = require("../prettier");
-const { literal } = require("../utils");
+const { align, concat, group, join, line } = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printSuper(path, opts, print) {
   const args = path.getValue().body[0];

src/nodes/undef.js → src/ruby/nodes/undef.js

@@ -5,7 +5,7 @@ const {
   group,
   join,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printUndefSymbol(path, opts, print) {
   const node = path.getValue();