SPL Iterators Mixing

I found myself again standing in the shoulder of giants. I got some hints on how I would be able to mixin some of the features that several iterators interfaces and implementations were offering me. So here is the code:

These two examples below are usages for implementing similar things. I went for the first since it was what I wanted.

class PlayerCollection implements IteratorAggregate
{
    protected $players;
 
    public function __construct() {
        $this->players = new ArrayIterator();
    }
 
    public function add(Player $player) {
        $this->players[] = $player;
    }
 
    public function first() {
        return $this->players[0];
    }
 
    public function getIterator() {
        return new InfiniteIterator($this->players);
    }
}
 
$p1 = new Player("foo");
$p2 = new Player("bar");
$p3 = new Player("baz");
 
$pc = new PlayerCollection();
$pc->add($p1);
$pc->add($p2);
 
/*
foreach ($pc as $p) {
    echo $p->symbol;
}
*/
 
$pc->add($p3);
 
/*
foreach ($pc as $p) {
    echo $p->symbol;
}
*/
 
highlight_file(__FILE__);
<?php
 
$array = array(1, 2, 3);
$arr_it = new ArrayIterator($array);
 
$inf = new InfiniteIterator ($arr_it);
for ($i = 0; $i < 10; $i++) {
	echo $inf->current(); $inf->next(); 
}
 
echo "<br/><br/>";
 
// Add 4 to it
$arr_it[] = 4;
 
for ($i = 0; $i < 10; $i++) {
	echo $inf->current(); $inf->next(); 
}

Capifony Chapter: The Lost Day with Ruby and Ubuntu 11.10

Today it was almost a lost day. My capistrano ruby etc broke after I attempted an update or to fix some kind of warning after the update to ubuntu 11.10. Thankfully after a long while i watched this video http://www.youtube.com/watch?v=j2vvXFGCtHM. Just rocks and saves you a ton of time just watching this guy doing the right thing and reading the right info in front of your screen in italian. Now I don’t fear rvm. My install of ruby system is broken however I don’t care. I have now rvm to try my capifony on it.

If it saves you time, for good purposes and apps, good, praise God.

Symfony2 Event Manager: The Stand Alone Way

My first clearer read on event manager on symfony2 was the following.

This article explains how to use the symfony2 even dispatcher to create custom listener and event using the symfony2 event manager component. The blog is very clear and teaches one how to get started on the code for when working inside a symfony2 project.

The second read was this article was a bit old. Actually a year old and taught me a lot about how to work with the stand-alone component however it was kind of unreliable but ultimately very useful. I really liked the examples that they have provided, that helped me to understand how to plug the events, how to work with priorities, how to filter values when working with events, and how use notifyUntil for instance, among other things.

Thirdly, we reviewed the symfony2 documentation chapter titled internal components here.

Basically the model has these components:

The Event is an object subclassed that is passed to all listeners with mechanisms to access information objects regarding the event. “The moral of the story is this: when creating a listener to an event, the Event object that’s passed to the listener may be a special subclass that has additional methods for retrieving information from and responding to the event.”
The Dispatcher class, which is the master class that notifies with the event all the listener classes.
The Listerner class, which is the class who is instructed to listen to the dispatcher events and that can be sub-classed so to extend with some methods to port some objects or data meant to be looked upon or processed/changed. Optionally we can gather all Events into an Events class for documentation purposes and have that class to hold statically the names or strings constants for the event names.

Note: It is important to realize that Dispatcher class is not singleton therefore it has to be injected into my master class from where O use it.
Note: On a last note, there are two approaches for using the event manager: (1) default listener approach, (2) using subscribers.
To stand on the shoulders of dustin10, I asked him what is the difference between these and he answered:

“cordoval they are basically the same thing except a subscriber implemements a method that lets doctrine know which events to subscribe to if using a listener you would create a tag for each event.”

Although I am using it standalone I can get that the idea.

Master Class

This class is in charge of creating all the objects, receive dispatcher injected through DI, assign the listeners on the constructor or elsewhere at initialization. Master class is also in charge of creating the specializing events that give access to some of the objects to compute from/on, and dispatching on a particular event string the corresponding event object just created.

So let’s get to the hands-on part. Let’s try to design this for the tictactoe problem I am facing.

/**
 * Central Class from where dispatcher is used
 */
namespace Tictactoe\Game;
use Symfony\Component\EventDispatcher\EventDispatcher;
class GameMaster
{
    protected $dispatcher = null;
    protected $player = null;
 
    public function __construct(EventDispatcher $dispatcher)
    {
        $this->dispatcher = $dispatcher;
 
        $listener = new GameListener();
        $dispatcher->addListener(GameEvents::onFinishPlay, array($listener, 'onFinishPlay'));
 
        $this->player = new Player();
    }
 
    public function play () {       
        $event = new FilterGameEvent($this->player);
        $dispatcher->dispatch(GameEvents::onFinishPlay, $event);
    }
}

Events Class

This class is not mandatory and its only purpose is to hold all the documentation for the strings corresponding to the event channels used in solving the problem. The Events class is mostly used when there are multiple events that need clear documentation. The Events class will allow a developer to easily find the specific event channels the core can dispatch through. This file then becomes very handy for when we need to hack the core, that is extending it, without touching it. We can see this as our list of hooks that we can use to clamp our added functionality to the application.

/**
 * Events Class
 */
namespace Tictactoe\Game;
 
final class GameEvents
{
    /**
     * The event listener receives an Tictactoe\Game\FilterGameEvent
     * instance.
     *
     * @var string
     */
    const onFinishPlay = 'turnswitcher.action';
}

Listener Class

