blog.rhp.org

Disabling TextMate’s auto-open of previous projects

Richard Pistole — Sat, 26 Mar 2011 15:21:09 +0000

defaults write -app TextMate OakDisableSessionRestore 1

Quickie: Running a Controller action from a script in LightVC

Richard Pistole — Wed, 29 Sep 2010 22:10:45 +0000

Create scripts/test_action.php in your LVC app:
http://pastie.org/1190014

Excitin’.

Just be aware you’re running things from the command line, and the usual caveats with respect to running PHP CLI apply (superglobals, etc).

Mass-op plugin for Colloquy

Richard Pistole — Sun, 29 Aug 2010 22:24:09 +0000

There’s no massop command in Colloquy, so here’s a javascript plugin that does it.

Copy/paste the following as whatever.js in your ~/Application Support/Colloquy/PlugIns/ directory:

function opNick(nick, connection, view)
{
	connection.sendRawMessage("MODE " + view.target() + " +o " + nick);
}
 
function massOp(connection, view)
{
	var members = view.chatMembers();
	var len = members.length;
 
	for (var i = 0; i < len; i++)
	{
		if (!members[i].operator())
		{
			opNick(members[i].nickname(), connection, view);
		}
	}
	return false;
 
}
 
// process the command and return true if you handle it or false to pass on to another plugin
function processUserCommand( command, arguments, connection, view ) {
	// return true if the command was handled or to prevent other plugins or Colloquy from handling it
	if (command == 'mop')
	{
		massOp(connection, view);
		return true;
	}
	return false;
}

mysqli driver, prepared statements and geometry types

Richard Pistole — Mon, 23 Aug 2010 18:36:49 +0000

FYI:
PHP Warning: mysqli_stmt_bind_result(): Server returned unknown type 255. Probably your client library is incompatible with the server version you use!

Probably means you’re selecting a geometry type without calling AsText on it.
Instead of

SELECT
	place.location_point
FROM
	place
WHERE
	place.place_id = ?

do:

SELECT
	AsText(place.location_point)
FROM
	place
WHERE
	place.place_id

Supposedly this is fixed in PHP 5.3. That isn’t really useful information, nor is the snotty svn commit message to use mysqlnd.

See: http://www.mail-archive.com/php-bugs@lists.php.net/msg127837.html

A little TextMate black magic

Richard Pistole — Fri, 20 Aug 2010 01:47:09 +0000

I do most of my code editing in TextMate in OSX.

However my current code environment consists of a CentOS VM running under parallels.

I have my linux home directory mounted via SMB in OSX, but I like to do a lot of poking around on the files from the shell on the VM.

So, here’s a shell script to let me open files in TextMate from the VM:

#!/bin/tcsh
set f="`pwd`/$*"
set f="$f:s./home/pistole./Volumes/pistole/."
ssh wrath open -a /Applications/TextMate.app "$f"

Tutorial: Controllers and Actions in LightVC

Richard Pistole — Tue, 25 Aug 2009 18:15:23 +0000

In this tutorial, we continue to create an MVC application using the bare LightVC and CoughPHP distributions, focusing on Controllers and Views in LighVC.

For this tutorial, you will need to have the skeleton application created in the previous article on combining CoughPHP and LightVC, as well as our database table and generated CoughPHP code.

Step 1: Creating a new controller and action in LightVC.

Create a new file in controllers/ called post.php:


 
class PostController extends AppController
{
	public function actionIndex()
	{	
 
	}
 
}
 
?>

This creates a new controller, page and a the default index action.

Now we need to create a view corresponding to the action.
Create a folder in the views/ folder called post.
Create a file in views/post/ called index.php:

 echo time() ?>

(Notice how the name for the folder corresponds to the lowercase name of the controller, and the name of the view corresponds to the lowercase name of the action)

Now if you’ve been following along the tutorial, navigate to http://cms.rhp.org/post/ and you should see the result of your work:

New Action

This page is composited from several different parts.
The outer shell comes from views/layouts/default.php
The inner content comes from the view we just edited views/post/index.php
The css resides in webroot/css/master.css

Let’s edit the layout to remove the congratulations messages:


 
	
		Welcome to cms.rhp.org

Reload the page, and see the changes.

Now let’s put that action we created to some use by listing all the posts we’ve got in the system.

Step 2: Listing Posts

The first thing we need to do is create a method on Post_Collection to load all the non-deleted posts:

