Stereo Interactive & Design

Symfony: return javascript response

Scott Meves — Fri, 03 Jul 2009 18:11:47 +0000

This is an old trick, but I still find it useful and will post it here in case it will help other symfony developers out there. If you are using the prototype.js library for your ajax requests, the Ajax.Request (and similar) utility methods will automatically evaluate the server’s response as javascript if the response has the ‘text/javascript’ content-type header. You can do this by setting your response headers like so:

// from within a template:
sfContext::getInstance()->getResponse()->setContentType('text/javascript');
 
// from your action
$this->getResponse()->setContentType('text/javascript');
 
// as an action that returns some javascript directly
$this->getResponse()->setContentType('text/javascript');
return $this->renderText("alert('This is a javascript alert')");

This proves useful when you want to open up a modal window, show an alert, update multiple areas on a page, or just about anything else with javascript returned from your ajax request.

Firebug and Firefox 3.5

Scott Meves — Wed, 01 Jul 2009 23:30:49 +0000

I rely on Firebug daily to help me debug javascript and work with css. After upgrading to Firefox 3.5, I updated Firebug to the latest beta release, Firebug 1.4 Beta.

The beta version is of course rough around the edges, and one rough spot is the fact that often when editing css properties of an element on an html page, the entire style definition would simply disappear from the console.

Fortunately, as of today, the firebug-1.5X.0a07.xpi release fixes the problem. Click the link for 1.5X0a07.xpi within Firefox to update. I haven’t found any serious problems with the alpha version yet.

As a side note, if any of you are Safari users or are just testing your sites out for safari, make sure you enable the development menu (Preferences > Advanced > Enable Develop Menu) and then you can use the command-option-i to show a Firebug-like inspector. It’s growing on me each time I use it.

Install/Upgrade Subversion on Mac OS X

Scott Meves — Tue, 05 May 2009 15:49:39 +0000

This is a great tutorial on SVN and it also includes a Intel disk image of SVN 1.6.1 which makes installing a breeze.

Subversion With Mac OS X Tutorial.

symfony cache system: cache growing too large

Scott Meves — Fri, 10 Apr 2009 17:56:27 +0000

Symfony has a really powerful cache mechanism, but if you turn it on and don’t configure it, it will cache one file for *every possible url*, and in the case of a dynamic site with thousands of pages, this grows to many gigabytes very fast. This is especially a problem if you have a dynamic search feature, and you have search-friendly URLS where you convert query parameters to /a/friendly/path/like/this. The number of unique paths that generate content on your site is literally infinite, since the URL can include anything the user types in the search box.

Changing the cache duration (or “expiration date”) doesn’t affect this issue, since there is no cron job that travels through the files and deletes old ones—rather, when symfony encounters a file that is older than the expiration date, it replaces it with a new one. But, you can (and will) end up with thousands of files in your cache, some of which may have been accessed only once and will sit there taking up precious space.

Instead, you have to be more specific about what you want symfony to cache and what you want it to ignore. I generally *turn off* the general cache (in frontend/config/cache.yml) and then go through and specify what partials I want to cache. This is useful because if you set “contextual: false” in your partial cache configuration, symfony will use the same partial across every page (say, a header or footer or a “what’s new” block) and will only store that file *once* regardless of the URL used to get to that page. Or, more specifically, it will cache that file once for every combination of parameters you pass into the partial, but we’ll get to the details in a minute.

As an example, in our main layout.php for our site, we use a partial for our navigation menu — we have a list of cities that is populated in the database, and there is no reason to fetch this every request. Let’s say this partial is in our app’s layout folder (ie not within a module context, but rather the “global” context) and is called _headerNav.php.

     include_partial('global/headerNav') ?>

We can tell symfony to use/cache this same partial regardless of the context (or “url” used to access this page). Since this is a global partial, the settings go inside app/frontend/config/cache.yml:

_searchTop:
  enabled:     on
  contextual:  false

So now symfony will store this searchTop partial inside:

cache/[env]/template/[hostname]/all/sf_cache_partial/global/_searchTop.cache

rather than

cache/[env]/template/[hostname]/all/path/to/your/unique/url/that/is/different/every/time/_searchTop.cache

