/Applications/MAMP/htdocs/quail/trunk/quail/quail.php

<?php 
define('QUAIL_TEST_SEVERE', 1);
define('QUAIL_TEST_MODERATE', 2);
define('QUAIL_TEST_SUGGESTION', 3);
define('QUAIL_LIB_VERSION', 038);

require_once('common/test.php');
require_once('common/css.php');
require_once('common/elements.php');
require_once('common/domExtensions.php');
require_once('common/accessibility_tests.php');

class quail {
        var $dom;
        
        var $type;
        
        var $value;
        
        var $uri;
        
        var $domain;
        
        var $guideline_name = 'wcag';
        
        var $reporter_name = 'static';
        
        var $reporter;
        
        var $guideline;
        
        var $base_url;
        
        var $path = array();
        
        var $css_files;
        
        var $css;
        
        var $options = array(
                                        'cms_mode' => false,
                                        'start_element' => 0,
                                        'end_element' => 0,
                                        'cms_template' => array());
        
        var $is_valid = true;
        
        function __construct($value, $guideline = 'wcag', $type = 'string', $reporter = 'static', $domain = 'en') {
                $this->dom = new DOMDocument();
                $this->type = $type;
                if($type == 'uri' || $type == 'file') {
                        $this->uri = $value;
                }
                $this->domain = $domain;
                $this->guideline_name = $guideline;
                $this->reporter_name = $reporter;
                $this->value = $value;

        }
        
        function prepareDOM() {
                $this->prepareValue();
                $this->is_valid = @$this->dom->loadHTML($this->value);
                $this->prepareBaseUrl($this->value, $this->type);
        }
        
        function prepareValue() {
                
                //We ignore the 'string' type because it would mean the value already contains HTML             
                if($this->type == 'file' || $this->type == 'uri') {
                        $this->value = @file_get_contents($this->value);
                }
        }
        
        
        function setOption($variable, $value = null) {
                if(!is_array($variable)) {
                        $variable = array($variable => $value);
                }
                foreach($variable as $k => $value) {
                        if(isset($this->options[$k])) {
                                $this->options[$k] = $value;
                        }
                }
        }
        
        function getAbsolutePath($absolute, $relative) {                
            if(substr($relative, 0, 2) == '//') {
                if($this->uri) {
                        $current = parse_url($this->uri);
                }
                else {
                        $current = array('scheme' => 'http');
                }
                return $current['scheme'] .':'. $relative;
            }
            $relative_url = parse_url($relative);
                if (isset($relative_url['scheme'])) {
                    return $relative;
                }
                $absolute_url = parse_url($absolute);
                if(isset($absolute_url['path'])) {
                        $path = dirname($absolute_url['path']); 
                }
                if ($relative{0} == '/') {
                    $c_parts = array_filter(explode('/', $relative));
                }
                else {
                        $a_parts = array_filter(explode('/', $path));
                        $r_parts = array_filter(explode('/', $relative));
                        $c_parts = array_merge($a_parts, $r_parts);
                foreach ($c_parts as $i => $part) {
                    if ($part == '.') {
                        $c_parts[$i] = NULL;
                    }
                    if ($part == '..') {
                        $c_parts[$i - 1] = NULL;
                        $c_parts[$i] = NULL;
                    }
                }
                $c_parts = array_filter($c_parts);
                }
                $path = implode('/', $c_parts);
                $url = "";
                if (isset($absolute_url['scheme'])) {
                        $url = $absolute_url['scheme'] .'://';
                }
                if (isset($absolute_url['user'])) {
                        $url .= $absolute_url['user'];
                        if ($absolute_url['pass']) {
                            $url .= ':'. $absolute_url['user'];
                        }
                        $url .= '@';
                }
                if (isset($absolute_url['host'])) {
                        $url .= $absolute_url['host'];
                        if(isset($absolute_url['port'])) {
                                $url .= ':'. $absolute_url['port'];
                        }
                        $url .= '/';
                }
                $url .= $path;
                return $url;
        }

