All Projects β†’ zaaack β†’ Foy

zaaack / Foy

Licence: mit
A simple, light-weight and modern task runner for general purpose.

Programming Languages

typescript
32286 projects

Projects that are alternatives of or similar to Foy

Mask
🎭 A CLI task runner defined by a simple markdown file
Stars: ✭ 495 (+215.29%)
Mutual labels:  build-tool, make, cli, task-runner
Sake Core
Sake's core interface.
Stars: ✭ 78 (-50.32%)
Mutual labels:  tasks, build-tool, make, promise
lets
CLI task runner for developers - a better alternative to make
Stars: ✭ 50 (-68.15%)
Mutual labels:  runner, task-runner, make
Ygor
Task toolkit. For when `npm run` isn't enough and everything else is too much.
Stars: ✭ 69 (-56.05%)
Mutual labels:  build-tool, make, task-runner
Sake Cli
🍢 Sake is a build tool for JavaScript.
Stars: ✭ 97 (-38.22%)
Mutual labels:  tasks, build-tool, make
makesure
Simple task/command runner with declarative goals and dependencies
Stars: ✭ 230 (+46.5%)
Mutual labels:  task-runner, build-tool, make
Start
πŸ”΄ Functional task runner for Node.js
Stars: ✭ 478 (+204.46%)
Mutual labels:  tasks, promise, runner
Task
A task runner / simpler Make alternative written in Go
Stars: ✭ 4,282 (+2627.39%)
Mutual labels:  build-tool, make, task-runner
Cargo Make
Rust task runner and build tool.
Stars: ✭ 895 (+470.06%)
Mutual labels:  build-tool, make, task-runner
Mmake
Mmake is a small program which wraps make to provide additional functionality, such as user-friendly help output, remote includes, and eventually more. It otherwise acts as a pass-through to standard make.
Stars: ✭ 1,593 (+914.65%)
Mutual labels:  build-tool, make, task-runner
Handroll
🍣 Expertly rolled JavaScript. CLI + library for bundling JavaScript with Rollup.js
Stars: ✭ 66 (-57.96%)
Mutual labels:  build-tool, cli
Flowa
πŸ”₯Service level control flow for Node.js
Stars: ✭ 66 (-57.96%)
Mutual labels:  promise, runner
Sparrow
Sparrow - script distribution platform for Linux OS
Stars: ✭ 77 (-50.96%)
Mutual labels:  cli, task-runner
Dog
Dog wants to be a very good task runner
Stars: ✭ 84 (-46.5%)
Mutual labels:  cli, task-runner
Run When
Run tasks based on "Git diff" changes πŸƒ βž• βž–
Stars: ✭ 63 (-59.87%)
Mutual labels:  cli, task-runner
Taskorama
βš™ A Task/Future data type for JavaScript
Stars: ✭ 90 (-42.68%)
Mutual labels:  tasks, promise
Pizza Cli
πŸ• Order a pizza in a CLI app (just for fun!)
Stars: ✭ 58 (-63.06%)
Mutual labels:  make, cli
Redrun
✨🐌 🐎✨ fastest npm scripts runner
Stars: ✭ 85 (-45.86%)
Mutual labels:  cli, task-runner
Walk
A fast, general purpose, graph based build and task execution utility.
Stars: ✭ 108 (-31.21%)
Mutual labels:  build-tool, make
Create Elm App
πŸƒ Create Elm apps with zero configuration
Stars: ✭ 1,650 (+950.96%)
Mutual labels:  build-tool, cli

Foy

Build Status npm npm install size

A simple, light-weight and modern task runner for general purpose.

Contents

Features

  • Promise-based tasks and built-in utilities.
  • shelljs-like commands
  • Easy to learn, stop spending hours for build tools.
  • Small install size
    • foy: install size
    • gulp: install size
    • grunt: install size

GIF

Install

yarn add -D foy # or npm i -D foy

Or install globally with

yarn add -g foy # or npm i -g foy

Write a Foyfile

You need to add a Foyfile.js(or Foyfile.ts with ts-node installed) to your project root.

Also, you can simply generate a Foyfile.js via:

foy --init

which will create a simple Foyfile.js in the current folder:

// Foyfile.js
const { task } = require('foy')

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

You can also generate a Foyfile.ts via

foy --init ts

Then we can run foy build to execute the build task.

foy build

You can also add some options and a description to your tasks:

import { task, desc, option, strict } from 'foy'

