This causes quite a lot of hassle as PHP 5.2 is less and less supported by frameworks, extensions etc. It is also waste of time as i have to manually build stuff instead of using regular packages, ports etc.

Here is a quick step by step guide on how to get mongodb and PHP5.2 mongo pecl extension going on your MacOSX in 32bit mode!

NOTE: 32 bit mongodb binaries have 2GB address space limit so you wont be able to process too much on your laptop. You will still be able to code and connect to remote instances just fine.

read more

Mockery is a simple yet flexible PHP mock object framework for use in unit testing with PHPUnit, PHPSpec or any other testing framework. Its core goal is to offer a framework for creating test doubles like mock objects through the use of a simple and succint API capable of clearly defining all possible object operations and interactions using a human readable Domain Specific Language (DSL). Designed as a drop in alternative to PHPUnit’s phpunit-mock-objects library, Mockery is easy to integrate with PHPUnit and can happily operate alongside phpunit-mock-objects.

Today, I am pleased to announce the release of Mockery 0.7.2, a maintenance release fixing a small number of bugs and annoyances. A special thanks to all those who forked the Github project at and submitted pull requests! Leaving a developer with hardly any work to do other than a quick test and merge is always appreciated! You can install or upgrade to the new version from the survivethedeepend.com PEAR channel.

Another piece of news is that Mockery is now available on Packagist.org for users of Composer. Composer is a tool to help you manage your own projects’ or librarys’ dependencies and it can handle and mix dependencies from Composer compatible repositories like Packagist.org, any git repository using tags, and any PEAR channel. I do this of my own free will and not because Luis Cordova and Benjamin Eberlei are standing behind me with pitchforks .

The more pertinant fixes include:

1. Fixed a problem in resolving methods chains which abuse the Law of Demeter (thanks to the wizardly Robert Basic).
2. Fixed unexpected static calls to an alias mock which were causing fatal errors (thanks to Luis Cordova).
3. Fixed a crash present since PHP 5.3.6 due to a referenced $this variable entering a closure (thanks to Martin Sadovy).
4. Added support for PHP_CodeCoverage 1.1 whose filter class is no longer a singleton (thanks to Matthew Vivian).
5. Added non-halting exception handling (for Mockery exceptions) to the PHPUnit TestListener (thanks to Adrian Slade).
6. Added boolean $prepend (defaults to FALSE) parameter to \Mockery\Loader::register() to allow for registering Mockery’s autoloader to the top of the autoloader stack even after other autoloaders have been registered (thanks to Hermann Kosselowski).
7. Updated documentation/tests for the release of Hamcrest 1.0.0 several days ago (thanks to me, me, me – who finally got to do something nobody else had a pull request for!).
8. Added new \Mockery::self() static method to make retrieving the current mock object simpler and more readable while setting expectations without the need to refer back to past variable assignments.

Users should also note that Hamcrest 1.0.0, which includes a small filename change (hamcrest.php was capitalised to Hamcrest.php), was released several days ago. If you use Hamcrest matchers with Mockery, you should ensure that both libraries are updated on your system.

As always, please report any bugs or potential improvements to the Github issue tracker using the relevant label or, even more appreciated, send me a pull request.

Image via Wikipedia

Back from my extended leave of absence, I’ll re-open the dusty cobwebbed depths of this blog to echo the sentiments of Paul Reinheimer in his recent article “Cookies don’t replace Sessions“. The topic is actually an old one since Ruby On Rails has adopted the strategy of storing application session data in cookies by default (take note, performance hounds). The purposes of storing sessions in userland cookies rather than the conventional “stick-it-on-the-filesystem/database” used by many apps is one of performance and a little obscuration. Cookie data can be accessed faster than hitting the filesystem/database plus it has the dubious ability to disguise the session-targeted programming language. Really though, PHP is assumed to be on all web servers so hiding its existence is a bit like trying to hide an elephant in a zoo. Hide it all you want – we still know there has to be one in there!

In exchange for speeding up session reading, storing session data in cookies has some fairly uncomfortable costs.