public function loadActive()
{
	$sql = '
		SELECT
			*
		FROM
			post
		WHERE
			is_deleted = 0
		ORDER BY
			post.name
	';
 
	$this->loadBySql($sql);
 
}

This is pretty straightforward, some SQL to fetch all the posts which we then pass to the loadBySql method that Post_Collection inherits from CoughCollection. This will populate the collection with all the posts. Note that the order in which the rows are retrieved will be the order they are in in the collection (unless we sort the collection after the fact), so we set an ORDER BY in the SQL statement.

Now to use it:

Edit the actionIndex method to create an instance of Post_Collection, and populate it, and then pass it to the view:

public function actionIndex()
{	
	$posts = new Post_Collection();
	$posts->loadActive();
 
	$this->setVar('posts', $posts);
}

Again, a note on conventions the same way we’re going to be using the singular for table names and objects representing individual rows in the table, we’re going to use the plural for aggregates.

Now edit views/post/index.php:


	
	foreach ($posts as $post)
	{
		?>
		
			 echo htmlentities($post->getName()) ?>
		
		
	}
	?>

Note that we call htmlentities on display to prevent any bad data in the db from messing up our page display.

Reload your index page, and if you’ve been following the tutorial, you should see the following:

Congratulations, you are dynamically reading data out of the db and displaying it on your page!

Next time: viewing and editing posts! Creating new posts!

Hashing Axapta 3 compatible passwords from PHP

Richard Pistole — Fri, 21 Aug 2009 17:01:18 +0000

As an interlude from the CoughPHP, I present the following:

The downside of working with legacy systems is that sometimes you find it necessary to work with existing data in ways that are completely arbitrary. The worst of all of these is password hashing.

It is often the case that you have to maintain compatibility with legacy passwords, and while you can replace the old algorithms going forward with a sensible schema, you still have to be able to validate against passwords stored in the old way.

So I present to you a way to hash passwords compatible with Axapta 3:

#!/usr/bin/php

echo "PHP_INT_SIZE: " . PHP_INT_SIZE . "\n";
 
function str2int($string)
{
	$string = strtolower($string);
	$tmpCode = "0x015A4E35";
 
	for ($i = 0; $i < strlen($string); $i++)
	{
		$tmpChar = gmp_and(gmp_init(ord($string[$i])), "0xff");
		$tmpCode = gmp_and($tmpCode, "0xFFFFFFFF");
		$tmpCode = gmp_add(gmp_and(gmp_mul($tmpCode, "8192"), "0x0FFFFE000"), gmp_and(gmp_div_q($tmpCode, "524288"), "0x000001FFF"));
		$tmpCode = gmp_xor($tmpCode, (gmp_and(gmp_mul($tmpChar, "32"), "0x01FE0")));
		$tmpCode = gmp_add(gmp_xor($tmpCode, $tmpChar), "3");
 
	}
	return gmp_and($tmpCode, "0xFFFFFFFF");
}
 
function int2code($intCode)
{
 
	$tmpCode = gmp_and($intCode,  "0xFFFFFFFF");
	$i = 0;
	$code = '';
	while ($i < 7)
	{
		$tmpByte = gmp_intval(gmp_mod($tmpCode, "0x24"));
		if ($tmpByte < 10)
		{
			$code = chr(ord('0') + (int)$tmpByte) . $code;
		}
		else
		{
			$code = chr(ord('A') + (int)$tmpByte - 10) . $code;
 
		}
		$tmpCode = gmp_div_q(gmp_mul($tmpCode, "0x38E38E39"), 8);
		$tmpCode = gmp_div_q(gmp_and($tmpCode, "0xFFFFFFFF00000000"), "4294967296");
		$i++;
	}
 
	return $code;
}
 
 
function cryptUserPass($password, $userName)
{
	$tmpConst = "0xA59C29F1";
 
	$tmpCode = gmp_xor(str2Int($userName . $password), $tmpConst);
	$code = int2Code($tmpCode);
 
	$tmpConst = gmp_and(gmp_add("0x928379A1", $tmpCode), "0xFFFFFFFF");
 
	$tmpCode = gmp_xor(str2Int($password), $tmpConst);
	$code = $code . Int2Code($tmpCode);
 
	return $code;
}
 
print_r(cryptUserPass('hello', 'jw02'));
echo "\n" . '0OYMDGB17QNP49' . "\n";

Or if you have a 64-bit PHP binary:

#!/usr/bin/php

