Basically you use it like this:


$inflector = new ZendAssetInflector();

$asset = new OneAsset($options);
$asset->create();

As you can see the constructor takes as a paramter one array with options(I have multiple apaches, mysqls at work so you will probably have to change some things, to adapt it to your personal setup). The keys of this array are:

inflector: a ZendAssetInflector object, an auxiliary class which I will present a little later.

cfg_Array: is a website config array which resulted from a ini config file with general options for the website:

under_development: true/false , whether in produciton or not(I know, it’s kinda superfluous, because I already have $cfg_Array above), it’s role is to echo or not error messages inside the class.

js_file: The name of the big js file that will result for this page:

js_config_dir: The absolute dir path where we have all the js config files. Below these dir there a directory for each module, under each module, there is a directory for each controller and bellw each controller directory there is a config file for every action like this:
For example for the index action in the index controller(let’s say that
js_config dir is /var/www/html/mywebsite/config/js_config/ and
we are in the default module
)

/var/www/html/mywebsite/config/js_config/default/index/config.index.php

[remote]
yui_url[]="yahoo/yahoo-min.js";
yui_url[]="event/event-min.js";
yui_url[]="connection/connection-min.js";
yui_url[]="yahoo-dom-event/yahoo-dom-event.js";
yui_url[]="dragdrop/dragdrop-min.js";
yui_url[]="container/container-min.js";
yui_url[]="utilities/utilities.js";
yui_url[]="element/element-min.js";
yui_url[]="animation/animation-min.js";
yui_url[]="carousel/carousel.js";

[local]
files[]= "swfobject.js";
files[]= "poll_functions.js";
files[]= "index_cover.js";
files[]= "homepage.js";
files[]= "home_carusel.js";
files[]= "validatePublishDate.js";

Ok, now the class methods:

__construct : the constructor, initializes the class variables, and calls init_files method

init_files: parses the js config file for every action, creates the local or remote paths of every js file, and then calls the methods
add_files, to add all the files to the $_files class variable:
$this->_files is an array with 2 keys, “local” and “remote” which contains arrays with the local and remote paths of the js files that will be aggregated.

needs_rebuilding: A method that will check if a local js file, or the config of this action has been modified in which case it will rebuild the js file of this action automatically.

create: This method will check if the “big js file” of a specific actions does not exist, or it needs rebuilding in which case it will create it/recreate it.

Ok, In the next post and the last one of these series, I will show you the auxiliary class ZendAssetInflector, and how you can use One_Asset together with Zend Framework!

<script src=”my_big_js_file.js”>
This is a great optimization for your webserver, because instead of having a dozen of requests to external js files, you will have only one request to a bigger file.This is also a good optimization for your visitor, because the page will load faster, and you can also cache the big js file on the client side. GREAT ADVANTAGE,I’d say!!!!
More exactly my application setup for ZF contains more modules, every module contains some controllers and every controller some actions of course. I think of every action as a “page”, and every “page” can be configured to use whichever js files I want. So i have in my application the following dir structure:
(Abbreviations used m = module,c= controller, a =action)

/config/js_config/m1/m1c1/config.m1c1a1.php
/config.m1c1a2.php
…………………
/m1c2/config.m1c2a1.php

/config.m1c2a2.php

/m2/m2c1/config.m2c1a1.php
/config.m2c1a2.php
…………………
/m2c2/config.m1c2a1.php
………………………………………………
So the modular structure from ZF in reflected on the modular structure of js config file.
A js config file looks like this:
ex: config.micjak.php

[remote]
yui_url[]=”yahoo/yahoo-min.js”;
yui_url[]=”event/event-min.js”;
yui_url[]=”connection/connection-min.js”;
yui_url[]=”yahoo-dom-event/yahoo-dom-event.js”;
yui_url[]=”dragdrop/dragdrop-min.js”;
yui_url[]=”container/container-min.js”;
yui_url[]=”utilities/utilities.js”;
yui_url[]=”element/element-min.js”;
yui_url[]=”animation/animation-min.js”;
yui_url[]=”carousel/carousel.js”;

[local]
files[]= “swfobject.js”;
files[]= “poll_functions.js”;
files[]= “index_cover.js”;
files[]= “homepage.js”;
files[]= “home_carusel.js”;
files[]= “validatePublishDate.js”;
files[]= “functions.js”;
files[]= “right_column.js”;

As you can see there are 2 sections in my ini files: remote and local. That’s because, you’ve guessed some js files are remote on other servers, and are fetched via curl, and other are local to the apache server. All these files are read and combined together resulting one big js file!

Enough words here is the class, One_Asset:

