Why Another Validation Library?

Valitron was created out of frustration with other validation libraries that have dependencies on large components from other frameworks unrelated to validation like Illuminate Validation (laravel 4) requiring Symfony HttpFoundation, pulling in a ton of extra files that aren’t needed for basic validation. It also has purposefully simple syntax used to run all validations in one call instead of individually validating each value by instantiating new classes and validating values one at a time like Respect Validation requires you to do. Valitron also has a focus on being concise – validation rules are just a single line per rule, and can include multiple fields in an array. This is handy, because in most use cases, a single validation rule – like “required” will be applied to many fields, so it doesn’t make sense to start with the field first like Fuel Validation does.

In short, Valitron is everything you’ve been looking for in a validation library but haven’t been able to find until now: simple pragmatic syntax, lightweight code that makes sense, extensibility for custom callbacks and validations, good test coverage, and no dependencies.

Usage Example

Valitron is made to setup all your validation rules on the fields you need, and then run all the validations in one call. This is better than validating the fields one-by-one, because that approach causes a lot of “if” statements and branching logic that doesn’t make the resulting code any better than doing the validations by hand (which obviously sucks).

1
2
3
4
5
6
7
8
9
10
11

$v = new Valitron\Validator($_POST); // Input array
$v->rule('required', ['name', 'email', 'date_start']);
$v->rule('email', 'email'); // Email uses filter_var
$v->rule('dateAfter', 'date_start', new \DateTime()); // After today
if($v->validate()) {
    echo "Yay! We're all good!";
    print_r($v->data());
} else {
    // Errors
    print_r($v->errors());
}

More usage examples and documentation can be found on the Valitron GitHub Page. Valitron is on Packagist, and can be installed via Composer.

The Problem with Independent Scope

The main problem with most micro-frameworks and even full-stack MVC frameworks that leads to code duplication is that the callback or method executed to perform the action and respond to the URL route lives fully within its own scope. This means that you are forced to repeat a lot of setup code across URL route handlers that load the same resource, authorize it, etc.

Some typical micro-framework code might look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// View single post
$app->get('/posts/:id', function($id) {
    $post = Post::find($id);
    check_user_acl_for($post);
    // ...
});
 
// Delete post
$app->delete('/posts/:id', function($id) {
    $post = Post::find($id);
    check_user_acl_for($post);
    $post->delete();
    // ...
});
 
// Edit post
$app->get('/posts/:id/edit', function($id) {
    $post = Post::find($id);
    check_user_acl_for($post);
    // ...
});

You may be able to move the ACL check to a middleware layer or “before” hook if the framework supports it, but there is always a certain amount of duplicate code you will either never be able to get rid of, or have to jump through hoops to get rid of (like adding more abstraction or re-checking the current URL, etc).

The Benefits of Shared Scope

Bullet uses a unique nested callback style that splits the URL by directory separator and only handles a single part of the URL at a time with it’s own callback. At first blush, this approach might seem like more work, but the key to how Bullet works is that nested closures – by definition – can use variables defined in the scope of their parent. This leads to some pretty powerful and profund capabilities that can only be done using the same nested closure style that Bullet uses.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

$app->path('posts', function($req) use($app) {
    $app->param('int', function($req, $id) use($app) {
        $post = Post::find($id);
        check_user_acl_for($post);
 
        // View (GET)
        $app->get(function($req) use($app, $post) {
            // ...            
        });
 
        // Delete
        $app->delete(function($req) use($app, $post) {
            $post->delete();
            // ...
        });
 
        // Edit ('edit' path added after id)
        $app->path('edit', function($req) use($app, $post) {
            // ...   
        });
    });
});

Notice in the example here how the code to load the desired post and perform the ACL check only have to be run ONCE. Any other code or URL routes below that point will automatically be safe and can use($post) to get access to the already loaded Post object.

Other Advantages and Positive Side-Effects

Since Bullet’s URL routes handle only a single path segment at a time and are relative to the parent execution scope, it opens up all kinds of possibilities for code re-use unimaginable in most other PHP frameworks today. The first and perhaps most obvious one is that URL routes can be crafted however you want, and can be nested unlimited levels deep with no restrictions beyond your imagination. The second one is that it becomes trivially easy to do things that are inexplicably difficult with other frameworks like create a base version folder for an API like “v1″ or “v2″ that then includes the other main paths below it like “v1/posts” and “v2/events”.

Perhaps the most significant benefit of this approach is that if you logically separate your routes into different include files (‘posts.php’, ‘events.php’, ‘comments.php’, etc.), you can include them inside other route handlers, and since both PHP includes and closures are context-sensitive, they will work perfectly and will act as nested routes from whatever path you include them in. Bullet even has a built-in url method that helps build context-sensitive URLs that can be dynamically nested in-context from the current URL path.

