Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1 
<?php
2 
 
3 
/**
4 
 * Parses string hash files. File format is as such:
5 
 *
6 
 *      DefaultKeyValue
7 
 *      KEY: Value
8 
 *      KEY2: Value2
9 
 *      --MULTILINE-KEY--
10 
 *      Multiline
11 
 *      value.
12 
 *
13 
 * Which would output something similar to:
14 
 *
15 
 *      array(
16 
 *          'ID' => 'DefaultKeyValue',
17 
 *          'KEY' => 'Value',
18 
 *          'KEY2' => 'Value2',
19 
 *          'MULTILINE-KEY' => "Multiline\nvalue.\n",
20 
 *      )
21 
 *
22 
 * We use this as an easy to use file-format for configuration schema
23 
 * files, but the class itself is usage agnostic.
24 
 *
25 
 * You can use ---- to forcibly terminate parsing of a single string-hash;
26 
 * this marker is used in multi string-hashes to delimit boundaries.
27 
 */
28 
class HTMLPurifier_StringHashParser
29 
{
30 
 
31 
    /**
32 
     * @type string
33 
     */
34 
    public $default = 'ID';
35 
 
36 
    /**
37 
     * Parses a file that contains a single string-hash.
38 
     * @param string $file
39 
     * @return array
40 
     */
41 
    public function parseFile($file)
42 
    {
43 
        if (!file_exists($file)) {
44 
            return false;
45 
        }
46 
        $fh = fopen($file, 'r');
47 
        if (!$fh) {
48 
            return false;
49 
        }
50 
        $ret = $this->parseHandle($fh);
51 
        fclose($fh);
52 
        return $ret;
53 
    }
54 
 
55 
    /**
56 
     * Parses a file that contains multiple string-hashes delimited by '----'
57 
     * @param string $file
58 
     * @return array
59 
     */
60 
    public function parseMultiFile($file)
61 
    {
62 
        if (!file_exists($file)) {
63 
            return false;
64 
        }
65 
        $ret = array();
66 
        $fh = fopen($file, 'r');
67 
        if (!$fh) {
68 
            return false;
69 
        }
70 
        while (!feof($fh)) {
71 
            $ret[] = $this->parseHandle($fh);
72 
        }
73 
        fclose($fh);
74 
        return $ret;
75 
    }
76 
 
77 
    /**
78 
     * Internal parser that acepts a file handle.
79 
     * @note While it's possible to simulate in-memory parsing by using
80 
     *       custom stream wrappers, if such a use-case arises we should
81 
     *       factor out the file handle into its own class.
82 
     * @param resource $fh File handle with pointer at start of valid string-hash
83 
     *            block.
84 
     * @return array
85 
     */
86 
    protected function parseHandle($fh)
87 
    {
88 
        $state   = false;
89 
        $single  = false;
90 
        $ret     = array();
91 
        do {
92 
            $line = fgets($fh);
93 
            if ($line === false) {
94 
                break;
95 
            }
96 
            $line = rtrim($line, "\n\r");
97 
            if (!$state && $line === '') {
98 
                continue;
99 
            }
100 
            if ($line === '----') {
101 
                break;
102 
            }
103 
            if (strncmp('--#', $line, 3) === 0) {
104 
                // Comment
105 
                continue;
106 
            } elseif (strncmp('--', $line, 2) === 0) {
107 
                // Multiline declaration
108 
                $state = trim($line, '- ');
109 
                if (!isset($ret[$state])) {
110 
                    $ret[$state] = '';
111 
                }
112 
                continue;
113 
            } elseif (!$state) {
114 
                $single = true;
115 
                if (strpos($line, ':') !== false) {
116 
                    // Single-line declaration
117 
                    list($state, $line) = explode(':', $line, 2);
118 
                    $line = trim($line);
119 
                } else {
120 
                    // Use default declaration
121 
                    $state  = $this->default;
122 
                }
123 
            }
124 
            if ($single) {
125 
                $ret[$state] = $line;
126 
                $single = false;
127 
                $state  = false;
128 
            } else {
129 
                $ret[$state] .= "$line\n";
130 
            }
131 
        } while (!feof($fh));
132 
        return $ret;
133 
    }
134 
}
135 
 
136 
// vim: et sw=4 sts=4