Paths

Table of Contentst

-
docs/
-
dev_environment.md

[docs] Add ShellCheck installation instructions
ClosedPublic
Actions

Authored by • abosh on Aug 8 2022, 9:32 AM.

Details

Reviewers

ashoat
varun
• jon
atul

Commits

rCOMM34ca4b335c25: [docs] Move ShellCheck installation instructions with rest of `brew install`…
rCOMMa6578e42469c: [docs] Add ShellCheck installation instructions

Summary

Related Linear issue here. This diff ensures developers install ShellCheck into their dev environments so that it can run with lint-staged on to-be-committed *.sh files.

D4772 adds the rule to lint all to-be-committed *.sh files.

Test Plan

Tested brew install shellcheck && brew upgrade shellcheck locally on Apple silicon Macbook. On Apple silicon, running which shellcheck should point to /opt/homebrew/bin/shellcheck.

Additionally, created a commit with a problematic *.sh file (after incorporating the changes in D4772) and lint-staged/shellcheck caught the error.

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

• abosh created this revision.Aug 8 2022, 9:32 AM

Herald added subscribers: • adrian, tomek. · View Herald TranscriptAug 8 2022, 9:32 AM

• abosh edited the test plan for this revision. (Show Details)Aug 8 2022, 9:34 AM

• abosh added a child revision: D4772: [lint-staged] Add ShellCheck to `.lintstagedrc.js`.Aug 8 2022, 9:41 AM

• abosh edited the summary of this revision. (Show Details)Aug 8 2022, 9:44 AM

• abosh edited the test plan for this revision. (Show Details)

• abosh edited the summary of this revision. (Show Details)

Harbormaster completed remote builds in B11213: Diff 15425.Aug 8 2022, 9:45 AM

• abosh requested review of this revision.Aug 8 2022, 9:45 AM

• abosh edited the test plan for this revision. (Show Details)Aug 8 2022, 9:54 AM

• abosh edited the test plan for this revision. (Show Details)

atul requested changes to this revision.Aug 8 2022, 10:49 AM

atul added inline comments.