The classic use-case for this nesting functionality is an ‘admin’ path:

1
2
3
4
5
6
7

$app->path('admin', function($req) use($app) {
    some_acl_check_to_ensure_admin_that_throws_exception_if_not();
 
    require 'posts.php'; // For /admin/posts ...
    require 'events.php'; // For /admin/events ...
    require 'comments.php'; // For /admin/comments ...
});

A lot of other frameworks – if they can even support doing this – use additional concepts like route namespaces to solve this problem. With Bullet, the usage is simple and straightforward, and the logic is simple and easy to understand – this is how bullet already works, so there are no new concepts in play. There are no routing tables or pre-determined rules that make this impossible to do, and the concepts here are all native to PHP and fully leverage how PHP already works – It’s just one more path to declare.

Polymorphic Code Re-Use

Taking this logic even further, you can create a file with routes that are intended for polymorphic-style code re-use, like allowing ‘comments.php’ to be nested within any other path – in our case, both ‘posts’ and ‘events’. Such use might look something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

$app->path('posts', function($req) use($app) {
    $app->param('int', function($req, $id) use($app) {
        $post = Post::find($id);
        check_user_acl_for($post);
 
        // View (GET)
        $app->get(function($req) use($app, $post) {
            // ...
 
            // Use array notation for variable passing on the $app instance
            // Tell comments to load comments for post_id
            $app['comments'] = array('type' => 'post', 'type_id' => $post->id);
 
            // Include our nested comments
            require 'comments.php'; // will be 'posts/42/comments'
        });
    });
 
    // Method handlers ensure the FULL path is matched, so comments.php will not get included twice
    $app->get(function($req) use($app) {
        // Use array notation for variable passing (via Pimple)
        $app['comments'] = array('type' => 'post'); // all comments for 'post' type
 
        // Include our nested comments
        require 'comments.php'; // will be 'posts/comments'
    });
});

This allows the re-use of specific paths and common functionality by nesting them in multiple contexts with a simple PHP include/require. Bullet is setup for this out of the box, and even encourages this type of code re-use through features like relative URL building – another unique feature among PHP frameworks:

1
2
3
4
5

// RELATIVE url (/posts/25/comments/57, /events/9/comments/57, /comments/57)
echo $app->url('./comments/' . $comment->id);
 
// ROOT url (always /comments/57)
echo $app->url('/comments/' . $comment->id);

Wrapping Up

This has been a brief overview of the main benefits, but there’s a lot more to get excited about regarding Bullet, and there is lots of explanation and documentation up on the Bullet site to dig through. It’s a very unique PHP framework that fully embraces and helps your app automatically conform to the HTTP spec, and I think you’ll love using it.

Get Bullet

View or fork the Source on GitHub

Visit the main Bullet Website

See the Composer Package on Packagist

Make sure to let me know if you start using it or if you have any questions or awesome ideas.

The only other place to add code that will catch exceptions for all jobs run is in the GearmanWorker::addFunction method. So I looked at the following one-liner for adding named job callbacks:

1

$worker->addFunction($name, $task);

And replaced it with a closure that uses a try/catch and then logs any exceptions to Exceptional so we can see the full stack trace and exact point of failure for any job – even background jobs:

1
2
3
4
5
6
7
8
9
10
11
12
13

$worker->addFunction($name, function() use($task) {
	try {
		$result = call_user_func_array($task, func_get_args());
	} catch(\Exception $e) {
		$result = GEARMAN_WORK_EXCEPTION;
		echo "Gearman: CAUGHT EXCEPTION: " . $e->getMessage();
 
		// Send exception to Exceptional so it can be logged with details
		Exceptional::handle_exception($e, FALSE);
	}
 
	return $result;
});

And it works beautifully. Now all the jobs are run, the Gearman daemon is never killed by a PHP process, and all the exceptions are logged with full granular details that makes it easy to troubleshoot and fix any errors.

The second talk I gave at Confoo was Hierarchical MVC (HMVC) – What, Why, and How - an architectural talk I have been wanting to give at several conferences for a little while now (but had until now not been accepted). The talk was very well received, and hopefully helped at least a few people though some of the tougher architectural decisions they might be facing in their own projects. The gist of the talk is that HMVC can help break up code into “widget” type blocks, and can go further down the path of fully separating concerns than more strict traditional MVC can. HMVC is all about code re-use across multiple places, like a comment module that is dispatched to anywhere you display comments across multiple types of content (blog posts, articles, pages, events, etc.). Traditional MVC forces you to use view partials, different layouts, duplicate code, or some other separate widget system to achieve the same level of flexibility you get from HMVC.

