rfbeam 0.2.0

data/node_modules/@prettier/plugin-ruby/rubocop.yml

@@ -0,0 +1,64 @@
+# Disabling all Layout/* rules, as they're unnecessary when the user is using
+# Syntax Tree to handle all of the formatting.
+Layout:
+  Enabled: false
+
+# Re-enable Layout/LineLength because certain cops that most projects use
+# (e.g. Style/IfUnlessModifier) require Layout/LineLength to be enabled.
+# By leaving it disabled, those rules will mis-fire.
+#
+# Users can always override these defaults in their own rubocop.yml files.
+# https://github.com/prettier/plugin-ruby/issues/825
+Layout/LineLength:
+  Enabled: true
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+# Syntax Tree will expand empty methods to put the end keyword on the subsequent
+# line to reduce git diff noise.
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+# lambdas that are constructed with the lambda method call cannot be safely
+# turned into lambda literals without removing a method call.
+Style/Lambda:
+  Enabled: false
+
+# When method chains with multiple blocks are chained together, rubocop will let
+# them pass if they're using braces but not if they're using do and end
+# keywords. Because we will break individual blocks down to using keywords if
+# they are multiline, this conflicts with rubocop.
+Style/MultilineBlockChain:
+  Enabled: false
+
+# Disable the single- vs double-quotes rules as these depend on whether the user
+# has added or not `plugin/single_quotes` for `syntax_tree`
+Style/StringLiterals:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/QuotedSymbols:
+  Enabled: false
+
+# We let users have a little more freedom with symbol and words arrays. If the
+# user only has an individual item like ["value"] then we don't bother
+# converting it because it ends up being just noise.
+Style/SymbolArray:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: false
+
+# Disable the trailing-comma rules as these depend on whether the user has added
+# or not `plugin/trailing_comma` for `syntax_tree`
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false

data/node_modules/@prettier/plugin-ruby/src/getInfo.js

@@ -0,0 +1,23 @@
+const { existsSync, readFileSync } = require("fs");
+
+// This is how long to wait for the parser to spin up. For the most part, 5
+// seconds is plenty of time. But in some environments, it may be necessary to
+// increase this value.
+const timeoutMs = parseInt(process.env.PRETTIER_RUBY_TIMEOUT_MS || "5000", 10);
+
+const filepath = process.argv[process.argv.length - 1];
+
+const timeout = setTimeout(() => {
+  clearInterval(interval);
+  throw new Error(`Failed to get information from parse server in time. If this
+    happens repeatedly, try increasing the PRETTIER_RUBY_TIMEOUT_MS environment
+    variable beyond 5000.`);
+}, timeoutMs);
+
+const interval = setInterval(() => {
+  if (existsSync(filepath)) {
+    process.stdout.write(readFileSync(filepath).toString("utf8"));
+    clearTimeout(timeout);
+    clearInterval(interval);
+  }
+}, 100);

data/node_modules/@prettier/plugin-ruby/src/netcat.js

@@ -0,0 +1,13 @@
+// A simple fallback when no netcat-compatible adapter is found on the system.
+// On average, this is 2-3x slower than netcat, but still much faster than
+// spawning a new Ruby process.
+
+const { createConnection } = require("net");
+
+const sock = process.argv[process.argv.length - 1];
+const client = createConnection(sock, () => process.stdin.pipe(client));
+
+client.on("data", (data) => process.stdout.write(data));
+client.on("error", (error) => {
+  console.error(error);
+});

data/node_modules/@prettier/plugin-ruby/src/parseSync.js

