prettier 1.6.1 → 2.0.0.pre.rc1

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;