One of the best things I like about Confoo is the sheer diversity of the schedule. There were 10 tracks this year, with talks spanning across all types of technologies, markets, and languages, like PHP, Ruby, Python, .NET, Java, and JavaScript to Scaling, Startups, CMSes and Agile. Confoo is the most technologically diverse conference I have had the privilege of speaking at, and I benefit from that diversity every year by expanding my horizons a little bit. While I was there, I attended a talk on a Ruby framework called Renee by Joshua Hull. Even though most of my background is in PHP and I was presenting with PHP examples and projects for my talks, I use Ruby on Rails quite a bit for client work at my company Brightbit and was working on a Rails API at the time, so I thought I’d check it out. I had been thinking about better REST frameworks beyond MVC for a little while, and the talk inspired me to try the same nested callback style with closures in PHP, and I started hacking together the very first (crude) implementation of Bullet on the plane ride back home the next day, just to see if it was possible. I had the basic concept working well in under an hour thanks to PHP 5.3′s awesome closures. That’s why I like and value the diversity at Confoo so much. You get to see things that are going on in other languages and expand your horizon a bit, then you can bring those benefits back to another language you work in, and benefit even more people. I’ve fleshed out Bullet a little more now and made it a proper project, but the details of that are for another blog post. For now, I leave you with the slide decks I presented at Confoo.

Slide Decks

Stackbox CMS Slides

Hierarchical MVC (HMVC) Slides

The solution is to open your “suhosin.ini” file to ensure the Suhosin patch is allowing PHP to open and execute PHAR files.

Mine was at:

1

/etc/php5/conf.d/suhosin.ini

If your suhosin config file is not there and you don’t know where it is, run this:

1

locate suhosin.ini

Find the config key “suhosin.executor.include.whitelist” and add “phar” to it.

1

suhosin.executor.include.whitelist ="phar"

Then restart PHP-FPM and Nginx and you should be good to go!

1
2

/etc/init.d/php5-fpm restart
/etc/init.d/nginx restart

My wife recently traded in her old iPhone 3G for a shiny new iPhone 4S, and within 10 days had exceeded her 200MB AT&T data plan limit when she has never exceeded it before. So what gives? It’s a new phone, and Siri does transmit voice data back to Apple’s servers, but could that really have caused the usage?

Fixing The Data Usage Problem

Turns out the problem is that Apple ships iOS5 with iCloud data syncing over cellular networks ON by default. This means all the documents and data stored on your phone for all the applications you have installed on your phone will be automatically uploaded to iCloud, decimating your puny cellular data plan you thought you’d never burn through.

If you are experiencing super high data usage on iOS5, just follow these steps:

1. Navigate to: Settings -> iCloud -> Documents & Data -> Use Cellular
2. Turn it OFF
3. Fight with AT&T (or other wireless carrier) about your excessive data usage charges

Usage Before iPhone 4S

Some months have clearly higher data usage than others depending on how long we were away from home or what we did while we were out with out phones, but we were never in any real danger of going over the low 200MB limit before.

Data Usage after 10 days with the iPhone 4S

On the left (green) is my data usage with an Android device, Right (red) is my wife’s data usage this month with the new iPhone 4S.

My wife got a text alert for 65% data plan usage on Monday, and then one on Friday for 80%, and one the day after on Saturday saying she had gone over her limit (exceeding 100% of the plan) and that we would be billed an additional $15 by AT&T for the overage.

1. Open the iPhone Simulator
2. Browse to the photo you want to put into the simulator (Finder or web browser)
3. Click and drag the photo over the simulator window. A green “plus” icon should appear under your cursor with the simulator frame highlighted. Drop the photo.
4. Mobile Safari should open on the simulator to the location of the image you just dragged and dropped over it
1. Note that if the image you dropped is linked in a webpage, it will open the link instead of the image URL.
5. Click the mouse down over the image and hold it until a popup window appears.
6. Click “Save Image”

The usage looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Geocode input text location
app.utils.ajax({
    url: 'http://maps.googleapis.com/maps/api/geocode/json?address=' + txtLocation.value +'&region=us&sensor=true',
    method: 'get',
    success: function(xhr) {
        var data = JSON.parse(xhr.responseText);
        Ti.API.info(data);
 
        if("OK" == data.status) {
            var res = data.results[0];
            if(res) {
                alert("Location: " + res.geometry.location.lat + ', ' + res.geometry.location.lng);
            }
            // Do something with coordinates
        } else {
            Ti.UI.createAlertDialog({
                title: 'Geocode Error',
                message: 'Unable to geocode location input'
            }).show();
        }
    },
    error: function(xhr) {
        Ti.UI.createAlertDialog({
            title: 'Geocode Error',
            message: 'No location matches found. Please try something else.'
        }).show();
    }
});