desc('Build ts files with tsc')
option('-w, --watch', 'watch file changes')
strict() // This will throw an error if you passed some options that doesn't defined via `option()`
task('build', async ctx => {
  await ctx.exec(`tsc ${ctx.options.watch ? '-w' : ''}`)
})
foy build -w

Warning! If you want to set flags like strict for all tasks, please use setGlobalOptions:

import { setGlobalOptions } from 'foy'

setGlobalOptions({ strict: true }) // all tasks' options will be strict.

option('-aa') // strict via default
task('dev', async ctx => {

})
option('-bb') // strict via default
task('build', async ctx => {

})

Using with built-in promised-based API

import { fs, task } from 'foy'

task('some task', async ctx => {
  await fs.rmrf('/some/dir/or/file') // Remove directory or file
  await fs.copy('/src', '/dist') // Copy folder or file
  let json = await fs.readJson('./xx.json')
  await ctx
    .env('NODE_ENV', 'production')
    .cd('./src')
    .exec('some command') // Execute an command
  let { stdout } = await ctx.exec('ls', { stdio: 'pipe' }) // Get the stdout, default is empty because it's redirected to current process via `stdio: 'inherit'`.
})

Using with other packages

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

task('build', async ctx => {
  let res = await axios.get('https://your.server/data.json')
  logger.info(res.data)
})

Using dependencies

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')
  }
)

Dependencies run serially by default but you can specify when a task should be run concurrently.

Example: Passing running options to dependencies:

task(
  'publish:patch',
  [{
    name: 'test',
    async: true, // run test parallelly
    force: true, // force rerun test whether it has been 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, higher values will be run earlier; so, in this next example, `build` will be run before `test`.
(Note: If you have multiple async dependencies with same priority, they will be executed in 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')
  }
)

You can also pass options to dependencies:

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

Using namespaces

To avoid name collisions, Foy provides namespaces to group tasks via the namespace function:

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

Useful utils

fs

Foy wraps the NodeJS's fs (file system) module with a promise-based API, so you can easily use async/await patterns, if you prefer. Foy also implements some useful utility functions for build scripts not present in NodeJS's built-in modules.

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')

  // iterate directory tree
  await fs.iter('./src', async (path, stat) => {
    if (stat.isDirectory()) {
      logger.info('directory:', path)
      // skip scan node_modules
      if (path.endsWith('node_modules')) {
        return true
      }
    } else if (stat.isFile()) {
      logger.warn('file:', path)
    }
  })
})

logger

Foy includes a light-weight built-in logger

import { logger } from 'foy'

task('build', async ctx => {

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

})

exec command

A simple wrapper for sindresorhus's lovely module execa

import { logger } from 'foy'

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

  // run multiple commands synchronously
  await ctx.exec([
    'tsc --outDir ./lib',
    'tsc --module es6 --outDir ./es',
  ])

  // run multiple commands concurrently
  await Promise.all([
    ctx.exec('eslint'),
    ctx.exec('tsc'),
    ctx.exec('typedoc'),
  ])
})


Using in CI servers

If you use Foy in CI servers, you won't want the loading spinners as most CI servers will log stdout and stderr in discreet frames not meant for continuous streaming animations. Luckily, Foy has already considered this! You can simply disable the loading animation like this:

import { task, setGlobalOptions } from 'foy'

setGlobalOptions({ loading: false }) // disable loading animations

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

Task: test
...
*/

Using lifecycle hooks

You can add lifecycle hooks via the before, after, and onerror functions.

import { before, after, onerror } from 'foy'
before(() => { // do something before all tasks tree start
  // ...
})
after(() => { // do something after all tasks tree finished
  // ...
})
onerror((err) => { // do something when error happens
  // ...
})

run task in task

task('task1', async ctx => { /* ... */ })
task('task2', async ctx => {
  // do things before task1

  // run task1 manually, so we can
  // do things before or after it
  await ctx.run('task1')

  // do things after task1
})

Watch and build

task('build', async ctx => { /* build your project */ })
task('run', async ctx => { /* start your project */ })

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')
  })
})

Using with custom compiler

# Write Foyfile in ts, enabled by default
foy -r ts-node/register -c ./some/Foyfile.ts build

# Write Foyfile in coffee
foy -r coffeescript/register -c ./some/Foyfile.coffee build

API documentation

https://zaaack.github.io/foy/api

License

MIT

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].