Next up, say that rather than having the same exact partial for *every page*, you have a few different contexts… a few, but not one for every URL that may access that partial. A great example is a blog. Say you want to cache the partial that shows you a blog post summary. You use this partial on your home page, on the blog category page, and the search results page. Once you generate the partial for blog ID #2, you can use that partial on all of those pages. But, you don’t want to use the same exact cached partial for different blog posts, because that obviously wouldn’t work. So, you set the cache key:

 include_partial('blog/post_short', array('post' => $post, 'sf_cache_key'=>$post->getId())) ?>

This tells symfony to use the same cached partial everytime that sf_cache_key is the same. So, the cache directory…

cache/[app]/[env]/template/[hostname]/all/sf_cache_partial/blog/_post_short/

ends up containing only 1 file per blog post:

.... where the cache file name is the sf_cache_key you set when you included the partial. Another nice thing about setting the sf_cache_key is that you can easily idenfity what cache file refers to what object. Otherwise, symfony generates a unique hash key for each cache file... and this can be a problem if you want to manually clear out specific cache files (you'll see this at the end).
If you do this enough then your massive cache which is storing cached files for every single URL that is used to access your site ends up being consolidated into the shared sf_cache_partial directory, which won't get nearly as large.
The trick is that you must set "contextual: false" for your partials... otherwise the partials end up being distributed across a directory structure that resembles the URL used to access the content.
The end goal is to keep you cache directory from being a million files large. This will *only* happen if you have sections of your pages that are **contextual** meaning that symfony will store them inside a directory structure that mirrors the URL that generated the cache in the first place. If you find that you still have lots of cache/.../path/to/your/unique/url/and/it/keeps/going then you should look inside those cache files to find out what is being saved there and either stop caching it, or try to figure out how you can move that into a shared cache file somewhere by setting a shared sf_cache_key.
A major problem with all this caching is that it gets really tough to keep track of what actions on the backend require you to clear out what cache on the frontend. In the case of the blog post, I want to clear out any cache for that particular post. This is what my Post::save() method looks like:

public function save($con = null) {
  $return = parent::save($con);
  $this->clearCache();
 
  return $return;
}
 
protected function clearCache()
{
  if (sfConfig::get('sf_cache'))
  {
    /* does not work cross app
    $cacheManager = sfContext::getInstance()->getViewCacheManager();
    $cacheManager->remove('@sf_cache_partial?module=blog&action=_recentPosts&sf_cache_key=1');
    $cacheManager->remove('@sf_cache_partial?module= blog&action=_tagList&sf_cache_key=1');
    $cacheManager->remove('@sf_cache_partial?module= blog&action=_post_short&sf_cache_key='.$this->getId());
    $cacheManager->remove('@sf_cache_partial?module=threeOneThird&action=_headerUpdates&sf_cache_key=1');
    $cacheManager->remove('blog/index');
    */
    $sf_root_cache_dir = sfConfig::get('sf_root_cache_dir');
    $cache_dir = $sf_root_cache_dir.'/frontend/*/template/*/all';
 
    sfToolkit::clearGlob($cache_dir.'/sf_cache_partial/blog/_post_short/'.$this->getId().'.cache');
    sfToolkit::clearGlob($cache_dir.'/sf_cache_partial/blog/_tag_list/*');
    sfToolkit::clearGlob($cache_dir.'/sf_cache_partial/blog/_recentPosts/*');
    sfToolkit::clearGlob($cache_dir.'/sf_cache_partial/threeOneThird/_headerUpdates/*');
    sfToolkit::clearGlob($cache_dir.'/third-word/index*');
 
    if ($this->getStrippedTitle()) { 
      //for some reason this doesn't work, perhaps due to cross app?
      //$cacheManager->remove('@blog_show?stripped_title='.$this->getStrippedTitle());
      // note this path is incorrect if no_script_name is off
      sfToolkit::clearGlob($cache_dir.'/third-word/read/'.$this->getStrippedTitle().'.cache');
    }
  }
}

In theory you are supposed to be able to rely on the cacheManager remove cache based on a pretty path like:

    $cacheManager->remove('[module]/[action]');

or

    $cacheManager->remove('@sf_cache_partial?module=[myModule]&action=_[partialName]&sf_cache_key=1');

But, if you are clearing your cache across apps (backend actions are trying to clear frontend partials) this totally breaks down because the cacheManager does not understand the routing rules for the other application. So, you have to specify the files you want delete manually. This isn't so bad if you use sfToolkit to remove files using a file pattern.
This post has grown far too long! But hopefully it gives you some insight how you can best utilize the caching system to speed up your site without ending up with gigabytes of useless cache files.

Symfony Propel Enum types

Scott Meves — Sat, 14 Mar 2009 19:46:13 +0000

Propel does not support enum column types in its schemas, since the enum type is not support across all database types. There are a few ways around this.

1) Use another table to list the enum options. Pros: most flexible. Works nicely within symfony. Cons: means more joins in your queries.

