Darragh Enright

Random, but probably mostly PHP and frontend stuff.

[darraghenright]

Vertically slice/rotate a multidimensional PHP array with array_map and call_user_func_array!

Yesterday, while trawling through the [`array_map()`](http://php.net/manual/en/function.array-map.php) entry in the PHP documentation I noticed the following line: > An interesting use of this function is to construct an array of arrays, which can be easily performed by using NULL as the name of the callback function Interesting indeed. In other words: Array ( [0] => 'a' [1] => 'A' [2] => 1 ) [1] => Array ( [0] => 'b' [1] => 'B' [2] => 2 ) [2] => Array ( [0] => 'c' [1] => 'C' [2] => 3 ) ) Cool! In short, it's a quick and painless way to rotate/vertically slice a bunch of data - just feed `array_map()` any number of arrays, and create a new multidimensional array that groups the values of the original arrays by their original element position. ##However... A glaring limitation of this however is that it's a bit _manual_ - you must add each array explicitly. How can we vary the number of arrays passed as arguments dynamically? ##Another example Let's find a solution for this, taking a slightly different example: a multidimensional array containing various translations of the numbers 1, 2, 3. Like so: $data = array( array(1, 2, 3), array('one', 'two', 'three'), array('aon', 'do', 'tri'), array('un', 'dos', 'tres'), ); Let's also imagine that there might be an arbritary number of different translations at run-time: French, German, Japanese etc. This might serve to be a better real-world representation of, say, a data set that was returned from a database call. ##Who you gonna call!? Not for the first (or last) time, [`call_user_func_array()`](http://php.net/manual/en/function.call-user-func-array.php) bounds to the rescue. To clarify, `call_user_func_array()` is used to "call a callback with an array of parameters". Here's a really basic example to illustrate what this means in practice: Array ( [0] => 1 [1] => 'one' [2] => 'aon' [3] => 'un' ) [1] => Array ( [0] => 2 [1] => 'two' [2] => 'do' [3] => 'dos' ) /* .... and so on .... */ ) ##Epilogue As a real-world example, it's pretty useful for example if you want to create series of numeric data that you're going to JSONify and display as grouped/stacked bars in a JavaScript charting tool. It's also pretty forgiving - if an array is shorter than the others PHP will square things up by adding `null` values where appropriate. It'd be interesting to test this out more and see if there what limits or performance issues pop up - playing with large arrays can get slow and some of the `array_*` functions do not have a great reputation for efficiency. However for a simple use case like above it's a quick, neat way to avoid doing horrible nested loops to twist your data :)

[darraghenright]

Embedding jsfiddle...

Just testing. Nothing to see here... :)

[darraghenright]

AngularJS style Dependency Injection in PHP