Now, developers are not unaware of the problems of storing potentially sensitive application data in plain text files on the user’s PC which users can manipulate, copy, and mangle to their (or the hacker’s currently fiddling with the user’s PC) heart’s content. It’s dangerous depending on just how much you rely on session data to drive other security rules or restrictions on business logic within the application. Technically, the reliance placed on sessions should be close to nothing – session data should drive the application towards other storage solutions for the really essential stuff and just stay around as a minimal identifier/stash of basic ID info. Such minimal information can be dumped, corrupted, or overwritten with the only cost being to perhaps require a user to login again when that happens. Stuffing a bank balance into a session, on the other hand, is one (very exaggerated!) example of the kind of data you should be shot for relying on a session for.

Programmers being programmers, it’s not rare to see sessions become a more intrinsically important storage location than it should be. In those cases, being able to manipulate the session data can become a problem and may give rise to exploitation scenarios where tampering with the stored data leads to some benefit for the manipulator. Obviously we want to make sure that that can’t happen even in scenarios where programmers may be a bit loose with where they store data. We don’t build frameworks and libraries for Gurus, we build them for all programmers – even the sometimes ignorant and under trained ones. This cookie stored session data is often coupled with the ability to encrypt that data. However…

As Paul Rainheimer remarks in his article, “Encryption is often viewed as a panacea for security problems, you sprinkle a little encryption dust around, and your problems dissolve”. This is an absolute truth in programming – programmers often view encryption as a solution without regard for one teeny tiny problem. If you encrypt a set of data for any purpose, even though it’s encrypted, the user (or the hacker hacking the user’s account) still has the data in some usable form!

With perfectly intact data, and even through it’s hidden by encryption, that data can be recycled simply by copying it to another machine. Depending on the data that is stored (which admittedly may require the hacker/user to figure out by doing actual work like finding your open source a

Truncated by Planet PHP.ie, read more at the original (another 3726 bytes)

http://vimeo.com/31100268

Imagine the need to censor every user post on your site. Most of the web projects I’ve been involved with has the “website claims no responsibility for user content”. That won’t be the case anymore. Imagine if you as a webmaster could go to jail if user posts a copyrighted piece of information.

Agile Toolkit website will be unavailable for 24-hours to join Wikipedia in efforts to raise awareness on Jan 18th.

More about SOPA: http://en.wikipedia.org/wiki/Stop_Online_Piracy_Act

How did we start?

Agile Toolkit 4.0.1 was publicly released about a year ago, in early 2011. It came with a brand new homepage, which by the middle of February was looking like this: http://old.agiletoolkit.org/ (Enjoy this older snapshot, I might remove it later).

The important point here is that Until February 2011 there were about 5-10 developer who knew Agile Toolkit. It hasn’t been a year but we now have thousands of installations across the world and we have very stable 4.1.3 and are working on 4.2. Back in February the whole community management deal was very new to me and I still think  we could use more active supporters.

At the start of the year, I knew of just a few cases where Agile Toolkit was used outside of our company and now there are lots of projects in development such as Support Ticket systems, Project management, Accounting systems, Payroll, Cloud Control Interfaces, Skill testing, Graphing and Plotting UI, Political discussion websites, Application Store Management System, Game statistics tracking, Racing database and even for an interface for ordering Salad from local cafeteria.

Lately we have been working further to commit back code and start several open-source project including Agile Content Management System, Agile Cart/Checkout, Generic Membership website, Project development collaboration platform (Colubris).

What Users Say?

Here is some of our user feedback I’ve collected:

Thanks. I think you have done an incredible project. With some more documentation it will overtake some big and hard to learn frameworks. [Jaume]

I am quite curious about atk4. I ran into AModules3 a few years back and was intrigued but did not have the time to do anything with it. I now ran into ATK and realized it is fact based on AModules3! I am taking a better look now. [skip] Cheers for what looks very promising! [Dominic]

Hi, I’m a simple php developer from Montevideo Uruguay.I’m in the process of adopt a PHP framework and are very Impressed with ATK, It’s really very simple to learn (for me) compared with other frameworks thath I have tried (zend, symfony, cake). [Alejandro]

This framework is very promising. We’re going to try it in a internal project initially and then if succesfull we will integrate it in our products. [Ivan]

Looks very interesting on first look through, anything that makes UI development/intigration more streamlined is welcome [Dave]

This framework looks solid and extremely sophisticated yet simple at what it does! [?]

Geez! How powerful is ATK, and getting even stronger! Thumbs up guys! Congrats.Hoping to become familiar with the toolkit and start using it as my best tool. [Fernando]

This is Babu…. your technology seems to be awesome and very efficient one.It would be more better for me if there is any complete reference materials for this technology because i am working in a project using this framework. [Babu]

I just checked the presentation .. and I can say WOW! indeed looks very promising and powerfull. I also am checkign the new demos. Very good impression! [Svetlozar]

Congratulations! I am glad, framework keeps on growing. With a lot of interest now I am going to check atk4.com looking for new things =) [Kirill]