/************
7 ian 2009 /changes for the Zend Framework, (it should work independently of any Framework now)
27 feb 2009 /small changes for debugging non-existentent js configs

}


As this has already been a big post, I’ll stop here for the moment and continue in the next post. Don’t worry if this may seem complicated it’s actually very simple to use!. I’ll show you in the next post how to instantiate this class, it’s methods and variables. Now take a break!

1)Download the PDF named Study Guide available for free from zend.com and read it(very carefully) 2 or 3 times. Take a good look at the questions. Once you will understand those questions, you will have a very good idea about what kind of questions you will be asked at the exam.

2)You will have something like 12 big chapters to learn from the study guide, each of them containing one big class or 2,3,4 perhaps even five smaller classes. Study the API of those classes very good and try to memorize most of their methods. The more you memorize the better! I did not joke in the first post when I said they will ask you from all of their API!!!

3)Try to answer at the questions from the Study Guide (after you think you are prepared and learned the API) and if you can answer at those you will probably do just fine at the exam. Attention! Do not look at those questions daily, because you will learn them by heart and it’s 100% that you will not be asked those questions at the exam!!!

4)I did not pay 1000$ for the training they offer because that would be an important financial effort for me and I passed the exam from the first time and so can you!!!

5)Basically all you have to have to pass the exam is
A)Good Memory, to memorize all those classes methods
B)a bit of logical thinking in your head and if you’re interested in ZF, you probably have it;)
C)190$, the price I have paid for the exam + VAT

I think that would be about all for the moment….

class ZendExt_Request extends Zend_Controller_Request_Http{

You set this this class in your front controller like this:
$front->setRequest(‘Zend_Controller_Request_Http’);
Next everytime in your controllers you will use
$this->_getParam(‘some_variable’), and then assign the variable to the $this->view object, you can echo it in the view script, without using $this->escape(….). Code example:
Before:

In controller:
$variable = $this->_getParam('variable');
$this->view->variable = $variable;

In the view script
<?=$this->escape($this->variable)?>

After:
In controller:
$variable = $this->_getParam('variable');
$this->view->variable = $variable;

In the view script
<?=$this->variable?>

AUTOMATICALLY is the keyword here!

<script>
a = '....';
b='......';
</script>
......more HTML code....
........

All the js functions and classes are in separate .js files.If i need a function to run when a page loads, i register it as an onload event with YUI. For example, let’s say I want a videoplayer to run when the page loads.
I include the following js file in my page:

video_player.js

function play_video(){
try {
if(video_file != undefined && image_file != undefined ) {
var player = new SWFObject( site_url + "design/flash/player.swf", "player-box", "400", "300", "8", "transparent");
player.addParam('wmode','transparent');
player.addParam('quality','best');
player.addParam('allowFullScreen','true');
player.addParam("allowScriptAccess", "always");
player.addParam("allowNetworking","all");
player.addParam("scale","exactfit");
player.addVariable("file", video_file);
player.addVariable("image", image_file);

player.addVariable(“controlbar”,”over” );
player.addVariable(“autostart”, autoplay);
player.addVariable(“channelIdentifier”, “X57wx%2BoGo%2Bfwl%2FmoJl5YMQ%3D%3D”);//CHANNEL IDENTIFIER – from NoPrimeTime system
player.write(“videoPlayer”);
}
}

}
catch(e) {
}
}
YAHOO.util.Event.addListener(window, “load”, play_video);

Now as you may be asking how does this function knows what video to play?It doesn’t take any parameters right? Wrong!!! If you will look closely it uses 3 GLOBAL VARIABLES, video_file,image_file, and site_url? Where do they come from?
Very simple actually! I set them in the view script, as I told you at the beggining. In my view script I will have:

........html code.......
..............
<script>
video_file='<?=$this->video_file?>';
image_file='<?=$this->image_file?>';
site_url='<?=$this->site_url?>';
</script>
........html code.......
..............

As you can see the js variables are set from the $this, view variable, which you guessed it it’s set in a controller…..
How does this function? When the page loads, the js parser will first discover the 3 variables, which will act as parameters to the play_video function, which will run on the window.onload event. What is the advantage of this technique? Well your views scripts are much easier to read and mantain and of course to reuse them. The same is true for your js code too.
In a future post, I will tell you how I aggregate all the js files, in one single file to reduce the no. of requests to your server.

More precisely:
$read = Zend_Db :: factory(...);
$write = Zend_Db :: factory(...);

Zend_Registry::set('write',$write);
Zend_Registry::set('read',$read);
Zend_Db_Table_Abstract::setDefaultAdapter($read);

So one solution would be for example to do like this
$write->insert(....),
$write->delete(....),
$read->fetchAll(....),

But if i do it like above I have to always be extra careful not to mix $write with $read. This is a very error proned solution.I’m lazy and I want this job to be done automatically so I don’t have to be extra careful everytime I write a query. So this is my solution:

I have extended Zend_Db_Table:

class ZendExt_Table extends Zend_Db_Table {

}

Now, all my models extend ZendExt_Table. So every time I do an insert,update or delete on a model, the database connection is switched to $write and then back to $read. This is 100% sure. Unfortunately this solution works only when you use models. The Zend_Db_Table proxys it’s methods to Zend_Db_Adapter,
$write or $read. Now you could implement the above setup for models in Zend_Db_Adapter, but that would mean to patch the ZF code, and I didn’t want that. And also I couldn’t find any other solution at that time.

So in conclusion when you will use models you are 100% safe. But when you use the Zend_Db_Adapter class directly for example:

$read->fetchAll(....)
$write->insert(....)
etc., then it’s your responsability to choose correctly between $read and $write.
Hope I make myself clear….

For all of you who want to pass this exam I advise you to take it very seriously. It’s not an easy exam. You’ll have to learn a  lot, because you’ll be asked a lot of questions, from the entire ZF API. The ZF exam will ask you “shameless” questions as I like to say.  Prior to take the exam, I had like 6 months of experience working in ZF, from which 4 months of hard work, creating a new website(refactoring an old one) and intense study.

I think that’s about all for the moment. For all the IT professionals out there, who want to take this exam, Good Luck!

ps: I hope I didn’t scared you very hard. It’s not an impossible exam, it’s just a serious one!