Integration is extremely easy using a helper with the framework.Here is the helper that I am currently using.

<?php
require_once(str_replace('admin_application', 'admin', APPLICATION_DIRECTORY).'/js/fckeditor/fckeditor.php');

class Zend_View_Helper_Rte
{
  function rte($name, $value = null, $attr = array())
  {
    $baseUrl = str_replace('/index.php', '', Zend_Controller_Front::getInstance()->getBaseUrl());
    $headLink = new Zend_View_Helper_HeadLink();
    // include js & css for rte
    $headScript = new Zend_View_Helper_HeadScript();
    $headScript->headScript()->appendFile($baseUrl.'/js/fckeditor/fckeditor.js');

    $oFCKeditor = new FCKeditor($name) ;
    $oFCKeditor->BasePath = $baseUrl.'/js/fckeditor/';
    $oFCKeditor->Config['SkinPath'] = $oFCKeditor->BasePath."editor/skins/office2003/";
    $oFCKeditor->Height = '400';  // default height
    if (key_exists('height', $attr)) {
      $oFCKeditor->Height = $attr['height'];
    }

    $oFCKeditor->Value = $value;

    return $oFCKeditor->Create();
  }
}

As this is being used in the application directory, I needed to replace the value in APPLICATION_DIRECTORY with my public direcotry so that my webpages know that path to the fckeditor files.

The file is saved as Rte.php in my helpers folder.

Now to use the editor, all I have todo is call the helper function providing the input name to use, and default value like:

<?php $this->rte('description', 'my default value'); ?>

At first glance, I was pretty excited to see how it was setup (Zend Framework, phpDoctrine, Modular layout, etc) as this is basically how I have my zf projects setup.

(From Php Taco’s site)

Libraries

PHP Taco consists of the following PHP libraries.

a)  Doctrine ORM for access to the database

b) PHPTAL for View Templates

c) PHPIDS to detect hacking attempts on the PHP website

d) Recaptcha to prevent spam

e) Blueprint CSS framework

f) JQuery AJAX framework

g) An initial database setup

h) DOT Language

Now let me cover my thoughts on what’s included/setup.

• Doctrine – Great, I use this in my current setup.
• PHPTAL – Personally I’ve never used it, I’m not big on adding a template engine as it is simply something else to be processed and parsed.
• PHPIDS – Never used it, but as it’s for detecting hacking attempts I’m all for it (and will check it out)
• Recaptcha – Simply it’s a service you have to suscribe to, It might be great, but if their service goes down then my site’s broken. I’ll stick to something running on my server.
• Blueprint Css Framework – I’ve not had the time to site and learn Blueprint, but do plan on using a css framework in the future.
• jQuery – Simply awsome.
• DOT Language – what the fucking hell is this SHIT!!!

$this->view->x

becomes

_x

or

@x

and

strtolower("This is a string");

becomes

@x=string lowercase("This is a string")

The excuse for the DOT Language is

The problem is that often PHP functions are not easy to remember what they do. I mean, do you know what reset() or explode() or krsort() do? I have too much trouble remembering new API’s and functions

So, instead of learning new functions, you create your own!!! “Do you know what reset() or explode() or krsort() do?” – Huh… YES!! If you’re going to be a programmer, learn the fucking language!! “string lowercase” might be easier for YOU to remember, but it involves more typing that strtolower, not to mention if I were to work on something that was coded with this BS, I would give it back to you and tell you to fix the shit first.

Take this scenerio for example, take somebody 100% new to php and say they learn this framework and become very good working with it. Now say that person gets a job as a php developer. This same peson will be FIRED on the first day for not knowing implode/explode/ksort etc all because of this DOT bullshit!! OR say this person descides they want to become php certified – now they have to unlearn all these aliases that they learned php with.

There’s a bit more with Php Taco’s setup I don’t like, some more things like the DOT Language, others are simply personal preference (so I really cannot complain about those).

Let me start off by saying that I never have cheated on my wife (or anybody I dated before I was married). This is just a curiosity check into the male and female mind.

Please take the poll that applies to your sex.