echo "PHP_INT_SIZE: " . PHP_INT_SIZE . "\n";
 
function str2int($string)
{
	$string = strtolower($string);
	$tmpCode = 0x015A4E35;
 
	for ($i = 0; $i < strlen($string); $i++)
	{
		$tmpChar = ord($string[$i]) & 0xff;
		$tmpCode = $tmpCode & 0xFFFFFFFF;
		$tmpCode = (($tmpCode << 13) & 0x0FFFFE000) + (($tmpCode >> 19) & 0x000001FFF);
		$tmpCode = $tmpCode ^ (($tmpChar << 5) & 0x01FE0);
		$tmpCode = ($tmpCode ^ $tmpChar) + 3;
 
	}
	return $tmpCode & 0xFFFFFFFF;
}
 
function int2code($intCode)
{
 
	$tmpCode = $intCode & 0xFFFFFFFF;
	$i = 0;
	$code = '';
	while ($i < 7)
	{
		$tmpByte = $tmpCode % 0x24;
		if ($tmpByte < 10)
		{
			$code = chr(ord('0') + (int)$tmpByte) . $code;
		}
		else
		{
			$code = chr(ord('A') + (int)$tmpByte - 10) . $code;
 
		}
		$tmpCode = ($tmpCode * 0x38E38E39) >> 3;
		$tmpCode = ($tmpCode & 0xFFFFFFFF00000000) >> 32;
		$i++;
	}
 
	return $code;
}
 
 
function cryptUserPass($password, $userName)
{
	$tmpConst = 0xA59C29F1;
 
	$tmpCode = str2Int($userName . $password) ^ $tmpConst;
	$code = int2Code($tmpCode);
 
	$tmpConst = (0x928379A1 + $tmpCode) & 0xFFFFFFFF;
 
	$tmpCode = str2Int($password) ^ $tmpConst;
	$code = $code . Int2Code($tmpCode);
 
	return $code;
}
 
print_r(cryptUserPass('hello', 'jw02'));
echo "\n" . '0OYMDGB17QNP49' . "\n";

You probably don’t need this, but if you do, it’s a lifesaver.

Originally found in delphi. In Russian.

Creating Cough models for our CoughPHP/LightVC application

Richard Pistole — Fri, 10 Apr 2009 17:27:29 +0000

In this tutorial, we continue to create an MVC application using the bare LightVC and CoughPHP distributions, focusing on creating working cough model classes and using them in the application, as well as best practices for different deployment environment files for LightVC applications, CoughPHP generation config, and suggested db schema patterns.

For this tutorial, you will need to have the skeleton application created in the previous article on combining CoughPHP and LightVC, as well as a working installation of MySQL. Installing and configuring MySQL is outside the scope of this tutorial, but there are many pre-packaged versions available.

Step 1: Create our Post table
Actually step 0 is to create the database in mysql. For the purposes of this tutorial, we’re going to be using a database called ‘cms’, with a user also called ‘cms’. Note that unlike many ORMs, CoughPHP has no trouble with cross-database object relationships, so at a later point we may be using multiple databases for the purpose of organization.

		CREATE DATABASE IF NOT EXISTS `cms` ;
		GRANT ALL PRIVILEGES ON `cms` . * TO 'cms'@'localhost';