My Wish for New Year

For the new year I wish that Agile Toolkit would simplify a daily life of as many web developers as our word of mouth could reach.

Happy New Year Everyone!

https://groups.google.com/forum/#!forum/agile-toolkit-devel

You can learn a lot buy learning fundamentals of Agile Toolkit.  I’m starting from the very bottom layers of the framework, so join in quick!

Unless you want to reinvent the wheel, you should look into using some AJAX / PHP library. Agile Toolkit amongst other can be a great help when you want to build interaction between JavaScript and PHP.

JavaScript event to trigger PHP function

Before going into AJAX, here is how you could produce random numbers in plain JavaScript:

<button id=”mybutton”>Click Me</button>
<script>
$(‘#mybutton’).click( function(){
$(‘#mybutton’).text( Math.random() );
}
</script>

Agile Toolkit comes up with an elegant way in PHP:

$mybutton=$this->add(‘Button’)->setLabel(‘Click me’);
if($mybutton->isClicked()){
$mybutton->js()->text( rand() )->execute();
}

See this example in action

More information of Binding JavaScript actions to PHP

Code achieves same result, but the “Rand” value is calculated on the server. This code relies on the JavaScript function “ajaxec()” defined in JavaScript Utility library (Universal Chain).

How to make it even better?

Wouldn’t it be even greater if you could bind any action to any object like that?

$this->add(‘H3′)->set(‘Move mouse over’)->on(‘mouseover’, function(){

$this->js()->text(‘Thank you’)->execute();

});

Subscribe to my channel on YouTube to see the screencasts as soon as I publish them.

The first 6 one-hour sessions is about creating a simple Task Manager. Many thanks to Maurizio for his participations.

Screencast with me!

If you’ve got Skype and great idea for Agile Toolkit we could help each-other. I can help you move forward with your idea and I would get a material for a new screencast session. Please use contact form to send me your ideas.

• Completely new “TMail” implementation
• Completely new “DB” implementation based on PDO
• Completely new “DSQL” implementation
• Completely new “Model” implementation
• Completely new SMlite implementation
• Improvements in Site Debugging

The new implementations are functionally compatible with the 4.1 branch, although the do offer a number of benefits. In this article, I’ll highlight some of the new features about the new component implementation.

Another important feature of all the new modules is that they are are under heavy automated testing from the very start.

What’s new in the “TMail 2.0″

The TMail class actually been pushed into 4.1.3 release adds much more modularity as well as support for transports. Previously TMail would only send out emails through the mail() function, now it could be written into database, sent over Amazon SES, mail() or any combination of these.

There are also number of improvements in how TMail manages templates – it allow both html and Text part to be defined in your template and will automatically produce non-html version if you supply with the html only.

What’s new in DB implementation

Actually there is nothing new in the DB as compared to “DBlite”. You initialize database by calling $api->dbConnect() and it’s going to stay this way. To use the new database driver you would need to supply the “pdo” in the $config file.

DB implementation features a “query cache”, if a query is executed multiple times, it is prepared only once. This actually makes a lot of sense when you operate with models and parametric values.

What’s new in DSQL implementation

DSQL has been rewritten, but the fundamentals are the same. You create dsql() instance then call methods such as “field()”, “where()”. The new version is much more consistent about escaping arguments and handling of expressions. The new implementation completely relies on parametric nature of PDO, which proved to be a little more challenging to implement, but the interface have not been changed.

1. where(‘id’,2);                    // equals
2. where(‘id’,'>’,2);                // explicit condition
3. where(array(‘id’,2),array(‘id’,3));    // or
4. where(‘id’,array(2,3));           // in
5. where($dsql,4);                   // subquery
6. where(‘id’,dsql);                // in subquery
7. where($dsql->expr(‘length(name)’),123);      // expressions

The new are expression and sub-qureies, and DSQL does a great job figuring out all the parametric queries as you wildly join tables. Dsql now support iterators and the following syntax is permitted:

$q=$this->api->db->dsql();
$q->table('books')->where('price<',20);
foreach($q as $row){
    echo implode(',',$row)."\n";
}

What’s new in Model implementation

It has become much simpler and modular. Also I’m adding implementation of interfaces which makes it possible to access active-record in a super-easy way. Here is an example of model use in 4.2 which implements Iterators and ArrayAccess:

foreach($this->add('Model_Books')->addCondition('price<',20) as $book){
    $author = $book->getRef('author_id')->sendNotification();
    echo $book['name']." by ".$author['name']."\n";
}

Additionally field implementation is now implemented as number of classes, not just a single “FieldDefinition” class.

$model->addField('name');
$model->addExpression('age')->calculated(function(){ return 'years(now())-years(birthday)'; });
$model->addReference('client_id')->setModel('Client');

In all 3 cases the field is defined by a different class which defines how the field is being queried. “Model_Table” is now implemented on top of “Model” class which is a very simple implementation of a model without data-source. This base class can be further extended to allow storing model data in No-SQL storage. Caching could also be further added through controllers.

Models have also some of their methods renamed shorter. Long version will continue to work throughout 4.2, but the use of shorter version is recommended.

Truncated by Planet PHP.ie, read more at the original (another 3976 bytes)

I first have learned about Object Oriented in the age of 10, in 1990. I have already mastered BASIC and was exploring the world of Turbo Pascal. My young mind couldn’t grasp the ideas of in capsulation and polymorphism so I asked my mom to help out. She took the book and carefully kept re-reading the introduction.

“Objects. Think Objects”.

Years later I have been eager to apply the Object Oriented principles everywhere: the games I wrote, the demo-scene productions, my copy of multiplayer user dungeon. When I settled in as a Web Developer and learned PHP3.0 I was disappointed at the poor implementation of the objects.

The birth of Agile Toolkit was as soon as the Zend Engine 2.0 alpha was released. I started to re-wrote the framework I had into a new, powerful language. From the first versions the most important distinctive feature of Agile Toolkit today have been embedded into the very core of the framework.

Rendering of the Runtime Object Tree

2-3 decades have passed since the concept of Object-Oriented User Interface have been launched on the desk-top computers. The realization that the elements you can see on your screen have many similarities even through the look differently defines every Graphics User Interface today. To understand this concept Imagine a “button” and a “input field” next to each-other.

Here a two object quite distinctive in their appearance are being rendered by the operating system by calling each object’s rendering function. The system may decide to force objects to re-render or skip rendering if they are not actually visible on the screen.

The exactly same idea is in the foundation of Agile Toolkit. Because I have been creating my own User Interface in Pascal and Assembler this was to me the best possible solution to interfaces in the Web Applications – implement them as a tree of visual objects generated during the run-time of your application and then rendering the necessary components.

Making Interface More “Webby”

Initial implementation of Agile Toolkit was only good to produce back-end administration systems as it was too in-flexible to do the requirements of the creative minds of our web-designers. Many UI Frameworks are destined with the same interface style, but Agile Toolkit was able to introduce a great breakthrough.

All the objects in Agile Toolkit, no matter how complex, are producing a valid html code based on object templates. This approach allows to easily change html behind individual or all objects and finally produce the great solution for website front-ends. However the default look and feel of Agile Toolkit application gives developers a great start.

Progressive Enhancement

By the time Agile Toolkit has matured the move towards Progressive Enhancements in CSS and Scripting made it possible to create a separate JavaScript layer which would  be optional for the elements. While earlier we would need to set “onchange” and “onsubmit” handlers into html baking templates extremely complex, now all of the JavaScript code have gone into a separate JavaScript API based on top of jQuery UI.

This allowed to purge all the JavaScript hacks from the code and rely on a much more powerful Object-oriented interface between JavaScript and PHP.

Business Logic

With the increasing complexity of our projects, it became apparent that a Objective Model layer is necessary. It finally appeared in Agile Toolkit in 2008 as an optional component. The models in Agile Toolkit serve a different role than the Models of other ORMs and Frameworks. Instead of only offering DataBase engine transparency and populating classes from data structures models in Agile Toolkit introduce a new dimension to modeling – inheritance. You can understand the power of this when you can narrow down values in the drop-down field by simply setting th

Truncated by Planet PHP.ie, read more at the original (another 2202 bytes)