File Source for ISBN.php

<?php
/**
* ISBN
*
* Handle, Convert and Validate ISBN Numbers
*
* PHP version 5
*
* LICENSE: LGPL (In cases LGPL is not appropriate, it is licensed under GPL)
*
* Package to handle, convert and validate ISBN numbers. It includes:
*
* - ISBN specifics: EAN/PrefixArrayAccess (integer)
* - ISBN specifics: Group/Registration Group [2001: Group identifier] (integer)
* - ISBN specifics: GroupTitle/Registration Group Title (string)
* - ISBN specifics: Publisher/Registrant [2001: Publisher identifier] (string)
* - ISBN specifics: Title/Publication [2001: Title identifier] (string)
* - ISBN specifics: Checkdigit (string)
* - ISBN specifics: 'ISBNBody' (string)
* - ISBN specifics: 'ISBNSubbody' (string)
* - ISBN Version handling
* - Syntactical Validation plus Validation based on real ISBN Data
* - ISBN-10 (ISO 2108) checksum calculation
* - Validation (ISBN-10 and ISBN-13-978)
* - Conversion to ISBN-13-978
* - ISBN-13-978 (2005 Handbook, ISO pending; ISBN-13)
* - ISBN-13 checksum calculation (EAN)
*
* Based on standards published by international ISBN Agency
* http://www.isbn-international.org/
*
* @category Pending
* @package ISBN
* @author Tom Klingenberg <tkli-php@lastflood.net>
* @copyright 2006-2007 Tom Klingenberg
* @license LGPL http://www.gnu.org/licenses/lgpl.txt
* @version v 0.1.6 CVS: <cvs_id>
* @link http://isbn.lastflood.com online docs
*
* @todo License for .js file or remove it
* @todo GroupTitle
* @todo PEAR Package.xml
*
*/
// {{{ constants
/**
* ISBN Versions supported
*/
define('ISBN_VERSION_NONE', false);
/**
* VERSION_UNKNOWN is by the caller only, this shall never
* be a value returned by a public function or getter
*/
define('ISBN_VERSION_UNKNOWN', 0);
define('ISBN_VERSION_ISBN_10', 10);
define('ISBN_VERSION_ISBN_13', 13978);
define('ISBN_VERSION_ISBN_13_978', ISBN_VERSION_ISBN_13);
define('ISBN_VERSION_ISBN_13_979', 13979); /* reserved */
/*
* Default ISBN Version for class input / usage
*/
define('ISBN_DEFAULT_INPUTVERSION', ISBN_VERSION_UNKNOWN);
/*
* Default ISBN Seperator string
*/
define('ISBN_DEFAULT_COSMETIC_SEPERATOR', '-');
/*
* ISBN_DEFAULT_PRINT_LANG_SPECIFIC_PREFIX
*
* When printed, the ISBN is always preceded by the letters "ISBN".
* Note: In countries where the Latin alphabet is not used, an abbreviation
* in the characters of the local script may be used in addition to the
* Latin letters "ISBN".
* This can be defined as a default value wihtin this constant.
*/
define('ISBN_DEFAULT_PRINT_LANG_SPECIFIC_PREFIX', '');
// }}}
require_once 'PEAR/Exception.php';
// {{{ ISBN_Exception
/**
* ISBN_Exception class
*
* @category Pending
* @package ISBN
* @author Tom Klingenberg <tkli-php@lastflood.net>
* @copyright 2006-2007 Tom Klingenberg
* @license LGPL http://www.gnu.org/licenses/lgpl.txt
* @link http://isbn.lastflood.com/
* @since Class available since Release 0.1.3
*/
class ISBN_Exception Extends PEAR_Exception
{
}
// }}}
// {{{ ISBN
/**
* ISBN class
*
* Class to Handle, Convert and Validate ISBN Numbers
*
* @category Pending
* @package ISBN
* @author Tom Klingenberg <tkli-php@lastflood.net>
* @copyright 2006-2007 Tom Klingenberg
* @license LGPL http://www.gnu.org/licenses/lgpl.txt
* @link http://isbn.lastflood.com/
* @since Class available since Release 0.0.0
*/
class ISBN
{
/**
* @var string ISBN Registration Group
*/
private $isbn_group = '';
/**
* @var string ISBN Publisher
*/
private $isbn_publisher = '';
/**
* @var string ISBN Title
*/
private $isbn_title = '';
/**
* @var mixed ISBN number version
*/
private $ver = ISBN_VERSION_NONE;
/**
* @var array ISBN Groups Data acting as cache
* @see _getISBN10Groups()
*/
private static $varISBN10Groups = array();
// {{{ __construct
/**
* Constructor
*
* @param array $isbn String of ISBN Value to use
* @param mixed $ver Optional Version Constant
*
* @access public
*
* @throws ISBN_Exception in case it fails
*/
function __construct($isbn = '', $ver = ISBN_DEFAULT_INPUTVERSION)
{
/* validate & handle optional isbn parameter */
if (is_string($isbn) == false ) {
throw new ISBN_Exception('ISBN parameter must be a string');
}
if (strlen($isbn) == 0) {
$this->setISBN($isbn);
return;
}
/* validate version parameter */
if (self::_isbnVersionIs($ver) == false) {
throw new ISBN_Exception(
'ISBN Version parameter is not an ISBN Version'
);
}
/* ISBN has been passed, check the version now:
* if it is unknown, try to dertine it, if this fails
* throw an exception
*/
if ($ver == ISBN_VERSION_UNKNOWN) {
$verguess = self::_isbnVersionGuess($isbn);
if (self::_isbnVersionIsValid($verguess)) {
$ver = $verguess;
} else {
/* throw new ISBN_Exception(
*'ISBN Version couldn\'t determined.');
*/
$ver = ISBN_VERSION_NONE;
}
}
/* version determined */
$this->ver = $ver;
/* handle a complete invalid ISBN of which a version could
* not be determined. */
if ($ver === ISBN_VERSION_NONE) {
$this->setISBN('');
return;
}
try {
$this->setISBN($isbn);
} catch(Exception $e) {
/* the isbn is invalid and not set, sothat this
* ISBN object will be set to a blank value. */
$this->setISBN('');
}
}
// }}}
// {{{ _extractCheckdigit()
/**
* extract Checkdigit of an ISBN-Number
*
* @param string $isbnn normalized ISBN string
*
* @return string|falseISBN-Body or false if failed
*
*/
private static function _extractCheckdigit($isbnn)
{
$checkdigit = false;
$checkdigit = substr($isbnn, -1);
return (string) $checkdigit;
}
// }}}
// {{{ _extractEANPrefix()
/**
* extracts EAN-Prefix of a normalized isbn string
*
* @param string $isbnn normalized isbn string
*
* @return string|falsePrefix or false if failed
*/
private static function _extractEANPrefix($isbnn)
{
$r = settype($isbnn, 'string');
if ($r === false) {
return false;
}
if (strlen($isbnn) < 3) {
return false;
}
$prefix = substr($isbnn, 0, 3);
return $prefix;
}
// }}}
// {{{ _extractGroup()
/**
* extract Registration Group of an ISBN-Body
*
* @param string $isbnbody ISBN-Body
*
* @return integer|false Registration Group or false if failed
*/
private static function _extractGroup($isbnbody)
{
$group = '';
$subbody = '';
$r = self::_isbnBodyParts($isbnbody, $group, $subbody);
if ($r === false) {
return false;
}
return $group;
}
// }}}
// {{{ _extractISBNBody()
/**
* extract ISBN-Body of an ISBN-Number
*
* @param string $isbnn normalized ISBN string
*
* @return string|falseISBN-Body or false if failed
*/
private static function _extractISBNBody($isbnn)
{
/* extract */
$body = false;
$isbnn = (string) $isbnn;
$l = strlen($isbnn);
if ($l == 10) {
$body = substr($isbnn, 0, -1);
} elseif ($l == 13) {
$body = substr($isbnn, 3, -1);
} else {
return false;
}
/* verify */
$r = settype($body, 'string');
if ($r === false) {
return false;
}
if (strlen($body) != 9) {
return false;
}
if (ctype_digit($body) === false) {
return false;
}
return $body;
}
// }}}
// {{{ _isbnBodyParts()
/**
* Get the 2 Parts of the ISBN-Body (ISBN-10/ISBN-13-978)
*
* @param string $isbnbody ISBN-Body
* @param string &$registrationgroup Registration Group
* @param string &$isbnsubbody ISBN-Subbody
*
* @return boolean False if failed, True on success
*
* @access private
*/
private static function _isbnBodyParts($isbnbody,
&$registrationgroup,
&$isbnsubbody)
{
/* validate input (should not be needed, @access private) */
$r = settype($isbnbody, 'string');
if ($r === false) {
return false;
}
if (strlen($isbnbody) != 9) {
return false;
}
if (ctype_digit($isbnbody) === false) {
return false;
}
/* extract registraion group
* boundaries see p.13 2005 handbook
*/
$boundaries = array();
$boundaries[] = array( 0, 59999, 1);
$boundaries[] = array(60000, 60099, 3); // Iran 2006-12-05
$boundaries[] = array(60100, 69999, 0);
$boundaries[] = array(70000, 79999, 1);
$boundaries[] = array(80000, 94999, 2);
$boundaries[] = array(95000, 98999, 3);
$boundaries[] = array(99000, 99899, 4);
$boundaries[] = array(99900, 99999, 5);
/* segment value */
$segment = substr($isbnbody, 0, 5);
$segmentvalue = intval($segment);
/* test segment value against boundaries */
$r = false;
foreach ($boundaries as $boundary) {
if ($segmentvalue >= $boundary[0] && $segmentvalue <= $boundary[1]) {
$r = $boundary[2];
}
}
if ($r === false) {
return false;
}
/* $r is 0 when the boundary is not defined */
if ($r === 0) {
return false;
}
$registrationgroup = substr($isbnbody, 0, $r);
$isbnsubbody = substr($isbnbody, $r);
return true;
}
// }}}
// {{{ _isbnSubbodyParts()
/**
* Get the 2 Parts of the ISBN-Subbody (ISBN-10/ISBN-13)
*
* @param string $isbnsubbody ISBN-Subbody
* @param integer $groupid Registrationgroup
* @param string &$registrant Registrant
* @param string &$publication Publication
*
* @return boolean False if failed, true on success
*
* @access private
*/
private static function _isbnSubbodyParts($isbnsubbody,
$groupid,
&$registrant,
&$publication)
{
/* validate input (should not be needed, @access private) */
$r = settype($isbnsubbody, 'string');
if ($r === false) {
return false;
}
$l = strlen($isbnsubbody);
if ( $l < 1 || $l > 8) {
return false;
}
if (ctype_digit($isbnsubbody) === false) {
return false;
}
$r = settype($groupid, 'integer');
if ($r === false) {
return false;
}
if ($groupid < 0 || $groupid > 99999) {
return false;
}
/* extract registrant based on group and registrant range
* parse this specific group format:
* array(
* 'English speaking area',
* '00-09;10-19;200-699;7000-8499;85000-89999;' .
* '900000-949999;9500000-9999999'
* );
*/
$group = self::_getISBN10Group($groupid);
if ($group === false) {
return false;
}
$len = self::_getRegistrantLength($isbnsubbody, $group[1]);
if ($len === false) {
return false;
}
$registrant = substr($isbnsubbody, 0, $len);
$publication = substr($isbnsubbody, $len);
return true;
}
// }}}
// {{{ _getRegistrantLength()
/**
* Return Length of Registrant part within an ISBNSubbody in a specific
* grouprange in this specific format:
*
* '00-09;10-19;200-699;7000-8499;85000-89999;900000-949999;9500000-9999999'
*
* Info: This function is compatible with Groupranges formatted in the
* .js file and might become obsolete if new formats are more fitting.
*
* @param string $isbnsubbody ISBN-Subbody
* @param string $grouprange Grouprange in the Format '#a1-#z1;#a2-z2[...]'
*
* @return boolean|int False if failed or Length (in chars) of Registrant
*
* @access private
*/
private static function _getRegistrantLength($isbnsubbody, $grouprange)
{
$r = settype($grouprange, 'string');
if ($r === false) {
return false;
}
if (strlen($grouprange) < 3) {
return false;
}
$sl = strlen($isbnsubbody);
$ranges = explode(';', $grouprange);
foreach ($ranges as $range) {
$range = trim($range);
$fromto = explode('-', $range);
if (count($fromto) !== 2) {
return false;
}
/* validation:
* from and to need to be in the same class,
* having the same length.
* registrant can not be bigger or same then the
* whole subbody, at least there is one digit for
* the publication.
*/
$l = strlen($fromto[0]);
if ($l != strlen($fromto[1])) {
return false;
}
if ($l >= $sl) {
return false;
}
/* check that from/to values are in order */
if (strcmp($fromto[0], $fromto[1]) >= 0) {
return false;
}
/* compare and fire if matched */
$comparec = substr($isbnsubbody, 0, $l);
if (strcmp($fromto[0], $comparec) < 1 &&
strcmp($fromto[1], $comparec) > -1) {
return $l;
}
}
return false;
}
// }}}
// {{{ _getISBN10Group()
/**
* Get ISBN-10 Registration Group Data by its numeric ID
*
* @param integer $id Registration Group Identifier
*
* @return mixed array: group array
* boolean: False if failed
*/
private static function _getISBN10Group($id)
{
$r = settype($id, 'integer');
if ($r === false) {
return false;
}
$groups = self::_getISBN10Groups();
if ($groups === false) {
return false;
}
if (isset($groups[$id]) === false) {
return false;
}
$group = $groups[$id];
return $group;
}
// }}}
// {{{ _getISBN10Groups()
/**
* Get all ISBN-10 Registration Groups
*
* @return array groups array
*
* Info: This function connects outer world data into this class logic
* which can be generated with the supplied tools.
* A user should not alter the array data. This data should be altered
* together with the international ISBN Agency only.
*/
private static function _getISBN10Groups()
{
/* check if data has been already loaded */
if (sizeof(self::$varISBN10Groups) > 0 ) {
return self::$varISBN10Groups;
}
/* load external data */
try {
$t = file_get_contents('data/groups.csv', true, null);
} catch(Exception $e) {
throw new ISBN_Exception(
'Unable to read ISBN Groups Data file.'
);
}
/* parse external data */
$groups = array();
$tls = split("\n", $t);
$line = 0;
foreach ($tls as $tl) {
$line++;
$tlp = split(',', $tl);
if (sizeof($tlp) == 3) {
$index = intval($tlp[0]);
if (isset($groups[$index])) {
throw new ISBN_Exception(
'ISBN Groups Data is invalid, Group ' .
$index . 'is a duplicate.'
);
}
/* edit+ mature: sanitize external
data */
$groups[$index] = array($tlp[1],$tlp[2]);
} else {
throw new ISBN_Exception(
'ISBN Groups Data is malformed on line #' . $line .
' (' . sizeof($tlp) . ').'
);
}

Source for file ISBN.php