Read config options from Prettier rather than hardcoding

.prettierrc

-{
-  "arrowParens": "avoid",
-  "bracketSpacing": true,
-  "endOfLine": "auto",
-  "filepath": "",
-  "htmlWhitespaceSensitivity": "css",
-  "insertPragma": false,
-  "jsxBracketSameLine": false,
-  "jsxSingleQuote": false,
-  "parser": "",
-  "printWidth": 80,
-  "proseWrap": "preserve",
-  "quoteProps": "as-needed",
-  "requirePragma": false,
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "es5",
-  "useTabs": false,
-  "vueIndentScriptAndStyle": false
-}

README.md

 # prettier-default-config
 
-This is a small CLI tool that dumps all of prettier's default configuration
+This is a small CLI tool that dumps all of Prettier's default configuration
 options to a file in the format of your choice.
 
 ## Installation
     --help            Prints help information
 ```
 
+## Exclusions
+
+The config file formats that Prettier uses are not able to represent all of
+Prettier's default values. For instance, TOML has no concept of `null`, neither
+TOML nor JSON can represent `Infinity`, and no format except actual JavaScript
+can represent `undefined`. As a result, depending on the chosen format, some
+configuration options may be excluded. The current list of exclusions is as
+follows:
+
+
+| Format | Excluded Options                  |
+|--------|-----------------------------------|
+| JSON   | `rangeEnd` , `filepath`, `parser` |
+| TOML   | `rangeEnd`, `filepath`, `parser`  |
+| YAML   | `rangeEnd`                        |
+
 ## License
 
-MIT
+MIT

index.js

 const fs = require('fs');
 const minimist = require('minimist');
 const path = require('path');
+const prettier = require('prettier');
 
-const defaultConfig = {
-  arrowParens: 'avoid',
-  bracketSpacing: true,
-  endOfLine: 'auto',
-  filepath: '',
-  htmlWhitespaceSensitivity: 'css',
-  insertPragma: false,
-  jsxBracketSameLine: false,
-  jsxSingleQuote: false,
-  parser: '',
-  printWidth: 80,
-  proseWrap: 'preserve',
-  quoteProps: 'as-needed',
-  requirePragma: false,
-  semi: true,
-  singleQuote: false,
-  tabWidth: 2,
-  trailingComma: 'none',
-  useTabs: false,
-  vueIndentScriptAndStyle: false,
+const defaultConfigFor = function(format) {
+  let config = prettier.getSupportInfo().options;
+
+  if (!['js', 'yaml'].includes(format)) {
+    config = config.filter(
+      option => ![null, Infinity].includes(option.default)
+    );
+  }
+
+  if (format != 'js') {
+    config = config.filter(option => option.default !== undefined);
+  }
+
+  return Object.fromEntries(
+    config.map(option => [option.name, option.default])
+  );
 };
 
 const formats = {
   json: {
     filename: '.prettierrc',
     generate: function() {
-      return JSON.stringify(defaultConfig, null, 2);
+      return JSON.stringify(defaultConfigFor('json'), null, 2);
     },
   },
   yaml: {
     filename: '.prettierrc.yaml',
     generate: function() {
-      return Object.entries(defaultConfig)
+      return Object.entries(defaultConfigFor('yaml'))
         .map(([key, value]) => {
           if (typeof value === 'string' && value === '') return `${key}: ''`;
+          if (value === null) return `${key}: ~`;
+          if (value === Infinity) return `${key}: .inf`;
+          if (!!value.forEach && value.length === 0) return `${key}: []`;
           return `${key}: ${value}`;
         })
         .join('\n');
   toml: {
     filename: '.prettierrc.toml',
     generate: function() {
-      return Object.entries(defaultConfig)
+      return Object.entries(defaultConfigFor('toml'))
         .map(([key, value]) => {
           if (typeof value === 'string') return `${key} = "${value}"`;
+          if (!!value.forEach && value.length === 0) return `${key} = []`;
           return `${key} = ${value}`;
         })
         .join('\n');
   js: {
     filename: '.prettierrc.js',
     generate: function() {
-      const contents = Object.entries(defaultConfig)
+      const contents = Object.entries(defaultConfigFor('js'))
         .map(([key, value]) => {
           if (typeof value === 'string') return `  ${key}: '${value}',`;
+          if (typeof value === 'undefined') return `  ${key}: undefined,`;
+          if (value === null) return `  ${key}: null,`;
+          if (!!value.forEach && value.length === 0) return `${key}: [],`;
           return `  ${key}: ${value},`;
         })
         .join('\n');
         process.exit(0);
       }
       const data = JSON.parse(fs.readFileSync(file));
-      data.prettier = defaultConfig;
+      data.prettier = defaultConfigFor('json');
       return JSON.stringify(data, null, 2);
     },
   },
 }
 
 module.exports = {
-  defaultConfig,
+  defaultConfigFor,
   formats,
 };
 

package.json

     "index.js"
   ],
   "dependencies": {
-    "minimist": "^1.2.0"
+    "minimist": "^1.2.0",
+    "prettier": "^1.19.1"
   },
   "devDependencies": {
     "faucet": "0.0.1",
-    "prettier": "^1.19.1",
     "tape": "^4.13.0",
     "toml": "^3.0.0",
     "yaml": "^1.7.2"

test.js

 const TOML = require('toml');
 const YAML = require('yaml');
 
-const { defaultConfig, formats } = require('.');
+const { defaultConfigFor, formats } = require('.');
 
 test('generate JSON', t => {
   t.plan(1);
   const result = formats.json.generate();
-  t.deepEqual(JSON.parse(result), defaultConfig);
+  t.deepEqual(JSON.parse(result), defaultConfigFor('json'));
 });
 
 test('generate TOML', t => {
   t.plan(1);
   const result = formats.toml.generate();
-  t.deepEqual(TOML.parse(result), defaultConfig);
+  t.deepEqual(TOML.parse(result), defaultConfigFor('toml'));
 });
 
 test('generate YAML', t => {
   t.plan(1);
   const result = formats.yaml.generate();
-  t.deepEqual(YAML.parse(result), defaultConfig);
+  t.deepEqual(YAML.parse(result), defaultConfigFor('yaml'));
 });
 
 test('generate JS', t => {
   t.plan(1);
   const result = formats.js.generate();
-  t.deepEqual(eval(result), defaultConfig);
+  t.deepEqual(eval(result), defaultConfigFor('js'));
 });
 
 test('generate package.json', t => {
   t.plan(1);
   const before = JSON.parse(fs.readFileSync('package.json'));
   const result = formats['package.json'].generate();
-  before.prettier = defaultConfig;
+  before.prettier = defaultConfigFor('package.json');
   t.deepEqual(JSON.parse(result), before);
 });
+
+test('YAML supports infinity, leave rangeEnd in', t => {
+  t.plan(1);
+  const result = formats.yaml.generate();
+  t.equal(YAML.parse(result).rangeEnd, Infinity);
+});
+
+test("YAML doesn't support undefined so leave out filepath and parser", t => {
+  t.plan(2);
+  const result = formats.yaml.generate();
+  t.false(Object.keys(result).includes('parser'));
+  t.false(Object.keys(result).includes('filepath'));
+});
+
+test("TOML doesn't support infinity, so leave out rangeEnd", t => {
+  t.plan(1);
+  const result = formats.toml.generate();
+  t.false(Object.keys(result).includes('rangeEnd'));
+});
+
+test('JS supports undefined, so leave in parser and filepath', t => {
+  t.plan(4);
+  const result = eval(formats.js.generate());
+  t.equal(result.parser, undefined);
+  t.equal(result.filepath, undefined);
+  t.true(Object.keys(result).includes('parser'));
+  t.true(Object.keys(result).includes('filepath'));
+});