As you might know, TinyMCE is capable of spellchecking, but what if we want to add a word to the dictionary so that the word never comes up again as a typo? After spending some time with Google, I never found a solution to my liking, so I had the unpleasurable task of adding the functionality myself. To my surprises, it was much easier that I expected.

Note: I am assuming that you already have TinyMCE and the spellchecker plugin installed along with PSell/ASpell. If not, here’s the wiki page.

Here’s how I did it.

First, the spellchecker plugin has to be configured for PSpell in config.php

//$config['general.engine'] = 'GoogleSpell';
$config['general.engine'] = 'PSpell';

Now, in the langs/en.js file I had to add what text would display in the suggested words to add the given word to the dictionary.

I added

add_dictionary:"Add to Dictionary",

to the file.

Next I renamed editor_plugin_src.js to editor_plugin.js and added

m.add({
  title : 'spellchecker.add_dictionary',
  onclick : function() {
    t._sendRPC('addToDictionary', [t.selectedLang, e.target.innerHTML],
      function(r) {
        dom.remove(e.target, 1);
        t._checkDone();
      });
  }
});

I placed this inside the _showMenu function, after

m.add({
  title : 'spellchecker.ignore_words',
  onclick : function() {
    t._removeWords(dom.decode(e.target.innerHTML));
    t._checkDone();
  }
});

This adds our ‘Add to Dictionary’ option in our options that display when we click on a misspelled word and calls our addToDictionary function when selected.

Now we need to modify PSpell.php (inside the classes directory).

First we have to update the the _getPLink function.

Change

$plink = pspell_new(
	$lang,
	$this->_config['PSpell.spelling'],
	$this->_config['PSpell.jargon'],
	$this->_config['PSpell.encoding'],
	$this->_config['PSpell.mode']
);

to this

$pspell_config = pspell_config_create (
	$lang,
	$this->_config['PSpell.spelling'],
	$this->_config['PSpell.jargon'],
	$this->_config['PSpell.encoding']
	);

pspell_config_personal ($pspell_config, realpath('.')."/custom_dictionary.pws");
$plink = pspell_new_config ($pspell_config);

This tells the spellchecker to create a personal dictionary and to use the custom_dictionary.pws. custom_dictionary.pws is the file that will hold all of the words we add to the dictionary. realpath(‘.’) will save this file inside our spellchecker plugin folder. You need to make sure that the web server has write permissions to this directory as well.

Now we’ll create our addToDictionary function, this is what will save our word to custom_dictionary.pws.

function &addToDictionary($lang, $word) {
  $plink = $this->_getPLink($lang);
  pspell_add_to_personal ($plink, $word);
  pspell_save_wordlist ($plink);

  return 'true';
}

I am simply returning ‘true’ as the function call expects a value returned.

Generally, my first script for trying out anything new is a bookmark script because it can be as simple or complex as you want.

Before starting, this post assumes you have a working install of Django. I would strongly suggest looking over the tutorial here for a more in depth explanation as to what everything is doing. This post is only a mile high overview and is to simply show some of process of creating a project along with the (minimal) amount of code it takes.

Here’s the first part.

First lets setup a new project using the terminal. I’ll call this project “simplebookmark”.

My projects are created in /var/www/html so if this is different than yours, adjust your path accordingly

cd /var/www/html/
django-admin.py startproject simplebookmark

Now you should have a directory called simplebookmark and inside simplebookmark you should have the following files.

    __init__.py
    manage.py
    settings.py
    urls.py

We’re going to add a bookmark application to our simplebookmarks proejct. Inside the simplebookark directory run

python manage.py startapp bookmark

Now our structure has:

bookmark/
    __init__.py
    models.py
    views.py

Now we’re going to need some tables setup. Our models file contains our table structure for the bookmark application. We’re going to need a table for categories and bookmarks. The bookmarks table will have a foreign key to the categories table.

Open models.py in your editor and add:

from django.db import models

class Categories(models.Model):
  name = models.CharField(max_length=200)
  pub_date = models.DateTimeField('date published')

  def __unicode__(self):
    return self.name

class Bookmarks(models.Model):
  category = models.ForeignKey(Categories)
  name = models.CharField(max_length=200)
  url = models.CharField(max_length=255)
  notes = models.TextField()
  pub_date = models.DateTimeField('date published')

  def __unicode__(self):
    return self.name

