The syntax is the same:

<?php

// include the class
require_once(dirname(__FILE__)."/../GDYMSpellChecker.class.php");

// instantiate the class
$spellCheck = new GDYMSpellChecker();

$textWithErrors = "PHP: the quik browm fox jumps over the lazi dog lazi today"; // this text has 3 errors
$result = $spellCheck->checkSpelling($textWithErrors, "en-US"); // will return an array with the wrong words with associated suggestions
//$result = $spellCheck->checkSpelling($textWithErrors, "en-US", false); // will return an array with the wrong words without associated suggestions
//print_r($spellCheck->getWarnings());// get all warnings
//print_r($spellCheck->getErrors());// get all errors
if (count($result) == 0) {
	print "Text is OK !<br/>";
} else {
	print "Text has errors !<br/>";
	print "<pre>";
	print_r($result);
}

?>

For further reading about the PHP class read this post.

Download the class from here

Also the usage of this class changed.

<?php

$xml = "http://www.protung.ro/feed/atom/"; // parse an Atom feed

// create a new object
$parser = new SimpleLargeXMLParser();
// load the XML
$parser->loadXML($xml);

// register the namespace
$parser->registerNamespace("atom", "http://www.w3.org/2005/Atom");
// this will get an array of entries
$array = $parser->parseXML("//atom:feed/atom:entry");

?>

As always, you can download the new version from here.

Now it’s possible to retrieve the structure of the XML document with the attributes of the nodes. If you choose to get the nodes also the structure of the result array will be different from the non-attribute array.

The new structure will be like this:

<?php

array('value'=> 'another node / value' ,
     'attributes'=>array('attribute name'=>'attribute value',
                    'another attribute'=>'some value',
                    'yet another attribute'=>'other value'
                    )
);

?>

In order to get the array with attributes you need to pass the 3rd parameter as true:

<?php

   SimpleLargeXMLParser::parseXML($xml, "//myFirstNode", true);

?>

You can download the new version from here.

Please read this post for more information about the functionality of the class:

I know 2 years have passed since the release (or actually any other modifications), but a friend asked me to modify it so he can use it to parse conference history files. So this is what’s new in this version.

I really don’t think a new version will be added, unless it will not work anymore with the latest yahoo messenger version (it still works with version 10 beta)

This class can be used to parse large XML files (it works with small one also) fast and with minimum of memory consumption.
It can parse any valid XML and convert it to an array. What it does not do is to get the attributes of the nodes.
If you need it, contact me and i can implement it for you if you want.

You can parse any part of the XML as it supports XPath with the same performance as parsing the entire XML (well, a little bit faster as it’s less data to parse)

Here is an example

