Core debug

packages/core/README.md

@@ -78,3 +78,20 @@ catch (err) {
   core.error(`Error ${err}, action may still succeed though`);
 }
 ```
+
+This library can also wrap chunks of output in foldable groups.
+
+```js
+const core = require('@actions/core')
+
+// Manually wrap output
+core.startGroup('Do some function')
+doSomeFunction()
+core.endGroup()
+
+// Wrap an asynchronous function call
+const result = await core.group('Do something async', async () => {
+  const response = await doSomeHTTPRequest()
+  return response
+})
+```

packages/core/__tests__/lib.test.ts

@@ -155,6 +155,29 @@ describe('@actions/core', () => {
     assertWriteCalls([`##[warning]%0D%0Awarning%0A${os.EOL}`])
   })
 
+  it('startGroup starts a new group', () => {
+    core.startGroup('my-group')
+    assertWriteCalls([`##[group]my-group${os.EOL}`])
+  })
+
+  it('endGroup ends new group', () => {
+    core.endGroup()
+    assertWriteCalls([`##[endgroup]${os.EOL}`])
+  })
+
+  it('group wraps an async call in a group', async () => {
+    const result = await core.group('mygroup', async () => {
+      process.stdout.write('in my group\n')
+      return true
+    })
+    expect(result).toBe(true)
+    assertWriteCalls([
+      `##[group]mygroup${os.EOL}`,
+      'in my group\n',
+      `##[endgroup]${os.EOL}`
+    ])
+  })
+
   it('debug sets the correct message', () => {
     core.debug('Debug')
     assertWriteCalls([`##[debug]Debug${os.EOL}`])

packages/core/src/command.ts

@@ -25,7 +25,7 @@ export function issueCommand(
   process.stdout.write(cmd.toString() + os.EOL)
 }
 
-export function issue(name: string, message: string): void {
+export function issue(name: string, message: string = ''): void {
   issueCommand(name, {}, message)
 }
 

packages/core/src/core.ts

@@ -130,3 +130,43 @@ export function error(message: string): void {
 export function warning(message: string): void {
   issue('warning', message)
 }
+
+/**
+ * Begin an output group.
+ *
+ * Output until the next `groupEnd` will be foldable in this group
+ *
+ * @param name The name of the output group
+ */
+export function startGroup(name: string): void {
+  issue('group', name)
+}
+
+/**
+ * End an output group.
+ */
+export function endGroup(): void {
+  issue('endgroup')
+}
+
+/**
+ * Wrap an asynchronous function call in a group.
+ *
+ * Returns the same type as the function itself.
+ *
+ * @param name The name of the group
+ * @param fn The function to wrap in the group
+ */
+export async function group<T>(name: string, fn: () => Promise<T>): Promise<T> {
+  startGroup(name)
+
+  let result: T
+
+  try {
+    result = await fn()
+  } finally {
+    endGroup()
+  }
+
+  return result
+}