Now that we have our models setup, we have to configure our project to use the bookmarks app.

Open your project’s ‘settings.py’ file and enter your database settings (you will also need to create your database if you have not already done so).

DATABASE_ENGINE = 'mysql'
DATABASE_NAME = 'simplebookmark'
DATABASE_USER = 'username'
DATABASE_PASSWORD = 'password'

Scroll to the INSTALLED_APPS section and add ‘simplebookmark.bookmark’ and ‘django.contrib.admin’ (django.contrib.admin tells django to autocreate the admin area)

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'simplebookmark.bookmark',
    'django.contrib.admin',
)

Alright, now we’re ready to generate some tables. In your terminal run

python manage.py sql bookmark

You should now see

BEGIN;
CREATE TABLE `bookmark_categories` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(200) NOT NULL,
    `pub_date` datetime NOT NULL
)
;
CREATE TABLE `bookmark_bookmarks` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `category_id` integer NOT NULL,
    `name` varchar(200) NOT NULL,
    `url` varchar(255) NOT NULL,
    `notes` longtext NOT NULL,
    `pub_date` datetime NOT NULL
)
;
ALTER TABLE `bookmark_bookmarks` ADD CONSTRAINT category_id_refs_id_6dc05859 FOREIGN KEY (`category_id`) REFERENCES `bookmark_categories` (`id`);
COMMIT;

Now lets create the tables

python manage.py syncdb

As this is the first time you’ve synced, you will be asked to create a superuser, simply fill in the details with any criteria you want (remember the username and password you specify).

If that completed successfully, you can now check out all the tables generated (using PhpMyAdmin), you can see that we now have 13 tables, including one for our categories and bookmarks.

Before we can checkout the admin area, we have to update our urls.py file.

Open urls.py and uncomment the following lines.

from django.contrib import admin
 admin.autodiscover()

and

 (r'^admin/(.*)', admin.site.root),

Now lets fire up the dev server and checkout our progress!!
Run

python manage.py runserver

The default port the dev server runs on is 8000, so open you web browser and goto http://127.0.0.1:8000/admin/
If everything is working correctly, you should see the login screen

Django Admin Login

Remember the username and password you entered when we ran the syncdb? Enter that now.

You should now see

Wait a minute, where’s the categories and bookmarks!! Simple, we have to tell django that the categories and bookmarks objects have an admin interface. To do this we have to create the admin.py file inside the bookmark directory and add

from simplebookmark.bookmark.models import Categories, Bookmarks
from django.contrib import admin

class BookmarksAdmin(admin.ModelAdmin):
  fields = ['category', 'name', 'url', 'notes', 'pub_date']

class CategoriesAdmin(admin.ModelAdmin):
  fields = ['name', 'pub_date']

admin.site.register(Bookmarks, BookmarksAdmin)
admin.site.register(Categories, CategoriesAdmin)

Save the file and refresh the page.
You should now have

Great, but lets fix the “Bookmakrss” and “Categoriess”

To do this, we need to import ‘ugettext_lazy’. At the top of models.py add:

from django.utils.translation import ugettext_lazy as _

and for each class we need to define our verbose_names

  class Meta:
    verbose_name = _('Category')
    verbose_name_plural = _('Categories')

and

  class Meta:
    verbose_name = _('Bookmark')
    verbose_name_plural = _('Bookmarks')

Save and refresh the page and you should now have “Bookmarks” and “Categories”.

Now, lets create our first category. Click the “Add” button next to categories.

As you can see, we have a place to enter the category name, along with our date and time (including a nice popup calendar). Lets go ahead and create our first category.

Now lets checkout the bookmarks section.

As you can see, we have a typical form for adding our bookmarks, along with a nice drop box for selecting which category to assign the bookmark to. Also, notice the plus next to the dropbox. This is so that we can create a new category with out haveing to leave the page to add a category.

This is the very basics of Django. I have only been playing around with  this wonderful framework a few days and there is so much more I could talk about (setting the Date Published to the current timestamp, adding multiple records at one time, filters, views, templates, etc, etc). I’ll have that for a later post.

