Author: Joshua

Cookies

April 14, 2015 by Joshua·0 Comments

In Liten, you can set regular cookies or secure cookies which are saved in a secure location on the server.

Cookie Settings

When instantiating a Liten application, you can set the cookie lifetime and/or you can set cookie lifetime via the set cookie or set secure cookie methods.

There are several settings you can set for regular and secure cookies:

$app = new \Liten\Liten([
    'cookies.lifetime'      => '1440',
    'cookies.path'          => '/',
    'cookies.domain'        => null,
    'cookies.secure'        => false,
    'cookies.httponly'      => false,
    // Secure Cookies
    'cookies.crypt'         => 'sha256',
    'cookies.secret.key'    => 'CHANGE_ME',
    'cookies.savepath'      => '/tmp/'
]);

$app = new \Liten\Liten([

'cookies.lifetime' => '1440',

'cookies.path' => '/',

'cookies.domain' => null,

'cookies.secure' => false,

'cookies.httponly' => false,

// Secure Cookies

'cookies.crypt' => 'sha256',

'cookies.secret.key' => 'CHANGE_ME',

'cookies.savepath' => '/tmp/'

]);

Note that the default path setting for secure cookies is the /tmp/ directory. If your server gets rebooted for some reason on a regular basis, you might want to change this setting. Just make sure that it is set below the root directory and is inaccessible to the public.

Regular Cookie

In order to set a regular cookie, use the set method:

$app->cookies->set($key, $value, $expires = null)

1	$app->cookies->set($key, $value, $expires = null)

The $expires value is the number of seconds.

To retrieve a regular cookie, use the get method:

$app->cookies->get($key)

1	$app->cookies->get($key)

In order to unset a regular or secure cookie, use the remove method:

$app->cookies->remove($key)

1	$app->cookies->remove($key)

Secure Cookie

Secure cookies are similar to sessions in that the cookie value is a string which corresponds to a file saved on the server. Also, just like sessions, the cookie file could be deleted when the server is rebooted. However, unlike sessions, you won’t have old cookie files sitting on the server taking up space. If they have expired, they will be deleted.

A secured cookie file may look like the following:

cookies.0c967426894f0fbff47273f150a81fcd3fb649f1fae269314a06a838642c54dd

1	cookies.0c967426894f0fbff47273f150a81fcd3fb649f1fae269314a06a838642c54dd

The data in the cookie file is serialized and below is an example of the serialized data:

a:2:{s:10:"auth_token";s:1:"1";s:3:"exp";i:1429147738;}

1	a:2:{s:10:"auth_token";s:1:"1";s:3:"exp";i:1429147738;}

Object Relational Mapping

March 30, 2015 by Joshua·0 Comments

With object relational mapping, you don’t have to know structured query language (SQL) in order to write database queries. Liten and the ORM helps facilitate simple and rapid development and also allows both fluent sql queries as well as CRUD operations.

ORM

Instantiate

To create a new database connection, we need to instantiate the ORM class. Throughout the rest of the docs, we will use the variable $orm for the database connection.

$pdo = new \PDO("mysql:host=localhost;dbname=$dbname", $username, $password);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$orm = new \Liten\Orm($pdo);

$pdo = new \PDO("mysql:host=localhost;dbname=$dbname", $username, $password);

$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$orm = new \Liten\Orm($pdo);

Table

Connect to a database table by calling the table() method.

$posts = $orm->table('posts');

1	$posts = $orm->table('posts');

An alternative to above is calling the database table as a method.

$posts = $orm->posts();

1	$posts = $orm->posts();

Insert

When calling the insert(array $data) method, $data can be passed as one dimensional array to insert one new record or multiple arrays to insert multiple records.

Single entry:

$post = $posts->insert([
                "title" => "Liden Framework",
                "content" => "The Liden framework is small, simple, restful.", 
                "authorID" => 1,
                "timestamp" => $orm->NOW()
            ]);

$post = $posts->insert([

"title" => "Liden Framework",

"content" => "The Liden framework is small, simple, restful.",

"authorID" => 1,

"timestamp" => $orm->NOW()

]);

Multiple entries:

$massPosts = $posts->insert([
                    [
                         "title" => "Micro Frameworks",
                         "content" => "Micro frameworks started...",
                         "authorID" => 1,
                         "timestamp" => $orm->NOW()
                    ],
                    [
                         "title" => "PHP 5.6",
                         "content" => "The new features in 5.6 are...",
                         "authorID" => 1,
                         "timestamp" => $orm->NOW()
                    ],
                    [
                         "title" => "RESTful API's",
                         "content" => "Building restful api's...",
                         "authorID" => 1,
                         "timestamp" => $orm->NOW()
                    ],
                ]);

$massPosts = $posts->insert([

[

"title" => "Micro Frameworks",

"content" => "Micro frameworks started...",

"authorID" => 1,

"timestamp" => $orm->NOW()

[

"title" => "PHP 5.6",

"content" => "The new features in 5.6 are...",

"authorID" => 1,

"timestamp" => $orm->NOW()

[

"title" => "RESTful API's",

"content" => "Building restful api's...",

"authorID" => 1,

"timestamp" => $orm->NOW()

]);

Update

There are two ways to update a record, by using the active record pattern or by or by using the where clause.

Single entry:

$post->update([
                    "title" => "PHP 6.0"
                ]);

$post->update([

"title" => "PHP 6.0"

]);

The above can also be written as:

$post->title = "PHP 6.0";
$post->update();

1 2	$post->title = "PHP 6.0"; $post->update();

You can use the alternative save() instead of update().

Or you can use the set(array $data) or set($key, $value)

$post->set('title','PHP 6.0')->update();

1	$post->set('title','PHP 6.0')->update();

For multiple entries using set(array $data) and where($key, $value).

$post->set([
             "content" => "PHP 6.0 is the greatest because..."
        ])
        ->where("title", "PHP 6.0")
        ->update();

$post->set([

"content" => "PHP 6.0 is the greatest because..."

])

->where("title", "PHP 6.0")

->update();

Save

Save() is a shortcut to insert() or update().

Insert:

$post = $orm->posts();
$post->title = "PHP 6.0";
$post->content = "PHP 6.0 is the greatest because...";
$post->save();

$post = $orm->posts();

$post->title = "PHP 6.0";

$post->content = "PHP 6.0 is the greatest because...";

$post->save();

Update:

$post = $posts->findOne(3847);
$post->title = "PHP 6.0 Update";
$post->save();

$post = $posts->findOne(3847);

$post->title = "PHP 6.0 Update";

$post->save();

Delete

Single entry:

$post = $posts->reset()->findOne(3847);
$post->delete();

1 2	$post = $posts->reset()->findOne(3847); $post->delete();

Multiple entries:

$posts->where("title", "PHP 6.0")->delete();

1	$posts->where("title", "PHP 6.0")->delete();

Count

Count all the entries based on where() clause.

$allPosts = $posts->count();

$count = $posts->where($x, $y)->count();

$allPosts = $posts->count();

$count = $posts->where($x, $y)->count();

Use count for a specific column name.

$count = $posts->where($x, $y)->count($columnName);

1	$count = $posts->where($x, $y)->count($columnName);

Max

Max based on where() clause.

$max = $posts->where($x, $y)->max($columnName);

1	$max = $posts->where($x, $y)->max($columnName);

Min

Min based on where() clause.

$min = $posts->where($x, $y)->min($columnName);

1	$min = $posts->where($x, $y)->min($columnName);

Sum

Sum based on where() clause.

$sum = $posts->where($x, $y)->sum($columnName);

1	$sum = $posts->where($x, $y)->sum($columnName);

Avg

Average based on where clause.

$avg = $posts->where($x, $y)->avg($columnName);

1	$avg = $posts->where($x, $y)->avg($columnName);

Aggregate

$agg = $posts->where($x, $y)->aggregate('GROUP_CONCAT $columnName');

1	$agg = $posts->where($x, $y)->aggregate('GROUP_CONCAT $columnName');

Querying

The fluent query feature of the ORM allows you to write simple queries without having to write SQL.

FindOne

Returns a single record is found otherwise it will return false.

$post = $posts->where('postID', 364)
              ->findOne();

1 2	$post = $posts->where('postID', 364) ->findOne();

You can achieve the same above by using only the primary key and dropping the where clause.

$post = $posts->findOne(364);

1	$post = $posts->findOne(364);

Retrieving the entry

if ($post) {
    echo " $post->title";

// On a retrieved entry you can perform update and delete
    $post->last_viewed = $posts->NOW();
    $post->save();
}

if ($post) {

echo " $post->title";

// On a retrieved entry you can perform update and delete

$post->last_viewed = $posts->NOW();

$post->save();

}

Find

Find returns and ArrayIterator of rows found, otherwise it will return false.

$allPosts = $posts->where('title', 'PHP 6.0')
                  ->find();

foreach ($allPosts as $post) {
    echo "{$post->content}";

// On a retrieved entry you can perform update and delete
    $post->last_viewed = $posts->NOW();
    $post->save();
}

$allPosts = $posts->where('title', 'PHP 6.0')

->find();

foreach ($allPosts as $post) {

echo "{$post->content}";

// On a retrieved entry you can perform update and delete

$post->last_viewed = $posts->NOW();

$post->save();

}

Find also accepts a closure ( find(Closure $callback) ) to perform data manipulation.

    $posts->where('title', 'PHP 6.0');

    $results = $posts->find(function($data){
        $newResults = array();

        foreach ($data as $d) {
            $d["new_title"] = "{$data["title"]}";
            $newResults[] = $d;
        }

        return $newResults;
    });

$posts->where('title', 'PHP 6.0');

$results = $posts->find(function($data){

$newResults = array();

foreach ($data as $d) {

$d["new_title"] = "{$data["title"]}";

$newResults[] = $d;

}

return $newResults;

});

Fluent Query Builder

Select

Select all:

$posts->select()

1	$posts->select()

Select columns:

$posts->select("title, content")
      ->select("last_viewed");

1 2	$posts->select("title, content") ->select("last_viewed");

Where

Where can be used to setup the where clauses and they work with find(), findOne(), update(), and delete(). This is the same for the where aliases as well.Repetitive call to where and it’s aliases will append to each other using the AND operator. Use _or() to mimic the OR operator.

Examples:

$posts->where("title", "PHP 6.0");

$posts->where("authorID > ?", 25);

$posts->where("name in (?, ?, ?)", "PHP 6.0", "HTML 5", "ROR");

$posts->where("(field1, field2)", array(array(1, 2), array(3, 4)))

$posts->where("title", "PHP 6.0");

$posts->where("authorID > ?", 25);

$posts->where("name in (?, ?, ?)", "PHP 6.0", "HTML 5", "ROR");

$posts->where("(field1, field2)", array(array(1, 2), array(3, 4)))

There where aliases can help shorten the where examples above.

Primary key:

$posts->wherePK(456)

1	$posts->wherePK(456)

Not equal to:

$posts->whereNot('postID', 24);

1	$posts->whereNot('postID', 24);

Like:

$posts->whereLike('title', 'PH%');

1	$posts->whereLike('title', 'PH%');

Not like:

$posts->whereNotLike('title', 'PH%');

1	$posts->whereNotLike('title', 'PH%');

Greater than:

$posts->whereGt('timestamp', 2014-09-14);

1	$posts->whereGt('timestamp', 2014-09-14);

Greater than equal to:

$posts->whereGte('timestamp', 2014-09-14);

1	$posts->whereGte('timestamp', 2014-09-14);

Less than:

$posts->whereLt('timestamp', 2014-09-14);

1	$posts->whereLt('timestamp', 2014-09-14);

Less than equal to:

$posts->whereLte('timestamp', 2014-09-14);

1	$posts->whereLte('timestamp', 2014-09-14);

Where in:

$posts->whereIn('authorID', array('2', '24'));

1	$posts->whereIn('authorID', array('2', '24'));

Where not in:

$posts->whereNotIn('authorID', array('2', '24'));

1	$posts->whereNotIn('authorID', array('2', '24'));

Where null:

$posts->whereNull('content');

1	$posts->whereNull('content');

Where not null:

$posts->whereNotNull('timestamp');

1	$posts->whereNotNull('timestamp');

Where with OR and AND

Use _and_() / _or_() chained to any where clauses.

_and_():

$posts->where("authorID", 24)->_and_()->whereGte("timestamp", 2014-09-14);

1	$posts->where("authorID", 24)->_and_()->whereGte("timestamp", 2014-09-14);

_or_:

$posts->where("authorID", 24)->_or_()->whereGte("authorID", 24)->_or_()->where("category", "Programming");

1	$posts->where("authorID", 24)->_or_()->whereGte("authorID", 24)->_or_()->where("category", "Programming");

Order, Group, Limit, Offset

$posts->orderBy('postID', 'DESC');

$posts->groupBy('category');

$posts->limit(10);

$posts->offset(10);

$posts->orderBy('postID', 'DESC');

$posts->groupBy('category');

$posts->limit(10);

$posts->offset(10);

Joins

/**
 * Defaults to LEFT JOIN, for others, use INNER, RIGHT, etc as the
 * $join_operator
 *
 * join( $tablename, $constraint, $table_alias , $join_operator )
 */

$posts->_join('category', 'c.catID = posts.catID', 'c')

/**

* Defaults to LEFT JOIN, for others, use INNER, RIGHT, etc as the

* $join_operator

* join( $tablename, $constraint, $table_alias , $join_operator )

$posts->_join('category', 'c.catID = posts.catID', 'c')

Status Messages

March 30, 2015 by Joshua·0 Comments

Status messages basically returns a cookie that was set when a particular action was successful or unsuccessful.

$app->flash('installerror', 'The application was unable to be installed.');

1	$app->flash('installerror', 'The application was unable to be installed.');

Middleware

March 30, 2015 by Joshua·0 Comments

With Liten, you can use before route middleware, before router middleware, and after router middleware. Below are a few code examples of each.

Before Route Middleware

$app->before('GET|POST', '/admin/.*', function() {
    if (!isset($_COOKIE['auth_token'])) {
        header('location: /auth/login');
        exit();
    }
});

$app->before('GET|POST', '/admin/.*', function() {

if (!isset($_COOKIE['auth_token'])) {

header('location: /auth/login');

exit();

}

});

Before Router Middleware

$app->before('GET', '/.*', function() {
    // ... this will always be executed no matter what the url is
});

$app->before('GET', '/.*', function() {

// ... this will always be executed no matter what the url is

});

After Router Middleware

$app->run(function() { … });

1	$app->run(function() { … });

Note: If the route handling function has exit()ed the run callback won’t be run.

View

March 30, 2015 by Joshua·0 Comments

When rendering a view using Liten’s view object, there are two parameters that can be passed to the display() method.

/**
 * $viewName is the file name minus .php
 * $data is an array that can be passed and then
 * manipulated in the view.

$app-view-display($viewName, $data = null);

/**

* $viewName is the file name minus .php

* $data is an array that can be passed and then

* manipulated in the view.

$app-view-display($viewName, $data = null);

Layouts

You can create a layout (template) that other files (children) can extend. The show() method displays a section of content defined by the child view extending it.

<html>
<head>
  <title><?=_h($title);?></title>
</head>
<body>
  <?=$show('content');?>
</body>
</html>

<html>

<head>

</head>

<body>

<?=$show('content');?>

</body>

</html>

Views

Create a view that extends the layout and provides content for the show() section in the layout.

<?php $app = \Liten\Liten::getInstance(); ?>
<?php $app->view->extend('_layouts/default'); ?>
<?php $app->view->block('content'); ?>

  <h1>Welcome, <?=_h($name);?></h1>

<?php $app->view->stop(); ?>

<?php $app = \Liten\Liten::getInstance(); ?>

<?php $app->view->extend('_layouts/default'); ?>

<?php $app->view->block('content'); ?>

<h1>Welcome, <?=_h($name);?></h1>

<?php $app->view->stop(); ?>

Partials

A somewhat alternative to default layouts is partial views which allows you to separate templates for headers and footers.

<?php $app = \Liten\Liten::getInstance(); ?>
<?php $app->view->partial('_layouts/header'); ?>

  <?php $app->view->block('content'); ?>
    <h1>Welcome, <?=_h($name);?></h1>
  <?php $app->view->stop(); ?>

<?php $app->view->partial('_layouts/footer'); ?>

<?php $app = \Liten\Liten::getInstance(); ?>

<?php $app->view->partial('_layouts/header'); ?>

<?php $app->view->block('content'); ?>

<h1>Welcome, <?=_h($name);?></h1>

<?php $app->view->stop(); ?>

<?php $app->view->partial('_layouts/footer'); ?>

Response

March 30, 2015 by Joshua·0 Comments

Liten sends true HTTP responses and returns a response back to the screen in json format.

	/**
	 * Returns data in the format specified
	 * (i.e. json, txt, html)
	 */
	
         _format($format, $content)

/**

* Returns data in the format specified

* (i.e. json, txt, html)

_format($format, $content)

Request

March 30, 2015 by Joshua·0 Comments

Request Method

Every HTTP request has a method (i.e. GET or POST). You can obtain the current HTTP request method via the below request objects:

/**
 * What is the request method?
 * @return string (e.g. GET, POST, PUT, DELETE)
 */
$app->req->getMethod();

/**
 * Is this a GET request?
 * @return bool
 */
$app->req->isGet();

/**
 * Is this a POST request?
 * @return bool
 */
$app->req->isPost();

/**
 * Is this a PUT request?
 * @return bool
 */
$app->req->isPut();

/**
 * Is this a DELETE request?
 * @return bool
 */
$app->req->isDelete();

/**
 * Is this a HEAD request?
 * @return bool
 */
$app->req->isHead();

/**
 * Is this a OPTIONS request?
 * @return bool
 */
$app->req->isOptions();

/**
 * Is this a PATCH request?
 * @return bool
 */
$app->req->isPatch();

/**
 * Get host
 * @return bool
 */
$app->req->getHost();

/**
 * Returns url based on protocol, route and prefix.
 */
$app->req->url_for($route,$prefix = null);

/**
 * Returns GET variable if set
 */
$app->req->_get($caller);

/**
 * Returns POST variable if set
 */
$app->req->_post($caller);

/**

* What is the request method?

* @return string (e.g. GET, POST, PUT, DELETE)

$app->req->getMethod();

/**

* Is this a GET request?

* @return bool

$app->req->isGet();

/**

* Is this a POST request?

* @return bool

$app->req->isPost();

/**

* Is this a PUT request?

* @return bool

$app->req->isPut();

/**

* Is this a DELETE request?

* @return bool

$app->req->isDelete();

/**

* Is this a HEAD request?

* @return bool

$app->req->isHead();

/**

* Is this a OPTIONS request?

* @return bool

$app->req->isOptions();

/**

* Is this a PATCH request?

* @return bool

$app->req->isPatch();

/**

* Get host

* @return bool

$app->req->getHost();

/**

* Returns url based on protocol, route and prefix.

$app->req->url_for($route,$prefix = null);

/**

* Returns GET variable if set

$app->req->_get($caller);

/**

* Returns POST variable if set

$app->req->_post($caller);

Routing

March 30, 2015 by Joshua·0 Comments

The routing feature of Liten, lets you map URI’s to HTTP request methods (GET, POST, PUT, DELETE, OPTIONS).

$app->match(method(s), pattern, function);

1	$app->match(method(s), pattern, function);

When a route matches, the attached route handling function will be executed. The route handling function must be a callable. Only the first route matched will be handled. When no matching route is found, an ‘HTTP/1.1 404 Not Found’ status code will be returned.

Shorthands for single request methods are provided:

$app->get('pattern', function() { … });

$app->post('pattern', function() { … });

$app->put('pattern', function() { … });

$app->delete('pattern', function() { … });

$app->options('pattern', function() { … });

$app->patch('pattern', function() { … });

$app->get('pattern', function() { … });

$app->post('pattern', function() { … });

$app->put('pattern', function() { … });

$app->delete('pattern', function() { … });

$app->options('pattern', function() { … });

$app->patch('pattern', function() { … });

There is also an alternative shorthand for request methods in the following format:

$app->route('HTTP Method', pattern, function);

1	$app->route('HTTP Method', pattern, function);

Here are some shorthand examples to above:

$app->route('GET', 'pattern', function() { … });

$app->route('POST', 'pattern', function() { … });

$app->route('PUT', 'pattern', function() { … });

$app->route('DELETE', 'pattern', function() { … });

$app->route('OPTIONS', 'pattern', function() { … });

$app->route('PATCH', 'pattern', function() { … });

$app->route('GET', 'pattern', function() { … });

$app->route('POST', 'pattern', function() { … });

$app->route('PUT', 'pattern', function() { … });

$app->route('DELETE', 'pattern', function() { … });

$app->route('OPTIONS', 'pattern', function() { … });

$app->route('PATCH', 'pattern', function() { … });

Another alternative to above is route matching. A particular code will run based on the HTTP Method sent.

$app->match('Piped Method', pattern, function);

1	$app->match('Piped Method', pattern, function);

Here is an example of using GET and POST.

$app->match('GET|POST', 'pattern', function() { … });

1	$app->match('GET\|POST', 'pattern', function() { … });

Note: Routes must be hooked before $app->run(); is being called.

Route Patterns

Route patterns can be static or dynamic.

Static Route Patterns are basic URIs, e.g. /about.
Dynamic Route Patterns are Perl-compatible regular expressions (PCRE) that resemble URIs, e.g. /api/(\d+)

Commonly used subpatterns within Dynamic Route Patterns are:

\d+ = One or more digits (0-9)
\w+ = One or more word characters (a-z 0-9 _)
[a-z0-9_-]+ = One or more word characters (a-z 0-9 _) and the dash (-)
.* = Any character (including /), zero or more
[^/]+ = Any character but /, one or more

Downloading the PHP PCRE Cheatsheet may come in handy.

Subpatterns must be parenthesized in order to work. See example below:

// Bad
$app->get('/hello/\w+', function($name) {
    echo 'Hello ' . _h($name);
});

// Good
$app->get('/hello/(\w+)', function($name) {
    echo 'Hello ' . _h($name);
});

// Bad

$app->get('/hello/\w+', function($name) {

echo 'Hello ' . _h($name);

});

// Good

$app->get('/hello/(\w+)', function($name) {

echo 'Hello ' . _h($name);

});

When multiple subpatterns are defined, the route handling parameters are interpreted in the order which they are defined.

$app->get('/posts/(\d+)/photos/(\d+)', function($postId, $photoId) {
    echo 'Post #' . $postId . ', photo #' . $photoId);
});

$app->get('/posts/(\d+)/photos/(\d+)', function($postId, $photoId) {

echo 'Post #' . $postId . ', photo #' . $photoId);

});

Subrouting / Grouping Routes

Use $app->group($baseroute, $fn) to group a collection of routes onto a subroute pattern. The subroute pattern is prefixed onto all following routes defined in the scope. e.g. Mounting a callback $fn onto /posts will prefix /posts onto all following routes.

Custom Error

$app->setError(function() {
    header('HTTP/1.1 404 Not Found');
    // ... do something special here
});

$app->setError(function() {

header('HTTP/1.1 404 Not Found');

// ... do something special here

});

Configuration

March 27, 2015 by Joshua·0 Comments

The configuration for Liten is easy, simple and you can follow the example in the main index.php application file.

System Requirements

PHP 5.4+

Rewrite Rules

.htaccess

RewriteEngine On

# Some hosts may require you to use the `RewriteBase` directive.
# If you need to use the `RewriteBase` directive, it should be the
# absolute physical path to the directory that contains this htaccess file.
#
# RewriteBase /

RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . index.php [L]

RewriteEngine On

# Some hosts may require you to use the `RewriteBase` directive.

# If you need to use the `RewriteBase` directive, it should be the

# absolute physical path to the directory that contains this htaccess file.

# RewriteBase /

RewriteCond %{REQUEST_FILENAME} !-f

RewriteCond %{REQUEST_FILENAME} !-d

RewriteRule . index.php [L]

Nginx (root directory)

location / {
    try_files $uri /index.php$is_args$args;
}

location / {

try_files $uri /index.php$is_args$args;

}

Nginx (subdirectory)

location /liten {
    try_files $uri /liten/index.php$is_args$args;
}

location /liten {

try_files $uri /liten/index.php$is_args$args;

}

Hello World

To get started using the framework, you will need to instantiate a Liten application like below.

$app = new \Liten\Liten();

1	$app = new \Liten\Liten();

Once it is instantiated, you can create a new route:

$app->get('/hello/(\w+)/' function($name) {
    echo "Howdy, $name";
}

$app->get('/hello/(\w+)/' function($name) {

echo "Howdy, $name";

}

Getting Started

March 27, 2015 by Joshua·0 Comments

It is very easy to get started with using this small and simple framework. Download the code from Github, extract the files to your server, navigate to the url and you should see a welcome page.