@@ -0,0 +1,236 @@
+const { spawn, spawnSync } = require("child_process");
+const {
+  existsSync,
+  unlinkSync,
+  mkdtempSync,
+  copyFileSync,
+  mkdirSync,
+  rmdirSync
+} = require("fs");
+const os = require("os");
+const path = require("path");
+const process = require("process");
+
+let parserArgs;
+
+if (process.env.PRETTIER_RUBY_HOST) {
+  const [cmd, ...args] = process.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;
+  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];
+}
+
+// Generate the filepath that should be used to communicate the connection
+// information between this process and the parser server.
+function getInfoFilepath() {
+  return path.join(os.tmpdir(), `prettier-ruby-parser-${process.pid}.info`);
+}
+
+// Return the list of plugins that should be passed to the server process.
+function getPlugins(opts) {
+  const plugins = new Set();
+
+  const rubyPlugins = opts.rubyPlugins.trim();
+  if (rubyPlugins.length > 0) {
+    rubyPlugins.split(",").forEach((plugin) => plugins.add(plugin.trim()));
+  }
+
+  if (opts.singleQuote) {
+    plugins.add("plugin/single_quotes");
+  }
+
+  if (opts.trailingComma !== "none") {
+    plugins.add("plugin/trailing_comma");
+  }
+
+  return Array.from(plugins);
+}
+
+// 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(opts) {
+  const tempDir = mkdtempSync(path.join(os.tmpdir(), "prettier-plugin-ruby-"));
+  const filepath = getInfoFilepath();
+
+  let serverRbPath = path.join(__dirname, "./server.rb");
+  let getInfoJsPath = path.join(__dirname, "./getInfo.js");
+  let cleanupTempFiles;
+
+  if (runningInPnPZip()) {
+    // If we're running in a Yarn PnP environment inside a ZIP file, it's not possible to run
+    // the Ruby server or the getInfo.js script directly.  Instead, we need to copy them and all
+    // the files they depend on to a temporary directory.
+
+    const sourceFiles = ["server.rb", "getInfo.js", "netcat.js"];
+    serverRbPath = path.join(tempDir, "server.rb");
+    getInfoJsPath = path.join(tempDir, "getInfo.js");
+
+    sourceFiles.forEach((rubyFile) => {
+      const destDir = path.join(tempDir, path.dirname(rubyFile));
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir);
+      }
+      copyFileSync(
+        path.join(__dirname, "..", "src", rubyFile),
+        path.join(tempDir, rubyFile)
+      );
+    });
+
+    cleanupTempFiles = () => {
+      [
+        getInfoJsPath,
+        ...sourceFiles.map((rubyFile) => path.join(tempDir, rubyFile))
+      ].forEach((tmpFilePath) => {
+        if (existsSync(tmpFilePath)) {
+          unlinkSync(tmpFilePath);
+        }
+      });
+
+      sourceFiles.forEach((rubyFile) => {
+        const tempSubdir = path.join(tempDir, path.dirname(rubyFile));
+        if (existsSync(tempSubdir)) {
+          rmdirSync(tempSubdir);
+        }
+      });
+
+      if (existsSync(tempDir)) {
+        rmdirSync(tempDir);
+      }
+    };
+  }
+
+  const server = spawn(
+    "ruby",
+    [serverRbPath, `--plugins=${getPlugins(opts).join(",")}`, filepath],
+    {
+      env: Object.assign({}, process.env, { LANG: getLang() }),
+      detached: true,
+      stdio: "inherit"
+    }
+  );
+
+  server.unref();
+  process.on("exit", () => {
+    if (existsSync(filepath)) {
+      unlinkSync(filepath);
+    }
+
+    if (cleanupTempFiles != null) {
+      cleanupTempFiles();
+    }
+
+    try {
+      if (server.pid) {
+        // Kill the server process if it's still running. If we're on windows
+        // we're going to use the process ID number. If we're not, we're going
+        // to use the negative process ID to indicate the group.
+        const pid = process.platform === "win32" ? server.pid : -server.pid;
+        process.kill(pid);
+      }
+    } catch (e) {
+      if (process.env.PLUGIN_RUBY_CI) {
+        throw new Error(`Failed to kill the parser server: ${e}`);
+      }
+    }
+  });
+
+  const info = spawnSync("node", [getInfoJsPath, 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.
+function runningInPnPZip() {
+  return process.versions.pnp && __dirname.includes(".zip");
+}
+
+// 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, opts) {
+  if (!parserArgs) {
+    parserArgs = spawnServer(opts);
+  }
+
+  const response = spawnSync(parserArgs.cmd, parserArgs.args, {
+    input: `${parser}|${opts.printWidth}|${opts.tabWidth}|${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;
+}
+
+module.exports = {
+  getLang,
+  getInfoFilepath,
+  parseSync
+};

data/node_modules/@prettier/plugin-ruby/src/plugin.js

@@ -0,0 +1,172 @@
+const { parseSync } = require("./parseSync");
+
+/*
+ * 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: {
+      parse(text, _parsers, opts) {
+        return parseSync("ruby", text, opts);
+      },
+      astFormat: "ruby",
+      hasPragma(text) {
+        return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/m.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    },
+    rbs: {
+      parse(text, _parsers, opts) {
+        return parseSync("rbs", text, opts);
+      },
+      astFormat: "rbs",
+      hasPragma(text) {
+        return /^\s*#[^\S\n]*@(prettier|format)\s*(\n|$)/.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    },
+    haml: {
+      parse(text, _parsers, opts) {
+        return parseSync("haml", text, opts);
+      },
+      astFormat: "haml",
+      hasPragma(text) {
+        return /^\s*-#\s*@(prettier|format)/.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    }
+  },
+  printers: {
+    ruby: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `# @format${text.startsWith("#") ? "\n" : "\n\n"}${text}`;
+      }
+    },
+    rbs: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `# @format${text.startsWith("#") ? "\n" : "\n\n"}${text}`;
+      }
+    },
+    haml: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `-# @format${text.startsWith("-#") ? "\n" : "\n\n"}${text}`;
+      }
+    }
+  },
+  options: {
+    rubyPlugins: {
+      type: "string",
+      category: "Ruby",
+      default: "",
+      description: "The comma-separated list of plugins to require",
+      since: "3.1.0"
+    }
+  },
+  defaultOptions: {
+    printWidth: 80,
+    tabWidth: 2,
+    trailingComma: "none",
+    singleQuote: false
+  }
+};
+
+module.exports = plugin;

