For example, this "raw php" code is verbose and inconsistent.

$a = explode(' ', 'FOO BAR');
$a = array_map('strtolower', $a);
sort($a);
echo implode(', ', $a); # "bar, foo"

Using _array, the same is as simple as:

echo _w('FOO BAR')->map('strtolower')->sort(); # "bar, foo"

Another example:

// read users from db
$qry = mysql_query("SELECT * FROM user");
$users = array();
while($rec = mysql_fetch_assoc($qry))
    $users[] = $rec;

// create list of names
$names = array();
foreach($users as $rec)
    $names[] = $users['name'];

// remove admin
$n = array_search('admin', $names);
if($n !== false)
    array_splice($names, $n, 1);

// format and print
$names = array_map('ucfirst', $names);
sort($names);
echo implode("<br>", $names);

with _array, this will be only two lines:

$users = _array()->from_call('mysql_fetch_assoc', mysql_query("SELECT * FROM user"));
echo $users->pluck('name')->remove('admin')->map('ucfirst')->sort()->join("<br>");

download

compact version (with comments stripped)

documentation

test file (requires testik)

Check some checkboxes and click 'foo' to sort this table.

The first column uses the following custom comparison function

// sort by checkboxes and then alphabetically

function compareCheckboxes(textA, textB, tdA, tdB) {
    var t = Number(tdA.firstChild.checked) -
        Number(tdB.firstChild.checked);
    if(t != 0) return t;
    return TableSort.compare.alpha(textB, textA);
}