And the actual code for the utility function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

/**
 * Application Utilities and Helper Methods
 **/
(function(_app) {
    _app.utils = {};
 
    // AJAX method that mimmicks jQuery's
    _app.utils.ajax = function(_props) {
 
        // Merge with default props
        var o = _app.combine({
            method: 'GET',
            url: null,
            data: false,
            contentType: 'application/json',
 
            // Ti API Options
            async: true,
            autoEncodeUrl: true,
 
            // Callbacks
            success: null,
            error: null,
            beforeSend: null,
            complete: null
        }, _props);
 
        Ti.API.info("XHR " + o.method + ": \n'" + o.url + "'...");
        var xhr = Ti.Network.createHTTPClient({
            autoEncodeUrl: o.autoEncodeUrl,
            async: o.async
        });
 
        // URL
        xhr.open(o.method, o.url);
 
        // Request header
        xhr.setRequestHeader('Content-Type', o.contentType);
 
        if(o.beforeSend) {
            o.beforeSend(xhr);
        }
 
        // Errors
        xhr.setTimeout(10000);
        xhr.onerror = function() {
            Ti.API.info('XHR "onerror" ['+this.status+']: '+this.responseText+'');
            if(null !== o.error) {
                return o.error(this);
            }
        };
 
        // Success
        xhr.onload = function() {
            // Log
            Ti.API.info('XHR "onload" ['+this.status+']: '+this.responseText+'');
 
            // Success = 1xx or 2xx (3xx = redirect)
            if(this.status < 400) {
                try {
                    if(null !== o.success) {
                        return o.success(this);
                    }
                } catch(e) {
                    Ti.API.info('XHR success function threw Exception: ' + e + '');
                    return;
                }
            // Error = 4xx or 5xx
            } else {
                Ti.API.info('XHR error ['+this.status+']: '+this.responseText+'');
                if(null !== o.error) {
                    return o.error(this);
                }
            }
        };
 
        // Send
        if(o.data) {
            Ti.API.info(o.data);
            xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            xhr.send(o.data);
        } else {
            xhr.send();
        }
 
        // Completed
        if(null !== o.complete) {
            return o.complete(this);
        }
    };
 
    // And it does depend on this code below to combine object properties:
 
    // Extend an object with the properties from another 
    // (thanks Dojo - http://docs.dojocampus.org/dojo/mixin)
    var empty = {};
    function mixin(/*Object*/ target, /*Object*/ source){
        var name, s, i;
        for(name in source){
            s = source[name];
            if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){
                target[name] = s;
            }
        }
        return target; // Object
    };
    _app.mixin = function(/*Object*/ obj, /*Object...*/ props){
        if(!obj){ obj = {}; }
        for(var i=1, l=arguments.length; i<l; i++){
            mixin(obj, arguments[i]);
        }
        return obj; // Object
    };
 
    // Create a new object, combining the properties of the passed objects with the last arguments having
    // priority over the first ones
    _app.combine = function(/*Object*/ obj, /*Object...*/ props) {
        var newObj = {};
        for(var i=0, l=arguments.length; i<l; i++){
            mixin(newObj, arguments[i]);
        }
        return newObj;
    };
})(app);

The particular organization of this utilities file assumes that your app structure follows the organization model shown in the Tweetanium example app (using the ‘app’ namespace within a single window context), but is easy to adapt if you are not.

1

files.length

Which returned undefined. So if there is no length property present, an easy way to count the number of keys or properties of an object in ES5-compliant javascript environments like Node.js is to use the Object prototype directly:

1

Object.keys(files).length

A little more typing, but it is fast, efficient, and most importantly: already built-in.

php|tek in Chicago was fun as always. It is the best PHP conference I have ever been to, which makes sense, given that it is focused solely on PHP and surrounding technologies. The best thing about the conference is the community feeling in general. You get a real sense that everyone there really cares about PHP and is heavily invested in it, which is good for moving the whole language and ecosystem forward.

I myself gave two talks – one about Stackbox CMS, a new CMS project I have been working on, and one about Apppcelerator Titanium Mobile since I have been working with it a lot lately. The presentations are embedded below.

Cross-Platform Mobile Development with Titanium

Stackbox CMS: Next-Generation Content Management