This class should be the keystone in comprising all the logic that should be decoupled from the main core or all the logic that will extend the functionality of the core. Other classes could be easily copy pasted but this one. This class is very customized. The other classes are just copied and adapted to specific problem, they are support classes, whereas the Listener class is the main class that will extend the functionality.

/**
 * Listener TurnSwitcher Class
 */
namespace Tictactoe\Game;
 
use Symfony\Component\EventDispatcher\Event;
 
class TurnSwitcherListener
{
    // ...
    public function onFinishPlay(GameEvent $event)
    {
        // do something like
        $player = $event->getPlayer();
        // extend here the functionality of the core
        // ...
    }
}

Event Class

This class’ main purpose is to provide access to specific objects or parameters that will be useful to our logic extending the core. This class just customizes the method to get certain objects and thereby can be adapted anytime to provide first hand access to the objects that are being read from the master class or that are being written onto the master class set of properties.

/**
 * FilterGameEvent class
 * allows access to the player object
 */
namespace Tictactoe\Game\Event;
 
use Symfony\Component\EventDispatcher\Event;
use Tictactoe\Game\Player;
 
class FilterGameEvent extends Event
{
    protected $player;
 
    public function __construct(Player $player)
    {
        $this->player = $player;
    }
 
    public function getPlayer()
    {
        return $this->player;
    }
}

I hope this makes clearer the Event Manager Pattern as used in symfony2. I will be updating this to correct some mistakes I have made and also I will apply the pattern to the tictactoe game and provide more details on how to install the symfony2 component to be used standalone. So far we have worked on making things understandable.

Closured Iterator: The Secret While Twig Tag

Lately I was wanting to do a while loop on twig and did not know what to do. The need arose when developing a site with twig and wordpress. In order to overcome the difficulty I had to stand on the shoulders of @Seldaek and @igorw from the symfony dev community.

Explanation: Iterators are an extension of php which is packaged with SPL and is ready to use for php newbies (me). With this you can extend Iterator interface and you will gain iteration powers. The idea was that with these powers we could just pass the object to let it iterate as if it were a for loop. Our template would look like this already transformed:

{% for post in whilePosts %}
    // display post contents, title, etc.
{% endfor %}

Our approach will allow us to set every variable upon calling the_post and stuff. WordPress needs this else it goes crazy. If you happen to install say a plugin and try to just use objects and their properties without the magic of their wordpress hooks and stuff you are left on your own. This is the justification why implementing an iterator as follows.

The code that does the marvel follows. We basically inject two closures for valid and current into Iterator constructor and call their callable values upon return of each of the implemented methods.

    /* create iterator for loops */
    $whilePosts = new whileIterator(
                                    function() { return have_posts(); },
                                    function() { the_post(); return true; }
                                   );
 
class WhileIterator implements Iterator {
    public function __construct($valid, $current) {
        $this->validClosure = $valid;
        $this->currentClosure = $current;
    }
    public function valid() {
        return call_user_func($this->validClosure);
    }
    public function current() {
        return call_user_func($this->currentClosure);
    }
    public function next() {}
    public function rewind() {}
    public function key() {}
}

Edifying version of quote from Philippians 1:7-11 MSG follows:

7-8It’s not at all fanciful for me to think this way about you. My prayers and hopes have deep roots in reality. You have, after all, stuck with me all the way from the time I was thrown in jail, put on trial, and came out of it in one piece. All along you have experienced with me the most generous help from God. He knows how much I love and miss you these days. Sometimes I think I feel as strongly about you as Christ does!

9-11So this is my prayer: that your love will flourish and that you will not only love much but well. Learn to love appropriately. You need to use your head and test your feelings so that your love is sincere and intelligent, not sentimental gush. Live a lover’s life, circumspect and exemplary, a life Jesus will be proud of: bountiful in fruits from the soul, making Jesus Christ attractive to all, getting everyone involved in the glory and praise of God.

SismoFinder + Sismo + Agile PHP Projects

Get SismoFinder local:

mkdir sismoFinder
git clone https://github.com/havvg/SismoFinder.git .
git submodule init
git submodule update --recursive

We will modify the sismo configuration to the following always noticing to change the path to sismoFinder source. Here I have placed sismoFinder folder at the same level than any of my project folders. So everything for me is currently under sites-2 folder and that is where I have placed it:

$loader = new Symfony\Component\ClassLoader\UniversalClassLoader();
$loader->registerNamespaces(array(
    'SismoFinder' => '/home/cordoval/sites-2/sismoFinder/src',
));
$loader->register();
 
$finder = new \SismoFinder\Finder();
$finder->addWorkspace('/home/cordoval/sites-2');
 
return $finder->getProjects();

Then at the project level we have the following configuration:

<?php
 
$notifier = new Sismo\DBusNotifier();
 
$graciaName = 'gracia';
 
$gracia = new Sismo\Project($graciaName);
$gracia->setRepository('/home/cordoval/sites-2/'.$graciaName);
$gracia->setBranch('develop');
$gracia->setCommand('/home/cordoval/sites-2/'.$graciaName.'/sismo');
$gracia->setSlug($graciaName);
//$gracia->setUrlPattern('http://sismo.local/'.$graciaName.'/commit/%commit%');
$gracia->setUrlPattern('http://localhost:8000/?p=.git;a=commitdiff;h=%commit%');
$gracia->addNotifier($notifier);
 
return $gracia;

And we also have our custom script which determines the command that sismo will run:

$gracia->setCommand('/home/cordoval/sites-2/'.$graciaName.'/sismo');

For our case we have called sismo as well. However when having many tasks or branches we could call it different names and have different hooks that will act upon command too. I have a git post-commit hook that triggers sismo with a name for the branch/action that needs to be build with respective sha1. We don’t want to touch the post-commit hook and have it as generic as possible and only touch the main script that is defined in the local project configuration sismo.config.php and have this and the command script decide what to do.