When TS compares two cells, it calls the function with four arguments. The first two are text content from the first and from the second table cell. The next two (that's what I added) are cells "themselves", i.e. DOM <TD> elements, so that you can access cells' DOM contents in the function.

Of course, the above comparison needs to be enabled, you have to add something like this to the onload sequence:

TableSort.enable('tableID', 'columnTitle', compareCheckboxes);

See TableSort docs for more details.

download updated version

factorial.test.php:

// include what we're testing
require 'factorial.php';

// include and run testik
require 'testik.php';
testik();

// tests

factorial(2); # 2
factorial(5); # 120

You run this file (no matter, in browser or from the command line) and... see just nothing. If testik has nothing to complain, it doesn't bother you.

Now, let's add a new test to the suite:

factorial.test.php:

require 'factorial.php';

require 'testik.php';
testik();

factorial(2); # 2
factorial(5); # 120
factorial(3); # 8

If we run this, we'll see something like

test failed in factorial_test.php on line 16
expect: int(8)
actual: int(6)

You got the idea: testik looks for the lines in php source containing the '#' symbol and compares what's on the left of '#' (= actual value) to what's on the right (= expected value). Other lines are executed as is, so that your test cases can be arbitrary complex:

$db = DBFactory::connection();
$mapper = new UserMapper($db);
$st = $mapper->select('*')->where('id')->moreThan(10);

$st->count(); # 123 <-- testik 'sees' only this line

Of course, you can also group test cases in functions or class methods, testik doesn't enforce any particular structure, but it's your responsibility to call the test functions when appropriate.

Back to the factorial example, suppose you decided to document your package and provide a small text file with comments and examples.

factorial.doc

Hello!

This is my very own implementation of the factorial function
(http://en.wikipedia.org/wiki/Factorial)

MIT license

factorial($n) computes a factorial of $n

    factorial(4); # 24
    factorial(5); # 120

By definition, 1! = 0! = 1

    factorial(1); # 1
    factorial(0); # 1

Invalid input yields "error"

    factorial(-1);    # "error"
    factorial('foo'); # "error"

Number more than 10 yields "overflow"

    factorial(10);    # 3628800
    factorial(11);    # "overflow"
    factorial(111);   # "overflow"

Hope you like this function!

Although this file is not php, you can still use testik to test the code examples:

factorial.test.php

require 'factorial.php';

require 'testik.php';
testik('factorial.doc', 'text');

The second parameter equal to text tells testik to ignore all lines that start with a non-space and execute other (indented) lines, following the same '#' rule as above. This means essentially that you can directly use your 'readme' files or specifications as test suites and vice versa. Quite neat!

Sometimes there's no need for the separate documentation file and everything is documented in the code, e.g. using phpdoc syntax.

factorial.php

/**
    * Takes an integer and computes the factorial of it
    *
    * @param int
    * @return int | string
    *
    * <code>
    *    factorial(5); # 120
    *    factorial(1); # 1
    *    factorial(0); # 1
    * </code>
    *
    * invalid input yields "error"
    * <code>
    *    factorial(-1);    # "error"
    *    factorial('foo'); # "error"
    * </code>
    *
    * number more than 10 yields "overflow"
    * <code>
    *    factorial(10);    # 3628800
    *    factorial(11);    # "overflow"
    *    factorial(111);   # "overflow"
    * </code>
    *
**/
function factorial($n) {
...

To test this with testik, we need to modify our test file slightly:

factorial.test.php

require 'factorial.php';

require 'testik.php';
testik('factorial.php', 'doc');

doc means that testik should only execute code within <code>...</code> tags.

Ok, that's pretty much all about that. Of course, testik is a very simple facility, it doesn't contain fancy assertion rules and cannot replace SimpleTest'ing of a 100,000 lines codebase. The good news are that the whole 'framework' is only 50 lines long.

<?php
function testik($file = null, $mode = 'php') {
    $args = func_get_args();
    if(count($args) < 4) {
        $d = debug_backtrace(); $f = realpath($d[0]['file']);
        $file = is_null($file) ?  $f : realpath($file);
        $line = ($file == $f) ? $d[0]['line'] : 0;
        $text = implode("\n",
            ($line > 0 ? array_fill(0, $line, '#') : array()) +
            preg_split("~\r?\n~", file_get_contents($file)));
        switch($mode) {
            case 'php':
                if($file == $f)
                    $text = preg_replace('~\b(function)[ \t]+([a-zA-Z])~',
                        '$1 _DISABLE_$2', $text);
                break;
            case 'text':
                $text = preg_replace('~^\S.*~m', '//', $text);
                break;
            case 'doc':
                $text = explode("\n",
                    str_replace(array('@code', '@endcode'),
                    array('<code>', '</code>'), $text));
                $text = preg_replace('~^[ \t]*\*(?!/)~m', '', $text);
                $t = array_fill(0, count($text), '//');
                $c = 0;
                foreach($text as $n => $s)
                    if(!$c && strpos($s, "<code>") !== false) $c = 1;
                        else if($c && strpos($s, "</code>") !== false) $c = 0;
                            else if($c) $t[$n] = $s;
                $text = implode("\n", $t);
                break;
        }
        $text = preg_replace('~^[ \t]*echo (.+);[ \t]*#~m', 'strval($1); #', $text);
        $text = preg_replace('~^(.+);[ \t]*#[ \t]*(.+)$~m',
            __FUNCTION__ . "($1,$2,'$file',__LINE__);", $text);
        if(preg_match("~^\s*<\?~", $text)) $text = "?>$text";
        #foreach(explode("\n", $text) as $k=>$v) printf("<pre>%04d: %s</pre>\n", $k+1, $v);
        eval($text);
        if($file == $f) exit;
    } else if($args[0] != $args[1]) {
        ob_start();
        echo "test failed in $args[2] on line $args[3]\n";
        echo "expect: "; var_dump($args[1]);
        echo "actual: "; var_dump($args[0]);
        $s = ob_get_clean();
        (php_sapi_name() == 'cli') ? fwrite(STDERR, $s) :
            print("<pre>" . htmlspecialchars($s) . "</pre>");
    }
}
?>

download

f(some_string) replaces ("interpolates") placeholders like $var or ${var} or $5 in the string. f can be called with one, two or more arguments. If only one argument is given (= the format string), $var placeholders are replaced with global variables or window properties:

s = f("position $screenX, $screenY");
alert(s);

try it

With two arguments, the second should be an object and $var s are replaced with the corresponding properties of that object

img = {
    src: 'woo.gif',
    title: 'hello',
    width: 150
};
s = f("<img src='$src' title='$title' style='width:${width}px'>", img);
alert(s);

try it

Numeric placeholders $1 , $2 etc. are replaced with the value of the n-th argument:

s = f("There are $1 monkeys on the $2", 100, 'tree');
alert(s);

try it

You can mix numeric and symbolic placeholders:

format = { bg: "black", fg: "white" }
s = f("<p style='background:$bg;color:$fg'>$2</p> ", format, "hello");
alert(s);

try it

\\$ or $$ escape the dollar sign:

s = f("$1 costs \\$2 and $2 costs $$5", "a beer", "a meal");
alert(s);

try it

<span class='foo'>the pic of my class mate</span>

We need to replace "class" with "school". The naive

$html = preg_replace('/class/', 'school', $html);

will obviously break the formatting. We need a more sophisticated expression with lookaround groups. Although it would work for the simple case like this, it can grow very complicated or, given the fact that lookbehids are fixed in length, just become impossible at some point. For example, how about "remove newlines everywhere except tags and inside <script> or <pre> "?

The alternate method I often use is to replace things step-by-step: first, remove everything we want to ignore (leaving some 'invisble' markers in text to be able to insert things back), apply transformation to the rest of the text and, finally, restore things we've removed before.

Here's a small class that illustrates this technique

class Clipboard
{
    var $_buf = array();

    function _tr($n) {
        static $dc = "0123456789";
        static $sc = "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19";
        return intval($n) ? strtr($n, $dc, $sc) :
            intval(strtr($n, $sc, $dc));
    }
    //
    function cut($subject, $regexp = null) {
        if(is_array($subject)) {
            $this->_buf[] = $subject[0];
            return "\x01" . $this->_tr(count($this->_buf)) . "\x01";
        }
        return preg_replace_callback($regexp,
            array(&$this, 'cut'), $subject);
    }
    function paste($subject) {
        if(is_array($subject))
            return $this->_buf[$this->_tr($subject[1]) - 1];
        return preg_replace_callback("~\x01([\x10-\x19]+)\x01~",
            array($this, 'paste'), $subject);
    }
}

For example, let's uppercase all text nodes in some html document. First, put together a regexp that represents a html tag.

$html_tag = <<<REGEXP
    ~
        </?\w+
            (
                "[^"]*" |
                '[^']*' |
                [^"'>]+
            )*
        >
    ~sx
REGEXP;

Instantiate a new Clipboard and cut (remove) all tags:

$c = &new Clipboard;
$html = $c->cut($html, $html_tag);

Make the rest uppercase and insert the tags back:

$html = strtoupper($html);
echo $c->paste($html);

For less verbosity, the calls can also be nested:

echo $c->paste(strtoupper($c->cut($html, $html_tag)))

This technique (along with other regexp tricks) is extensively used in makrell.

foreach(new Combinations("ABCD", 2) as $substring)
    echo $substring, ' ';

prints

AB AC AD BC BD CD

$fruits = array('apple', 'banana', 'orange', 'pear');
foreach(new Combinations($fruits, 3) as $k => $v)
    echo $k + 1, ' ', implode(',', $v), " \n";

prints

1 apple,banana,orange
2 apple,banana,pear
3 apple,orange,pear
4 banana,orange,pear

The code is partially based on the java one found here.

class Combinations implements Iterator
{
    protected $c = null;
    protected $s = null;
    protected $n = 0;
    protected $k = 0;
    protected $pos = 0;

    function __construct($s, $k) {
        if(is_array($s)) {
            $this->s = array_values($s);
            $this->n = count($this->s);
        } else {
            $this->s = (string) $s;
            $this->n = strlen($this->s);
        }
        $this->k = $k;
        $this->rewind();
    }
    function key() {
        return $this->pos;
    }
    function current() {
        $r = array();
        for($i = 0; $i < $this->k; $i++)
            $r[] = $this->s[$this->c[$i]];
        return is_array($this->s) ? $r : implode('', $r);
    }
    function next() {
        if($this->_next())
            $this->pos++;
        else
            $this->pos = -1;
    }
    function rewind() {
        $this->c = range(0, $this->k);
        $this->pos = 0;
    }
    function valid() {
        return $this->pos >= 0;
    }
    //
    protected function _next() {
        $i = $this->k - 1;
        while ($i >= 0 && $this->c[$i] == $this->n - $this->k + $i)
            $i--;
        if($i < 0)
            return false;
        $this->c[$i]++;
        while($i++ < $this->k - 1)
            $this->c[$i] = $this->c[$i - 1] + 1;
        return true;
    }
}

This code generates permutations in a "lexicographical" (alphabetical) order. We start with the sorted array of numbers and repeat until array is reverse sorted:

$a = array(1, 2, 3);
$k = 0;
do {
    echo ++$k, '. ', implode('', $a), " <br> \n";
} while(next_permutation($a));

1. 123
2. 132
3. 213
4. 231
5. 312
6. 321

This works ok, but not good enough: first, it's limited to integer arrays, we'd like it to work with arbitrary arrays and strings, and second, do...while is certainly not the best way to loop, we want the "natural" php way, i.e. foreach. Fortunately, there is the Iterator interface in php5, we can utilize it to make our "API" as simple as

foreach(new Permutations("ABC") as $k => $v)
    echo $v, " <br> \n";

or

$fruits = array('apple', 'banana', 'orange');
foreach(new Permutations($fruits) as $k => $v)
    echo implode(' ', $v), " <br> \n";

The code is as follows:

class Permutations implements Iterator
{
    protected $c = null;
    protected $s = null;
    protected $n = 0;
    protected $pos = 0;

    function __construct($s) {
        if(is_array($s)) {
            $this->s = array_values($s);
            $this->n = count($this->s);
        } else {
            $this->s = (string) $s;
            $this->n = strlen($this->s);
        }
        $this->rewind();
    }
    function key() {
        return $this->pos;
    }
    function current() {
        $r = array();
        foreach($this->c as $k)
            $r[] = $this->s[$k];
        return is_array($this->s) ? $r : implode('', $r);
    }
    function next() {
        if($this->_next())
            $this->pos++;
        else
            $this->pos = -1;
    }
    function rewind() {
        $this->c = range(0, $this->n - 1);
        $this->pos = 0;
    }
    function valid() {
        return $this->pos >= 0;
    }
    //
    protected function _next() {
        $n = count($this->c);
        if($n == 1) return false;
        for($i = $n - 2; $this->c[$i] > $this->c[$i + 1]; $i--)
            if(!$i) return false;
        for($j = $n - 1; $this->c[$i] > $this->c[$j]; $j--);
        $q = $this->c[$j];
        $this->c[$j] = $this->c[$i];
        $this->c[$i] = $q;
        while(++$i < --$n) {
            $q = $this->c[$n];
            $this->c[$n] = $this->c[$i];
            $this->c[$i] = $q;
        }
        return true;
    }
}

Every templating engine comes with its own language and even if it appears simple, you still have to learn it and to teach it to someone else, for example the designer you're working with. Sometimes the language is great, but not extensible, sometimes it's practical, but ugly, sometimes it just doesn't do what you want.

On the contrary, makrell doesn't have any hard-coded language, instead it provides the means for creating your own one on the fly. You are who decides what syntax is right for you.

Ok, enough happy talk for now. Let's just make a simple website with makrell. The first (and only) php file we need looks like this:

file: index.php

include 'makrell.inc.php';

$page = key($_GET);
if(!ctype_alpha($page))
    $page = 'index';

$m = new Makrell;
echo $m->parse_file("$page.html");

We get an url like index.php?about and tell makrell to parse and output the file about.html .

The layout of our site is quite conventional: there is a header, navigation menu, content area and a footer.

file: index.html

header
navigation
content
footer

If we run it right away, what do we see?

header navigation content footer

Well... what did we expect? makrell is powerful, but it will not magically create our site for us. We have to tell it what we want.

file: index.html

header
navigation
content
footer

header {{
    logo <b>title</b>
}}

navigation {{
    <div>
    | <a href="?about">About us</a>
    | <a href="?news">News</a>
    | <a href="?services">Services</a>
    </div>
}}

footer {{
    <p><small>copyright, terms of use</small></p>
}}

What do we see now?

logo title

| About us | News | Services

content

copyright, terms of use

What happened? makrell has "expanded" the macros, i.e. replaced "header", "navigation" and "footer" with corresponding {{ ... }} blocks. The word "content" is not replaced, because we didn't define any substitution for it.

Did I say makrell doesn't have syntax? I lied. Of course, macro definitions must follow the rules, otherwise makrell won't be able to recognize them. The syntax is simple, though

macro {{ substitution }}

The macro doesn't have be an identifier, we could also have used {header} or <header/> or even <ilovexml:tag xmlns:xmllovesme="blah" foobar:tagname="header" /> ... Just name it like you want, makrell doesn't limit your creativity.

Since we've got three navigation items (about, news, services), we need three html files besides index. Apparently, the header, navigation and footer are common to all pages, it would be a good idea to store them in a separate file:

file: layout

header
navigation
content
footer

header {{
    logo <b>title</b>
}}

navigation {{
    <div>
    | <a href="?about">About us</a>
    | <a href="?news">News</a>
    | <a href="?services">Services</a>
    </div>
}}

footer {{
    <p><small>copyright, terms of use</small></p>
}}

Now, in index.html we define only homepage content and attach layout , that takes care of the rest:

file: index.html

{{ include layout }}

content {{
    <p>Welcome to our site!</p>
}}

logo title

| About us | News | Services

Welcome to our site!

copyright, terms of use

Once we have this, the rest is easy:

file: about.html

{{ include layout }}

content {{
    <p>Content for "about us" page</p>
}}

and the same for the "services" page:

file: services.html

{{ include layout }}

content {{
    <p>Our services</p>
}}

Just to make things interesting, suppose that the "news" page has a different header. To achieve that, we don't need to touch our layout , we just define the header once again in news.html :

file: news.html

{{ include layout }}

header {{
    <b>Hot News</b>
}}

content {{
    <p>Some news</p>
}}

Hot News

| About us | News | Services

Some news

copyright, terms of use

Since the new definition is textually below that of layout , makrell "prefers" it over the old one. The whole thing is much like how inheritance in object-oriented languages works: we build an abstract prototype and override some parts of it to create specific functionality.

Of course, makrell can do much more than simply replacing one string with another, but more on that later... in the meantime, feel free to download makrell and to view examples

$users = array(
    array('id' => 1,
        'name' => 'Joe',
        'age' => '15',
        'city' => 'London'),
    array('id' => 12,
        'name' => 'Sally',
        'age' => '25',
        'city' => 'Yoknapatawha'),
    array('id' => 123,
        'name' => 'Yu',
        'age' => '35',
        'city' => 'Seoul'),
    array('id' => 12345,
        'name' => 'Ermenegildo',
        'age' => '45',
        'city' => 'Roma'),
);

and want (for whatever reason) a plain text table like in mysql command-line client:

+-------+-------------+-----+--------------+
| id    | name        | age | city         |
+-------+-------------+-----+--------------+
| 1     | Joe         | 15  | London       |
+-------+-------------+-----+--------------+
| 12    | Sally       | 25  | Yoknapatawha |
+-------+-------------+-----+--------------+
| 123   | Yu          | 35  | Seoul        |
+-------+-------------+-----+--------------+
| 12345 | Ermenegildo | 45  | Roma         |
+-------+-------------+-----+--------------+

The function is as follows:

function text_table($data) {
    $keys = array_keys(end($data));
    $size = array_map('strlen', $keys);
    foreach(array_map('array_values', $data) as $e)
        $size = array_map('max', $size,
            array_map('strlen', $e));
    foreach($size as $n) {
        $form[] = "%-{$n}s";
        $line[] = str_repeat('-', $n);
    }
    $form = '| ' . implode(' | ', $form) . " |\n";
    $line = '+-' . implode('-+-', $line) . "-+\n";
    $rows = array(vsprintf($form, $keys));
    foreach($data as $e)
        $rows[] = vsprintf($form, $e);
    return $line . implode($line, $rows) . $line;
}

# example

echo "<pre>\n";
echo text_table($users);
echo "</pre>\n";

It expects two arguments: vars is a hash that maps variables' names to values (as in compact), body is the code of resulting function. Within the body , $0, $1 etc. can be used as arguments placeholders.

function closure($vars, $body) {
    global $_cvars;

    if(!isset($_cvars))
        $_cvars = array();
    $len = count($_cvars);
    $_cvars[$len] = $vars;

    $argc = 0;
    preg_replace('/\$(\d)/e', '$argc = max($argc, $1)', $body);
    $args = '$_' . implode("='',\$_", range(0, $argc)) . "=''";
    $expr = preg_replace('/(?<!\\\\)\\$(\d)/', '$_$1', $body);

    return create_function($args, "
        extract(\$GLOBALS['_cvars'][$len], EXTR_REFS);
        $expr;
    ");
}

Example of using closure :

# fibonacci n-step number generator
# http://mathworld.wolfram.com/Fibonaccin-StepNumber.html

function fibonacci($n) {
    $a = array(1);
    return closure(compact('a', 'n'), '
        $f = end($a);
        $a[] = array_sum($a);
        if(--$n <= 0)
            array_shift($a);
        return $f;
    ');
}

# ordinary fibonacci numbers
$f = fibonacci(2);
for($i = 0; $i < 20; $i++)
    echo $f(),' ';

# tetranacci numbers
$f = fibonacci(4);
for($i = 0; $i < 20; $i++)
    echo $f(),' ';

Calling compact and typing-in lists of variables can become tedious, therefore there's another interface that is able to discover variables automatically. The price is that you must use eval with it.

function cc($body) {
    $body = addcslashes($body, "'\\");
    $v = array();
    preg_replace('/(?<!\\\\)\\$([a-zA-Z]\w*)/e',
        '$v[]="$1"', $body);
    if(!count($v))
        return "return closure(array(), '$body');";
    $v = "'" . implode("','", array_unique($v)) . "'";
    return "return closure(compact($v), '$body');";
}

The usage is eval(cc('function body')) . Note that cc is not very accurate about parsing, fancy variable-variables syntax will probably confuse it. Præmonitus, præmunitus. ;)

cc example:

function file_reader($filename) {
    $fp = fopen($filename, "r");
    return eval(cc('
        $line = fgets($fp);
        if(FALSE === $line)
            fclose($fp);
        return $line;
    '));
}

function sql_reader($query, $separator) {
    $qq = mysql_query($query);
    return eval(cc('
        $rec = mysql_fetch_row($qq);
        if(!$rec) {
            mysql_free_result($qq);
            return FALSE;
        }
        return implode($separator, $rec);
    '));
}

function line_printer($reader) {
    $n = 0;
    while(FALSE !== ($line = $reader())) {
        $n++;
        print "line $n: $line<br>\n";
    }
}

# lets print a file, line-by-line
line_printer(file_reader(__FILE__));

# lets print a mysql table
line_printer(sql_reader('SHOW VARIABLES', '='));

function qe($body) {
    static $cache = array();
    if(!isset($cache[$body])) {
        $argc = 0;
        preg_replace('/\$(\d)/e', '$argc = max($argc, $1)', $body);
        $args = '$_' . implode("='',\$_", range(0, $argc)) . "=''";
        $expr = preg_replace('/\$(\d)/', '$_$1', $body);
        $cache[$body] = create_function($args, "return $expr;");
    }
    return $cache[$body];
}

qe() (= "quoted expression") creates a dynamic function from an expression given in a string. $0...$9 act as function parameters (like in preg_replace). Examples

# find odd numbers < 30

$a = array_filter(range(1, 30), qe('$0 % 2'));
print_r($a);

# muliply two arrays

$a = array(3, 5, 7);
$b = array(4, 6, 8);

$product = array_map(qe('$0 * $1'), $a, $b);
print_r($product);

Unlike create_function, qe also caches its results, so that the identical functions are created only once. This is quite practical when calling qe in a loop.

qe requires its argument to be an expression, i.e. no operators are allowed. The slight variation called qf ("quoted function") takes the complete function body as an argument.

function qf($body) {
    static $cache = array();
    if(!isset($cache[$body])) {
        $argc = 0;
        preg_replace('/\$(\d)/e', '$argc = max($argc, $1)', $body);
        $args = '$_' . implode("='',\$_", range(0, $argc)) . "=''";
        $expr = preg_replace('/\$(\d)/', '$_$1', $body);
        $cache[$body] = create_function($args, "$expr;");
    }
    return $cache[$body];
}

Example

$apples = array(0, 1, 2, 3);

$messages = array_map(qf('
    if($0 == 0) return "no apples";
    if($0 == 1) return "one apple";
    else return "$0 apples"
'), $apples);

print_r($messages);

Of course, this kind of code only makes sense with very short function definitions.

Convert object to a new class is fairly simple, because serializer stores class name along with object's data. The new mutated object inherits the properties from source object, but not methods.

function to_class($obj, $klass) {
    return unserialize(preg_replace(
        '/^O:\d+:\"(\w+)/',
        'O:' . strlen($klass) . ':"' . $klass,
        serialize($obj)));
}

# example

class A {
    public $a_var = "var in A\n";
    function a_method() {
        echo "method in A\n";
    }
}

class B {
    public $b_var = "var in B\n";
}

$old = new B;
$new = to_class($old, 'A');
$new->a_method();
echo $new->a_var;
echo $new->b_var;

accessing private members

More convoluted (and far dirtier) serialize trick for accessing private members from outside of the class.

function get_private($obj, $member) {
    $c = get_class($obj);
    $s = array("O:".strlen($c).":\"$c\"", "\000$c\000$member");
    $r = array("O:8:\"stdClass\"", "\001$c\001$member");
    $q = unserialize(str_replace($s, $r, serialize($obj)));
    return $q->{$r[1]};
}

function set_private(&$obj, $member, $value) {
    $c = get_class($obj);
    $s = array("O:".strlen($c).":\"$c\"", "\000$c\000$member");
    $r = array("O:8:\"stdClass\"", "\001$c\001$member");
    $q = unserialize(str_replace($s, $r, serialize($obj)));
    $q->{$r[1]} = $value;
    $obj = unserialize(str_replace($r, $s, serialize($q)));
}

# example:

class A {
    private $x = 'foo';
    function echo_priv() {
        echo "private x= ",  $this->x, "\n";
    }
}

$a = new A();

echo get_private($a, 'x'), "\n";

$a->echo_priv();
set_private($a, 'x', 'NEW');
$a->echo_priv();

Important notice: these functions are not for use in production environments. ;)

lazy ajax

At page load time, Ajaxik finds forms and links in document, that have jtarget attribute and makes them ajax'able. When user clicks such a link (or submits such a form), server response will be inserted in a html element instead of reloading the whole page. The value of jtarget should be an ID of that element.

<a href="/files/ajaxik/test.php" jtarget="BOX">click me</a>

<div id="BOX"></div>

If for some reason ajax cannot be started or any kind of error occurs during transfer, Ajaxik "downgrades gracefully" and just follows the link (or submits).

on-demand initialization

If you feel uncomfortable with a non-standard attribute and autoload, you can also ajaxize html elements in an unobtrusive way.

Ajaxik.enable(element, target)

This makes given element (link or form) ajax'able. element and target are DOM objects or their ids. No changes in html are needed.

<div id="LINKS"><a href="/files/ajaxik/test.php">click me</a></div>
<div id="BOX"></div>

....

<script>
window.onload = function() {
    Ajaxik.enable(
          document.getElementById("LINKS").firstChild, 
          "BOX")
}
</script>

loading feedback

When Ajaxik starts receiving data from the server, it searches for a special event handler on the target element: onajax . If defined, the handler is invoked with three arguments: readyState (which is XMLHttpRequest readyState property), text (= server response, responseText) and xmlhttp (XMLHttpRequest itself).

<a href="/files/ajaxik/test.php" jtarget="BOX_2">click me too</a>

<div id="BOX_2" 
   onajax="this.innerHTML = (readyState==4) ? text : 'Loading...' "
></div>

Note that if you define the handler directly in HTML (like above), you should name the arguments exactly as documented. Out-of-line definition allows arbitrary argument names:

someElement.onajax = function(ready, text_from_server, xml_http) { ... }

on the server side

Ajaxik adds __ajax__ variable (equal to some random integer) to the request. This makes it possible for server-side script to tell the difference between "normal" and ajax calls, e.g.

if(isset($_REQUEST['__ajax__']))
    // output only updated block
else
    // output whole page

api

For direct http communication there are two methods in Ajaxik, get and post :

Ajaxik.get(url, proc);
Ajaxik.post(url, data, proc);

proc is an (optional) onpropertychange callback, that takes three arguments: readyState, text and XMLHttpRequest object.

Ajaxik.get('page.php', function(readyState, text, xmlhttp) {
    if(readyState == 4) {
        if(xmlhttp.status == 200)
            alert(text);
        else
            alert("Error!");
    }
})

Adjacency lists are widely used to store trees in SQL tables. With ALs, inserts and updates are cheap, but retrieving the whole tree is tricky. Some people use recursion and nested queries for this (which doesn't scale well) or build JOIN statements dynamically (which is messy). The "pure php" solution is, on the contrary, quite trivial: we simply select all rows and "sieve" them through tree builder function.

function adj_tree(&$tree, $item) {
    $i = $item['id'];
    $p = $item['parent_id'];
    $tree[$i] = isset($tree[$i]) ? $item + $tree[$i] : $item;
    $tree[$p]['_children'][] = &$tree[$i];
}

$tree = array();
$rs = my_query("SELECT * FROM categories");
while($row = my_fetch($rs))
    adj_tree($tree, $row);

At the end, $tree[0] contains the root of the hierarchy. Moreover, $tree[N] will be a subtree for the node with id = N, so you can easily select subtrees.

Indented lists

The second function reconstructs the tree from the data "printed" as an indented list like this one (spaces replaced with dots for clarity):

Hardware
...Scanners
....Monitors
......CRT monitors
.......LCD monitors
...Input devices
......Keyboards
......Mice

The function is as follows:

function indent_tree($text, $indent = ' ') {
    $root  = array();
    $stack = array(&$root);
    $depth = -1;
    $temp  = array();
    $re = '/^(' . preg_quote($indent) . ')+/';
    $len = strlen($indent);

    foreach(explode("\n", trim($text)) as $line) {
        $v = preg_replace($re, '', $line);
        $k = (strlen($line) - strlen($v)) / $len;
        while($depth-- >= $k)
            array_pop($stack);
        while(++$depth < $k) {
            array_unshift($temp, array());
            $stack[count($stack) - 1]['_children'][] = &$temp[0];
            $stack[] = &$temp[0];
        }
        $stack[count($stack) - 1]['value'] = trim($v);
    }
    return $root;
}

The code doesn't require the list to be precisely indented: indents are rounded down, you only need to pass the "average" indent string (in above case, it would be three spaces).

download js file

usage

<script src="tablesort.js"></script>

that's all about it. ;)

By default, the script starts automatically at page load and makes all tables in document sortable. To disable autostart, set TableSortNoAutoStart to true before including the script.

As usual, your tables should be divided into THEAD and TBODY, you also need to declare three css classes for table header cells, for example:

/* indicates that the column can be sorted */
td.sortable
    { background:#606060; font-weight: bold; cursor: pointer; }

/* indicates that the column is sorted from low to high */
td.sorted_asc
    { background:#606060 url(up.gif) center right no-repeat; }

/* indicates that the column is sorted from high to low */
td.sorted_desc
    { background:#606060 url(down.gif) center right no-repeat; }

data types

TS can handle different kinds of data in table columns. The built-in sorting rules are

• nocase -- case-insensitive sort (default)
• alpha -- case-sensitive sort
• numeric -- 123 or 123.5 or 1e+3
• natural -- natural sort (like Image column in the table above)
• currency -- currency values like $0,55 or 1,234.56€
• date -- dates (in any format javascript parse can handle)
• usdate -- US dates (mm/dd/yyyy)
• eudate -- German dates (dd.mm.yyyy)

TS is able to detect most data types based on the contents of the first cell in the column.

api

For javascript programmers among us ;) TS provides two public functions: enable() and sort() . The prototype of enable() is as follows

TableSort.enable(table, column, compare)

This turns on sorting of table table on column column using compare as comparison function (well, was it really necessary to say that? Good programs don't need any documentation, do they? ;) Anyways,

• table is either an id or DOM table object
• column is a column number (starting from 1) or title (without any html)
• compare is one of the rules listed above (in quotes) or a pointer to your own comparison function (as in sort)

If an argument is omitted (use '' or null as placeholder when appropriate), TS uses the following defaults:

• if table is omitted, it takes all tables (with THEADs)
• if column is omitted, all columns will be sortable
• if compare is omitted, TS does its best to guess the correct datatype for the column

Examples:

// sort all columns in all tables using default comparison rules
TableSort.enable()

// sort 'Points' (the second) column in the 'people' table
// using default comparison rule
TableSort.enable('people', 'Points')

// same as above
TableSort.enable('people', 2)

// same as above
TableSort.enable(document.getElementsByTagName('TABLE')[0],  2)

// sort 'Created at' using 'human date' comparison
TableSort.enable('people', 'Created at', 'date')

// sort 'Product Number' in all tables using custom comparator
TableSort.enable('', 'Product Number',  MyDomain.compareProductNumbers)

TS handles events (clicks) on its own, it is also possible to call the sorting function from your code. That's what the sort method is for.

TableSort.sort(table, column, compare)

The parameters are as above, but table and column are required.

previous work

This script is based on the works of Paul Sowden and Stuart Langridge. There is also a plenty of similar scripts already written...

Here's what the Console can do (feel free to click "try it" links, to hide the console reload the page).

p() -- print multiple arguments

p('hello', 99, ['a', 'b', 'c'], window.noSuchObject);

try it

// whitespaces are "visible"

p('a line \n with tabs\t\t and spaces\t and tabs');

try it

// trace nested array

ary = [1, 2, [33, [444, 555], 66], 7]
p(ary);

try it

pp() -- print a single structured object

// second argument is a maximal depth (negative = infinite)
// by default, functions are not traced

var person = {
    name : 'John', age : 33,
    occupation : {
        type : 'programmer',
        skills : {
            php : 'good',
            js : 'expert',
            ruby : 'poor'
        },
        points: [1, 2, [33, 44], 5]
    },
    someMethod: function() { alert('Hi') }
}
pp(person, -1);

try it

// pp() is able to break infinite recursion

var ring = {
    a: 1, b: 2, c: 3
}
ring.self = ring
pp(ring, -1);

try it

// trace DOM node (default recursion depth 1 recommended)

pp(document.body);

try it

dbgc "API"

Dbgc.print('Hello')

try it

Dbgc.trace('Hello')

try it

Dbgc.clear()

try it

Dbgc.close()

try it

alert(Dbgc.inspect('Hello'))

try it

miscellaneous

// time()
// measure execution time

function foo() {
    for(var i = 0; i != 500; i++)
        Math.sin(i)
}
Dbgc.print(Dbgc.time(foo))

try it

// stack()
// print stack trace

function a(x, y, z) {
    Dbgc.stack();
}
function b(one, two) {
    a(11, 22, 33);
}
function c() {
    b('aa', 'bb');
}
c()

try it