Now we’re going to create our sample Post table:

		CREATE TABLE `cms`.`post` (
		`post_id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
		`name` VARCHAR( 255 ) NULL DEFAULT NULL ,
		`body` TEXT NULL DEFAULT NULL ,
		`is_deleted` TINYINT( 1 ) NOT NULL DEFAULT '0',
		`date_created` DATETIME NULL DEFAULT NULL ,
		`date_modified` TIMESTAMP ON UPDATE CURRENT_TIMESTAMP NULL DEFAULT NULL
		) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;

A few notes on some of the conventions we will be using here:
* Singular table names:
Cough generates its objects names based on the table names and it would be confusing if the class representing a single row in the ‘posts’ table was called Posts, and your aggregate object was called Posts_Collection.
* is_deleted column: in general, it is a common idea to do logical deletes rather than actually deleting data from the db, and an is_deleted flag is one of the simpler paradigms. In future articles we will go into more detail about logical deletions, the reasonings behind them and how CoughPHP can work with them most effectively.
* c_style_naming: This is just convention, deal with it.
* table_name_id primary key: CoughPHP by default will look for joins to other tables by looking for columns named
_id. This can be configured, and joins can be manually specified, but we will take use the default for now.

Step 2: Create models directory, set up generate script, set up generator config:
Now that we have created a table to generate our objects from, we need to set up the CoughPHP generator to point at the right database, put the objects where we went them, etc.

First, create a directory in the cms project to hold our generated classes:
mkdir models
Next, we’ll create a shell script that will generate the classes:
edit config/generate:

		#!/bin/sh
		../modules/coughphp/scripts/cough -g generator_config $@

and make it executable”
chmod +x config/generate
And create our base generator configs:
mkdir config/generator_config cp ../modules/coughphp/config_examples/default/*.php generator_config/
Now to actually set up the generator configs. We’re going to tell it to put the generated classes into the models/ directory we just created.

edit config/generator_config/cough_generator.inc.php and add the following line:

		$generated = dirname(dirname(dirname(__FILE__))) . '/models/';

Now we need to tell the generator the connection information we’ll be using, as well as which databases to generate objects for.
Edit config/generator_config/database_schema_generator.inc.php and change the $config array:

		$config = array(
			'dsn' => array(
				'host' => 'localhost',
				'user' => 'cms',
				'pass' => 'mypassword',
				'port' => 3306,
				'driver' => 'mysql'
			),

			'database_settings' => array(
				'include_databases_matching_regex' => '/cms/x',
				'exclude_databases_matching_regex' => '/(_bak$)|(^bak_)|(^temp_)/',
			),
		);

Step 3: Generate
To generate the Cough objects:
cd config ./generate
You should get output similar to the following:

		Generating for ../config/generator_config
		=========================================
		Success writing 4 classes (220 lines) with 0 one-to-one relationships and 0 one-to-many relationships!

Now we only have 1 table, why is did it generating 4 classes?
For each table, Cough generates classes of two forms, a single and an aggregate. For each of these forms, it generates a base-class and if it doesn’t already exist, a sub-class.
This latter distinction is important. For a table called post, it will generate a Post_Generated class, which contains all the getters/setters/base CRUD logic/etc. It will also create an empty Post class for the developer to add functionality to. Similarly for the aggregate collections, it will create a Post_Colllection_Generated class and a Post_Collection class. Each time you re-run the generator, the *_Generated classes will be overwritten by the generator, but if the Post/Post_Collection classes already exist, they will be left untouched.

Step 4: App changes
Now that we have the models generated, we’ll need to modify the autoloader setClassPaths in config/application.php:

		Autoloader::setClassPaths(array(
			APP_PATH . 'classes/',
			APP_PATH . 'models/',
		));

Next we need to set up the application to include our database credentials. However, we might want to change database credentials between say the development and production versions of the application, so we’ll create a separate file with the credentials and include a symlink to it from inside application.php. That way when we deploy to production, we can just change the symlink.

mkdir config/environment
Create a file config/environment/dev.php:

		 'as',
			'driver' => 'mysql',
			'host' => '127.0.0.1',
			'user' => 'cms',
			'pass' => 'mypassword',
			'aliases' => array('cms'),
		));
		?>

Now symlink the file:
cd config/ ln -s environment/dev.php environment.php

Edit config/application.php and add the following lines before the line about loading routes:

	// Include env specific confs
	include('environment.php');

Step 5: Test Cough
Congratulations, you’ve successfully set up CoughPHP! Let’s test it out:
We’re going to add some code to the view action in the page controller, just to create a Post object, set some fields on it and then save it to the db. Next time we’ll talk about pulling it back out, and really doing something with it, with collections and actually using the View/Controller parts of the MVC paradigm.

For now, edit controllers/page.php and add the following to the actionPage method:

		$post = new Post();
		$post->setName('Test Post');
		$post->setBody('This is a test post.');
		$post->setDateCreated(date("Y-m-d H:i:s",time()));

		$post->save();

Now hit your http://cms.rhp.org or equivalent URL. If you get any error messages, make sure that all the CoughPHP classes are accessible by your apache user, make sure your config/application.php has the following lines in it:

		include(APP_PATH . 'modules/coughphp/load.inc.php');
		include(APP_PATH . 'modules/coughphp/as_database/load.inc.php');

And make sure your database is readable/writable by the user specified in your db configuration above.

Given a lack of errors, check your database. You should see a row in the post table!

Next Time:
We’ll create a simple list of all posts in the db, create/edit/view actions, and more!

Combining CoughPHP and LightVC

Richard Pistole — Mon, 16 Feb 2009 10:15:30 +0000

In this tutorial, we will be creating an MVC application using the bare LightVC and CoughPHP distributions.

For the purposes of this tutorial, I will be working on my Macbook, with Apache 2. You may need to consult your documentation on your webserver to set up the server configs correctly.

Step 1:
Download the LightVC and CoughPHP distribution files.

I am using CoughPHP version 1.3.5 and LightVC 1.0.4 for this tutorial.

Step 2:
Unpack the LightVC and CoughPHP distributions.
I used the following command to unpack LightVC:
cd ~/Documents/ mkdir Source cd Source unzip -d cms.rhp.org ~/Downloads/lightvc-1.0.4.zip
And CoughPHP:
cd ~/Documents/Source/cms.rhp.org cd modules tar -xzvf ~/Downloads/coughphp-1.3.5.tgz mv coughphp-1.3.5 coughphp

Step 3:
Prepare LightVC.
Upon unpacking the LightVC distribution, I noticed that unzip set the permissions wrong, so I had to do the following:
cd ~/Documents/Source/cms.rhp.org chmod -R a+r . chmod a+x * webroot/* views/* modules/coughphp modules/coughphp/*
In addition the autoloader will need a world writable tmp directory:
cd ~/Documents/Source/cms.rhp.org mkdir tmp chmod 777 tmp
Step 4:
Edit your /etc/hosts file:
sudo nano /etc/hosts
(you will be prompted for your password)
Change the 127.0.0.1 line to look like

		127.0.0.1	localhost cms.rhp.org

Step 5:
Edit your apache conf files and (re)start apache
sudo nano /etc/apache2/httpd.conf
Add the lines:

		
		    Options Indexes FollowSymLinks MultiViews

		    AllowOverride All

		    Order allow,deny
		    Allow from all

Replacing /Users/pistole/Documents/Source/cms.rhp.org/ with the path you installed LightVC into.
Then run
sudo nano /etc/apache2/extra/httpd-vhosts.conf
Add the lines:

		
		    ServerAdmin pistole@rhp.org
		    DocumentRoot "/Users/pistole/Documents/Source/cms.rhp.org/webroot"
		    ServerName cms.rhp.org
		    ErrorLog "/private/var/log/apache2/www-error_log"
		    CustomLog "/private/var/log/apache2/www-access_log" common
		    AddType application/x-httpd-php .php .html

Again, setting the right path. Also set the ServerAdmin to your email address.
Now start apache:
sudo /usr/sbin/apachectl start
If that doesn’t work, try:
sudo /usr/sbin/apachectl restart
Step 6:
Configure the Autoloader
edit cms.rhp.org/config/application.php and replace the following lines:

		// Lvc doesn't autoload the AppController, so we have to do it: (this also means we can put it anywhere)
		include(APP_PATH . 'classes/AppController.class.php');
		include(APP_PATH . 'classes/AppView.class.php');

with:

		include(APP_PATH . 'modules/coughphp/extras/Autoloader.class.php');
		Autoloader::setCacheFilePath(APP_PATH . 'tmp/class_path_cache.txt');
		Autoloader::excludeFolderNamesMatchingRegex('/^CVS|\..*$/');
		Autoloader::setClassPaths(array(
			APP_PATH . 'classes/',
		));
		spl_autoload_register(array('Autoloader', 'loadClass'));

This will load any classes named *.class.php in your cms.rhp.org/classes/ directory automagically, including the aforementioned AppController and AppView classes.
Step 7:
Load the base CoughPHP include:
Once again edit cms.rhp.org/config/application.php and add the following below the autoloader block:

		include(APP_PATH . 'modules/coughphp/load.inc.php');
		include(APP_PATH . 'modules/coughphp/as_database/load.inc.php');

Step 8:
You’re done!
You have successfully created a LightVC application that loads the CoughPHP framework! go to http://cms.rhp.org in your browser to see your handywork!
In the next part of our tutorial, we will set up CoughPHP to talk to the database, generate some models and use them in the application.

Welcome to blog.rhp.org

Richard Pistole — Mon, 16 Feb 2009 00:14:25 +0000

Welcome to my personal blog, blog.rhp.org. This blog will be kept updated with my musings on technology, programming tutorials and other randomness.

First up will be a series of articles detailing how to make a simple content management system in PHP using LightVC and CoughPHP, lightweight VC and ORM frameworks the combine to create a simple and powerful MVC solution.