Format all source code using Prettier

js/modules/types/attachment.js

@@ -2,9 +2,15 @@ const is = require('@sindresorhus/is');
 
 const AttachmentTS = require('../../../ts/types/Attachment');
 const MIME = require('../../../ts/types/MIME');
-const { arrayBufferToBlob, blobToArrayBuffer, dataURLToBlob } = require('blob-util');
+const {
+  arrayBufferToBlob,
+  blobToArrayBuffer,
+  dataURLToBlob,
+} = require('blob-util');
 const { autoOrientImage } = require('../auto_orient_image');
-const { migrateDataToFileSystem } = require('./attachment/migrate_data_to_file_system');
+const {
+  migrateDataToFileSystem,
+} = require('./attachment/migrate_data_to_file_system');
 
 // // Incoming message attachment fields
 // {
@@ -30,7 +36,7 @@ const { migrateDataToFileSystem } = require('./attachment/migrate_data_to_file_s
 // Returns true if `rawAttachment` is a valid attachment based on our current schema.
 // Over time, we can expand this definition to become more narrow, e.g. require certain
 // fields, etc.
-exports.isValid = (rawAttachment) => {
+exports.isValid = rawAttachment => {
   // NOTE: We cannot use `_.isPlainObject` because `rawAttachment` is
   // deserialized by protobuf:
   if (!rawAttachment) {
@@ -41,12 +47,15 @@ exports.isValid = (rawAttachment) => {
 };
 
 // Upgrade steps
-exports.autoOrientJPEG = async (attachment) => {
+exports.autoOrientJPEG = async attachment => {
   if (!MIME.isJPEG(attachment.contentType)) {
     return attachment;
   }
 
-  const dataBlob = await arrayBufferToBlob(attachment.data, attachment.contentType);
+  const dataBlob = await arrayBufferToBlob(
+    attachment.data,
+    attachment.contentType
+  );
   const newDataBlob = await dataURLToBlob(await autoOrientImage(dataBlob));
   const newDataArrayBuffer = await blobToArrayBuffer(newDataBlob);
 
@@ -76,7 +85,7 @@ const INVALID_CHARACTERS_PATTERN = new RegExp(
 // NOTE: Expose synchronous version to do property-based testing using `testcheck`,
 // which currently doesn’t support async testing:
 // https://github.com/leebyron/testcheck-js/issues/45
-exports._replaceUnicodeOrderOverridesSync = (attachment) => {
+exports._replaceUnicodeOrderOverridesSync = attachment => {
   if (!is.string(attachment.fileName)) {
     return attachment;
   }
@@ -95,9 +104,12 @@ exports._replaceUnicodeOrderOverridesSync = (attachment) => {
 exports.replaceUnicodeOrderOverrides = async attachment =>
   exports._replaceUnicodeOrderOverridesSync(attachment);
 
-exports.removeSchemaVersion = (attachment) => {
+exports.removeSchemaVersion = attachment => {
   if (!exports.isValid(attachment)) {
-    console.log('Attachment.removeSchemaVersion: Invalid input attachment:', attachment);
+    console.log(
+      'Attachment.removeSchemaVersion: Invalid input attachment:',
+      attachment
+    );
     return attachment;
   }
 
@@ -115,12 +127,12 @@ exports.hasData = attachment =>
 //      loadData :: (RelativePath -> IO (Promise ArrayBuffer))
 //                  Attachment ->
 //                  IO (Promise Attachment)
-exports.loadData = (readAttachmentData) => {
+exports.loadData = readAttachmentData => {
   if (!is.function(readAttachmentData)) {
     throw new TypeError("'readAttachmentData' must be a function");
   }
 
-  return async (attachment) => {
+  return async attachment => {
     if (!exports.isValid(attachment)) {
       throw new TypeError("'attachment' is not valid");
     }
@@ -142,12 +154,12 @@ exports.loadData = (readAttachmentData) => {
 //      deleteData :: (RelativePath -> IO Unit)
 //                    Attachment ->
 //                    IO Unit
-exports.deleteData = (deleteAttachmentData) => {
+exports.deleteData = deleteAttachmentData => {
   if (!is.function(deleteAttachmentData)) {
     throw new TypeError("'deleteAttachmentData' must be a function");
   }
 
-  return async (attachment) => {
+  return async attachment => {
     if (!exports.isValid(attachment)) {
       throw new TypeError("'attachment' is not valid");
     }

js/modules/types/attachment/migrate_data_to_file_system.js

@@ -1,10 +1,4 @@
-const {
-  isArrayBuffer,
-  isFunction,
-  isUndefined,
-  omit,
-} = require('lodash');
-
+const { isArrayBuffer, isFunction, isUndefined, omit } = require('lodash');
 
 // type Context :: {
 //   writeNewAttachmentData :: ArrayBuffer -> Promise (IO Path)
@@ -13,7 +7,10 @@ const {
 //      migrateDataToFileSystem :: Attachment ->
 //                                 Context ->
 //                                 Promise Attachment
-exports.migrateDataToFileSystem = async (attachment, { writeNewAttachmentData } = {}) => {
+exports.migrateDataToFileSystem = async (
+  attachment,
+  { writeNewAttachmentData } = {}
+) => {
   if (!isFunction(writeNewAttachmentData)) {
     throw new TypeError("'writeNewAttachmentData' must be a function");
   }
@@ -28,15 +25,16 @@ exports.migrateDataToFileSystem = async (attachment, { writeNewAttachmentData }
 
   const isValidData = isArrayBuffer(data);
   if (!isValidData) {
-    throw new TypeError('Expected `attachment.data` to be an array buffer;' +
-      ` got: ${typeof attachment.data}`);
+    throw new TypeError(
+      'Expected `attachment.data` to be an array buffer;' +
+        ` got: ${typeof attachment.data}`
+    );
   }
 
   const path = await writeNewAttachmentData(data);
 
-  const attachmentWithoutData = omit(
-    Object.assign({}, attachment, { path }),
-    ['data']
-  );
+  const attachmentWithoutData = omit(Object.assign({}, attachment, { path }), [
+    'data',
+  ]);
   return attachmentWithoutData;
 };

js/modules/types/errors.js

@@ -1,5 +1,5 @@
 //      toLogFormat :: Error -> String
-exports.toLogFormat = (error) => {
+exports.toLogFormat = error => {
   if (!error) {
     return error;
   }

js/modules/types/message.js

@@ -3,9 +3,9 @@ const { isFunction, isString, omit } = require('lodash');
 const Attachment = require('./attachment');
 const Errors = require('./errors');
 const SchemaVersion = require('./schema_version');
-const { initializeAttachmentMetadata } =
-  require('../../../ts/types/message/initializeAttachmentMetadata');
-
+const {
+  initializeAttachmentMetadata,
+} = require('../../../ts/types/message/initializeAttachmentMetadata');
 
 const GROUP = 'group';
 const PRIVATE = 'private';
@@ -37,19 +37,17 @@ const INITIAL_SCHEMA_VERSION = 0;
 // how we do database migrations:
 exports.CURRENT_SCHEMA_VERSION = 5;
 
-
 // Public API
 exports.GROUP = GROUP;
 exports.PRIVATE = PRIVATE;
 
 // Placeholder until we have stronger preconditions:
-exports.isValid = () =>
-  true;
+exports.isValid = () => true;
 
 // Schema
-exports.initializeSchemaVersion = (message) => {
-  const isInitialized = SchemaVersion.isValid(message.schemaVersion) &&
-    message.schemaVersion >= 1;
+exports.initializeSchemaVersion = message => {
+  const isInitialized =
+    SchemaVersion.isValid(message.schemaVersion) && message.schemaVersion >= 1;
   if (isInitialized) {
     return message;
   }
@@ -59,27 +57,23 @@ exports.initializeSchemaVersion = (message) => {
     : 0;
   const hasAttachments = numAttachments > 0;
   if (!hasAttachments) {
-    return Object.assign(
-      {},
-      message,
-      { schemaVersion: INITIAL_SCHEMA_VERSION }
-    );
+    return Object.assign({}, message, {
+      schemaVersion: INITIAL_SCHEMA_VERSION,
+    });
   }
 
   // All attachments should have the same schema version, so we just pick
   // the first one:
   const firstAttachment = message.attachments[0];
-  const inheritedSchemaVersion = SchemaVersion.isValid(firstAttachment.schemaVersion)
+  const inheritedSchemaVersion = SchemaVersion.isValid(
+    firstAttachment.schemaVersion
+  )
     ? firstAttachment.schemaVersion
     : INITIAL_SCHEMA_VERSION;
-  const messageWithInitialSchema = Object.assign(
-    {},
-    message,
-    {
-      schemaVersion: inheritedSchemaVersion,
-      attachments: message.attachments.map(Attachment.removeSchemaVersion),
-    }
-  );
+  const messageWithInitialSchema = Object.assign({}, message, {
+    schemaVersion: inheritedSchemaVersion,
+    attachments: message.attachments.map(Attachment.removeSchemaVersion),
+  });
 
   return messageWithInitialSchema;
 };
@@ -98,7 +92,10 @@ exports._withSchemaVersion = (schemaVersion, upgrade) => {
 
   return async (message, context) => {
     if (!exports.isValid(message)) {
-      console.log('Message._withSchemaVersion: Invalid input message:', message);
+      console.log(
+        'Message._withSchemaVersion: Invalid input message:',
+        message
+      );
       return message;
     }
 
@@ -138,15 +135,10 @@ exports._withSchemaVersion = (schemaVersion, upgrade) => {
       return message;
     }
 
-    return Object.assign(
-      {},
-      upgradedMessage,
-      { schemaVersion }
-    );
+    return Object.assign({}, upgradedMessage, { schemaVersion });
   };
 };
 
-
 // Public API
 //      _mapAttachments :: (Attachment -> Promise Attachment) ->
 //                         (Message, Context) ->
@@ -154,19 +146,24 @@ exports._withSchemaVersion = (schemaVersion, upgrade) => {
 exports._mapAttachments = upgradeAttachment => async (message, context) => {
   const upgradeWithContext = attachment =>
     upgradeAttachment(attachment, context);
-  const attachments = await Promise.all(message.attachments.map(upgradeWithContext));
+  const attachments = await Promise.all(
+    message.attachments.map(upgradeWithContext)
+  );
   return Object.assign({}, message, { attachments });
 };
 
 //      _mapQuotedAttachments :: (QuotedAttachment -> Promise QuotedAttachment) ->
 //                               (Message, Context) ->
 //                               Promise Message
-exports._mapQuotedAttachments = upgradeAttachment => async (message, context) => {
+exports._mapQuotedAttachments = upgradeAttachment => async (
+  message,
+  context
+) => {
   if (!message.quote) {
     return message;
   }
 
-  const upgradeWithContext = async (attachment) => {
+  const upgradeWithContext = async attachment => {
     const { thumbnail } = attachment;
     if (!thumbnail) {
       return attachment;
@@ -185,7 +182,9 @@ exports._mapQuotedAttachments = upgradeAttachment => async (message, context) =>
 
   const quotedAttachments = (message.quote && message.quote.attachments) || [];
 
-  const attachments = await Promise.all(quotedAttachments.map(upgradeWithContext));
+  const attachments = await Promise.all(
+    quotedAttachments.map(upgradeWithContext)
+  );
   return Object.assign({}, message, {
     quote: Object.assign({}, message.quote, {
       attachments,
@@ -193,8 +192,7 @@ exports._mapQuotedAttachments = upgradeAttachment => async (message, context) =>
   });
 };
 
-const toVersion0 = async message =>
-  exports.initializeSchemaVersion(message);
+const toVersion0 = async message => exports.initializeSchemaVersion(message);
 
 const toVersion1 = exports._withSchemaVersion(
   1,
@@ -241,25 +239,28 @@ exports.upgradeSchema = async (rawMessage, { writeNewAttachmentData } = {}) => {
   return message;
 };
 
-exports.createAttachmentLoader = (loadAttachmentData) => {
+exports.createAttachmentLoader = loadAttachmentData => {
   if (!isFunction(loadAttachmentData)) {
     throw new TypeError('`loadAttachmentData` is required');
   }
 
-  return async message => (Object.assign({}, message, {
-    attachments: await Promise.all(message.attachments.map(loadAttachmentData)),
-  }));
+  return async message =>
+    Object.assign({}, message, {
+      attachments: await Promise.all(
+        message.attachments.map(loadAttachmentData)
+      ),
+    });
 };
 
 //      createAttachmentDataWriter :: (RelativePath -> IO Unit)
 //                                    Message ->
 //                                    IO (Promise Message)
-exports.createAttachmentDataWriter = (writeExistingAttachmentData) => {
+exports.createAttachmentDataWriter = writeExistingAttachmentData => {
   if (!isFunction(writeExistingAttachmentData)) {
     throw new TypeError("'writeExistingAttachmentData' must be a function");
   }
 
-  return async (rawMessage) => {
+  return async rawMessage => {
     if (!exports.isValid(rawMessage)) {
       throw new TypeError("'rawMessage' is not valid");
     }
@@ -282,17 +283,21 @@ exports.createAttachmentDataWriter = (writeExistingAttachmentData) => {
       return message;
     }
 
-    (attachments || []).forEach((attachment) => {
+    (attachments || []).forEach(attachment => {
       if (!Attachment.hasData(attachment)) {
-        throw new TypeError("'attachment.data' is required during message import");
+        throw new TypeError(
+          "'attachment.data' is required during message import"
+        );
       }
 
       if (!isString(attachment.path)) {
-        throw new TypeError("'attachment.path' is required during message import");
+        throw new TypeError(
+          "'attachment.path' is required during message import"
+        );
       }
     });
 
-    const writeThumbnails = exports._mapQuotedAttachments(async (thumbnail) => {
+    const writeThumbnails = exports._mapQuotedAttachments(async thumbnail => {
       const { data, path } = thumbnail;
 
       // we want to be bulletproof to thumbnails without data
@@ -315,10 +320,12 @@ exports.createAttachmentDataWriter = (writeExistingAttachmentData) => {
       {},
       await writeThumbnails(message),
       {
-        attachments: await Promise.all((attachments || []).map(async (attachment) => {
-          await writeExistingAttachmentData(attachment);
-          return omit(attachment, ['data']);
-        })),
+        attachments: await Promise.all(
+          (attachments || []).map(async attachment => {
+            await writeExistingAttachmentData(attachment);
+            return omit(attachment, ['data']);
+          })
+        ),
       }
     );
 

js/modules/types/schema_version.js

@@ -1,5 +1,3 @@
 const { isNumber } = require('lodash');
 
-
-exports.isValid = value =>
-  isNumber(value) && value >= 0;
+exports.isValid = value => isNumber(value) && value >= 0;

js/modules/types/settings.js

@@ -1,4 +1,3 @@
 const OS = require('../os');
 
-exports.isAudioNotificationSupported = () =>
-  !OS.isLinux();
+exports.isAudioNotificationSupported = () => !OS.isLinux();