2) Use enum anyway. You can add custom column types using a little known trick in your schema:

status:
  id:
  name: { type: varchar, sqltype:enum, size: "'inactive','active'", default: inactive }

Pros: You get your enum. Cons: Not very portable, a bit of a hack.

3) Simulate an enum column using your model. I typically end up doing this for columns that have a finite number of defined options *that will not change*. Pros: Fast. Cons: Not as flexible as optino 1. Example:


class UserProfilePeer extends BaseUserProfilePeer
{
  static protected $USER_TYPE_INTEGERS = array('student', 'supervisor', 'coordinator', 'researcher', 'admin');
  static protected $USER_TYPE_VALUES = null;

  /**
   * Returns a user type label from an index value.
   *
   * @param integer $index
   * @return string user type label
   * @author Scott Meves
   */
  static public function getUserTypeFromIndex($index)
  {
    return self::$USER_TYPE_INTEGERS[$index];
  }

  /**
   * Returns the user type index from a string value
   *
   * @param string $value
   * @return integer $index
   * @author Scott Meves
   */
  static public function getUserTypeFromValue($value)
  {
    if (!self::$USER_TYPE_VALUES)
    {
      self::$USER_TYPE_VALUES = array_flip(self::$USER_TYPE_INTEGERS);
    }

    $values = strtolower($value);

    if (!isset(self::$USER_TYPE_VALUES[$value]))
    {
      throw new PropelException(sprintf('User type cannot take "%s" as a value', $value));
    }

    return self::$USER_TYPE_VALUES[strtolower($value)];
  }

  public static function getUserTypeOptions()
  {
    return self::$USER_TYPE_INTEGERS;
  }
}

Symfony: How to render a partial from an action

Scott Meves — Wed, 11 Mar 2009 06:55:27 +0000

If you ever find yourself wanting to return the contents of a partial as the entire response for an action, Symfony makes it possible. Using symfony partials with ajax, you have a lot of options of how you want to arrange your templates, but here I’ll show you what has worked best for me.

Oftentimes I find myself wanting to return the contents of a partial as the entire response for an ajax request. I do this a lot when I am already using a partial in my template, and then I want to replace that section with the results of an ajax call. We already have a partial set up to display that content, so we might as well reuse it when we have to refresh that area with new content.

Imagine we have a page that presents a list of articles. In the right sidebar we’d like to feature a preview of the first article. We’d also like to allow a “quick look” for the other articles. Clicking on the quick look button should load a preview of the selected article in the right sidebar, replaced the default preview.

To do this, I set up a partial that contains the article preview. In the default list template (e.g. listSuccess.php) I include the partial along with the featured article.

 include_partial('preview', array('article'=>$article)) ?>

Then, when someone clicks the quick look button, we want to make an ajax call that returns the new preview content with that particular article. Our action might look something like this:

public function executeLoadPreview()
{
  $this->article = ArticlePeer::retrieveByPk($this->getRequestParamer('articleId'));
}

The most obvious thing to do now would be to set up a standard loadPreviewSuccess.php tempate and within that template simply include the partial just as you would normally.

