Security News
Cloudflare Adds Security.txt Setup Wizard
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
Jake is a JavaScript build tool for Node.js, similar to Make or Rake. It is designed to automate the building of complex tasks, running shell commands, and managing file operations. Jake can be used for a wide range of automation tasks, from minifying and compiling code to running tests and deploying applications.
Task definition and execution
This feature allows you to define and execute tasks. In the code sample, a default task is defined which depends on another task named 'dependency'. When the default task is run, it first ensures that the 'dependency' task is executed.
"use strict";
let jake = require('jake');
task('default', ['dependency'], function () {
console.log('Running default task');
});
task('dependency', function () {
console.log('Running dependency task');
});
File operations
Jake can perform various file operations such as creating directories, copying files, and iterating over sets of files. In this example, a task named 'createFile' is defined to process all JavaScript files in the current directory, create a new directory named 'build', and copy all files from 'src/' to 'build/'.
"use strict";
let jake = require('jake');
task('createFile', function () {
jake.FileList('*.js').forEach(function (file) {
console.log('Processing file: ' + file);
});
jake.mkdirP('build');
jake.cpR('src/', 'build/');
});
Running shell commands
Jake allows you to run shell commands directly from your tasks. This example shows a task named 'deploy' that runs a shell command to push changes to the master branch of a git repository. The output of the command is printed to the console.
"use strict";
let jake = require('jake');
task('deploy', function () {
let command = 'git push origin master';
jake.exec(command, {printStdout: true}, function () {
console.log('Deployed to master');
});
});
Gulp is a toolkit for automating painful or time-consuming tasks in your development workflow. It is stream-based, which can make it faster for I/O tasks compared to Jake. Gulp uses code over configuration strategy, making it more intuitive for JavaScript developers.
Grunt is a JavaScript task runner that offers a wide array of plugins for automating almost any task. Unlike Jake, Grunt uses a configuration-over-code approach, which can make it easier to manage complex tasks but might be less flexible for some use cases.
Webpack is a static module bundler for modern JavaScript applications. While it is primarily used for bundling JavaScript files for usage in a browser, it can also be configured to manage tasks similar to Jake. Webpack is more focused on the development of web applications and offers a rich plugin ecosystem.
Prerequisites: Node-Jake requires Node.js. (http://nodejs.org/)
Get Node-Jake:
git clone git://github.com/mde/node-jake.git
Build Node-Jake:
cd node-jake && make && sudo make install
npm install jake
Or, get the code, and npm link
in the code root.
jake [-f Jakefile] [-C directory] [--version] target (commands/options ...)
Jake is a simple JavaScript build program with capabilities similar to the regular make or rake command.
Jake has the following features:
* Jakefiles are in standard JavaScript syntax
* Tasks with prerequisites
* Namespaces for tasks
--version Display the program version.
-f *FILE*
--jakefile *FILE* Use FILE as the Jakefile.
-C *DIRECTORY*
--directory *DIRECTORY* Change to DIRECTORY before running tasks.
-T
--tasks Display the tasks, with descriptions, then exit.
Use task
to define tasks. Call it with three arguments:
task(name, dependencies, handler);
Where name
is the string name of the task, dependencies
is an array of the dependencies, and handler
is a function to run for the task.
Use desc
to add a string description of the task.
Here's an example:
var sys = require('sys');
desc('This is the default task.');
task('default', [], function (params) {
sys.puts('This is the default task.');
sys.puts(sys.inspect(arguments));
});
Use namespace
to create a namespace of tasks to perform. Call it with two arguments:
namespace(name, namespaceTasks);
Where is name
is the name of the namespace, and namespaceTasks
is a function with calls inside it to task
or desc
definining all the tasks for that namespace.
Here's an example:
var sys = require('sys');
desc('This is the default task.');
task('default', [], function () {
sys.puts('This is the default task.');
sys.puts(sys.inspect(arguments));
});
namespace('foo', function () {
desc('This the foo:bar task');
task('bar', [], function () {
sys.puts('doing foo:bar task');
sys.puts(sys.inspect(arguments));
});
desc('This the foo:baz task');
task('baz', ['default', 'foo:bar'], function () {
sys.puts('doing foo:baz task');
sys.puts(sys.inspect(arguments));
});
});
In this example, the foo:baz task depends on both the default and the foo:bar task.
Two kinds of parameters can be passed to Node-Jake: positional and named parameters.
Any single parameters passed to the jake command after the task name are passed along to the task handler as positional arguments. For example, with the following Jakefile:
var sys = require('sys');
desc('This is an awesome task.');
task('awesome', [], function () {
sys.puts(sys.inspect(Array.prototype.slice.call(arguments)));
});
You could run jake
like this:
jake awesome foo bar baz
And you'd get the following output:
[ 'foo', 'bar', 'baz' ]
Any paramters passed to the jake command that contain a colon (:) or equals sign (=) will be added to a keyword/value object that is passed as a final argument to the task handler.
With the above Jakefile, you could run jake
like this:
jake awesome foo bar baz qux:zoobie frang:asdf
And you'd get the following output:
[ 'foo'
, 'bar'
, 'baz'
, { qux: 'zoobie', frang: 'asdf' }
]
Running jake
with no arguments runs the default task.
James Coglan's "Jake": http://github.com/jcoglan/jake
Confusingly, this is a Ruby tool for building JavaScript packages from source code.
280 North's Jake: http://github.com/280north/jake
This is also a JavaScript port of Rake, which runs on the Narwhal platform.
Matthew Eernisse, mde@fleegix.org
FAQs
JavaScript build tool, similar to Make or Rake
The npm package jake receives a total of 12,110,034 weekly downloads. As such, jake popularity was classified as popular.
We found that jake demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 4 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
Security News
The Socket Research team breaks down a malicious npm package targeting the legitimate DOMPurify library. It uses obfuscated code to hide that it is exfiltrating browser and crypto wallet data.
Security News
ENISA’s 2024 report highlights the EU’s top cybersecurity threats, including rising DDoS attacks, ransomware, supply chain vulnerabilities, and weaponized AI.