        function setUri($uri) {
                if(parse_url($uri)) {
                        $this->uri = $uri;
                }
        }
        
        function prepareBaseUrl($value, $type) {
                if($type == 'file') {
                        $path = explode('/', $this->uri);
                        array_pop($path);
                        $this->path = $path;
                }
                elseif($type == 'uri' || $this->uri) {
                        
                        $parts = explode('://', $this->uri);
                        $this->path[] = $parts[0] .':/';
                        if(is_array($parts[1])) {
                                foreach(explode('/', $this->getBaseFromFile($parts[1])) as $part) {
                                        $this->path[] = $part;
                                }
                        }
                        else { 
                                $this->path[] = $parts[1] .'/';
                        }
                }
        }
        
         function getBaseFromFile($file) {  
                 $find = '/';  
                 $after_find = substr(strrchr($file, $find), 1);  
                 $strlen_str = strlen($after_find);  
                 $result = substr($file, 0, -$strlen_str);  
                 return $result;  
         }
        

        
        function addCSS($css) {
                if(is_array($css)) {
                        $this->css_files = $css;
                }
                else {
                        $this->css_files[] = $css;
                }
        }
        
        function getError($error) {
                return $this->reporter->getError($error);
        }
        
        function loadReporter($options = array()) {
                $classname = 'report'.ucfirst($this->reporter_name);
                if(!class_exists($classname)) {
                        require_once('reporters/reporter.'. $this->reporter_name .'.php');
                }
                $this->reporter = new $classname($this->dom, $this->css, $this->guideline, $this->path);
                if(count($options))
                        $this->reporter->setOptions($options);
        }
        

        function isValid() {
                return $this->is_valid;
        }
        
        
        function runCheck($options = null) {
                $this->prepareDOM();
                if(!$this->isValid())
                        return false;
                $this->getCSSObject();
                $classname = ucfirst(strtolower($this->guideline_name)).'Guideline';
                if(!class_exists($classname)) {         
                        require_once('guidelines/'. $this->guideline_name .'.php');
                }
                $this->guideline = new $classname($this->dom, $this->css, $this->path, $options, $this->domain, $this->options['cms_mode']);
        }
        
        function getCSSObject() {
                $this->css = new quailCSS($this->dom, $this->uri, $this->type, $this->path, false, $this->css_files);
        }
        
        function getReport($options = array()) {
                if(!$this->reporter)
                        $this->loadReporter($options);
                if($options) {
                        $this->reporter->setOptions($options);
                }
                return $this->reporter->getReport();
        }
        
        function getTest($test) {
                if(!class_exists($test)) {
                        return false;
                }
                $test_class = new $test($this->dom, $this->css, $this->path);
                return $test_class->report;
        }
        
        function getTestSeverity($test) {
                $test_class = new $test($this->dom, $this->css, $this->path);
                return $test_class->getSeverity();
        }
        
        function cleanup() {
                unset($this->dom);
                unset($this->css);
                unset($this->guideline);
                unset($this->reporter);
        }
}

class quailReporter {
        
        var $dom;
        
        var $css;
        
        var $translation;
        
        var $report;
        
        var $path;
        
        var $options;
        
        var $absolute_attributes = array('src', 'href');
        
        function __construct(&$dom, &$css, &$guideline, $path = '') {
                $this->dom = &$dom;
                $this->css = &$css;
                $this->path = $path;
                $this->options = new stdClass;
                $this->guideline = &$guideline;
        }
        

        
        function setOptions($options) {
                foreach($options as $key => $value) {
                        $this->options->$key = $value;
                }
        }
        