Further to my short post about AngularJS recently, I decided to have a bit of fun and try to explore AngularJS style Dependency Injection, and implement a naive version in PHP, with a special emphasis on naive! The plan is, we want create a function and define arguments that refer to specific "services", but we want to make calling the function automatic, in the sense that we want to avoid explicity handling arguments. ##Glad to be of service For our example, we'll use [Pimple](http://pimple.sensiolabs.org/), a small, simple DI container for PHP. Step 1: create a directory and grab a copy: curl -O https://raw.github.com/fabpot/Pimple/master/lib/Pimple.php Step 2: create a PHP file, and include Pimple share(function($c) { return new PDO($c['db.dsn'], $c['db.user'], $c['db.pass']); }); Now we have a basic DI container with a basic service! You'd normally call this as follows: $db = $container['db']; echo get_class($db); // PDO ##The Angular approach To inject a service into a controller function in Angular, you generally do the following: var FooCtrl = function($scope, $http) { $http.get('/articles') .success(function(json) { $scope.articles = json; }); }; Most of the time a service is a dollar-prefixed argument, that AngularJS 'just knows' to inject. There are two injected services in the above code: * `$scope` which refers to the controller context. * `$http` which is a low-level AJAX interface. (I say most of the time because you can have services that aren't dollar-prefixed, but we won't worry about that.) ##So, how does AngularJS know? Just about everything in JavaScript behaves like an object, including functions. A function has properties and methods. For example, you can get the number of arguments in a function with the `fn.length` property. Commonly used methods are `fn.bind()` and `fn.apply()`. Unfortunately, there is no `fn.argumentNames()` method* - instead, AngularJS [calls the `fn.toString()` method of the controller and parses the argument list](https://github.com/angular/angular.js/blob/master/src/auto/injector.js#L33). \* If you have Console/Firebug open now, and you're wondering how can see a method `fn.argumentList()` - that's from Prototype.js :) ##PHP Fortunately, it's a **lot** easier to inspect argument details in PHP thanks to reflection. Let's look at an example function: $fn = function($db) { $sql = 'SELECT name FROM user'; $stmt = $db->query($sql, PDO::FETCH_OBJ); foreach ($stmt as $obj) { echo $user->name . PHP_EOL; } }; So, basically this is a completely normal anonymous function, assigned to variable `$fn`. Our goal: we want to 'inject' our `$db` service from Pimple when we call this function. ##Let's reflect! This is really simple but let's assume it's a really stripped down version of some code that's called when a function is called, maybe by a URI matcher or something. It goes a little something like: // injectable args $inject = array(); // create a reflection object for $fn $reflect = new ReflectionFunction($fn); // now.. iterate over the functions arg list foreach ($reflect->getParameters() as $param) { // each $param is a ReflectionParameter object // with a 'name' property; e.g: 'db' // we'll use this to lookup our service // throw an exception if we encounter a non-existent offset if (!$container->offsetExists($param->name)) { throw new InvalidArgumentException( sprintf('%s does not exist!', $param->name) ); } // found one! add it to the list... $inject[] = $container[$param->name]; } // done. call our function! call_user_func_array($fn, $inject); ##So, it's possible... In summary, with `ReflectionFunction` and `call_user_func_array()` it's super simple to implement AngularJS style Dependency Injection. So, curiosity satisfied. But is it useful? Sure.. A more straightforward approach would be to use PHP's `use` keyword to provide the function with visibility of variables present in the function's parent scope: $container = new Pimple(); $fn = function() use ($container) { $db = $container['db']; // use the DI as you see fit }; Indeed this is exactly what some 5.3 micro-frameworks like [Silex](http://silex.sensiolabs.org/) do. It's definitely simpler.

[darraghenright]

AngularJS - some initial thoughts

##Tools! A cool thing about being a web developer today: the ever-growing plethora of awesome open-source tools out there. No more reinventing the wheel, and in many cases the wheel also comes with chunky chrome rims and a high powered sports car attached. So, you spend less time writing code from scratch, and more time… trying to figure out which tools to use? ##JavaScript! JavaScript exemplifies this situation: for example, there's an explosion of MV* frameworks out there for the front-end. A tiny list that springs to mind: * [Backbone.js](http://backbonejs.org/) * [Ember.js](http://emberjs.com/) * [Knockout](http://knockoutjs.com/) * [Spine.js](http://spinejs.com/) * [AngularJS](http://angularjs.org) All offering structure and awesome features like routing, templating, models and more. So much research... ##Backbone.js! There’s probably little doubt that Backbone.js has most of the mindshare from the above list. LinkedIn’s HTML5 mobile site is well-publicised example of Backbone.js in action, and there are plenty of other high profile Backbone apps. It’s popular. Google trends seems to back up this assertion: [Google Trends for various JS Frameworks](http://www.google.com/trends/?q=backbone.js,spine.js,ember.js,angularjs,knockout.js&ctab=0&geo=all&date=ytd&sort=0) With this in mind I spent some time playing with Backbone.js - I could say stuff like 'structure', 'skeletal' and 'flexible'... :) Let's say it's aptly named. Backbone doesn't try to do too much except provide a bit of a base with some very useful abstractions - otherwise, it just tries to keep out of your way. The models and collections are quite cool and super-simple to use. And clear, concise documentation, which is always lovely. There were some fiddly things that were a bit annoying like making sure to [clean up bound events](http://lostechies.com/derickbailey/2011/09/15/zombies-run-managing-page-transitions-in-backbone-apps/) after changing the view, and so on. Just part of the learning curve I s'pose. As a bonus, Backbone's only hard dependency, [Underscore.js](http://underscorejs.org/) is a fantastic, incredibly useful little library that you can, and probably will, use in any JS project. ##AngularJS! I didn't look into AngularJS until I read [AngularJS - Superheroic JavaScript MVC Framework](http://avalanche123.com/blog/2012/02/29/angularjs-superheroic-javascript-mvc-framework/) by Bulat Shakirzyanov, a familiar name to any PHP dev following the Symfony/Doctrine communities. His posts are always informative, so I was intrigued to know his opinion! The opinion was quite positive so I did some reading... Right away it was clear that Angular is a bit different. The declarative approach with 'custom' html tags and attributes for creating directives might be a little off-putting at first: and:

{{ user }}

But therein lies some of Angular's formidable power. Besides you can now use the `data-` attribute, or even identify your custom widget with a class name like so:

So that should keep the W3C from kicking your door in :) ###Two-way binding The first massive win is two-way binding: a change to a model value in a controller is automatically reflected in the view, and _vice versa_. This is really powerful and it abstracts away a LOT of work you might have to do otherwise, manually updating the DOM and dealing with events. ###Controllers and views Setting up a controller is super easy. In your HTML:

{{ greet }}

In your `controller.js`: var HelloWorldController = function($scope) { $scope.greet = 'Hello, World!'; // assign to view binding }; A controller is just a straight-up JavaScript function, with a bit of a twist: ###Dependency Injection DI allows `$` prefixed services to be injected into the controller. In the case above, the `$scope` service is the model 'glue' between the HTML view and the controller. To add a new service, just add it to the controller's argument list and Angular will inject it! Very modular. Naturally, you can define (and reuse) your own services pretty easily. ###Plus loads of other cool stuff I won't go on but there's loads of other great stuff: *directives*, *filters*, *routing*, *templates* etc. Plus the focus on testability. The documentation is good, and there are some fantastic [screencasts](http://www.youtube.com/user/johnlindquist) too. Well worth checking. ##TL;DR In summary, I was convinced so I started using AngularJS for a project and I noticed pretty quickly was that I was getting things done at a rate of knots, compared to similar attempts with Backbone.js. Most importantly, I've had no unpleasant surprises; everything works well, and it seems actually very easy to implement most things. It's great :) If for no other reason you have to love it because it has the best [RC/changelog](https://github.com/angular/angular.js/blob/master/CHANGELOG.md) names: * tesseract-giftwrapping * bubblewrap-cape * inexorable-juggernaut * turkey blast Apparently, version 1.0 is being released tomorrow. Happy days :)

[darraghenright]

Installing Intl package on OSX Lion

When you deploy a new instance of Symfony2 standard edition to your development environment one of the first things you should do is run %SITE%/app/check.php to perform the Symfony Requirements Check. It checks that your environment meets all the mandatory requirements to run the framework.

In addition, it performs a bunch of optional checks to ascertain if certain recommended functionality and extensions are available, such as APC cache, PDO and iconv.

One of these recommended extensions is the Internationalization a.k.a. intl extension. If available it's used to provide extra locale-based functionality in several form field types including money and date.

The intl Package is a bundled PHP extension since PHP 5.3. Of course this doesn't necessarily mean it shipped with OSX Lion. But if you have PECL and Homebrew installed it's very easy. So let's install it!

Step 1. Install ICU Libraries with Homebrew

First we'll need to install any dependencies. To quote the intl package description:

"The Internationalization extension exposes functionality of the ICU library to PHP".

The ICU Libraries is our only dependency. If you have Homebrew installed you can use that; alternatively, you can download and compile from source.

Using homebrew:

$ brew update $ brew search icu # returns 'icu4c'

Success. Install:

$ brew install icu4c

A couple of minutes to download and compile, and ICU is installed. PECL will prompt you for the path where the header files and stuff were installed; on my machine this was:

/usr/local/Cellar/icu4c/4.8.1.1

Step 2. Install Intl with PECL

Next, let's fire up PECL and run the following commands:

$ sudo pecl update-channels $ sudo pecl install intl

Add the path to the ICU Library when prompted. Installation will take a short while to complete.

Step 3. Register Extension in php.ini

Once that is done, you need to open your php.ini file:

$ sudo cp /etc/php.ini{,.bak} # first, backup php.ini $ sudo vim /etc/php.ini

Add the following line at the bottom of the file (or wherever you prefer):

extension=intl.so

Save the file, test syntax and restart apache:

$ sudo apachectl -t $ sudo apache restart

Step 4. Check!

Finally, check that the module is registered:

$ php -m | grep intl # should return 'intl'

And you're done! Happy "internationalizationing" ;)