Now this is what sparked this posting. I (like most guys) simply do not understand women.
I pointed out to my wife, that men are very quite simple. As men go, we are quite primal in nature. All a woman has todo remember three simple things.

Now, before getting to these three things I, want to give a small bit of background on myself so nobody gets (a completely) wrong impression. I am happily married and have been for 8 years now. We have three children together (2, 4, and 8 years in age). I get along great with my wife (not saying we don’t have a disagreement from time to time). So, I feel that have a very good relationship with my wife.

To the point:
Ok ladies, to sum up my three things to keep a man happy – make it about us!

• Feed Me
• Love Me
• Fuck Me

Feed Me – I enjoy a home cooked meal. I’m not saying I need a fat juicy steak every night. I am quite happy with anything, hamburger mac & cheese or sloppy joe’s upto a full blown meal with the works. Simply put, home made is always better than some fast food joint. It shows us guys that you care enough about us to spend abit of time preparing something for us to enjoy together. I eat dinner with my wife because I know she worked hard on the meal she’s prepared. We spend this time to talk about each other’s day and BS. I always compliment my wife on her cooking (her mother taught her well). Tell me, when was the last time you were complemented for picking up a Big Mac??

Love Me – To put it simple, act like you care about us. Nobody wants to get their balls ripped off when they walk in the door after a long day of work. Everybody makes a mistake from time to time, yelling and screaming at us is not going to do any good!! If all you can do is yell at us, we’re simply not going to pay any attention because we’re busy thinking about payback. Instead, talk to us like a person. Simply point out our mistake like “Honey, you forgot to take out the trash today” and leave it at that. If that’s all you say, you’re more likely to get a good reaction and we’ll try harder to do better. My point is, if you treat us kindly, we’ll treat you the way you want to be treated and when we goto work and hear our buddies talking their bitchy wife we’ll sit back and think about how good we have it. We remember this feelings out of the blue, this is where those surprises and random “I love you”s come from.

Fuck Me – Ok girls, you know how you simply get that unexplainable urge to have chocolate from time to time? Guess what, you’re our chocolate bunny!! We can’t explain it, it just hits and we’ve got to have you! We have to nibble on your ears, lick your neck and rub our hands all over your body. Lets us kiss you deeply and passionatly then slowly work our way up to your belly button. My wife does not understand how she can be cleaning house, doing laundry, brushing her teeth or simply be doing nothing and I’m ready to take her. Remember ladies, unless we’re completely occupied doing whatever it is we do (our hobbies, or work), we’re thinking about sex!! There’s no such think as a “clean” conversation in our mind, if it can be twisted to perversion, it will be. If you want to keep your man happy you have to give it up.

I’m not saying put out every hour on the hour (though you wont get any complaints), but I am saying it is one of our basic needs. Hell, we don’t even have to be in “the mood” – we’ll take it. So, even if you’re not in the mood showing us “the love” shows you care (even if it’s to get us to shut up). Think about the number of things we do that we really don’t want to.

If you want us to be happy all day, there’s simply nothing better than waking up getting some action (a BJ is even better). Think about it for a sec. We’ll goto work with the biggest cheeseball grin on our face. When something shitty happens at work that would normally upset us – it’s not that bad, all thanks to you!!

Now, we have three kids, I know the whole morning thing is not easy to pull off, but there’s good news for you ladies. Guys are visual creatures, showing us some skin will give us a grin, shake your titties at us while heading to the shower, bend over that way we like while your getting dressed or rub yourself between your legs or body – all these things will have us thinking about you ALL DAY LONG!!

To sum things up:

Ladies – any man (worth keeping anyway) will meet you half way. If you treat us nice, we’ll treat you nice. If you’re nasty, we’ll be nasty. A man DOES think about sex in one form or another 95% of the time. If you don’t think so, he’s gay or you simply do not know him well enough. If you’re with a man you want to keep, follow these three steps. We’re like a big dumb dog, all we need is food, love and that special attention. In return you’ll have our lasting love and obedience. If on the other hand you come home, throw a bag of takeout at us and start yelling and screaming… well, we can get #3 anywhere!

