prettier 1.5.5 → 2.0.0.pre.rc2

data/dist/parser/parseSync.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInfoFilepath = exports.getLang = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+let parserArgs;
+if (process_1.default.env.PRETTIER_RUBY_HOST) {
+    const [cmd, ...args] = process_1.default.env.PRETTIER_RUBY_HOST.split(" ");
+    parserArgs = { cmd, args };
+}
+// In order to properly parse ruby code, we need to tell the ruby process to
+// parse using UTF-8. Unfortunately, the way that you accomplish this looks
+// differently depending on your platform.
+/* istanbul ignore next */
+function getLang() {
+    const { env, platform } = process_1.default;
+    const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    // If an env var is set for the locale that already includes UTF-8 in the
+    // name, then assume we can go with that.
+    if (envValue && envValue.includes("UTF-8")) {
+        return envValue;
+    }
+    // Otherwise, we're going to guess which encoding to use based on the system.
+    // This is probably not the best approach in the world, as you could be on
+    // linux and not have C.UTF-8, but in that case you're probably passing an env
+    // var for it. This object below represents all of the possible values of
+    // process.platform per:
+    // https://nodejs.org/api/process.html#process_process_platform
+    return {
+        aix: "C.UTF-8",
+        android: "C.UTF-8",
+        cygwin: "C.UTF-8",
+        darwin: "en_US.UTF-8",
+        freebsd: "C.UTF-8",
+        haiku: "C.UTF-8",
+        linux: "C.UTF-8",
+        netbsd: "C.UTF-8",
+        openbsd: "C.UTF-8",
+        sunos: "C.UTF-8",
+        win32: ".UTF-8"
+    }[platform];
+}
+exports.getLang = getLang;
+// Generate the filepath that should be used to communicate the connection
+// information between this process and the parser server.
+function getInfoFilepath() {
+    return path_1.default.join(os_1.default.tmpdir(), `prettier-ruby-parser-${process_1.default.pid}.info`);
+}
+exports.getInfoFilepath = getInfoFilepath;
+// Create a file that will act as a communication mechanism, spawn a parser
+// server with that filepath as an argument, then spawn another process that
+// will read that information in order to enable us to connect to it in the
+// spawnSync function.
+function spawnServer() {
+    const filepath = getInfoFilepath();
+    const server = (0, child_process_1.spawn)("ruby", [path_1.default.join(__dirname, "./server.rb"), filepath], {
+        env: Object.assign({}, process_1.default.env, { LANG: getLang() }),
+        detached: true,
+        stdio: "inherit"
+    });
+    server.unref();
+    process_1.default.on("exit", () => {
+        if ((0, fs_1.existsSync)(filepath)) {
+            (0, fs_1.unlinkSync)(filepath);
+        }
+        try {
+            if (server.pid) {
+                process_1.default.kill(-server.pid);
+            }
+        }
+        catch (e) {
+            if (process_1.default.env.PLUGIN_RUBY_CI) {
+                throw new Error(`Failed to kill the parser server: ${e}`);
+            }
+        }
+    });
+    const info = (0, child_process_1.spawnSync)("node", [
+        path_1.default.join(__dirname, "./getInfo.js"),
+        filepath
+    ]);
+    if (info.status !== 0) {
+        throw new Error(`
+      We failed to spawn our parser server. Please report this error on GitHub
+      at https://github.com/prettier/plugin-ruby. The error message was:
+
+        ${info.stderr.toString()}.
+    `);
+    }
+    const [cmd, ...args] = info.stdout.toString().split(" ");
+    return { cmd, args };
+}
+// If we're in a yarn Plug'n'Play environment, then the relative paths being
+// used by the parser server and the various scripts used to communicate
+// therein are not going to work with its virtual file system. Presumably
+// there's a way to fix this but I haven't figured out how yet.
+function checkPnP() {
+    if (process_1.default.versions.pnp) {
+        throw new Error(`
+      @prettier/plugin-ruby does not current work within the yarn Plug'n'Play
+      virtual file system. If you would like to help support the effort to fix
+      this, please see https://github.com/prettier/plugin-ruby/issues/894.
+    `);
+    }
+}
+// Formats and sends a request to the parser server. We use netcat (or something
+// like it) here since Prettier requires the results of `parse` to be
+// synchronous and Node.js does not offer a mechanism for synchronous socket
+// requests.
+function parseSync(parser, source) {
+    if (!parserArgs) {
+        checkPnP();
+        parserArgs = spawnServer();
+    }
+    const response = (0, child_process_1.spawnSync)(parserArgs.cmd, parserArgs.args, {
+        input: `${parser}|${source}`,
+        maxBuffer: 15 * 1024 * 1024
+    });
+    const stdout = response.stdout.toString();
+    const stderr = response.stderr.toString();
+    const { status } = response;
+    // If we didn't receive anything over stdout or we have a bad exit status,
+    // then throw whatever we can.
+    if (stdout.length === 0 || (status !== null && status !== 0)) {
+        throw new Error(stderr || "An unknown error occurred");
+    }
+    const parsed = JSON.parse(stdout);
+    if (parsed.error) {
+        const error = new Error(parsed.error);
+        if (parsed.loc) {
+            error.loc = parsed.loc;
+        }
+        throw error;
+    }
+    return parsed;
+}
+exports.default = parseSync;