        function setAbsolutePath(&$element) {
                foreach($this->absolute_attributes as $attribute) {
                        if($element->hasAttribute($attribute)) 
                                $attr = $attribute;
                }
                
                if($attr) {
                        $item = $element->getAttribute($attr);
                        //We are ignoring items with absolute URLs
                        if(strpos($item, '://') === false) {
                                
                                $item = implode('/', $this->path) . ltrim($item, '/');
                                $element->setAttribute($attr, $item);
                                
                        }
                }
                if($element->tagName == 'style') {
                        if(strpos($element->nodeValue, '@import') !== false) {
                                
                        
                        }
                }
        }
        
}

class quailReportItem {
        
        var $element;
        
        var $message;
        
        var $manual;
        
        var $pass;
        
        function getLine() {
                if(is_object($this->element) && method_exists($this->element, 'getLineNo')) {
                        return $this->element->getLineNo();
                }
                return 0;
        }
        
        function getHTML($extra_attributes = array()) {
                if(!$this->element)
                        return '';
                $result_dom = new DOMDocument();
                try {

                        $result_element = $result_dom->createElement(utf8_encode($this->element->tagName));
                }
                catch (Exception $e) {
                        return false;
                }
                foreach($this->element->attributes as $attribute) {
                        if($attribute->name != 'quail_style_index') {
                                $result_element->setAttribute($attribute->name, $attribute->value);
                        }
                }
                foreach($extra_attributes as $name => $value) {
                        $result_element->setAttribute($name, $value);
                }
                $result_element->nodeValue = htmlentities($this->element->nodeValue);
                        //We utf8 encode per http://us2.php.net/manual/en/domdocument.save.php#67952
                //$result_dom->appendChild(utf8_encode($result_element));
                @$result_dom->appendChild($result_element);
                return @$result_dom->saveHTML();
        
        }
        
}

class quailGuideline {
        
        var $dom;
        
        var $css;
        
        var $path;

        var $report;
        
        var $translations;
        
        var $cms_mode = false;
        
        var $severity = array(); 
        
        function __construct(&$dom, &$css, &$path, $arg = null, $domain = 'en', $cms_mode = false) {
                $this->dom = &$dom;
                $this->css = &$css;
                $this->path = &$path;
                $this->cms_mode = $cms_mode;
                $this->loadTranslations($domain);
                $this->run($arg, $domain);
        }
        
        function getTests() {
                return $this->tests;
        }
        
        function loadTranslations($domain) {
                $csv = fopen(dirname(__FILE__) .'/guidelines/translations/'. $domain .'.txt', 'r');
                if ($csv) {
                    while ($translation = fgetcsv($csv)) {
                                if(count($translation) == 4) {
                                        $this->translations[$translation[0]] = array(
                                                'title' => $translation[1],
                                                'description' => $translation[2],
                                                );
                                }
                        }
                }
        }
        function getTranslation($testname) {
                $translation = (isset($this->translations[$testname]))
                                                ? $this->translations[$testname]
                                                : $testname;
                return $translation;
        }
        function run($arg = null, $language = 'en') {
                foreach($this->tests as $testname => $options) {
                        if(is_numeric($testname) && !is_array($options)) {
                                $testname = $options;
                        }
                        if(class_exists($testname) && $this->dom) {
                                $$testname = new $testname($this->dom, $this->css, $this->path, $language, $arg);
                                if(!$this->cms_mode || ($$testname->cms && $this->cms_mode)) {
                                        $this->report[$testname] = $$testname->getReport();     
                                }
                                $this->severity[$testname] = $$testname->default_severity;
                                unset($$testname);
                        }
                        else {
                                $this->report[$testname] = false;
                        }
                }
        }
        
        function getReport(){
                return $this->report;
        }
        
        function getSeverity($testname) {
                if(isset($this->tests[$testname]['severity'])) {
                        return $this->tests[$testname]['severity'];
                }
                if(isset($this->severity[$testname])) {
                        return $this->severity[$testname];
                }
                return QUAIL_TEST_MODERATE;
        }
}

---