Jaxer

How do I use Jaxer.Dir.grep and Jaxer.Dir.map

A recent addition to the Jaxer IO capabilities are the grep/map methods, lets look at some use cases to explain the powerful functionality these provide to the developer.

The signature of the grep method looks like the following

The path parameter is a directory path to the folder you want to search.

The options parameter is a Javascript Object that contains some required properties.

The supported properties are pattern, flags and recursive.
pattern is a string value representing a javascript regular expression,
flags contains any regexp flags you want to provide to govern the behavour of the regular expression provided by the pattern parameter,
recursive is used to indicate whether the search should also scan sub folders.

Let's look at some examples of this in practice.

consider the following folder structure

c:\rootFolder
----foo.txt
----bar.txt
----subFolder1
--------foo1.txt
--------foo2.txt
--------foo3.html (1)
--------ignore.html
----subFolder2
--------a.js
--------b.js
--------c.js
----subFolder3
-------subFolder3a
------------deepFOO1.txt (2)
------------deepFOO2.txt

example paths

(1) c:\rootFolder\subFolder1\foo3.html

(2) c:\rootFolder\subFolder3\subFolder3a\deepFOO1.txt

Jaxer.Dir.grep

So given the example folder structure we can use the simplest form of the grep method specifying only the folder to search in.

which returns an array of file objects representing these files :-

c:\rootFolder\bar.txt
c:\rootFolder\foo.txt

Note that is only files in the specified folder that are returned and no subfolder searching is attempted

The next example provides a pattern parameter that matches a single file in the top level folder.

this returns an array containing a single file object representing :-

c:\rootFolder\foo.txt

Now we add the recursive property to the invocation

and this returns an array of file objects that includes matches from the scanned subfolders :-

c:\rootFolder\foo.txt
c:\rootFolder\subFolder1\foo1.txt,
c:\rootFolder\subFolder1\foo2.txt
c:\rootFolder\subFolder1\foo3.html

Next we add a flag property to the options object to include case insensitive results.

which returns an array of file objects including some containing 'FOO' :-

c:\rootFolder\foo.txt,
c:\rootFolder\subFolder1\foo1.txt
c:\rootFolder\subFolder1\foo2.txt
c:\rootFolder\subFolder1\foo3.html
c:\rootFolder\subFolder3\subFolder3a\deepFOO1.txt
c:\rootFolder\subFolder3\subFolder3a\deepFOO2.txt

You can also provide a string containing the folder path and use an object literal for your options parameter

which returns an array of file objects :-

c:\rootFolder\subFolder1\foo1.txt
c:\rootFolder\subFolder1\foo2.txt
c:\rootFolder\subFolder3\subFolder3a\deepFOO1.txt
c:\rootFolder\subFolder3\subFolder3a\deepFOO2.txt

OK, so you get the idea, you can provide an fairly complex query and get a result set of matched values in an array, and you can do it without a whole lot of scaffolding code to navigate the folder tree.

Jaxer.Dir.map

Taking Jaxer.Dir.grep as a given we can now look at the Jaxer.Dir.Map functionality, this has a signature that is extended from the grep method and adds a third parameter of a function to invoke on each matched file object.

The function can be declared inline or externally and if omitted the map method will behave exactly like the grep method and return an array of Jaxer.File objects.

Let's look at some examples.

will write a log entry out for each of the matched files and return an array of matched Jaxer.File objects

13:55:19 02/20/2008 [  2356] [INFO] [JS Framework] [framework.] c:\rootFolder\subFolder1\foo1.txt
13:55:19 02/20/2008 [  2356] [INFO] [JS Framework] [framework.] c:\rootFolder\subFolder1\foo2.txt
13:55:19 02/20/2008 [  2356] [INFO] [JS Framework] [framework.] c:\rootFolder\subFolder3\subFolder3a\deepFOO1.txt
13:55:19 02/20/2008 [  2356] [INFO] [JS Framework] [framework.] c:\rootFolder\subFolder3\subFolder3a\deepFOO2.txt

The important point to note here is that the function is defined to expect a parameter containing the matching file object being handled

this code could be rewritten as

A more complex example using a decorator function to format the results of the matches

which outputs the following to the log.

15:43:05 02/20/2008 [framework.] foo1.txt|0|txt|Tue Feb 19 2008 19:15:04 GMT-0800 (Pacific Standard Time)|c:\rootFolder\subFolder1
15:43:05 02/20/2008 [framework.] foo2.txt|0|txt|Tue Feb 19 2008 19:15:04 GMT-0800 (Pacific Standard Time)|c:\rootFolder\subFolder1
15:43:05 02/20/2008 [framework.] deepFOO1.txt|0|txt|Tue Feb 19 2008 19:15:04 GMT-0800 (Pacific Standard Time)|c:\rootFolder\subFolder3\subFolder3a
15:43:05 02/20/2008 [framework.] deepFOO2.txt|0|txt|Tue Feb 19 2008 19:15:04 GMT-0800 (Pacific Standard Time)|c:\rootFolder\subFolder3\subFolder3a