data/dist/parser/server.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'bundler/setup' if ENV['PLUGIN_RUBY_CI']
+require 'socket'
+require 'json'
+require 'fileutils'
+require 'open3'
+
+require_relative '../ruby/parser'
+require_relative '../rbs/parser'
+require_relative '../haml/parser'
+
+# Make sure we trap these signals to be sure we get the quit command coming from
+# the parent node process
+quit = false
+trap(:INT) { quit = true }
+trap(:TERM) { quit = true }
+trap(:QUIT) { quit = true } if Signal.list.key?('QUIT')
+
+# The information variable stores the actual connection information, which will
+# either be an IP address and port or a path to a unix socket file.
+information = ''
+
+# The candidates array is a list of potential programs that could be used to
+# connect to our server. We'll run through them after the server starts to find
+# the best one to use.
+candidates = []
+
+if Gem.win_platform?
+  # If we're on windows, we're going to start up a TCP server. The 0 here means
+  # to bind to some available port.
+  server = TCPServer.new('127.0.0.1', 0)
+  address = server.local_address
+
+  # Ensure that we close the server when this process exits.
+  at_exit { server.close }
+
+  information = "#{address.ip_address} #{address.ip_port}"
+  candidates = %w[nc telnet]
+else
+  # If we're not on windows, then we're going to assume we can use unix socket
+  # files (since they're faster than a TCP server).
+  filepath = "/tmp/prettier-ruby-parser-#{Process.pid}.sock"
+  server = UNIXServer.new(filepath)
+
+  # Ensure that we close the server and delete the socket file when this
+  # process exits.
+  at_exit do
+    server.close
+    File.unlink(filepath)
+  end
+
+  information = server.local_address.unix_path
+  candidates = ['nc -w 3 -U', 'ncat -w 3 -U']
+end
+
+# This is the actual listening thread that will be acting as our server. We have
+# to start it in another thread to begin with so that we can run through our
+# candidate connection programs. Eventually we'll just join into this thread
+# though and it will act as a daemon.
+listener =
+  Thread.new do
+    loop do
+      break if quit
+
+      # Start up a new thread that will handle each successive connection.
+      Thread.new(server.accept_nonblock) do |socket|
+        parser, source = socket.read.force_encoding('UTF-8').split('|', 2)
+
+        response =
+          case parser
+          when 'ping'
+            'pong'
+          when 'ruby'
+            Prettier::Parser.parse(source)
+          when 'rbs'
+            Prettier::RBSParser.parse(source)
+          when 'haml'
+            Prettier::HAMLParser.parse(source)
+          end
+
+        if response
+          socket.write(JSON.fast_generate(response))
+        else
+          socket.write('{ "error": true }')
+        end
+      rescue Prettier::Parser::ParserError => error
+        loc = { start: { line: error.lineno, column: error.column } }
+        socket.write(JSON.fast_generate(error: error.message, loc: loc))
+      rescue StandardError => error
+        begin
+          socket.write(JSON.fast_generate(error: error.message))
+        rescue Errno::EPIPE
+          # Do nothing, the pipe has been closed by the parent process so we don't
+          # actually care about writing to it anymore.
+        end
+      ensure
+        socket.close
+      end
+    rescue IO::WaitReadable, Errno::EINTR
+      # Wait for select(2) to give us a connection that has content for 1
+      # second. Otherwise timeout and continue on (so that we hit our
+      # "break if quit" pretty often).
+      IO.select([server], nil, nil, 1)
+
+      retry unless quit
+    end
+  end
+
+# Map each candidate connection method to a thread that will check if it works.
+candidates.map! do |candidate|
+  Thread.new do
+    Thread.current.report_on_exception = false
+
+    stdout, status =
+      Open3.capture2("#{candidate} #{information}", stdin_data: 'ping')
+
+    candidate if JSON.parse(stdout) == 'pong' && status.exitstatus == 0
+  rescue StandardError
+    # We don't actually care if this fails, because we'll just skip that
+    # connection option.
+  end
+end
+
+# Find the first one prefix that successfully returned the correct value.
+prefix =
+  candidates.detect do |candidate|
+    value = candidate.value
+    break value if value
+  end
+
+# Default to running the netcat.js script that we ship with the plugin. It's a
+# good fallback as it will always work, but it is slower than the other options.
+prefix ||= "node #{File.expand_path('netcat.js', __dir__)}"
+
+# Write out our connection information to the file given as the first argument
+# to this script.
+File.write(ARGV[0], "#{prefix} #{information}")
+
+listener.join

