logger.info(res.data)
})

import { task } from 'foy'
import * as axios from 'axios'

task('test', async ctx => {
  await ctx.exec('mocha')
})

task('build', async ctx => {
  let res = await axios.get('https://your.server/data.json')
  console.log(res.data)
  await ctx.exec('build my awesome project')
})
task(
  'publish:patch',
  ['test', 'build'], // Run test and build before publish
  async ctx => {
    await ctx.exec('npm version patch')
    await ctx.exec('npm publish')
  }
)

task(
  'publish:patch',
  [{
    name: 'test',
    async: true, // run test parallelly
    force: true, // force rerun test whether it is executed before or not,
  }, {
    name: 'build',
    async: true,
    force: true,
  }],
  async ctx => {
    await ctx.exec('npm version patch')
    await ctx.exec('npm publish')
  }
)

/* Sugar version */
task(
  'publish:patch',
  [ 'test'.async().force(),
    'build'.async().force() ],
  async ctx => {
    await ctx.exec('npm version patch')
    await ctx.exec('npm publish')
  }
)

/*
Priority for async tasks

Default is 0, bigger is formmer, then we will run `build` before `test`.
If you have multi async dependencies with same priority, they will be executed parallel.
*/
task(
  'publish:patch',
  [ 'test'.async(0).force(),
    'build'.async(1).force() ],
  async ctx => {
    await ctx.exec('npm version patch')
    await ctx.exec('npm publish')
  }
)

task('task1', async ctx => {
  console.log(ctx.options) // "{ forceRebuild: true, lazyOptions: 1 }"
  console.log(ctx.global.options) // options from command line "{ a: 1 }"
})


task('task2', [{
  name: 'task1',
  options: {
    forceRebuild: true,
  },
  // Some options that rely on ctx or asynchronization,
  // it will be merged to options.
  resolveOptions: async ctx => {
    return { lazyOptions: 1 }
  }
}])

// foy task2 -a 1

import { task, namespace } from 'foy'

namespace('client', ns => {
  before(() => {
    logger.info('before')
  })
  after(() => {
    logger.info('after')
  })
  onerror(() => {
    logger.info('onerror')
  })
  task('start', async ctx => { /* ... */ }) // client:start
  task('build', async ctx => { /* ... */ }) // client:build
  task('watch', async ctx => { /* ... */ }) // client:watch
  namespace('proj1', ns => { // nested namespace
    onerror(() => {
      logger.info('onerror', ns)
    })
    task('start', async ctx => { /* ... */ }) // client:proj1:start

  })
})

namespace('server', ns => {
  task('build', async ctx => { /* ... */ }) // server:build
  task('start', async ctx => { /* ... */ }) // server:start
  task('watch', async ctx => { /* ... */ }) // server:watch
})

task('start', ['client:start'.async(), 'server:start'.async()]) // start

// foy start
// foy client:build

import { fs } from 'foy'


task('build', async ctx => {
  let f = await fs.readFileSync('./assets/someFile')

  // copy file or directory
  await fs.copy('./fromPath', './toPath')

  // watch a directory
  await fs.watchDir('./src', (event, filename) => {
    logger.info(event, filename)
  })

  // make directory with parent directories
  await fs.mkdirp('./some/directory/with/parents/not/exists')

  // write file will auto create missing parent directories
  await fs.outputFile('./some/file/with/parents/not/exists', 'file data')

  // write json file will auto create missing parent directories
  await fs.outputJson('./some/file/with/parents/not/exists', {text: 'json data'})
  let file =
``` **await fs.readJson('./some/jsonFile')**

  // **перебираем дерево каталогов**
  **await fs.iter('./src', async (path, stat) => {**
    **if (stat.isDirectory()) {**
      **logger.info('каталог:', path)**
      // **пропускаем сканирование node_modules**
      **if (path.endsWith('node_modules')) {**
        **return true**
      **}**
    **} else if (stat.isFile()) {**
      **logger.warn('файл:', path)**
    **}**
  **) })**

### logger

Лёгкий встроенный логгер.

```ts
import { logger } from 'foy'

task('build', async ctx => {

  logger.debug('debug', { aa: 1})
  logger.info('info')
  logger.warn('warn')
  logger.error('error')

})

import { logger } from 'foy'

task('build', async ctx => {
  await ctx.exec('tsc')

  // запускаем несколько команд синхронно
  await ctx.exec([
    'tsc --outDir ./lib',
    'tsc --module es6 --outDir ./es',
  ])

  // запускаем несколько команд параллельно
  await Promise.all([
    ctx.exec('eslint'),
    ctx.exec('tsc'),
    ctx.exec('typedoc'),
  ])
})

## Использование на серверах CI

Если вы используете Foy на серверах CI, возможно, вы не захотите использовать загрузку, потому что большинство серверов CI будут регистрировать stdout и stderr в файлы, загрузка будет регистрироваться как кадры. К счастью, Foy уже учёл этот вариант использования, вы можете просто отключить поведение загрузки следующим образом:

```ts
import { task, setGlobalOptions } from 'foy'

setGlobalOptions({ loading: false }) // отключаем анимацию загрузки

task('test', async cyx => { /* ... */ })
/*
$ foy test
DependencyGraph for task [test]:
─ test

Task: test
...
*/

import { before, after, onerror } from 'foy'
before(() => { // делаем что-то перед запуском всего дерева задач
  // ...
})
after(() => { // делаем что-то после завершения всего дерева задач
  // ...
})
onerror((err) => { // делаем что-то при возникновении ошибки
  // ...
})

task('task1', async ctx => { /* ... */ })
task('task2', async ctx => {
  // делаем что-то до task1

  // вручную запускаем task1, чтобы мы могли
  // сделать что-то до или после неё
  await ctx.run('task1')

  // делаем что-то после task1
})

task('build', async ctx => { /* собираем ваш проект */ })
task('run', async ctx => { /* запускаем ваш проект */ })

let p = null
task('watch', async ctx => {
  ctx.fs.watchDir('./src', async (evt, file) => {
    await ctx.run('build')
    p && !p.killed && p.kill()
    p = await ctx.run('run')
  })
})

# Пишем Foyfile на ts, включено по умолчанию
foy -r ts-node/register -c ./some/Foyfile.ts build

# Пишем Foyfile на coffee
foy -r coffeescript/register -c ./some/Foyfile.coffee build