So as you can see the grep and map methods of the Jaxer.Dir namespace provide you with an excellent utility knife to deal with accessing objects on the file system

One final note, as these kind of searches can take some time depending on the depth of the nested searching, care needs to be taken when invoking through a callback to ensure that a timeout doesn't occur.

TwitJax - Jaxer, Twitter, Javascript 1.8 and E4X

This sample application demonstrates using some of the advanced Javascript language features available out of the box with Jaxer.

We show how to use the ECMASCRIPT for XML additions to Javascript to pull an XML feed of the latest public twit list remotely and reprocess it inside Jaxer using server-side Javascript.

fileGrep - Jaxer Filesystem Access Sample

This sample application demonstrates some of the filesystem access capabilities of the Jaxer Javascript framework.

You can download a zip of the sample here.

1 attachment

Running Jaxer with MySQL

Changing the Database Configuration Settings

To run Jaxer with the mysql database it is just a matter of making a very simple change, to a single file
<INSTALL FOLDER>/local_jaxer/config.js

As shipped this file contains a set of common configuration overrides, but they are all commented out. The file is a simple JS function that updates a set of property values on the Config object. The source for this file is shown below

uncomment lines 33-43 if you only want to use MYSQL for your application data

uncomment lines 44-54 if you only want to use MYSQL for the jaxer server metadata

uncomment lines 33-54 if you want to use MYSQL for both application data and server metadata

Once you have uncommented the lines you need to provide the connection parameters for your MYSQL instance.

The Config.DB_CONNECTION_PARAMS / Config.DB_FRAMEWORK_CONNECTION_PARAMS objects have properties for

HOST : the ip address or uri for the server
PORT : the port the server is running on (typically 3306 for MYSQL)
NAME : the name of the database to use
USER : user name
PASS : password

Set these value to match your database. Then restart Jaxer to load the changes, your Jaxer instance will now be running with MYSQL

After the changes the config file will look something like this.

/* 
 * Use this file to override the default configuration settings.
 * This file is read right after the default config.js is read
 * but before anything else is done, so you can override anything you need.
 * Since these only gets read at server startup, you'll need to restart Jaxer
 * after modifying this file for those modifications to have an effect.
 */