Let’s say we have the following XML file (called example.xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!--
/**********************
 * Example XML (not that large, but it's for demo purpose only)
 **********************/
 -->
<myFirstNode>
	<color-palettes>
		<color type='txt'>red</color>
		<color type='txt'>yellow</color>
		<color type='txt'>lime</color>
		<color type='txt'>cyan</color>
		<color type='txt'>blue</color>
		<color type='txt'>magenta</color>
		<color type='txt'>white</color>
		<color type='txt'>black</color>
		<color type='hex'>#FF0000</color>
		<color type='hex'>#FFFF00</color>
		<color type='hex'>#00FF00</color>
		<color type='hex'>#00FFFF</color>
		<color type='hex'>#0000FF</color>
		<color type='hex'>#FF00FF</color>
		<color type='hex'>#FFFFFF</color>
		<color type='hex'>#000000</color>
	</color-palettes>
	<first-100-numbers>
		<number n='1'>1</number>
		<number n='2'>2</number>
		<number n='3'>3</number>
		...
		<number n='97'>97</number>
		<number n='98'>98</number>
		<number n='99'>99</number>
		<number n='100'>100</number>
	</first-10-numbers>
	<searchengines>
		<engine>
			<name>Google</name>
			<website>http://www.google.com</website>
		</engine>
		<engine>
			<name>Yahoo</name>
			<website>http://www.yahoo.com</website>
		</engine>
		<engine>
			<name>Bing</name>
			<website>http://www.bing.com</website>
		</engine>
	</searchengines>
</myFirstNode>

And here is the PHP code to extract some data from it as an array:

<php

// include the class
require_once('SimpleLargeXMLParser.class.php');
$xml = "example.xml";

// get all colors in hex format as an array
$array = SimpleLargeXMLParser::parseXML($xml, "//myFirstNode/color-palettes/color[@type='hex']");

// get all numbers bigger then 50 as an array
$array = SimpleLargeXMLParser::parseXML($xml, "//myFirstNode/first-100-numbers/number[@n>'50']");

// get all search engines as an array
$array = SimpleLargeXMLParser::parseXML($xml, "//myFirstNode/searchengines");

// get the full XML file as an array
// if you don't specify the first node the script will search for it and use the root node
// for performance reasons is better to specify it if you know it
$array = SimpleLargeXMLParser::parseXML($xml, "//myFirstNode"); 

?>

A new version is available. See this post for more information about what’s new.

Download

Download here. (there are some examples in the package)

The new PHP parser is almost done. Now you can also add classes without specifying files. Just include them in your code and tell the generator to also use those classes. Of course the old way to add classes (by specifying files with PHP code) will still be available, but unlike before when the content of the files was parsed, now the files first will be included (using require_once() ). I know this is not ideal if you have other code that must not arbitrary execute, but then again it’s good practice to have the classes separated from any other code. The new parser will be much faster and more accurate.

That’s all for now, I will post more news about this after more work is done.

Please don’t ask when the release will happen as I don’t know. I do this in my free time witch is somehow limited right now.

There is a base class that defines functions for spell checking.

There are also two classes for checking the spelling of text using either PHP scripts that contain arrays of valid words and grammar definitions, or using the hunspell program.

If the classes determine that there are misspelled words, they may return suggestions for eventual fixes.

1. Installation
   This class uses affix dictionaries. This means that you can use the dictionaries from OpenOffice or Mozilla products.
   Just go to https://addons.mozilla.org/en-US/firefox/browse/type:3 and download the dictionaries that you want.
   Unpack the *.xpi files and extract the *.aff and *.dic files into dictionaries/hunspell/ folder.
   This class also works with MySpell dictionaries.
   There is nothing more you have to do, just start using the class. Please read further and then take a look at the examples.
2. HunSpell version
   The hunspell version of this class is preferred.
   It uses less memory for complex languages or with a very big dictionary (over 150.000 words) and the word suggestion is excellent.
   You can get the binaries from http://sourceforge.net/projects/hunspell/files/Hunspell/1.2.8/
   When using this version of the class you need to specify where hunspell is installed by calling the setHunspellPath() method
   or add hunspell to the system path.
3. PHP version
   In case you can not install hunspell on your server you can use a pure PHP version.
   The words suggestions is not as good as the HunSpell version (will implement a new algorithm soon).
   Also the PHP version can use a lot of memory for complex languages or with a very big dictionary (over 150.000 words).
   As an example, for German languages the script can use over 100Mb. On the other hand for simple languages it only uses about 10Mb.
   The affix dictionaries can not be used as it is. They need to be converted to PHP code.
   This can be done manuall by calling the compileHunAffixDictionary() method.
   If the dictionary is not compiled yet, the first time you use it it will try to compile it from hunspell.
   For complex languages this file can be over 15Mb.
4. Known bugs, accuracy and performance concerns
   There are several known bugs:
   • initially if a word has the suffix doubled (misspell) the spell checker reports it as a correct word. (pure PHP version only).There is a fix implmented that will rezolve the issue but if a word is correctly spelled with the doubled sufix it will be reported ar wrong.You can remove the fix by commenting the 93-95 lines in PHPSpellChecker.class.php
   • in some languages there is a need for a special encoding and this is not yet supported (will be soon)

   Accuracy: (pure PHP version)

   • Word suggestion is not very smart. It’s just a simple “algorithm”. I plan on improveing this (maybe you can help out)

   Performance:

   • For very complex languages, or with a very big dictionary (over 150.000 words) (pure PHP version only) the script can use alot of memmory (100Mb)
5. Conclusion
   The PHP version can be used very efficient for simple languages or with small dictionary (ex. english)
   This is just the first release and it will be greatlly improved.
   If you want to participate on this project please contact me.

Example (PHP Based):

<?php

// include the class
require_once(dirname(__FILE__)."/../PHPSpellChecker.class.php");

// instantiate the class
$spellCheck = new PHPSpellChecker();

/////////////////////////
// set some text to check
$text1 = "Die Commerzbank blickt besorgt in die Zukunft: Das Geldhaus rechnet in der zweiten Jahreshälfte mit einer Zunahme von Kreditausfällen - denn Firmen wie Privatkunden bekommen Probleme, ihre Schulden zu bedienen. Schon jetzt hat das Institut vorsichtshalber knapp eine Milliarde Euro zurückgelegt";
$result = $spellCheck->checkSpelling($text1, "de-DE"); // should return an empty array (text is correct)
//print_r($spellCheck->getWarnings());// get all warnings
//print_r($spellCheck->getErrors());// get all errors
if (count($result) == 0) {
    print "Text is OK !
";
} else {
    print "Text has errors !
";
    print "<pre>";
    print_r($result);
}
$spellCheck->clearWarnings(); // clear all previous warnings
$spellCheck->clearErrors(); // clear all previous errors

$text1 = "PHP: the quik browm fox jumps over the lazi dog"; // this text has 3 errors
$result = $spellCheck->checkSpelling($text1, "en-US"); // will return an array with the wrong words with associated suggestions
//$result = $spellCheck->checkSpelling($textWithErrors, "en-US", false); // will return an array with the wrong words without associated suggestions
//print_r($spellCheck->getWarnings());// get all warnings
//print_r($spellCheck->getErrors());// get all errors
if (count($result) == 0) {
    print "Text is OK !
";
} else {
    print "Text has errors !
";
    print "<pre>";
    print_r($result);
}

?>

Example (HunSpell Based):

<?php
// include the class
require_once(dirname(__FILE__)."/../HunSpellChecker.class.php");

// instantiate the class
$spellCheck = new HunSpellChecker();
$spellCheck->setHunspellPath(dirname(__FILE__)."/../hunspell"); // set path for windows systems
/////////////////////////
// set some text to check
$text1 = "Die Commerzbank blickt besorgt in die Zukunft: Das Geldhaus rechnet in der zweiten Jahreshälfte mit einer Zunahme von Kreditausfällen - denn Firmen wie Privatkunden bekommen Probleme, ihre Schulden zu bedienen. Schon jetzt hat das Institut vorsichtshalber knapp eine Milliarde Euro zurückgelegt";
$result = $spellCheck->checkSpelling($text1, "de-DE"); // should return an empty array (text is correct)
//print_r($spellCheck->getWarnings());// get all warnings
//print_r($spellCheck->getErrors());// get all errors
if (count($result) == 0) {
    print "Text is OK !
";
} else {
    print "Text has errors !
";
    print "<pre>";
    print_r($result);
}
$spellCheck->clearWarnings(); // clear all previous warnings
$spellCheck->clearErrors(); // clear all previous errors

$text1 = "PHP: the quik browm fox jumps over the lazi dog"; // this text has 3 errors
$result = $spellCheck->checkSpelling($text1, "en-US"); // will return an array with the wrong words with associated suggestions
//$result = $spellCheck->checkSpelling($textWithErrors, "en-US", false); // will return an array with the wrong words without associated suggestions
//print_r($spellCheck->getWarnings());// get all warnings
//print_r($spellCheck->getErrors());// get all errors
if (count($result) == 0) {
    print "Text is OK !
";
} else {
    print "Text has errors !
";
    print "<pre>";
    print_r($result);
}
?>

In the package you will also get an interactive example page so you can easily test it out.

Download class and hope it’s useful to you.

It parses the code of a given PHP class script files and generates a WSDL definition from the list of the class functions.

Certain functions may be skipped to not be included in the WSDL definition based on the function access type.

The generated WSDL may be saved to a given file, returned as a string or served for download.

Download class

It generates a code based on a secret key that is valid during a period of time.

The class can also be used to validate the generated code in a different server and check if the code expired.

Download class

July 2008 Number 6

One time passwords are useful to provide authorization to access restricted resources during a single access.

This class enhances the concept of one time passwords by giving a single access to the resources for a limited period of time.

Manuel Lemos

It can parse a given chat history file and extract several details of each message that was exchanged in the chat sessions.

The class retrieves the message text and length, timestamp and the identifier of the user that sent the message.

The message text is retrieved in HTML format, but the class may strip HTML formatting.

Download class