This posting is simply to show how much the environment a computer is in effects everything.

About a year ago, I setup a fileserver for a friend using an old computer they had laying around (old, old duron). About a month ago I get the computer back because it stopped working. The system simply would not boot successfully (perhaps once out of every 10 tries).

The photos are of a computer that is in a ‘garage’ slash office, in the country next to an open field.

I have been wanting something for personal projects for rapid development.

I am a strong believer in using whatever works best for the task at hand.

First, a little background:

We use Symfony where I work. While symfony is great, it is very resource intensive (we run a few dozen ecommerce sites with a database holding around 200 tables storing many gig of data) – so, in reality symfony really does fit the project. The downside is everything is running on multiple, mulitcore servers sitting on 8 to 16 Gig of memory.

While I cannot justify a beefy server setup for my own (or a clients) project, I do enjoy the benefits of using a framework.

I have been developing with the Zend Framework for outside projects and really do like the features available, but the biggest thing Zend is missing is a crud generator (I have even started building my own).

In my latest search to see what was out there, I came across a post comparing Symfony, RoR, and Django here. Like any opinion, it must be read with a grain of salt. I can however relate to the performance mentioned regarding the symfony framework. From past readings I was not very interested in RoR, so that left Django (which from the poster had the best performance).

Checking it out:

I did a quick scan over Django’s website, and feature list. Next I read the installation guide and the first page on the tutorial. Normally I can get a decent impression from simply ready a tutorial, but Django was not quite that way… But I got a good vibe from the feature list and the opinions for other bloggers, so I decided to take an existing vmware install and setup Django.

Django is a python framework, python is already included with many linux distro’s, so nothing to install for that. For Django it’s 3 simple steps:

• download Django.
• untar the downloadable file.
• run the install script.

That’s it!

For the first half of the tutorial, most of the work is done in the terminal – creating the project, setting up the database tables, modules, etc (alot like symfony).

Django also has an interactive python shell that integrates with Django’s API (nice for basic queries and such).

The majority of the tutorial is an intro to the *.py files that contain the framework’s settings (such as enabling the admin area). I’ll openly have to say that the admin pages generated are ALOT prettier than symfony’s default (at work we have customized the admin area – thank god) and offer more features and flexibility out of the box than symfony.

Most of the config settings are for what is included in the project and how it’s displayed (what fields, if they’re inside a collapsible div, setting filters and the like).

For example, the tutorial is setting up a Poll with choices. In the section where you add new choices you have a drop down box for which Poll to assign the choice to, Django has a setting so that next to the drop down box, you have an ‘add new’ icon for creating a new poll (which opens in a pop up window), you can also specify how many ‘new fields’ are available (say on the create new choice page, you want to have 3 fields for new entries) – all this is powered by settings in one file!

The file structure layout is very simple and modular.

You have a basic settings.py file, this is where you set your database settings, template dir, and included modules. There is also a urls.py file that basically handles url routing.

In the modules directory (in the example Polls directory), you have an admin.py which tells the admin area how to handle the generated pages for managing the module (display, filters, etc). Next is the models.py which works with the database fields, views.py that deals with the views, and you can also place a urls.py that handles all module related urls for the given module (simply include it in the project’s urls.py file).

My terminology may not be correct, this writeup is after going through the tutorial the first time.

I am not going to give a step-by-step reproduction of the tutorial, but can say I am impressed with what is able to be generated with very little code (a handful of files and non of them have more that 20 lines of code).

Conclusion:

I’ll  have to say, I am really impressed with what I have seen.

Pros:

• Simple to install.
• Simple to configure.
• Common MVC layout.
• 100% modular.
• Lightweight
• Powerful

Cons:

• Configuration files can be picky due to spacing.
• Error messages can leave you hunting in the dark for the real error.

This is the first time I have ever worked with python, so it will be somewhat of a learning curve, but I do believe (and others have also said) that the time is well worth the effort.

I have also ready about a few people using Django for the backend (administration area) and php for the frontend. I think this also would be a great middle ground.

Here’s the beginings of linux on the iPhone.

http://linuxoniphone.blogspot.com/2008/11/linux-on-iphone.html