bagit_manifest.php

<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
 
class BagItManifest
{
 
    //{{{ properties
 
    var $pathPrefix;
 
    var $fileName;
 
    var $hashEncoding;
 
    var $fileEncoding;
 
    var $data;
 
    //}}}
 
    //{{{ Public Methods
 
    public function __construct(
        $fileName, $pathPrefix='', $fileEncoding='UTF-8'
    ) {
        $this->fileName = $fileName;
        $this->pathPrefix = $pathPrefix;
        $this->fileEncoding = $fileEncoding;
        $this->data = array();
 
        $this->hashEncoding = $this->_parseHashEncoding($fileName);
 
        if (file_exists($fileName)) {
            $this->read();
        } else if (is_dir(dirname($this->fileName))) {
            touch($this->fileName);
        }
    }
 
    public function read($fileName=null)
    {
        $this->_resetFileName($fileName);
 
        $manifest = array();
        $hashLen = ($this->hashEncoding == 'sha1') ? 40 : 32;
        $lines = readLines($this->fileName, $this->fileEncoding);
 
        foreach ($lines as $line) {
            $hash = trim(substr($line, 0, $hashLen));
            $payload = trim(substr($line, $hashLen));
 
            if (strlen($payload) > 0) {
                $manifest[$payload] = $hash;
            }
        }
 
        $this->data = $manifest;
        return $manifest;
    }
 
    public function clear()
    {
        $this->data = array();
        file_put_contents($this->fileName, '');
    }
 
    public function update($fileList)
    {
        $csums = array();
 
        foreach ($fileList as $file) {
            if (file_exists($file)) {
                $hash = $this->calculateHash($file);
                $csums[$this->_makeRelative($file)] = $hash;
            }
        }
 
        $this->data = $csums;
 
        $this->write();
 
        return $csums;
    }
 
    public function calculateHash($fileName)
    {
        return hash_file($this->hashEncoding, $fileName);
    }
 
    public function write($fileName=null)
    {
        $this->_resetFileName($fileName);
 
        ksort($this->data);
        $output = array();
 
        foreach ($this->data as $path => $hash) {
            array_push($output, "$hash $path\n");
        }
 
        writeFileText(
            $this->fileName,
            $this->fileEncoding,
            implode('', $output)
        );
    }
 
    public function getHash($fileName)
    {
        if (array_key_exists($fileName, $this->data)) {
            return $this->data[$fileName];
        } else if (array_key_exists($this->_makeRelative($fileName), $this->data)) {
            return $this->data[$this->_makeRelative($fileName)];
        } else {
            return null;
        }
    }
 
    public function getData()
    {
        return $this->data;
    }
 
    public function getFileName()
    {
        return $this->fileName;
    }
 
    public function getFileEncoding()
    {
        return $this->fileEncoding;
    }
 
    public function setFileEncoding($fileEncoding)
    {
        $this->fileEncoding = $fileEncoding;
    }
 
    public function getHashEncoding()
    {
        return $this->hashEncoding;
    }
 
    public function setHashEncoding($hashEncoding)
    {
        $this->hashEncoding = $hashEncoding;
 
        $fileName = preg_replace(
            '/-\w+\.txt$/',
            "-$hashEncoding.txt",
            $this->fileName
        );
 
        if ($fileName != $this->fileName) {
            rename($this->fileName, $fileName);
            $this->fileName = $fileName;
        }
    }
 
    public function validate(&$errors)
    {
        $errLen = count($errors);
 
        // That the manifest file does exist;
        if (! file_exists($this->fileName)) {
            $basename = basename($this->fileName);
            array_push(
                $errors,
                array($basename, "$basename does not exist.")
            );
            // There's no manifest file, so we might as well bail now.
            return false;
        }
 
        // That the files in the hash mapping do exist; and
        // That the hashes in the mapping are correct.
        foreach ($this->data as $fileName => $hash) {
            $fullPath = $this->pathPrefix . $fileName;
            if (! file_exists($fullPath)) {
                array_push(
                    $errors,
                    array($fileName, 'Missing data file.')
                );
            } else if ($this->calculateHash($fullPath) != $hash) {
                array_push(
                    $errors,
                    array($fileName, 'Checksum mismatch.')
                );
            }
        }
 
        return ($errLen == count($errors));
    }
 
    //}}}
 
    //{{{ Private Methods
 
    private function _parseHashEncoding($filename)
    {
        $matches = array();
        if (preg_match('/-(sha1|md5)\.txt$/', $filename, $matches)) {
            return $matches[1];
        }
        return null;
    }
 
    private function _resetFileName($fileName=null)
    {
        if ($fileName === null) {
            return $this->fileName;
        } else {
            $this->hashEncoding = $this->_parseHashEncoding($fileName);
            $this->fileName = $fileName;
            return $fileName;
        }
    }
    
    private function _makeRelative($filename)
    {
        $rel = substr($filename, strlen($this->pathPrefix));
        if (! $rel) {
            return '';
        } else {
            return $rel;
        }
    }
    //}}}
 
}
 
 
/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */
 
 
?>