data/dist/plugin.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const printer_1 = __importDefault(require("./ruby/printer"));
+const parser_1 = __importDefault(require("./ruby/parser"));
+const printer_2 = __importDefault(require("./rbs/printer"));
+const parser_2 = __importDefault(require("./rbs/parser"));
+const printer_3 = __importDefault(require("./haml/printer"));
+const parser_3 = __importDefault(require("./haml/parser"));
+/*
+ * metadata mostly pulled from linguist and rubocop:
+ * https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+ * https://github.com/rubocop/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
+ */
+const plugin = {
+    languages: [
+        {
+            name: "Ruby",
+            parsers: ["ruby"],
+            extensions: [
+                ".arb",
+                ".axlsx",
+                ".builder",
+                ".eye",
+                ".fcgi",
+                ".gemfile",
+                ".gemspec",
+                ".god",
+                ".jb",
+                ".jbuilder",
+                ".mspec",
+                ".opal",
+                ".pluginspec",
+                ".podspec",
+                ".rabl",
+                ".rake",
+                ".rb",
+                ".rbi",
+                ".rbuild",
+                ".rbw",
+                ".rbx",
+                ".ru",
+                ".ruby",
+                ".thor",
+                ".watchr"
+            ],
+            filenames: [
+                ".irbrc",
+                ".pryrc",
+                ".simplecov",
+                "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"]
+        },
+        {
+            name: "RBS",
+            parsers: ["rbs"],
+            extensions: [".rbs"]
+        },
+        {
+            name: "HAML",
+            parsers: ["haml"],
+            extensions: [".haml"],
+            vscodeLanguageIds: ["haml"]
+        }
+    ],
+    parsers: {
+        ruby: parser_1.default,
+        rbs: parser_2.default,
+        haml: parser_3.default
+    },
+    printers: {
+        ruby: printer_1.default,
+        rbs: printer_2.default,
+        haml: printer_3.default
+    },
+    options: {
+        rubyArrayLiteral: {
+            type: "boolean",
+            category: "Ruby",
+            default: true,
+            description: "When possible, favor the use of string and symbol array literals.",
+            since: "1.0.0"
+        },
+        rubyHashLabel: {
+            type: "boolean",
+            category: "Ruby",
+            default: true,
+            description: "When possible, uses the shortened hash key syntax, as opposed to hash rockets.",
+            since: "1.0.0"
+        },
+        rubyModifier: {
+            type: "boolean",
+            category: "Ruby",
+            default: true,
+            description: "When it fits on one line, allows if, unless, while, and until statements to use the modifier form.",
+            since: "1.0.0"
+        },
+        rubySingleQuote: {
+            type: "boolean",
+            category: "Ruby",
+            default: true,
+            description: "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.",
+            since: "1.0.0"
+        },
+        rubyToProc: {
+            type: "boolean",
+            category: "Ruby",
+            default: false,
+            description: "When possible, convert blocks to the more concise Symbol#to_proc syntax.",
+            since: "1.0.0"
+        }
+    },
+    defaultOptions: {
+        printWidth: 80,
+        tabWidth: 2,
+        trailingComma: "none"
+    }
+};
+module.exports = plugin;

data/dist/prettier.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// If `RBPRETTIER` is set, then this is being run from the `Prettier::run` ruby
+// method. In that case, we need to pull `prettier` from the node_modules
+// directly, as it's been shipped with the gem.
+/* istanbul ignore next */
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const source = require(process.env.RBPRETTIER
+    ? "../node_modules/prettier"
+    : "prettier");
+// Cramming everything together to make it simpler to pull in all of the right
+// utilities and builders.
+const builders = source.doc.builders;
+const exported = { ...builders, ...source.doc.utils, ...source.util };
+exports.default = exported;

data/dist/rbs/parser.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSync_1 = __importDefault(require("../parser/parseSync"));
+const parser = {
+    // This function is responsible for taking an input string of text and
+    // returning to prettier a JavaScript object that is the equivalent AST that
+    // represents the code stored in that string. We accomplish this by spawning a
+    // new Ruby process of parser.rb and reading JSON off STDOUT.
+    parse(text) {
+        return (0, parseSync_1.default)("rbs", text);
+    },
+    astFormat: "rbs",
+    // This function handles checking whether or not the source string has the
+    // pragma for prettier. This is an optional workflow for incremental adoption.
+    hasPragma(text) {
+        return /^\s*#[^\S\n]*@(format|prettier)\s*(\n|$)/.test(text);
+    },
+    // This function is critical for comments and cursor support, and is
+    // responsible for returning the index of the character within the source
+    // string that is the beginning of the given node.
+    locStart(node) {
+        return node.location.start_pos;
+    },
+    // This function is critical for comments and cursor support, and is
+    // responsible for returning the index of the character within the source
+    // string that is the ending of the given node.
+    locEnd(node) {
+        return node.location.end_pos;
+    }
+};
+exports.default = parser;