New Features (2.0)

• Propel 1.7 moved to custom post types. Propel 2.0 now takes full advantage of the default UI functionality and used the interface provided by custom post types. This allows for better integration with WordPress as a whole, and Propel now plays well with other plugins that modify custom post types.
• In 1.7 project and task meta were stored as a single key as a serialized array. This made filtering data impossible. Each piece of data is now stored as an individual metakey (documentation will be provided on how to take advantage of this). This is why you will receive a database update notice when you upgrade from Propel 1.7 to 2.0.
• Changed the priority from 1-10 to use Low, Medium, and High instead. After the upgrade, any tasks previously with a priority of 1-3 will be low priority. Tasks with a priority with 4-7 will have a medium priority and tasks with a priority 8-10 will have a high priority.
• Changed progress from intervals of one to intervals of five. Upon upgrading, your previous tasks progress will be rounded to the nearest five.
• Removed the shortcode for a frontend display (sorry! I know some people used this, but it is kind of unnecessary. I will explain how to display your projects and tasks in the frontend in another post later)
• Ability to categorize tasks
• A better interface for adding terms to tasks
• Ability to assign projects to clients
• Ability to globally turn on/off start date, end date, project progress, and project client (keep in mind, using the “Screen Options” at the top of your WordPress admin pages, you can hide columns and widgets).
• Task “type” taxonomy – giving you the ability to classify tasks as bugs or features.

Partially Implemented / Hidden Features (2.1 ETA ~1.5 months)

• A taxonomy to reflect the “state” of a task –  Not Started, Started, Completed, Delivered, etc…
• Ability to add custom task “types”
• Better filtering (if you have a lot of tasks, it is very hard to manage the tasks via the All Tasks page)
• Roles and capabilities. In its current release, everyone can see all the tasks. The goal here is to create two “roles” – Project Manager and Developer. Developers would only see tasks assigned to them, while project managers would be able to see all tasks.
• Email notifications when a user is assigned a task, a task is updated, or a comment is made on a task.

Planned Features (2.2+)

• A full featured theme (this will likely be a paid add-on)
• GitHub post-receive hook endpoint (add comments to tasks and complete tasks when you commit to github)
• Integration with WP-Invoice (need help from the WP-Invoice guys for this)
• Ability to group tasks into “task lists” or “milestones” or “sprints” or “iterations” or whatever project management paradigm calls it.
• Gantt Chart
• Burn Down Chart
• Other charts that I don’t know about
• Features you request

class Test {
  private $foo;
  protected $bar;
  public $bat;

  public function __construct() {
    $this->foo = "lorem";
    $this->bar = "dolor";
    $this->bat = "amit";
  }
}

Now create a new instance of the class and cast it to an array.

$test = new Test();
print_r((array)$test);

The result is as follows:

Array
(
    [Testfoo] => lorem
    [*bar] => dolor
    [bat] => amit
)

On the surface it appears as if the private property had the class name prepended and the and the protected property had an astrick prepended. Now what happens if we cast this array back to an object?

$test_object = new Test();
$test_array = (array)$test_object;
var_dump((object)$test_array);

Results in:

object(stdClass)#2 (3) {
  ["foo":"Test":private]=>
  string(5) "lorem"
  ["bar":protected]=>
  string(5) "dolor"
  ["bat"]=>
  string(4) "amit"
}

How did PHP know the Testfoo key and the *bar key were private and protected? After all, doing the following does not work:

$test_array = array("Testfoo" => "lorem", "*bar" => "dolor", "bat" => "amit");
var_dump((object)$test_array);

It turns out, PHP stores meta information with the keys in the form of null bytes. Thus

$test_array = array(
  "\x00Test\x00foo" => "lorem",
  "\x00*\x00bar" => "dolor",
  "bat" => "amit"
  );
var_dump((object)$test_array);

Results in the object we expect.

object(stdClass)#2 (3) {
  ["foo":"Test":private]=>
  string(5) "lorem"
  ["bar":protected]=>
  string(5) "dolor"
  ["bat"]=>
  string(4) "amit"
}

Before we get started, here is some information about my system:

ubuntu@domU-12-31-38-04-6D-D7:~$ uname -a
Linux domU-12-31-38-04-6D-D7 2.6.38-8-virtual #42-Ubuntu SMP Mon Apr 11 07:04:38 UTC 2011 i686 i686 i386 GNU/Linux
ubuntu@domU-12-31-38-04-6D-D7:~$ lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 11.04
Release:	11.04
Codename:	natty

1. Install the necessary Ubuntu packages (not sure if you need all of these).

sudo apt-get install git build-essential libssl-dev libreadline5 libreadline5-dev zlib1g zlib1g-dev 