// loadPreviewSuccess.php
 include_partial('preview', array('article'=>$article) ?>

This is totally fine, and you may like it, but there is another way to do it. We can just render the contents of the partial directly from our action. Here is what it looks like. (Note that I turn off the web debugging so that it doesn’t render within the ajax call!)

public function executeLoadPreview()
{
  sfConfig::set('sf_web_debug', false);
  sfLoader::loadHelpers('Partial');
 
  $article = ArticlePeer::retrieveByPk($this->getRequestParamer('articleId'));
 
  return $this->renderText(get_partial('preview', array('article' => $article)));
}

Nice!

Create zip archive from the command line

Scott Meves — Thu, 05 Mar 2009 22:44:28 +0000

I never remember how to do this. I like doing it from the terminal better than the “Compress X Items” option in the finder, because the finder method will sometimes add hidden files like __MACOSX which I don’t like seeing floating around.

This is so simple, it’s stupid.

zip [name of archive] [filepattern 1] [filepattern2] ...

So if you wanted to compress all of your PHP files from a directory:

zip phpArchive.zip *.php

If you want to zip up all the files in the current directory, including files within directories, but still only include files that match a pattern:

zip -r phpArchive.zip . -i \*.php

Now, if only I would do this often enough so I could remember it without wasting 5 minutes reading the man page.

Recursively delete .svn directories

Scott Meves — Tue, 17 Feb 2009 21:32:44 +0000

This came in handy today when I copied a directory from another project and didn’t recognize that it was under version control in that project. Needless to say, my current project got very confused during an svn commit when it encountered this copied directory. To reconcile the situation, I had to recursively delete all of the .svn directories from the copied directory, and then check it in as a fresh copy to the new project.

find . -type d -name .svn -exec rm {} \;

Update 1: Thanks to Jon for this improved method!

Update 2: I have this in my notes too, but I don’t know enough about the shell to know which is better.

find . -iname '.svn' -print0 | xargs -0 rm -rf

SVN merge trunk changes to your branch

Scott Meves — Tue, 17 Feb 2009 17:43:59 +0000

I always have to look up the documentation on how to merge a whole SVN branch to another. Today there were bug fixes to trunk of my project that I wanted to port into my branch. I expected this to be easy since I hadn’t made many changes to my branch, and no changes to the same files that were modified in the trunk.

Using Common Use-Cases as a reference, this is what I did:

From within my branch:

svn log

This displays the revision number for when my branch was created:

------------------------------------------------------------------------
r23 | stereosv | 2009-02-17 11:42:28 -0500 (Tue, 17 Feb 2009) | 1 line
 
creating branch for xyz

Now I need to find out what revision number the trunk is at. Perfoming an “svn update” within the trunk shows me what version it’s at.

> svn update
At revision 25.

In my case the trunk is at revision 25… implying there were only two commits since the time I checked out my branch. Nice.

Now, it’s time to carry merge these changes into my branch. Back in my branch directory, it’s time to put these revision numbers to good use.

svn merge -r 23:25 svn+ssh://username@svnserver/home/username/svn/project/trunk

What this does is merge the changes that were made between revision 23 (when I created my branch) and revision 25 (the most recent revision of the trunk) in the trunk into my working copy.

Now, it’s time to check in my branch, with the updated changes from the trunk.

svn ci -m "Merged trunk changes r23:25 into my branch"

SVN 1.5 has made some improvements to the way merging works.. So check your SVN version with “svn –version” to make sure you are using the right syntax for your version.

Symfony Cross Application Links

Scott Meves — Tue, 17 Feb 2009 14:14:25 +0000

This blog post by Fabien Potencier describes how to use symfony 1.2 to create link between your applications within a symfony project. This has been difficult in the past because applications within a symfony project shared only model classes and basic project configuration, but routing was handled by unique application-based configuration.

In symfony 1.2, there is a new sfRoutingConfigHandler class that can be used to evaluate specific routing configuration (even if that configuration lives within another application), and you can pass that configuration class into a new sfPatternRouting::setRoutes() method which will then allow you to generate your routes. Read the full details on the symfony project blog:

Blog | Cross Application Links | symfony | Web PHP Framework.

This is a great feature and it represents how making a framework more modular can bring many benefits and increase flexibility.