mapping m1 = ([ "key1" : "Value 1", "key2" : "Value 2" ]);
mapping m2 = ([ "key3" : "Value 3" ]);

write("My mapping: %O\n", m1 + m2);
//> My mapping: ([ /* 3 elements */
//>   "key1": "Value 1",
//>   "key2": "Value 2",
//>   "key3": "Value 3"
//> ])

And I noted that I had done the same thing in PHP and the result was perfectly valid:

$a1 = array("key1" => "Value 1", "key2" => "Value 2");
$a2 = array("key3" => "Value 3");

echo "My mapping: ";
print_r($a1 + $a2);
//> My mapping: Array
//> (
//>     [key1] => Value 1
//>     [key2] => Value 2
//>     [key3] => Value 3
//> )

This method doesn’t work on flat array though so there you’ll still have to use array_merge(), but pretty nice anyway.

And oh, the PHP Bitly class will be part of the new PLib release once done!

To give you an idea of what PLib is all about let me give you an example:

Emit('*.jpg')) {
  $img = new Image($file->path);
  $img = $img->Copy($file->path.'/thumb-'.$file->name)->Scale($mw, $mh);
  wbr($img->Path()); // The full path to the thumbnail
}
?>

Rather easy I think!

AutoDoc

Another cool feature (if I may say so) is the auto documentation. If you quickly want a list of all available classes and functions just type PLib::Info() and you will get the list. Each class and function is then clickable and will lead you to the documentation for which ever class or function you clicked.

If you want the documentation for a specific class just type PLib::Info() and there you have the documentation.

The third way to use the autodoc is to pass an instance of a class as argument like PLib::Info().

And if you wan’t a full documentation site just type PLib::Info() and you will get the same documentation as available at the PLib site.

The site

Anyway, PLib has its site of it’s own where anyone curious can download the latest version of PLib and find out more about the project.

plib.poppa.se

Difference from CHM

Although there’s a CHM equivalent, XCHM, for Unix like systems I decided that my application serves a purpose: What I like about the PHP manual is that you can hit www.php.net/the_function in you browser and you will get the documentation for “the_function”. Of course I implemented the same functionality in PHPDoc Browser. You can also do a wild card search like “array_*” and you will get a list of all “array_*” functions.

I also implemented a free text search but that’s not “a real” FTS at the moment. FTS in SQLite in a little bit harder than in MySQL so while awaiting the next SQLite version the FTS is a bit of a hack. But you can quote the search to narrow it down

What’s learned?

Most of the unnecessary stuff I do I do to learn and the PHPDoc Browser is no exception. I learned how to use SQLite in Mono/C# and I also wrote a self contained installer in Bash, and Bash I havn’t really touch although I’ve been using GNU/Linux for 6-7 years! I found it quite fun writing the installer

Howto

If you would like to try it out:

1. Download the install script
2. Un-tar it (`tar zxvf phpdocbrowser-installer.tgz`)
3. Make sure the script is executable (`chmod +x phpdocbrowser-installer`)
4. Open a console and run the installer: ./phpdocbrowser-installer
5. Answer the questions and you’r ready to go.

The script will create a directory, ./phpdocbrowser-installer, in your home directory in wich you will find ./phpdocbrowser-installer, ./phpdocbrowser-installer and a directory, ./phpdocbrowser-installer, with the PHP documentation. A “run script” will also be installed either in ./phpdocbrowser-installer or in your home directory depending on how you answered the questions and if you agreed to create a desktop shortcut one will hopefully appear on your desktop (havn’t tested this on KDE but it should work fine in Gnome).

To run the application hit the desktop shortcut, if one was created, or invoke ./phpdocbrowser-installer from a console.

If you wish to remove the PHPDoc Browser run the following from a console:
./phpdocbrowser-installer.

And that’s that!

Download

PHPDoc Browser

Screen shots

Changelog for this version

• Fixed a bug where the end of strings (quotes) wasn’t found correctly in languages that has no escape character (like XSL, XML and HTML).
• Also changed the Syntaxer::AutoDetect() method to return the extension of a file if no alias was found. In this way we can pass a path to the method and use the result directly as argument to `Sytaxer::__construct()`

$file = '/some/path/to/file.xsl';
$lang = Syntaxer::AutoDetect($file);
$stx  = new Syntaxer($lang);
$stx->Parse(file_get_contents($file));

The Syntaxer can be read about and downloaded over here.

The Syntaxer can be downloaded here

Since I have gotten a few years more of knowledge, and PHP5 has arrived, I though I should write a new version of it. I could reuse some of the code but alot was rewritten and redesigned totally. The script has two classes:

1. One class to parse the Edit+ syntax files which gets converted into PHP files so that the syntax files doesn’t have to to be parsed for every request. If the given .stx file has a newer timestamp than the cached PHP file the PHP file will be regenerated. Alot of this code could be reused from the older version
2. The actual highlighting class. This class was almost entirely rewritten. Here I loop through every character of the code to highlight. When a keyword, delimiter or something else detectable is matched I grab that and searches forward to where the rule ends. In the older version I had a different approach where the code was splitted on newlines so I looped through line by line and for each line I looped throuh each charachter and did a similar match as in the new version.

   The new approach has some advantages:

   1. There’s no need to duplicate the code wich means a lot less memory is used.
   2. Fewer flags is needed since when I match a detectable rule I at once search for the end of the rule. This means that fewer .stx statements is needed wich speeds thing up alot.

      And foremost the code got much much cleaner!

Anyhow! There are a few minor bugs but the code is pretty usable (I have implemented it here in the blogging system). I added the scripts with documentation and a simple example on the server for anyone to download.

The Syntaxer2 can be found and downloaded over here. Some bug fixes and more examples will be done in the very near future.

So I though: How hard can it be to implement the same kind of functionality in a user defined function. Well, it’s not hard att all, and here’s how simple it is:

/**
 * issetor
 *
 * @param mixed &$what Assoc array key
 * @param mixed $else Default value
 * @return mixed
*/
function issetor(&$what, $else)
{
  return isset($what) ? $what : $else;
}

#=================================================

$arr = array('key1' => 'value1', 'key2' => 1);

$var1 = issetor($arr['key1'], 'some value');
echo $var1; # will echo: value1

$var2 = issetor($arr['key5'], 'default for key 5');
# will echo: default for key 5
echo $var2;

The only thing noticable here is that the first argument needs to be passed by reference or PHP will throw a warning (depending on the error/warning level set).

Of cource you can escape this issue all together just by choking PHP errors/warnings – $var = isset($_GET['var']) ? $_GET['var'] : 'default'; – but that’s just pure ugly in my opinion.

Just by modifying the function above slightly we also get a nice way for writing:
$var = isset($_GET['var']) ? $_GET['var'] : 'default';

/**
 * isemptyor
 *
 * @param mixed &$what Assoc array key
 * @param mixed $else
 * @return mixed
*/
function isemptyor(&$what, $else)
{
  return empty($what) ? $else : $what;
}

#=================================================

$var1 = "Hello";
$var2 = "";

$myvar = isemptyor($var1, 'Default');
echo $myvar; # will echo: Hello

$myvar = isemptyor($var2, 'Default');
# will echo: Default
echo $myvar;

And that’s it. I use them all the time!

This is where the database abstraction layer comes in handy. There already exist many of them so, again and as always, why bother writing another one? Well, it’s fun and you always learn new stuff and, for good and bad, third party APIs tend to be packed with features that you never use so it get quite tedious learning the API.

So I wrote my own database abstraction layer that only contain the functionality I mostly use. If I need more functionaly it’s easy to implement. When I wrote the abstraction layer I tried to evolve my OOP (object orientated programming) skills (which isn’t too great) so that in it self was I goal.

The abstraction layer contains of two interfaces and two master classes: A connection interface and class and a result interface and class. To create a driver for a new type of database you inherit the master classes and implement the interfaces. This is how the skelleton looks like:

• interface IDB
  The connection interface
• interface IDBResult
  The query result interface
• abstract class DB
  The connection master class
• abstract class DBResult
  The query result master class

So a database driver should have two classes: One that extends the DB class and implements the IDB interface and one class that extends the DBResult class and implements the IDBResult interface.

Example

Here’s a simple example of usage:

Connect();
  $res = $db->Query("SELECT * FROM table WHERE cat_id = '%d'", $category);

  if ($res->NumRows() > 0) {
    while ($row = $res->Fetch()) {
      echo "Title: " . $row->title . "
";
    }
  }
}
//! Could be DBDriverNotFound, DBConnectionFail, DBNotFound, DBQueryFail
catch (Exception $e) {
  die("Error: " . $e->getMessage();
}

//! SQLite example
try {
  $category = $_GET['category'];

  $db = DB::Create('SQLite', 'mysqlitedb');
  $db->Connect();
  $res = $db->Query("SELECT * FROM table WHERE cat_id = '%d'", $category);

  if ($res->NumRows() > 0) {
    while ($row = $res->Fetch()) {
      echo "Title: " . $row->title . "
";
    }
  }
}
//! Could be DBDriverNotFound, DBConnectionFail, DBNotFound, DBQueryFail
catch (Exception $e) {
  die("Error: " . $e->getMessage();
}
?>

As you can see here we’re using exactly the same code, except for the instantiation of the database object, wether we’re using MySQL or SQLite, and that’s the meaning of the database abstraction layer.

Sources

I currently have two implementations for MySQL and SQLite. The MySQL implementation is what I’m using for this blog and the SQLite implementation is not very well tested yet.

The classes are pretty well documented and the documentation is bundled in the package below.

Database abstraction layer

NOTE! This is not as reliable as the Fileinfo Functions but it works in most cases.

In most GNU/Linux systems (if not all) there’s a file called mime.types (in /etc/) which is mapping of mimetype -> extension. The file looks like this:

application/x-gnumeric                          gnumeric
application/x-go-sgf                            sgf
application/x-graphing-calculator               gcf
application/x-gtar                              gtar tgz taz
application/x-hdf                               hdf
application/x-httpd-php                         phtml pht php

Quite obvious you could build an array from this file where the mimetype could be the key and the extension(s) the value as an array:

$_MIMETYPES = array(
  "mime/type" => array("ext1", "ext2", "ext3")
);

When we’ve got this array populated we can easily look up a mimetype for an extention (and vice versa) by these two functions:

/**
 * Find mimetype for extension
 * @global array  $_MIMETYPES
 * @param  string $ext
 * @return string|bool
*/
function find_mimetype($ext)
{
  global $_MIMETYPES;
  foreach ($_MIMETYPES as $mime => $exts)
    if (in_array($ext, $exts))
      return $mime;

  return false;
}
/**
 * Get extension(s) for a given mimetype
 * @global array  $_MIMETYPES
 * @param  string $mimetype
 * @return array
*/
function findextensionfor_mimetype($mimetype)
{
  global $_MIMETYPES;
  return isset($MIMETYPES[$mimetype]) ? $MIMETYPES[$mimetype] : array();
}

The script to convert the mime.types database into an array an auto generate the two functions above looks like this (note that this PHP script is intended to run as a command line (cli) script, thus the shebang (#!/usr/bin/php), since we don’t need to do this conversion run time but only once):

#!/usr/bin/php

*/

//! Mimetype file
$mime_db  = '/etc/mime.types';

//! Resulting file for the PHP array
$php_file = 'mimetypes.php';

fileexists($mimedb) or die("No mimetype database ($mime_db) found\\n");
$lines = @file($mimedb) or die("Couldn't read $mimedb");
$fh    = @fopen($phpfile, "w+") or die("Couldn't create $phpfile");
$date  = strftime("%A %B %d %Y", time());

//! Write the PHP header to the file.
@fwrite($fh,
"FILE) . "
*/
$_MIMETYPES = array(n"
);

//! Loop through the lines array
while ($line = array_shift($lines))
{
  //! Match a comment or a blank line
  if ($line{0} == "#" || $line{0} == "\\n")
    continue;

  //! A line looks like:
  //!    mime.type              extention[ extension[ extension]]
  //! so lets grab the mimetype and extensions
  preg_match('/^(.?)\\s+(.?)$/', trim($line), $match);
  list(, $mime, $ext) = $match;

  if (empty($mime)) continue;

  //! This converts "ext ext ext" to "ext','ext','ext"
  $ext  = join("', '", explode(' ', $ext));

  //! And lets write the new array index to the file
  fwrite($fh, sprintf(
    "\\t'%s' => array('%s')%s\\n",
    $mime, $ext, (empty($lines) ? "" : ","))
  );
}

//! Close the array, add a nifty search function, and close the PHP block
//! and we're done!
fwrite($fh, ");
/**
 * Find mimetype for extension
 * @global array  $_MIMETYPES
 * @param  string $ext
 * @return string|bool
*/
function find_mimetype($ext)
{
  global $_MIMETYPES;
  foreach ($_MIMETYPES as $mime => $exts)
    if (in_array($ext, $exts))
      return $mime;

  return false;
}
/**
 * Get extension(s) for a given mimetype
 * @global array  $_MIMETYPES
 * @param  string $mimetype
 * @return array
*/
function findextensionfor_mimetype($mimetype)
{
  global $_MIMETYPES;
  return isset($MIMETYPES[$mimetype]) ? $MIMETYPES[$mimetype] : array();
}
?>");
fclose($fh);
?>

And this should result in a file called mimetypes.php that you just can include in you PHP scripts.

Download the scripts