Note: For Ubuntu 11.10 use libreadline-gplv2-dev instead of libreadline5-dev

2. Install RVM. At the time of writing this, the Ruby and Gems in the official repo are a little out of date. Note: I am running this as root for a multi-user install (more on this can be found here.)

sudo bash < <(curl -sk https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)

3. Add necessary users to the RVM group.

sudo usermod -a -G rvm ubuntu

4. Now you need to restart your shell for the changes to take affect. You can try to source the necessary files, but it is just as easy to exit and restart a new session.

5. At this point, it is a good idea to run rvm notes and rvm requirements and do/install anything it tells you (at the time of writing this, there was nothing extra I needed to install. By the time you read this, that probably will not be the case)

6. I was having some major problems with zlib, so I had to install that (here for more information).

rvm pkg install zlib

7. Install Ruby 1.8.7 and set it as the default

rvm install 1.8.7
rvm --defaut use 1.8.7

8. Install Sinatra and Thin

gem install sinatra
gem install thin

$a['1st_key'] = "first_key";
$a['k e y'] = "value";

Now lets say, for whatever reason, we cast this array to an object:

$o = (object)$a;

This will convert all the array keys into the objects properties. But, how do we access them? Both $o->k e y and $o->1st_key are obvious syntax errors. As a solution, you can use curly braces.

echo $o->{'1st_key'};
echo $o->{'k e y'};

$url = "http://api.twitter.com/1/trends/1.json";
$data = json_decode(file_get_contents($url));
print_r($data);

Characters

Characters are broken up into two types: literal characters and special characters. Literal characters are treated literally while the regular expression treats special characters uniquely.
Special Characters
The following characters have special meanings, and we will explore their meanings in more depth soon.
[ ] \ ^ $ . | ? * + ( ) { }
Literal Characters
Any character that you can type on your keyboard, that is not a special character, is a literal character.

Character Classes

