2014-01-02 19:46:46 +01:00
|
|
|
'use strict';
|
2014-02-19 23:17:19 +01:00
|
|
|
var File = java.io.File,
|
|
|
|
bkBukkit = org.bukkit.Bukkit,
|
|
|
|
bkLocation = org.bukkit.Location,
|
|
|
|
bkBlockCommandSender = org.bukkit.command.BlockCommandSender;
|
2013-02-10 18:53:08 +01:00
|
|
|
/************************************************************************
|
2013-12-28 09:44:40 +01:00
|
|
|
## Utilities Module
|
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
The `utils` module is a storehouse for various useful utility
|
|
|
|
functions which can be used by plugin and module authors. It contains
|
|
|
|
miscellaneous utility functions and classes to help with programming.
|
2013-02-10 18:53:08 +01:00
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
### utils.player() function
|
2013-12-31 19:21:40 +01:00
|
|
|
|
|
|
|
The utils.player() function will return a [bukkit Player][bkpl] object
|
|
|
|
with the given name. This function takes a single parameter
|
|
|
|
`playerName` which can be either a String or a [Player][bkpl] object -
|
|
|
|
if it's a Player object, then the same object is returned. If it's a
|
|
|
|
String, then it tries to find the player with that name.
|
|
|
|
|
|
|
|
#### Parameters
|
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
* playerName : A String or Player object. If no parameter is provided
|
|
|
|
then player() will try to return the `self` variable . It is
|
|
|
|
strongly recommended to provide a parameter.
|
2013-12-31 19:21:40 +01:00
|
|
|
|
|
|
|
#### Example
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
var name = 'walterh';
|
|
|
|
var player = utils.player(name);
|
|
|
|
if ( player ) {
|
|
|
|
player.sendMessage('Got ' + name);
|
|
|
|
} else {
|
|
|
|
console.log('No player named ' + name);
|
|
|
|
}
|
|
|
|
```
|
2013-12-31 19:21:40 +01:00
|
|
|
|
|
|
|
[bkpl]: http://jd.bukkit.org/dev/apidocs/org/bukkit/entity/Player.html
|
2013-12-31 21:12:57 +01:00
|
|
|
[bkloc]: http://jd.bukkit.org/dev/apidocs/org/bukkit/Location.html
|
2013-12-31 19:21:40 +01:00
|
|
|
|
|
|
|
***/
|
|
|
|
var _player = function ( playerName ) {
|
2014-01-29 20:49:15 +01:00
|
|
|
if ( typeof playerName == 'undefined' ) {
|
|
|
|
if ( typeof self == 'undefined' ) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return self;
|
2013-12-24 01:17:33 +01:00
|
|
|
}
|
2014-01-29 20:49:15 +01:00
|
|
|
} else {
|
|
|
|
if ( typeof playerName == 'string' )
|
2014-02-19 23:17:19 +01:00
|
|
|
return bkBukkit.getPlayer( playerName );
|
2014-01-29 20:49:15 +01:00
|
|
|
else
|
|
|
|
return playerName; // assumes it's a player object
|
|
|
|
}
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
2013-12-31 21:12:57 +01:00
|
|
|
/*************************************************************************
|
|
|
|
### utils.locationToJSON() function
|
|
|
|
|
|
|
|
utils.locationToJSON() returns a [org.bukkit.Location][bkloc] object in JSON form...
|
|
|
|
|
|
|
|
{ world: 'world5',
|
|
|
|
x: 56.9324,
|
|
|
|
y: 103.9954,
|
|
|
|
z: 43.1323,
|
|
|
|
yaw: 0.0,
|
|
|
|
pitch: 0.0
|
|
|
|
}
|
|
|
|
|
|
|
|
This can be useful if you write a plugin that needs to store location data since bukkit's Location object is a Java object which cannot be serialized to JSON by default.
|
2013-12-24 01:17:33 +01:00
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
#### Parameters
|
|
|
|
|
|
|
|
* location: An object of type [org.bukkit.Location][bkloc]
|
|
|
|
|
|
|
|
#### Returns
|
|
|
|
|
|
|
|
A JSON object in the above form.
|
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
var _locationToJSON = function( location ) {
|
|
|
|
return {
|
|
|
|
world: ''+location.world.name,
|
|
|
|
x: location.x,
|
|
|
|
y: location.y,
|
|
|
|
z: location.z,
|
|
|
|
yaw: location.yaw,
|
|
|
|
pitch: location.pitch
|
|
|
|
};
|
2013-12-31 19:21:40 +01:00
|
|
|
};
|
2013-12-31 21:12:57 +01:00
|
|
|
/*************************************************************************
|
|
|
|
### utils.locationToString() function
|
|
|
|
|
|
|
|
The utils.locationToString() function returns a
|
|
|
|
[org.bukkit.Location][bkloc] object in string form...
|
|
|
|
|
|
|
|
'{"world":"world5",x:56.9324,y:103.9954,z:43.1323,yaw:0.0,pitch:0.0}'
|
|
|
|
|
|
|
|
... which can be useful if you write a plugin which uses Locations as
|
|
|
|
keys in a lookup table.
|
|
|
|
|
|
|
|
#### Example
|
2014-02-04 22:36:00 +01:00
|
|
|
|
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
...
|
|
|
|
var key = utils.locationToString(player.location);
|
|
|
|
lookupTable[key] = player.name;
|
|
|
|
```
|
2013-12-31 21:12:57 +01:00
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
exports.locationToString = function( location ) {
|
|
|
|
return JSON.stringify( _locationToJSON( location ) );
|
2013-12-31 19:21:40 +01:00
|
|
|
};
|
|
|
|
exports.locationToJSON = _locationToJSON;
|
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
/*************************************************************************
|
|
|
|
### utils.locationFromJSON() function
|
|
|
|
|
|
|
|
This function reconstructs an [org.bukkit.Location][bkloc] object from
|
|
|
|
a JSON representation. This is the counterpart to the
|
|
|
|
`locationToJSON()` function. It takes a JSON object of the form
|
|
|
|
returned by locationToJSON() and reconstructs and returns a bukkit
|
|
|
|
Location object.
|
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
exports.locationFromJSON = function( json ) {
|
|
|
|
var world;
|
|
|
|
if ( json.constuctor == Array ) {
|
|
|
|
// for support of legacy format
|
2014-02-19 23:17:19 +01:00
|
|
|
world = bkBukkit.getWorld( json[0] );
|
|
|
|
return new bkLocation( world, json[1], json[2] , json[3] );
|
2014-01-29 20:49:15 +01:00
|
|
|
} else {
|
2014-02-19 23:17:19 +01:00
|
|
|
world = bkBukkit.getWorld( json.world );
|
|
|
|
return new bkLocation( world, json.x, json.y , json.z, json.yaw, json.pitch );
|
2014-01-29 20:49:15 +01:00
|
|
|
}
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
|
|
|
|
2013-12-31 19:21:40 +01:00
|
|
|
exports.player = _player;
|
2014-01-29 20:49:15 +01:00
|
|
|
|
|
|
|
exports.getPlayerObject = function( player ) {
|
|
|
|
console.warn( 'utils.getPlayerObject() is deprecated. Use utils.player() instead.' );
|
|
|
|
return _player(player);
|
2013-12-31 19:21:40 +01:00
|
|
|
};
|
2013-12-31 21:12:57 +01:00
|
|
|
/*************************************************************************
|
|
|
|
### utils.getPlayerPos() function
|
|
|
|
|
|
|
|
This function returns the player's [Location][bkloc] (x, y, z, pitch
|
|
|
|
and yaw) for a named player. If the "player" is in fact a
|
|
|
|
[org.bukkit.command.BlockCommandSender][bkbcs] then the attached
|
|
|
|
Block's location is returned.
|
2013-12-24 01:17:33 +01:00
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
#### Parameters
|
|
|
|
|
|
|
|
* player : A [org.bukkit.command.CommandSender][bkbcs] (Player or BlockCommandSender) or player name (String).
|
|
|
|
|
|
|
|
#### Returns
|
|
|
|
|
|
|
|
An [org.bukkit.Location][bkloc] object.
|
|
|
|
|
|
|
|
[bkbcs]: http://jd.bukkit.org/dev/apidocs/org/bukkit/command/BlockCommandSender.html
|
|
|
|
[bksndr]: http://jd.bukkit.org/dev/apidocs/index.html?org/bukkit/command/CommandSender.html
|
|
|
|
***/
|
2013-12-24 01:17:33 +01:00
|
|
|
exports.getPlayerPos = function( player ) {
|
2014-01-29 20:49:15 +01:00
|
|
|
player = _player( player );
|
|
|
|
if ( player ) {
|
2014-02-19 23:17:19 +01:00
|
|
|
if ( player instanceof bkBlockCommandSender )
|
2014-01-29 20:49:15 +01:00
|
|
|
return player.block.location;
|
2013-12-31 19:21:40 +01:00
|
|
|
else
|
2014-01-29 20:49:15 +01:00
|
|
|
return player.location;
|
|
|
|
}
|
|
|
|
return null;
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
2013-12-31 21:12:57 +01:00
|
|
|
/************************************************************************
|
|
|
|
### utils.getMousePos() function
|
|
|
|
|
|
|
|
This function returns a [org.bukkit.Location][bkloc] object (the
|
|
|
|
x,y,z) of the current block being targeted by the named player. This
|
|
|
|
is the location of the block the player is looking at (targeting).
|
|
|
|
|
|
|
|
#### Parameters
|
|
|
|
|
|
|
|
* player : The player whose targeted location you wish to get.
|
|
|
|
|
|
|
|
#### Example
|
|
|
|
|
|
|
|
The following code will strike lightning at the location the player is looking at...
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
var playerName = 'walterh';
|
|
|
|
var targetPos = utils.getMousePos(playerName);
|
|
|
|
if (targetPos){
|
|
|
|
targetPos.world.strikeLightning(targetPos);
|
|
|
|
}
|
|
|
|
```
|
2013-12-24 01:17:33 +01:00
|
|
|
|
2013-12-31 21:12:57 +01:00
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
exports.getMousePos = function( player ) {
|
|
|
|
|
|
|
|
player = _player(player);
|
|
|
|
if ( !player ) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
// player might be CONSOLE or a CommandBlock
|
|
|
|
if ( !player.getTargetBlock ) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
var targetedBlock = player.getTargetBlock( null, 5 );
|
|
|
|
if ( targetedBlock == null || targetedBlock.isEmpty() ) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return targetedBlock.location;
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
2013-02-17 23:29:41 +01:00
|
|
|
/************************************************************************
|
2013-12-31 21:12:57 +01:00
|
|
|
### utils.foreach() function
|
2013-12-28 09:44:40 +01:00
|
|
|
|
2013-02-17 23:29:41 +01:00
|
|
|
The utils.foreach() function is a utility function for iterating over
|
2013-03-17 12:57:48 +01:00
|
|
|
an array of objects (or a java.util.Collection of objects) and processing each object in turn. Where
|
2013-02-17 23:29:41 +01:00
|
|
|
utils.foreach() differs from other similar functions found in
|
|
|
|
javascript libraries, is that utils.foreach can process the array
|
|
|
|
immediately or can process it *nicely* by processing one item at a
|
|
|
|
time then delaying processing of the next item for a given number of
|
|
|
|
server ticks (there are 20 ticks per second on the minecraft main
|
|
|
|
thread). This method relies on Bukkit's [org.bukkit.scheduler][sched]
|
|
|
|
package for scheduling processing of arrays.
|
|
|
|
|
|
|
|
[sched]: http://jd.bukkit.org/beta/apidocs/org/bukkit/scheduler/package-summary.html
|
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Parameters
|
2013-02-17 23:29:41 +01:00
|
|
|
|
2013-03-17 12:57:48 +01:00
|
|
|
* array : The array to be processed - It can be a javascript array, a java array or java.util.Collection
|
2013-02-17 23:29:41 +01:00
|
|
|
* callback : The function to be called to process each item in the
|
|
|
|
array. The callback function should have the following signature
|
|
|
|
`callback(item, index, object, array)`. That is the callback will
|
|
|
|
be called with the following parameters....
|
|
|
|
|
|
|
|
- item : The item in the array
|
|
|
|
- index : The index at which the item can be found in the array.
|
|
|
|
- object : Additional (optional) information passed into the foreach method.
|
|
|
|
- array : The entire array.
|
|
|
|
|
2014-01-29 20:49:15 +01:00
|
|
|
* context (optional) : An object which may be used by the callback.
|
2013-02-17 23:29:41 +01:00
|
|
|
* delay (optional, numeric) : If a delay is specified (in ticks - 20
|
|
|
|
ticks = 1 second), then the processing will be scheduled so that
|
|
|
|
each item will be processed in turn with a delay between the completion of each
|
|
|
|
item and the start of the next. This is recommended for big builds (say 200 x 200 x 200
|
|
|
|
blocks) or any CPU-intensive process.
|
|
|
|
* onDone (optional, function) : A function to be executed when all processing
|
|
|
|
is complete. This parameter is only used when the processing is delayed. (It's optional even if a
|
|
|
|
delay parameter is supplied).
|
|
|
|
|
|
|
|
If called with a delay parameter then foreach() will return
|
|
|
|
immediately after processing just the first item in the array (all
|
|
|
|
subsequent items are processed later). If your code relies on the
|
|
|
|
completion of the array processing, then provide an `onDone` parameter
|
|
|
|
and put the code there.
|
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Example
|
|
|
|
|
2013-02-17 23:29:41 +01:00
|
|
|
The following example illustrates how to use foreach for immediate processing of an array...
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
var players = ['moe', 'larry', 'curly'];
|
|
|
|
utils.foreach (players, function(item){
|
|
|
|
server.getPlayer(item).sendMessage('Hi ' + item);
|
|
|
|
});
|
|
|
|
```
|
2013-08-03 14:50:06 +02:00
|
|
|
|
|
|
|
... The `utils.foreach()` function can work with Arrays or any Java-style collection. This is important
|
|
|
|
because many objects in the Bukkit API use Java-style collections...
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
utils.foreach( server.onlinePlayers, function(player){
|
|
|
|
player.chat('Hello!');
|
|
|
|
});
|
|
|
|
```
|
2013-08-03 14:50:06 +02:00
|
|
|
|
2013-12-31 19:21:40 +01:00
|
|
|
... the above code sends a 'Hello!' to every online player.
|
2013-08-03 14:50:06 +02:00
|
|
|
|
2013-02-17 23:29:41 +01:00
|
|
|
The following example is a more complex use case - The need to build an enormous structure
|
|
|
|
without hogging CPU usage...
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
// build a structure 200 wide x 200 tall x 200 long
|
|
|
|
// (That's 8 Million Blocks - enough to tax any machine!)
|
|
|
|
var utils = require('utils');
|
|
|
|
|
|
|
|
var a = [];
|
|
|
|
a.length = 200;
|
|
|
|
var drone = new Drone();
|
|
|
|
var processItem = function(item, index, object, array){
|
|
|
|
// build a box 200 wide by 200 long then move up
|
|
|
|
drone.box(blocks.wood, 200, 1, 200).up();
|
|
|
|
};
|
|
|
|
// by the time the job's done 'self' might be someone else
|
|
|
|
// assume this code is within a function/closure
|
|
|
|
var player = self;
|
|
|
|
var onDone = function(){
|
|
|
|
player.sendMessage('Job Done!');
|
|
|
|
};
|
|
|
|
utils.foreach (a, processItem, null, 10, onDone);
|
|
|
|
```
|
2013-02-17 23:29:41 +01:00
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
var _foreach = function( array, callback, context, delay, onCompletion ) {
|
|
|
|
if ( array instanceof java.util.Collection ) {
|
|
|
|
array = array.toArray();
|
|
|
|
}
|
|
|
|
var i = 0;
|
|
|
|
var len = array.length;
|
|
|
|
if ( delay ) {
|
|
|
|
var next = function( ) {
|
|
|
|
callback(array[i], i, context, array);
|
|
|
|
i++;
|
|
|
|
};
|
|
|
|
var hasNext = function( ) {
|
|
|
|
return i < len;
|
|
|
|
};
|
|
|
|
_nicely( next, hasNext, onCompletion, delay );
|
|
|
|
} else {
|
|
|
|
for ( ;i < len; i++ ) {
|
|
|
|
callback( array[i], i, context, array );
|
2013-12-24 01:17:33 +01:00
|
|
|
}
|
2014-01-29 20:49:15 +01:00
|
|
|
}
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
|
|
|
exports.foreach = _foreach;
|
2013-02-17 23:29:41 +01:00
|
|
|
/************************************************************************
|
2013-12-28 09:44:40 +01:00
|
|
|
### utils.nicely() function
|
|
|
|
|
2013-02-17 23:29:41 +01:00
|
|
|
The utils.nicely() function is for performing processing using the
|
|
|
|
[org.bukkit.scheduler][sched] package/API. utils.nicely() lets you
|
|
|
|
process with a specified delay between the completion of each `next()`
|
|
|
|
function and the start of the next `next()` function.
|
|
|
|
`utils.nicely()` is a recursive function - that is - it calls itself
|
|
|
|
(schedules itself actually) repeatedly until `hasNext` returns false.
|
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Parameters
|
2013-02-17 23:29:41 +01:00
|
|
|
|
|
|
|
* next : A function which will be called if processing is to be done.
|
|
|
|
* hasNext : A function which is called to determine if the `next`
|
|
|
|
callback should be invoked. This should return a boolean value -
|
|
|
|
true if the `next` function should be called (processing is not
|
|
|
|
complete), false otherwise.
|
|
|
|
* onDone : A function which is to be called when all processing is complete (hasNext returned false).
|
|
|
|
* delay : The delay (in server ticks - 20 per second) between each call.
|
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Example
|
|
|
|
|
2013-02-17 23:29:41 +01:00
|
|
|
See the source code to utils.foreach for an example of how utils.nicely is used.
|
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
var _nicely = function( next, hasNext, onDone, delay ) {
|
|
|
|
if ( hasNext() ){
|
|
|
|
next();
|
|
|
|
server.scheduler.runTaskLater( __plugin, function() {
|
|
|
|
_nicely( next, hasNext, onDone, delay );
|
|
|
|
}, delay );
|
|
|
|
}else{
|
|
|
|
if ( onDone ) {
|
|
|
|
onDone();
|
2013-12-24 01:17:33 +01:00
|
|
|
}
|
2014-01-29 20:49:15 +01:00
|
|
|
}
|
2013-12-24 01:17:33 +01:00
|
|
|
};
|
2013-12-30 02:07:41 +01:00
|
|
|
exports.nicely = _nicely;
|
2013-08-03 14:14:09 +02:00
|
|
|
/************************************************************************
|
2013-12-28 09:44:40 +01:00
|
|
|
### utils.at() function
|
|
|
|
|
2013-08-03 14:14:09 +02:00
|
|
|
The utils.at() function will perform a given task at a given time every
|
|
|
|
(minecraft) day.
|
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Parameters
|
2013-08-03 14:14:09 +02:00
|
|
|
|
2013-12-31 19:21:40 +01:00
|
|
|
* time24hr : The time in 24hr form - e.g. 9:30 in the morning is '09:30' while
|
|
|
|
9:30 pm is '21:30', midnight is '00:00' and midday is '12:00'
|
2013-08-03 14:14:09 +02:00
|
|
|
* callback : A javascript function which will be invoked at the given time.
|
2013-12-30 02:07:41 +01:00
|
|
|
* worlds : (optional) An array of worlds. Each world has its own clock. If no array of worlds is specified, all the server's worlds are used.
|
2013-08-03 14:14:09 +02:00
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
#### Example
|
2013-08-03 14:14:09 +02:00
|
|
|
|
|
|
|
To warn players when night is approaching...
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
2013-12-24 01:17:33 +01:00
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
utils.at( '19:00', function() {
|
2013-08-08 09:02:27 +02:00
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
utils.foreach( server.onlinePlayers, function( player ) {
|
2014-01-29 20:49:15 +01:00
|
|
|
player.chat( 'The night is dark and full of terrors!' );
|
2013-12-30 02:07:41 +01:00
|
|
|
});
|
2014-02-04 22:36:00 +01:00
|
|
|
|
|
|
|
});
|
|
|
|
```
|
2013-08-03 14:14:09 +02:00
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
exports.at = function( time24hr, callback, worlds ) {
|
|
|
|
var forever = function(){ return true; };
|
|
|
|
var timeParts = time24hr.split( ':' );
|
|
|
|
var hrs = ( (timeParts[0] * 1000) + 18000 ) % 24000;
|
|
|
|
var mins;
|
|
|
|
if ( timeParts.length > 1 ) {
|
|
|
|
mins = ( timeParts[1] / 60 ) * 1000;
|
|
|
|
}
|
|
|
|
var timeMc = hrs + mins;
|
|
|
|
if ( typeof worlds == 'undefined' ) {
|
|
|
|
worlds = server.worlds;
|
|
|
|
}
|
|
|
|
_nicely( function() {
|
|
|
|
_foreach( worlds, function ( world ) {
|
|
|
|
var time = world.getTime();
|
|
|
|
var diff = timeMc - time;
|
|
|
|
if ( diff > 0 && diff < 100 ) {
|
|
|
|
callback();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}, forever, null, 100 );
|
2013-02-10 18:53:08 +01:00
|
|
|
};
|
2013-12-24 01:17:33 +01:00
|
|
|
|
2013-12-28 09:44:40 +01:00
|
|
|
/************************************************************************
|
|
|
|
### utils.find() function
|
|
|
|
|
|
|
|
The utils.find() function will return a list of all files starting at
|
|
|
|
a given directory and recursiving trawling all sub-directories.
|
|
|
|
|
|
|
|
#### Parameters
|
|
|
|
|
|
|
|
* dir : The starting path. Must be a string.
|
|
|
|
* filter : (optional) A [FilenameFilter][fnfltr] object to return only files matching a given pattern.
|
|
|
|
|
|
|
|
[fnfltr]: http://docs.oracle.com/javase/6/docs/api/java/io/FilenameFilter.html
|
|
|
|
|
|
|
|
#### Example
|
|
|
|
|
2014-02-04 22:36:00 +01:00
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
var jsFiles = utils.find('./', function(dir,name){
|
|
|
|
return name.match(/\.js$/);
|
|
|
|
});
|
|
|
|
```
|
2013-12-28 09:44:40 +01:00
|
|
|
|
|
|
|
***/
|
2014-01-29 20:49:15 +01:00
|
|
|
exports.find = function( dir , filter ) {
|
|
|
|
var result = [];
|
|
|
|
var recurse = function( dir, store ) {
|
2014-02-11 22:10:56 +01:00
|
|
|
var files, dirfile = new File( dir );
|
2014-01-29 20:49:15 +01:00
|
|
|
|
|
|
|
if ( typeof filter == 'undefined' ) {
|
|
|
|
files = dirfile.list();
|
|
|
|
} else {
|
|
|
|
files = dirfile.list(filter);
|
2013-12-24 01:17:33 +01:00
|
|
|
}
|
2014-01-29 20:49:15 +01:00
|
|
|
_foreach( files, function( file ) {
|
|
|
|
file = new java.io.File( dir + '/' + file );
|
|
|
|
if ( file.isDirectory() ) {
|
|
|
|
recurse( file.canonicalPath, store );
|
|
|
|
} else {
|
|
|
|
store.push( file.canonicalPath );
|
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
recurse( dir, result );
|
|
|
|
return result;
|
|
|
|
};
|
2014-02-10 21:55:32 +01:00
|
|
|
/************************************************************************
|
|
|
|
### utils.serverAddress() function
|
|
|
|
|
|
|
|
The utils.serverAddress() function returns the IP(v4) address of the server.
|
|
|
|
|
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
var serverAddress = utils.serverAddress();
|
|
|
|
console.log(serverAddress);
|
|
|
|
```
|
|
|
|
***/
|
|
|
|
exports.serverAddress = function() {
|
|
|
|
var interfaces = java.net.NetworkInterface.getNetworkInterfaces();
|
|
|
|
var current,
|
|
|
|
addresses,
|
|
|
|
current_addr;
|
|
|
|
while ( interfaces.hasMoreElements() ) {
|
|
|
|
current = interfaces.nextElement();
|
|
|
|
if ( ! current.isUp() || current.isLoopback() || current.isVirtual() ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
addresses = current.getInetAddresses();
|
|
|
|
while (addresses.hasMoreElements()) {
|
|
|
|
current_addr = addresses.nextElement();
|
|
|
|
if ( current_addr.isLoopbackAddress() )
|
|
|
|
continue;
|
|
|
|
if ( current_addr instanceof java.net.Inet4Address)
|
|
|
|
return current_addr.getHostAddress();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
/************************************************************************
|
|
|
|
### utils.watchFile() function
|
|
|
|
|
|
|
|
Watches for changes to the given file or directory and calls the function provided
|
|
|
|
when the file changes.
|
|
|
|
|
|
|
|
#### Parameters
|
|
|
|
|
|
|
|
* File - the file to watch (can be a file or directory)
|
|
|
|
* Callback - The callback to invoke when the file has changed. The callback takes the
|
|
|
|
changed file as a parameter.
|
|
|
|
|
|
|
|
#### Example
|
|
|
|
|
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
utils.watchFile( 'test.txt', function( file ) {
|
|
|
|
console.log( file + ' has changed');
|
|
|
|
});
|
|
|
|
```
|
|
|
|
***/
|
|
|
|
var filesWatched = {};
|
|
|
|
exports.watchFile = function( file, callback ) {
|
|
|
|
if ( typeof file == 'string' ) {
|
|
|
|
file = new File(file);
|
|
|
|
}
|
|
|
|
filesWatched[file.canonicalPath] = {
|
|
|
|
callback: callback,
|
|
|
|
lastModified: file.lastModified()
|
|
|
|
};
|
|
|
|
};
|
2014-02-11 22:10:56 +01:00
|
|
|
/************************************************************************
|
|
|
|
### utils.unwatchFile() function
|
|
|
|
|
|
|
|
Removes a file from the watch list.
|
|
|
|
|
|
|
|
#### Example
|
|
|
|
```javascript
|
|
|
|
var utils = require('utils');
|
|
|
|
utils.unwatchFile( 'test.txt');
|
|
|
|
```
|
|
|
|
|
|
|
|
***/
|
|
|
|
exports.unwatchFile = function( file, callback ) {
|
|
|
|
if ( typeof file == 'string' ) {
|
|
|
|
file = new File(file);
|
|
|
|
}
|
|
|
|
delete filesWatched[file.canonicalPath];
|
|
|
|
};
|
|
|
|
|
2014-02-10 21:55:32 +01:00
|
|
|
function fileWatcher() {
|
|
|
|
for (var file in filesWatched) {
|
|
|
|
var fileObject = new File(file);
|
|
|
|
var lm = fileObject.lastModified();
|
|
|
|
if ( lm != filesWatched[file].lastModified ) {
|
|
|
|
filesWatched[file].lastModified = lm;
|
|
|
|
filesWatched[file].callback(fileObject);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setTimeout( fileWatcher, 5000 );
|
|
|
|
};
|
|
|
|
setTimeout( fileWatcher, 5000 );
|