docs/dev_environment.md
337–343 ↗	(On Diff #15425)	Can we move this closer to the rest of the `brew install` commands?

This revision now requires changes to proceed.Aug 8 2022, 10:49 AM

Sure, that makes sense. Moved ShellCheck instructions up to the top of the Prerequisites section under Rust and above Yarn (to keep it "alphabetized"?). It's such a small command I doubt it should be an issue, but open to thoughts about where to place it in the doc.

Harbormaster failed remote builds in B11215: Diff 15427!Aug 8 2022, 11:05 AM

• abosh mentioned this in D4772: [lint-staged] Add ShellCheck to `.lintstagedrc.js`.Aug 8 2022, 11:05 AM

atul accepted this revision.Aug 8 2022, 11:06 AM

atul added 2 blocking reviewer(s): varun, ashoat.

varun accepted this revision.Aug 8 2022, 11:11 AM

Harbormaster completed remote builds in B11215: Diff 15427.Aug 8 2022, 11:55 AM

• jon accepted this revision.Aug 8 2022, 2:12 PM

ashoat accepted this revision.Aug 8 2022, 5:49 PM

This revision is now accepted and ready to land.Aug 8 2022, 5:49 PM

Closed by commit rCOMMa6578e42469c: [docs] Add ShellCheck installation instructions (authored by • abosh). · Explain WhyAug 9 2022, 8:51 AM

This revision was automatically updated to reflect the committed changes.

• abosh added a commit: rCOMMa6578e42469c: [docs] Add ShellCheck installation instructions.

• abosh added a commit: rCOMM34ca4b335c25: [docs] Move ShellCheck installation instructions with rest of `brew install`….Aug 9 2022, 8:57 AM

• abosh mentioned this in D4779: [lintstaged] Add cmake-lint to lintstagedrc.Aug 9 2022, 10:15 AM

Revision Contents
Changeset List

Path

Size

docs/

dev_environment.md

8 lines

Diff 15471

View Options

docs/dev_environment.md

// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js';		import _groupBy from 'lodash/fp/groupBy.js';
import _keyBy from 'lodash/fp/keyBy.js';		import _keyBy from 'lodash/fp/keyBy.js';
import _omit from 'lodash/fp/omit.js';		import _omit from 'lodash/fp/omit.js';
import _partition from 'lodash/fp/partition.js';		import _partition from 'lodash/fp/partition.js';
import _sortBy from 'lodash/fp/sortBy.js';		import _sortBy from 'lodash/fp/sortBy.js';
import _memoize from 'lodash/memoize.js';		import _memoize from 'lodash/memoize.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react';		import * as React from 'react';
import { useDispatch } from 'react-redux';		import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';		import { createSelector } from 'reselect';
import uuid from 'uuid';

import {		import {
createLocalMessageActionType,		createLocalMessageActionType,
sendMultimediaMessageActionTypes,		sendMultimediaMessageActionTypes,
legacySendMultimediaMessage,		legacySendMultimediaMessage,
sendTextMessageActionTypes,		sendTextMessageActionTypes,
sendTextMessage,		sendTextMessage,
} from 'lib/actions/message-actions.js';		} from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js';		import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js';		import { newThread } from 'lib/actions/thread-actions.js';
import {		import {
uploadMultimedia,		uploadMultimedia,
uploadMediaMetadata,		uploadMediaMetadata,
updateMultimediaMessageMediaActionType,		updateMultimediaMessageMediaActionType,
deleteUpload,		deleteUpload,
		blobServiceUpload,
type MultimediaUploadCallbacks,		type MultimediaUploadCallbacks,
type MultimediaUploadExtras,		type MultimediaUploadExtras,
		type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js';		} from 'lib/actions/upload-actions.js';
import {		import {
useModalContext,		useModalContext,
type PushModal,		type PushModal,
} from 'lib/components/modal-provider.react.js';		} from 'lib/components/modal-provider.react.js';
import blobService from 'lib/facts/blob-service.js';		import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js';		import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { getNextLocalUploadID } from 'lib/media/media-utils.js';		import { getNextLocalUploadID } from 'lib/media/media-utils.js';
Show All 15 Lines
import type { CalendarQuery } from 'lib/types/entry-types.js';		import type { CalendarQuery } from 'lib/types/entry-types.js';
import type {		import type {
UploadMultimediaResult,		UploadMultimediaResult,
UploadMediaMetadataRequest,		UploadMediaMetadataRequest,
MediaMissionStep,		MediaMissionStep,
MediaMissionFailure,		MediaMissionFailure,
MediaMissionResult,		MediaMissionResult,
MediaMission,		MediaMission,
Dimensions,
} from 'lib/types/media-types.js';		} from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js';		import { messageTypes } from 'lib/types/message-types-enum.js';
import {		import {
type RawMessageInfo,		type RawMessageInfo,
type RawMultimediaMessageInfo,		type RawMultimediaMessageInfo,
type SendMessageResult,		type SendMessageResult,
type SendMessagePayload,		type SendMessagePayload,
} from 'lib/types/message-types.js';		} from 'lib/types/message-types.js';
Show All 9 Lines	import {
type ThreadInfo,		type ThreadInfo,
type RawThreadInfo,		type RawThreadInfo,
} from 'lib/types/thread-types.js';		} from 'lib/types/thread-types.js';
import {		import {
type DispatchActionPromise,		type DispatchActionPromise,
useServerCall,		useServerCall,
useDispatchActionPromise,		useDispatchActionPromise,
} from 'lib/utils/action-utils.js';		} from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import {		import {
makeBlobServiceEndpointURL,		makeBlobServiceEndpointURL,
isBlobServiceURI,		isBlobServiceURI,
blobHashFromBlobServiceURI,		blobHashFromBlobServiceURI,
} from 'lib/utils/blob-service.js';		} from 'lib/utils/blob-service.js';
import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js';		import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js';		import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { generateReportID } from 'lib/utils/report-utils.js';		import { generateReportID } from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';

import {		import {
type PendingMultimediaUpload,		type PendingMultimediaUpload,
type TypeaheadState,		type TypeaheadState,
InputStateContext,		InputStateContext,
} from './input-state.js';		} from './input-state.js';
import { encryptFile } from '../media/encryption-utils.js';		import { encryptFile } from '../media/encryption-utils.js';
import { generateThumbHash } from '../media/image-utils.js';		import { generateThumbHash } from '../media/image-utils.js';
Show All 21 Lines	type Props = {
+dispatch: Dispatch,		+dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise,		+dispatchActionPromise: DispatchActionPromise,
+calendarQuery: () => CalendarQuery,		+calendarQuery: () => CalendarQuery,
+uploadMultimedia: (		+uploadMultimedia: (
multimedia: Object,		multimedia: Object,
extras: MultimediaUploadExtras,		extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks,		callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>,		) => Promise<UploadMultimediaResult>,
		+blobServiceUpload: BlobServiceUploadAction,
+uploadMediaMetadata: (		+uploadMediaMetadata: (
input: UploadMediaMetadataRequest,		input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>,		) => Promise<UploadMultimediaResult>,
+deleteUpload: (id: string) => Promise<void>,		+deleteUpload: (id: string) => Promise<void>,
+sendMultimediaMessage: (		+sendMultimediaMessage: (
threadID: string,		threadID: string,
localID: string,		localID: string,
mediaIDs: $ReadOnlyArray<string>,		mediaIDs: $ReadOnlyArray<string>,
▲ Show 20 Lines • Show All 729 Lines • ▼ Show 20 Lines	try {
(upload.mediaType === 'encrypted_photo' \|\|		(upload.mediaType === 'encrypted_photo' \|\|
upload.mediaType === 'encrypted_video')		upload.mediaType === 'encrypted_video')
) {		) {
const { blobHash, dimensions, thumbHash } = upload;		const { blobHash, dimensions, thumbHash } = upload;
invariant(		invariant(
encryptionKey && blobHash && dimensions,		encryptionKey && blobHash && dimensions,
'incomplete encrypted upload',		'incomplete encrypted upload',
);		);
uploadResult = await this.blobServiceUpload(		uploadResult = await this.props.blobServiceUpload({
{		input: {
		blobInput: {
		type: 'file',
file: upload.file,		file: upload.file,
		},
blobHash,		blobHash,
encryptionKey,		encryptionKey,
dimensions,		dimensions,
loop: false,		loop: false,
...(thumbHash ? { thumbHash } : undefined),		thumbHash,
},		},
{ ...callbacks },		callbacks,
);		});
} else {		} else {
let uploadExtras = {		let uploadExtras = {
...upload.dimensions,		...upload.dimensions,
loop: false,		loop: false,
thumbHash: upload.thumbHash,		thumbHash: upload.thumbHash,
};		};
if (encryptionKey) {		if (encryptionKey) {
uploadExtras = { ...uploadExtras, encryptionKey };		uploadExtras = { ...uploadExtras, encryptionKey };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines	this.setState(prevState => {
loop: result.loop,		loop: result.loop,
},		},
},		},
},		},
};		};
});		});
}		}