A character class allows you to match one out of all the characters in the set. Character classes are defined by using the square brackets [ ] and placing the list of characters between the brackets. For example [aeiou] will match a single vowel. Character classes also support the range operator (hyphen), so instead of writing [0123456789] to match a single digit, you can simply use [0-9]. If you want to use special characters in a character class you must escape them with the backslash. For example, if you wanted to match The square bracket you would use [\[]. You may also use non-printable characters and if your engine supports them, unicode characters as well. Some examples: [\t] will match the tab character, [\x09] will also match the tab character using hex notation. [\u0394] will match the unicode Greek letter capital delta.

Negated character classes
By using the carat after the opening square braket, you can negate a character class. As an example, if we want to only match consonants, we can negate our vowel character class we defined above [^aeiou]. This is a lot easier than creating a character class with the 21 consonants.

Shorthand Characters

The following shorthand characters are provided by many regular expression engines. However, if your engine does not support the shorthand characters, the equivalent character class is also provided.
\d matches a digit. The equivalent character class would be [0-9]
\w matches a word. The equivalent character class would be [a-zA-Z0-9_]
\s matches white space. The equivalent character class would be [ \t\r\n] (space, tab, or line break)
\D negated digit. This is the same as [^\d] or [^0-9]
\W negated word. This is the same as [^\w] or [^a-zA-Z0-9_]
\S negated white space. This is the same as [^\s] or [^ \t\r\n]
. The dot/period character will match anything, except for newlines characters, meaning the dot character is actually a negated newline class [^\n]. It is extremely powerful as it lets you be lazy, which is often a bad thing when you are trying to validate data.

Repeating Character Classes

Matching a single character is often necessary. However, under many circumstances, you will want to match more than one character. For this you can use quantifiers. Quantifiers are placed strong the character or character you want to match.
? The question mark will match zero or one character.
* The star, formally known as the Kleene star, will match a character zero or more times.
+ The plus will match a character one or more times.
Using curly brackets, you can specify quantities as well.
{5} This matches a character exactly five times.
{1,3} This matches a character one, two, or three times.
{5,} This matches a character five or more times.

Lets build a regular expression to match a phone number of the form 111-222-3333:

[\d]{3}-[\d]{3}-[\d]{4}

We can also make the hyphens optional

[\d]{3}-?[\d]{3}-?[\d]{4}

Anchors

Literal characters and character classes allow you to match characters, where as anchors allow you to match positions.
^ The carat matches the position before a string.
$ The dollar sign matches the position after a string.
It is important to not that when the carat is used inside a character class, it is used to negate the class. However, when the carat is used outside of a character class, it acts as an anchor. If we want to match the word the we would use the literal characters. However the would also match there and them. Using the dollar sign we tell the regular expression to only match patterns that end in the. Thus the$ will not match there and them since the words do not end in the. However, this regular expression will still match words like bathe and clothe. To fix this, we can use the carat to tell the regular expression to match only words that begin with the: ^the$

Modifiers

Modifiers allow you to change the behavior of some characters.
/i will make the expression case insensitive. By default, regular expressions are case sensitive. If you noticed above, when we specified the character class to match a word, we specified lowercase as well as uppercase characters. In some instances, you may want to turn off the case sensitivity, and for this you use the /i modifier.
/s enables single-line mode. In this mode, the dot character will match new lines.
/m enables multi-line mode. In this mode, the ^ and $ anchors will span multiple lines.

That is it for this tutorial. Next, we will take a look at grouping, back-references, look-aheads, look-behinds, and extend some of the concepts we have already looked at. Do you have any hand crafted regular expressions you would like to share? I would love to seem them in the comments below!

//because I can...
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

int main(int argc, char **argv) {

	if(argc != 3)
		printf("%s <input-file> <output-file>\n", argv[0]);

	FILE *input_file, *output_file;
	long size;
	char *buffer;
	size_t result;

	input_file = fopen(argv[1], "rb");
	if(input_file == NULL) { fputs ("File error", stderr); exit(1); }

	fseek(input_file, 0, SEEK_END);
	size = ftell(input_file);
	rewind(input_file);

	buffer = (char*)malloc(sizeof(char)*size);
	if (buffer == NULL) { fputs("Memory error", stderr); exit (2); }

	result = fread(buffer, 1, size, input_file);
	if (result != size) { fputs("Reading error", stderr); exit(3); }

	uint8_t header[54] =
		{
			'B', 'M', 	//2		signature
			0,0,0,0,	//6		size of BMP file in bytes
			0,0,		//8  	reserved must be zero
			0,0,		//10	reserved must be zero
			54,0,0,0,	//14	offset to start of image data
			40,0,0,0,	//18	size of BITMAPINFOHEADER structure, must be 40
			0,0,0,0,	//22	image width in pixels
			0,0,0,0,	//26	image height in pixels
			1,0,		//28	number of planes in the image, must be 1
			24,0,		//30	number of pits per pixel (1, 4, 8, or 24)
			0,0,0,0		//34	compression type
						//54	useless stuff
		};

	//Set the image size
	header[2] = (uint8_t)(size + sizeof header);
	header[3] = (uint8_t)((size + sizeof header) >> 8);
	header[4] = (uint8_t)((size + sizeof header) >> 16);
	header[5] = (uint8_t)((size + sizeof header) >> 24);

	//Do something fancy calculation for with the width/height
	header[18] = (uint8_t)(size/3);	//image width
	header[22] = (uint8_t)(1);		//image height

	output_file = fopen(argv[2], "wb");
	fwrite(header, sizeof header, 1, output_file);
	fwrite(buffer, size + sizeof header, 1, output_file);

	fclose(input_file);
	fclose(output_file);
	free (buffer);
	return 0;
}

dhcp197-066:~ johnciacia$ cat hello.c
#include <stdio.h>

int main(void) {
	printf("Hello, World!\n");
	return 0;
}

dhcp197-066:~ johnciacia$ cat hello.bmp
BM?6(#include <stdio.h>

int main(void) {
	printf("Hello, World!\n");
	return 0;
}

dhcp197-066:~ johnciacia$ hexdump hello.bmp
0000000 42 4d 84 00 00 00 00 00 00 00 36 00 00 00 28 00
0000010 00 00 1a 00 00 00 01 00 00 00 01 00 18 00 00 00
0000020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0000030 00 00 00 00 00 00 23 69 6e 63 6c 75 64 65 20 3c
0000040 73 74 64 69 6f 2e 68 3e 0a 0a 69 6e 74 20 6d 61
0000050 69 6e 28 76 6f 69 64 29 20 7b 0a 09 70 72 69 6e
0000060 74 66 28 22 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64
0000070 21 5c 6e 22 29 3b 0a 09 72 65 74 75 72 6e 20 30
0000080 3b 0a 7d 0a 00 00 00 00 00 00 00 00 00 00 00 00

(there is a small problem somewhere that leads to extra padding at the end, but oh well, they are null bytes)

To change the default company name, simply change the company associated with your contact information in the address book. Simple as that!

Recursively search your directory tree starting at . (dot) and chmod all the folders to 755.

find . -type d -exec chmod 755 {} \;

Recursively search your directory tree starting at . (dot) and chmod all the files (ignoring folders) to 644.

find . -type f -exec chmod 644 {} \;

Do you have any useful find commands? Please share below!