data/node_modules/@prettier/plugin-ruby/src/server.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "socket"
+require "json"
+require "fileutils"
+require "open3"
+
+require "prettier_print"
+require "syntax_tree"
+require "syntax_tree/haml"
+require "syntax_tree/rbs"
+
+# First, require all of the plugins that the user specified.
+ARGV.shift[/^--plugins=(.*)$/, 1]
+  .split(",")
+  .each { |plugin| require "syntax_tree/#{plugin}" }
+
+# 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 }
+
+if Signal.list.key?("QUIT") && RUBY_ENGINE != "jruby"
+  trap(:QUIT) { quit = true }
+end
+
+# 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, maxwidth_string, tabwidth_string, source =
+          socket.read.force_encoding("UTF-8").split("|", 4)
+
+        source.each_line do |line|
+          case line
+          when /^\s*#.+?coding/
+            # If we've found an encoding comment, then we're going to take that
+            # into account and reclassify the encoding for the source.
+            encoding = Ripper.new(line).tap(&:parse).encoding
+            source = source.force_encoding(encoding)
+            break
+          when /^\s*#/
+            # continue
+          else
+            break
+          end
+        end
+
+        # At the moment, we're not going to support odd tabwidths. It's going to
+        # have to be a multiple of 2, because of the way that the prettyprint
+        # gem functions. So we're going to just use integer division here.
+        scalar = tabwidth_string.to_i / 2
+        genspace = ->(n) { " " * n * scalar }
+
+        maxwidth = maxwidth_string.to_i
+        response =
+          case parser
+          when "ping"
+            "pong"
+          when "ruby"
+            formatter =
+              SyntaxTree::Formatter.new(source, [], maxwidth, "\n", &genspace)
+            SyntaxTree.parse(source).format(formatter)
+            formatter.flush
+            formatter.output.join
+          when "rbs"
+            formatter =
+              SyntaxTree::RBS::Formatter.new(
+                source,
+                [],
+                maxwidth,
+                "\n",
+                &genspace
+              )
+            SyntaxTree::RBS.parse(source).format(formatter)
+            formatter.flush
+            formatter.output.join
+          when "haml"
+            formatter_class =
+              if defined?(SyntaxTree::Haml::Format::Formatter)
+                SyntaxTree::Haml::Format::Formatter
+              else
+                PrettierPrint
+              end
+
+            formatter =
+              formatter_class.new(source, +"", maxwidth, "\n", &genspace)
+
+            SyntaxTree::Haml.parse(source).format(formatter)
+            formatter.flush
+            formatter.output
+          end
+
+        if response
+          socket.write(JSON.fast_generate(response.force_encoding("UTF-8")))
+        else
+          socket.write("{ \"error\": true }")
+        end
+      rescue SyntaxTree::Parser::ParseError => 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
+
+    # We do not care about stderr here, so throw it away
+    stdout, _stderr, status =
+      Open3.capture3("#{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