async blobServiceUpload(
input: {
+file: File,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash?: string,
},
options?: ?CallServerEndpointOptions,
): Promise<{
...UploadMultimediaResult,
+blobHolder: string,
}> {
const blobHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);

// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: blobHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);

handleHTTPResponseError(assignHolderResponse);

const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}

// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
const formData = new FormData();
formData.append('blob_hash', blobHash);
formData.append('blob_data', input.file);

const xhr = new XMLHttpRequest();
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
xhr.open(
uploadEndpoint.method,
makeBlobServiceEndpointURL(uploadEndpoint),
);
if (options?.timeout) {
xhr.timeout = options.timeout;
}
if (options && options.onProgress) {
const { onProgress } = options;
xhr.upload.onprogress = _throttle(
({ loaded, total }) => onProgress(loaded / total),
50,
);
}

let failed = false;
const responsePromise = new Promise((resolve, reject) => {
xhr.onload = () => {
if (failed) {
return;
}
resolve();
};
xhr.onabort = () => {
failed = true;
reject(new Error('request aborted'));
};
xhr.onerror = event => {
failed = true;
reject(event);
};
if (options && options.timeout) {
xhr.ontimeout = event => {
failed = true;
reject(event);
};
}
if (options && options.abortHandler) {
options.abortHandler(() => {
failed = true;
reject(new Error('request aborted'));
xhr.abort();
});
}
});