(function(){

// Use the following to override where some of your local overrides are located:
//	Config.LOCAL_CONFIG_LOG = 		"../local_jaxer/conf/configLog.js";
//	Config.LOCAL_CONFIG_ROUTES = 	"../local_jaxer/conf/configRoutes.js";
//	Config.LOCAL_EXTENSIONS_DIR = 	"../local_jaxer/extensions";
	
	// Use the following to override some of the default error-handling settings:
//	Config.UNCAUGHT_ERRORS_ARE_RESPONSE_ERRORS = true;
//	Config.INCLUDE_ERRORS_ARE_RESPONSE_ERRORS = true;
//	Config.RESPONSE_ERROR_PAGE = "resource:///content/responseError.html"; 
//	Config.FATAL_ERROR_PAGE = "resource:///content/fatalError.html";
//	Config.CALLBACK_ERROR_MESSAGE = "Error on server during callback - further information has been logged";
//	Config.CALLBACK_FATAL_ERROR_MESSAGE = "Callback could not be processed due to server error - further information has been logged";
//	Config.DISPLAY_ERRORS = true; // set to true only in development/debug stage: some error messages may be displayed within the served page or in callbacks
//	Config.ALERT_CALLBACK_ERRORS = true; // whether to popup a window.alert(...) when a callback returns an error
	
	// To include scripts and access files and so on, Jaxer may need to get that content from the web server.
	// If your web server needs to be reached via a different domain/port than the incoming request,
	// uncomment and change the following to replace the protocol://domain:port with this value
//	Config.REWRITE_RELATIVE_URL = "http://192.168.0.1:8082"; // If your web server is reachable at IP 192.168.0.1 on port 8082
//	Config.REWRITE_RELATIVE_URL_REGEX = "^http\\:\\/\\/my.domain.com"; // Optional -- if e.g. you only want to replace URLs that start with this

// To have Jaxer use MySQL rather than SQLite, for its own needs or your applications or both,
	// use settings similar to the following:
	Config.DB_IMPLEMENTATION = "MySQL";
	Config.DB_CONNECTION_PARAMS =
	{
		HOST: "127.0.0.1",
		PORT: 4417,        // This uses a port different than the default of 3306, to minimize conflicts with existing installs
		NAME: "myApplicationDB",
		USER: "root",
		PASS: "",
		CLOSE_AFTER_EXECUTE: false,
		CLOSE_AFTER_REQUEST: true
	};
	Config.DB_FRAMEWORK_IMPLEMENTATION = "MySQL";
	Config.DB_FRAMEWORK_CONNECTION_PARAMS =
	{
		HOST: "127.0.0.1",
		PORT: 4417,        // This uses a port different than the default of 3306, to minimize conflicts with existing installs
		NAME: "jaxerFrameworkDB",
		USER: "root",
		PASS: "",
		CLOSE_AFTER_EXECUTE: false,
		CLOSE_AFTER_REQUEST: true
	};

// To embed the client part of the Jaxer framework in the web page, 
	// specify its location in EMBEDDED_CLIENT_FRAMEWORK_SRC
	// Alternatively, to have the web server serve its contents, 
	// 1) comment out EMBEDDED_CLIENT_FRAMEWORK_SRC,
	// 2) copy the client framework to somewhere the web server can reach it, and
	// 3) use CLIENT_FRAMEWORK_SRC to specify the src of the <SCRIPT> element that will be inserted into the page
//	Config.EMBEDDED_CLIENT_FRAMEWORK_SRC = "resource:///framework/clientFramework_compressed.js";
//	// Config.CLIENT_FRAMEWORK_SRC = "/aptana/clientFramework.js";
	
	// If you are modifying the Jaxer framework, you may want to use the modified copy, so you
	// can quickly test out your modifications. Here's how (replace <...> with the right values:
//	var depotDir = "file:///C:/Documents and Settings/<username>/My Documents/Aptana Studio/<framework_project>";
//	var depotConfigPath = depotDir + "/config.js";
//	// Get the latest config settings from the local depot copy, not the install directory
//	Jaxer.include(depotConfigPath);
//	// But the depot's config will point back to the install directory, so override that explicitly
//	Config.FRAMEWORK_DIR = depotDir;

})();

Creating a Connection to a MySQL db.

For many applications you wont want to use the built-in jaxer DB instance definitions and will require a dedicated connection to another instance or perhaps a separate database on the same instance.

The code below is an example of how to create and use a connection to a database.

/*
 * The following example shows how to connect to MySQL DB and how to run a query against it
 */

// First we need to create a connection object
 	var myConnection = new Jaxer.DB.MySQL.Connection({
    	'HOST': 'localhost',
    	'PORT': 3306,
    	'USER': 'root',
    	'PASS': 'mySQL',
    	'NAME': 'users',
    	'CLOSE_AFTER_EXECUTE': false //this parameter is optional, default value is false
	});
	
// define a query and execute
	var query = "select * from table_name";
	var queryResult = myConnection.execute(query);
	
// query result is an object type of Jaxer.DB.ResultSet

/*
 * The following example demonstrates how to extract data from Jaxer.DB.ResultSet object
 * based on the given columns
 * 
 */

//Let's assume we have a table in the database, which contains user information, i.e. first
//and last names, SSN, DOB, address and so on. 
  
//Using sample that describes how to connect to DB and run query against it, let's run
//the follwing query

var myQueryResultSet = myConnection.execute("SELECT * FROM users");

//Result of the query is stored in object myQueryResultSet, which is type of Jaxer.DB.ResultSet
//Now we need to extract data based on the given columns, for instance, first and last names.
//In order to do so, we need to build an array of columns to be extracted, which will be used
//as an input parameter for extractColumns() method

var columnsToExtract = ["FirstName", "LastName"];
 
//In this array, each element is the column name, for which we want to extract data
//If you need to extract data for all columns ycan get array of the columns using following 
//propery:
//var tableColumns = myQueryResultSet.columns;
//Now we can call extractColumns() method

var extractedColumnsData = myQueryResultSet.extractColumns(columnsToExtract);

//The return value of this method is an array of objects, one per row, that only have properties 
//corresponding to the given columns.
//Here is how we can access specific cell from returned array

//var cellValue = extractedColumnsData[<nRow>].<colName>

//where nRow is a row number and colName is name of the column
//So if I need to get first and last names from first row than here is what I need to do

var fName = extractedColumnsData[0].FirstName;
 var lName = extractedColumnsData[0].LastName;
 
 // print values to the log file
 Jaxer.Log.info("First Name is: " + fName);
 Jaxer.Log.info("Last Name is: " + lName);