if (!failed) {
xhr.send(formData);
}
await responsePromise;
}

// 3. Send upload metadata to the keyserver, return response
const result = await this.props.uploadMediaMetadata({
...input.dimensions,
loop: input.loop ?? false,
blobHolder,
blobHash,
encryptionKey: input.encryptionKey,
mimeType: input.file.type,
filename: input.file.name,
thumbHash: input.thumbHash,
});
return { ...result, blobHolder };
}

handleAbortCallback(		handleAbortCallback(
threadID: string,		threadID: string,
localUploadID: string,		localUploadID: string,
abort: () => void,		abort: () => void,
) {		) {
this.setState(prevState => {		this.setState(prevState => {
const newThreadID = this.getRealizedOrPendingThreadID(threadID);		const newThreadID = this.getRealizedOrPendingThreadID(threadID);
const uploads = prevState.pendingUploads[newThreadID];		const uploads = prevState.pendingUploads[newThreadID];
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines	React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
const threadStoreThreadInfos = useSelector(		const threadStoreThreadInfos = useSelector(
state => state.threadStore.threadInfos,		state => state.threadStore.threadInfos,
);		);
const pendingToRealizedThreadIDs = useSelector(state =>		const pendingToRealizedThreadIDs = useSelector(state =>
pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),		pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
);		);
const calendarQuery = useSelector(nonThreadCalendarQuery);		const calendarQuery = useSelector(nonThreadCalendarQuery);
const callUploadMultimedia = useServerCall(uploadMultimedia);		const callUploadMultimedia = useServerCall(uploadMultimedia);
		const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);		const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
const callDeleteUpload = useServerCall(deleteUpload);		const callDeleteUpload = useServerCall(deleteUpload);
const callSendMultimediaMessage = useServerCall(		const callSendMultimediaMessage = useServerCall(
legacySendMultimediaMessage,		legacySendMultimediaMessage,
);		);
const callSendTextMessage = useServerCall(sendTextMessage);		const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread);		const callNewThread = useServerCall(newThread);
const dispatch = useDispatch();		const dispatch = useDispatch();
Show All 24 Lines	return (
drafts={drafts}		drafts={drafts}
viewerID={viewerID}		viewerID={viewerID}
messageStoreMessages={messageStoreMessages}		messageStoreMessages={messageStoreMessages}
threadStoreThreadInfos={threadStoreThreadInfos}		threadStoreThreadInfos={threadStoreThreadInfos}
pendingRealizedThreadIDs={pendingToRealizedThreadIDs}		pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
calendarQuery={calendarQuery}		calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia}		uploadMultimedia={callUploadMultimedia}
uploadMediaMetadata={callUploadMediaMetadata}		uploadMediaMetadata={callUploadMediaMetadata}
		blobServiceUpload={callBlobServiceUpload}
deleteUpload={callDeleteUpload}		deleteUpload={callDeleteUpload}
sendMultimediaMessage={callSendMultimediaMessage}		sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage}		sendTextMessage={callSendTextMessage}
newThread={callNewThread}		newThread={callNewThread}
dispatch={dispatch}		dispatch={dispatch}
dispatchActionPromise={dispatchActionPromise}		dispatchActionPromise={dispatchActionPromise}
pushModal={modalContext.pushModal}		pushModal={modalContext.pushModal}
sendCallbacks={sendCallbacks}		sendCallbacks={sendCallbacks}
registerSendCallback={registerSendCallback}		registerSendCallback={registerSendCallback}
unregisterSendCallback={unregisterSendCallback}		unregisterSendCallback={unregisterSendCallback}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}		textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/>		/>
);		);
});		});

export default ConnectedInputStateContainer;		export default ConnectedInputStateContainer;

[docs] Add ShellCheck installation instructionsClosedPublicActions