MetadataIndex::lookupKey() - Code Metrics - Inspection of "Refactor fulltext search functions and class Doku_..." - splitbrain/dokuwiki - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#2943)

by Andreas

created 2020-09-10 15:40 UTC

MetadataIndex::lookupKey() F

↳ Parent: MetadataIndex

Complexity

Conditions	21
Paths	480

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	21
nc	480
nop	3
dl	0
loc	91
rs	0.7221
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

namespace dokuwiki\Search;

use dokuwiki\Search\Exception\IndexAccessException;

/**
 * Class DokuWiki Metadata Index (Singleton)
 *
 * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)
 * @author     Andreas Gohr <[email protected]>
 * @author Tom N Harris <[email protected]>
 */
class MetadataIndex extends AbstractIndex
{
    /** @var MetadataIndex $instance */
    protected static $instance = null;

    /**
     * Get new or existing singleton instance of the MetadataIndex
     *
     * @return MetadataIndex
     */
    public static function getInstance()
    {
        if (is_null(static::$instance)) {
            static::$instance = new static();
        }
        return static::$instance;
    }

    /**
     * Return a list of pages containing the metadata key
     * Note: override parent class methods
     *
     * @param string    $key    list only pages containing the metadata key
     * @return array            list of page names
     *
     * @author Tom N Harris <[email protected]>
     */
    public function getPages($key = null)
    {
        $page_idx = $this->getIndex('page', '');
        if (is_null($key)) return $page_idx; // same as parent method

        // Special handling for titles
        if ($key == 'title') {
            $title_idx = $this->getIndex('title', '');
            array_splice($page_idx, count($title_idx));
            foreach ($title_idx as $i => $title) {
                if ($title === '') unset($page_idx[$i]);
            }
            return array_values($page_idx);
        }

        $metaname = $this->cleanName($key);
        $pages = array();
        $lines = $this->getIndex($metaname.'_i', '');
        foreach ($lines as $line) {
            $pages = array_merge($pages, $this->parseTuples($page_idx, $line));
        }
        return array_keys($pages);
    }

    /**
     * Add/update keys to/of the metadata index
     *
     * Adding new keys does not remove other keys for the page.
     * An empty value will erase the key.
     * The $key parameter can be an array to add multiple keys. $value will
     * not be used if $key is an array.
     *
     * @param string $page a page name
     * @param mixed $key a key string or array of key=>value pairs
     * @param mixed $value the value or list of values
     * @param bool $requireLock should be false only if the caller is resposible for index lock
     * @return bool  if the function completed successfully
     *
     * @throws IndexAccessException
     * @throws Exception\IndexLockException
     * @throws Exception\IndexWriteException
     * @author Michael Hamann <[email protected]>
     * @author Tom N Harris <[email protected]>
     */
    public function addMetaKeys($page, $key, $value = null, $requireLock = true)
    {
        if (!is_array($key)) {
            $key = array($key => $value);
        } elseif (!is_null($value)) {
            // $key is array, but $value is not null
            throw new IndexAccessException('array passed to addMetaKeys but value is not null');
        }

        // load known documents
        $pid = $this->getPID($page);
        if ($pid === false) {
            return false;
        }

        if ($requireLock) $this->lock();

        // Special handling for titles so the index file is simpler
        if (array_key_exists('title', $key)) {
            $value = $key['title'];
            if (is_array($value)) {
                $value = $value[0];
            }
            $this->saveIndexKey('title', '', $pid, $value);
            unset($key['title']);
        }

        foreach ($key as $name => $values) {
            $metaname = $this->cleanName($name);
            $this->addIndexKey('metadata', '', $metaname);
            $metaidx = $this->getIndex($metaname.'_i', '');
            $metawords = $this->getIndex($metaname.'_w', '');
            $addwords = false;

            if (!is_array($values)) $values = array($values);

            $val_idx = $this->getIndexKey($metaname.'_p', '', $pid);
            if ($val_idx !== '') {
                $val_idx = explode(':', $val_idx);
                // -1 means remove, 0 keep, 1 add
                $val_idx = array_combine($val_idx, array_fill(0, count($val_idx), -1));
            } else {
                $val_idx = array();
            }

            foreach ($values as $val) {
                $val = (string)$val;
                if ($val !== '') {
                    $id = array_search($val, $metawords, true);
                    if ($id === false) {
                        // didn't find $val, so we'll add it to the end of metawords
                        // and create a placeholder in metaidx
                        $id = count($metawords);
                        $metawords[$id] = $val;
                        $metaidx[$id] = '';
                        $addwords = true;
                    }
                    // test if value is already in the index
                    if (isset($val_idx[$id]) && $val_idx[$id] <= 0) {
                        $val_idx[$id] = 0;
                    } else { // else add it
                        $val_idx[$id] = 1;
                    }
                }
            }

            if ($addwords) {
                $this->saveIndex($metaname.'_w', '', $metawords);
            }
            $vals_changed = false;
            foreach ($val_idx as $id => $action) {
                if ($action == -1) {
                    $metaidx[$id] = $this->updateTuple($metaidx[$id], $pid, 0);
                    $vals_changed = true;
                    unset($val_idx[$id]);
                } elseif ($action == 1) {
                    $metaidx[$id] = $this->updateTuple($metaidx[$id], $pid, 1);
                    $vals_changed = true;
                }
            }

            if ($vals_changed) {
                $this->saveIndex($metaname.'_i', '', $metaidx);
                $val_idx = implode(':', array_keys($val_idx));
                $this->saveIndexKey($metaname.'_p', '', $pid, $val_idx);
            }

            unset($metaidx);
            unset($metawords);
        }

        if ($requireLock) $this->unlock();
        return true;
    }

    /**
     * Delete keys of the page from metadata index
     *
     * @param string $page a page name
     * @param mixed $keys a key string or array of keys
     * @param bool $requireLock should be false only if the caller is resposible for index lock
     * @return bool  If renaming the value has been successful, false on error
     *
     * @throws Exception\IndexLockException
     * @author Satoshi Sahara <[email protected]>
     * @author Tom N Harris <[email protected]>
     */
    public function deleteMetaKeys($page, $keys = [], $requireLock = true)
    {
        // load known documents
        $pid = $this->getPID($page);
        if ($pid === false) {
            return false;
        }

        if ($requireLock) $this->lock();

        $knownKeys = $this->getIndex('metadata', '');
        $knownKeys[] = 'title';

        // remove all metadata keys of the page when $keys is empty
        $keys = (empty($keys)) ? $knownKeys : (array)$keys;

        foreach ($keys as $metaname) {
            if ($metaname == 'title') {
                // Special handling for titles so the index file is simpler
                $this->saveIndexKey('title', '', $pid, '');
            } elseif (in_array($metaname, $knownKeys)) {
                $meta_idx = $this->getIndex($metaname.'_i', '');
                $val_idx = explode(':', $this->getIndexKey($metaname.'_p', '', $pid));
                foreach ($val_idx as $id) {
                    if ($id === '') continue;
                    $meta_idx[$id] = $this->updateTuple($meta_idx[$id], $pid, 0);
                }
                $this->saveIndex($metaname.'_i', '', $meta_idx);
                $this->saveIndexKey($metaname.'_p', '', $pid, '');
            }
        }

        if ($requireLock) $this->unlock();
        return true;
    }

    /**
     * Find pages containing a metadata key
     *
     * The metadata values are compared as case-sensitive strings. Pass a
     * callback function that returns true or false to use a different
     * comparison function. The function will be called with the $value being
     * searched for as the first argument, and the word in the index as the
     * second argument. The function preg_match can be used directly if the
     * values are regexes.
     *
     * @param string    $key    name of the metadata key to look for
     * @param string    $value  search term to look for, must be a string or array of strings
     * @param callback  $func   comparison function
     * @return array            lists with page names, keys are query values if $value is array
     *
     * @author Tom N Harris <[email protected]>
     * @author Michael Hamann <[email protected]>
     */
    public function lookupKey($key, &$value, $func = null)
    {
        if (!is_array($value)) {
            $value_array = array($value);
        } else {
            $value_array =& $value;
        }

        // the matching ids for the provided value(s)
        $value_ids = array();

        $metaname = $this->cleanName($key);

        // get all words in order to search the matching ids
        if ($key == 'title') {
            $words = $this->getIndex('title', '');
        } else {
            $words = $this->getIndex($metaname.'_w', '');
        }

        if (!is_null($func)) {
            foreach ($value_array as $val) {
                foreach ($words as $i => $word) {
                    if (call_user_func_array($func, array($val, $word))) {
                        $value_ids[$i][] = $val;
                    }
                }
            }
        } else {
            foreach ($value_array as $val) {
                $xval = $val;
                $caret = '^';
                $dollar = '$';
                // check for wildcards
                if (substr($xval, 0, 1) == '*') {
                    $xval = substr($xval, 1);
                    $caret = '';
                }
                if (substr($xval, -1, 1) == '*') {
                    $xval = substr($xval, 0, -1);
                    $dollar = '';
                }
                if (!$caret || !$dollar) {
                    $re = $caret.preg_quote($xval, '/').$dollar;
                    foreach (array_keys(preg_grep('/'.$re.'/', $words)) as $i) {
                        $value_ids[$i][] = $val;
                    }
                } else {
                    if (($i = array_search($val, $words, true)) !== false) {
                        $value_ids[$i][] = $val;
                    }
                }
            }
        }

        unset($words); // free the used memory

        // initialize the result so it won't be null
        $result = array();
        foreach ($value_array as $val) {
            $result[$val] = array();
        }

        $page_idx = $this->getIndex('page', '');

        // Special handling for titles
        if ($key == 'title') {
            foreach ($value_ids as $pid => $val_list) {
                $page = $page_idx[$pid];
                foreach ($val_list as $val) {
                    $result[$val][] = $page;
                }
            }
        } else {
            // load all lines and pages so the used lines can be taken
            // and matched with the pages
            $lines = $this->getIndex($metaname.'_i', '');

            foreach ($value_ids as $value_id => $val_list) {
                // parse the tuples of the form page_id*1:page2_id*1 and so on,
                // return value is an array with page_id => 1, page2_id => 1 etc.
                // so take the keys only
                $pages = array_keys($this->parseTuples($page_idx, $lines[$value_id]));
                foreach ($val_list as $val) {
                    $result[$val] = array_merge($result[$val], $pages);
                }
            }
        }
        if (!is_array($value)) $result = $result[$value];
        return $result;
    }

    /**
     * Renames a meta value in the index
     * This doesn't change the meta value in the pages, it assumes that
     * all pages will be updated.
     *
     * @param string $key The metadata key of which a value shall be changed
     * @param string $oldvalue The old value that shall be renamed
     * @param string $newvalue The new value to which the old value shall be renamed,
     *                          if exists values will be merged
     * @return bool  If renaming the value has been successful, false on error
     * @throws Exception\IndexLockException
     */
    public function renameMetaValue($key, $oldvalue, $newvalue)
    {
        $this->lock();

        // change the relation references index
        $metavalues = $this->getIndex($key, '_w');
        $oldid = array_search($oldvalue, $metavalues, true);
        if ($oldid !== false) {
            $newid = array_search($newvalue, $metavalues, true);
            if ($newid !== false) {
                // free memory
                unset($metavalues);

                // okay, now we have two entries for the same value. we need to merge them.
                $indexline = $this->getIndexKey($key.'_i', '', $oldid);
                if ($indexline != '') {
                    $newindexline = $this->getIndexKey($key.'_i', '', $newid);
                    $pagekeys     = $this->getIndex($key.'_p', '');
                    $parts = explode(':', $indexline);
                    foreach ($parts as $part) {
                        list($id, $count) = explode('*', $part);
                        $newindexline = $this->updateTuple($newindexline, $id, $count);

                        $keyline = explode(':', $pagekeys[$id]);
                        // remove old meta value
                        $keyline = array_diff($keyline, array($oldid));
                        // add new meta value when not already present
                        if (!in_array($newid, $keyline)) {
                            array_push($keyline, $newid);
                        }
                        $pagekeys[$id] = implode(':', $keyline);
                    }
                    $this->saveIndex($key.'_p', '', $pagekeys);
                    unset($pagekeys);
                    $this->saveIndexKey($key.'_i', '', $oldid, '');
                    $this->saveIndexKey($key.'_i', '', $newid, $newindexline);
                }
            } else {
                $metavalues[$oldid] = $newvalue;
                if (!$this->saveIndex($key.'_w', '', $metavalues)) {
                    $this->unlock();
                    return false;
                }
            }
        }

        $this->unlock();
        return true;
    }

    /**
     * Return a list of words or frequency sorted by number of times used
     *
     * @param int       $min    bottom frequency threshold
     * @param int       $max    upper frequency limit. No limit if $max<$min
     * @param int       $minlen minimum length of words to count
     * @param string    $key    metadata key to list. Uses the fulltext index if not given
     * @return array            list of words as the keys and frequency as values
     *
     * @author Tom N Harris <[email protected]>
     */
    public function histogram($min=1, $max=0, $minlen=3, $key=null)
    {
        if ($min < 1)    $min = 1;
        if ($max < $min) $max = 0;

        $result = array();

        if ($key == 'title') {
            $index = $this->getIndex('title', '');
            $index = array_count_values($index);
            foreach ($index as $val => $cnt) {
                if ($cnt >= $min && (!$max || $cnt <= $max) && strlen($val) >= $minlen) {
                    $result[$val] = $cnt;
                }
            }
        } elseif (!is_null($key)) {
            $metaname = $this->cleanName($key);
            $index = $this->getIndex($metaname.'_i', '');
            $val_idx = array();
            foreach ($index as $wid => $line) {
                $freq = $this->countTuples($line);
                if ($freq >= $min && (!$max || $freq <= $max)) {
                    $val_idx[$wid] = $freq;
                }
            }
            if (!empty($val_idx)) {
                $words = $this->getIndex($metaname.'_w', '');
                foreach ($val_idx as $wid => $freq) {
                    if (strlen($words[$wid]) >= $minlen) {
                        $result[$words[$wid]] = $freq;
                    }
                }
            }
        } else {
            $FulltextIndex = FulltextIndex::getInstance();
            $lengths = $FulltextIndex->listIndexLengths();
            foreach ($lengths as $length) {
                if ($length < $minlen) continue;
                $index = $this->getIndex('i', $length);
                $words = null;
                foreach ($index as $wid => $line) {
                    $freq = $this->countTuples($line);
                    if ($freq >= $min && (!$max || $freq <= $max)) {
                        if ($words === null) {
                            $words = $this->getIndex('w', $length);
                        }
                        $result[$words[$wid]] = $freq;
                    }
                }
            }
        }

        arsort($result);
        return $result;
    }

    /**
     * Clear the Metadata Index
     *
     * @param bool $requireLock should be false only if the caller is resposible for index lock
     * @return bool  If the index has been cleared successfully
     * @throws Exception\IndexLockException
     */
    public function clear($requireLock = true)
    {
        global $conf;

        if ($requireLock) $this->lock();

        $knownKeys = $this->getIndex('metadata', '');
        foreach ($knownKeys as $metaname) {
            @unlink($conf['indexdir'].'/'.$metaname.'_w.idx');
            @unlink($conf['indexdir'].'/'.$metaname.'_i.idx');
            @unlink($conf['indexdir'].'/'.$metaname.'_p.idx');
        }
        @unlink($conf['indexdir'].'/title.idx');
        @unlink($conf['indexdir'].'/metadata.idx');

        if ($requireLock) $this->unlock();
        return true;
    }

    /**
     * Returns the backlinks for a given page
     *
     * Uses the metadata index.
     *
     * @param string $id           The id for which links shall be returned
     * @param bool   $ignore_perms Ignore the fact that pages are hidden or read-protected
     * @return array The pages that contain links to the given page
     *
     * @author     Andreas Gohr <[email protected]>
     */
    public function backlinks($id, $ignore_perms = false)
    {
        $result = $this->lookupKey('relation_references', $id);

        if (!count($result)) return $result;

        // check ACL permissions
        foreach (array_keys($result) as $idx) {
            if (($ignore_perms !== true
                && (isHiddenPage($result[$idx]) || auth_quickaclcheck($result[$idx]) < AUTH_READ)
                ) || !page_exists($result[$idx], '', false)
            ) {
                unset($result[$idx]);
            }
        }

        sort($result);
        return $result;
    }

    /**
     * Returns the pages that use a given media file
     *
     * Uses the relation media metadata property and the metadata index.
     *
     * Note that before 2013-07-31 the second parameter was the maximum number
     * of results and permissions were ignored. That's why the parameter is now
     * checked to be explicitely set to true (with type bool) in order to be
     * compatible with older uses of the function.
     *
     * @param string $id           The media id to look for
     * @param bool   $ignore_perms Ignore hidden pages and acls (optional, default: false)
     * @return array A list of pages that use the given media file
     *
     * @author     Andreas Gohr <[email protected]>
     */
    public function mediause($id, $ignore_perms = false)
    {
        $result = $this->lookupKey('relation_media', $id);

        if (!count($result)) return $result;

        // check ACL permissions
        foreach (array_keys($result) as $idx) {
            if (($ignore_perms !== true
                && (isHiddenPage($result[$idx]) || auth_quickaclcheck($result[$idx]) < AUTH_READ)
                ) || !page_exists($result[$idx], '', false)
            ) {
                unset($result[$idx]);
            }
        }

        sort($result);
        return $result;
    }
}


1			<?php
2
3			namespace dokuwiki\Search;
4
5			use dokuwiki\Search\Exception\IndexAccessException;
6
7			/**
8			* Class DokuWiki Metadata Index (Singleton)
9			*
10			* @license GPL 2 (http://www.gnu.org/licenses/gpl.html)
11			* @author Andreas Gohr <[email protected]>
12			* @author Tom N Harris <[email protected]>
13			*/
14			class MetadataIndex extends AbstractIndex
15			{
16			/** @var MetadataIndex $instance */
17			protected static $instance = null;
18
19			/**
20			* Get new or existing singleton instance of the MetadataIndex
21			*
22			* @return MetadataIndex
23			*/
24			public static function getInstance()
25			{
26			if (is_null(static::$instance)) {
27			static::$instance = new static();
28			}
29			return static::$instance;
30			}
31
32			/**
33			* Return a list of pages containing the metadata key
34			* Note: override parent class methods
35			*
36			* @param string $key list only pages containing the metadata key
37			* @return array list of page names
38			*
39			* @author Tom N Harris <[email protected]>
40			*/
41			public function getPages($key = null)
42			{
43			$page_idx = $this->getIndex('page', '');
44			if (is_null($key)) return $page_idx; // same as parent method
45
46			// Special handling for titles
47			if ($key == 'title') {
48			$title_idx = $this->getIndex('title', '');
49			array_splice($page_idx, count($title_idx));
50			foreach ($title_idx as $i => $title) {
51			if ($title === '') unset($page_idx[$i]);
52			}
53			return array_values($page_idx);
54			}
55
56			$metaname = $this->cleanName($key);
57			$pages = array();
58			$lines = $this->getIndex($metaname.'_i', '');
59			foreach ($lines as $line) {
60			$pages = array_merge($pages, $this->parseTuples($page_idx, $line));
61			}
62			return array_keys($pages);
63			}
64
65			/**
66			* Add/update keys to/of the metadata index
67			*
68			* Adding new keys does not remove other keys for the page.
69			* An empty value will erase the key.
70			* The $key parameter can be an array to add multiple keys. $value will
71			* not be used if $key is an array.
72			*
73			* @param string $page a page name
74			* @param mixed $key a key string or array of key=>value pairs
75			* @param mixed $value the value or list of values
76			* @param bool $requireLock should be false only if the caller is resposible for index lock
77			* @return bool if the function completed successfully
78			*
79			* @throws IndexAccessException
80			* @throws Exception\IndexLockException
81			* @throws Exception\IndexWriteException
82			* @author Michael Hamann <[email protected]>
83			* @author Tom N Harris <[email protected]>
84			*/
85			public function addMetaKeys($page, $key, $value = null, $requireLock = true)
86			{
87			if (!is_array($key)) {
88			$key = array($key => $value);
89			} elseif (!is_null($value)) {
90			// $key is array, but $value is not null
91			throw new IndexAccessException('array passed to addMetaKeys but value is not null');
92			}
93
94			// load known documents
95			$pid = $this->getPID($page);
96			if ($pid === false) {
97			return false;
98			}
99
100			if ($requireLock) $this->lock();
101
102			// Special handling for titles so the index file is simpler
103			if (array_key_exists('title', $key)) {
104			$value = $key['title'];
105			if (is_array($value)) {
106			$value = $value[0];
107			}
108			$this->saveIndexKey('title', '', $pid, $value);
109			unset($key['title']);
110			}
111
112			foreach ($key as $name => $values) {
113			$metaname = $this->cleanName($name);
114			$this->addIndexKey('metadata', '', $metaname);
115			$metaidx = $this->getIndex($metaname.'_i', '');
116			$metawords = $this->getIndex($metaname.'_w', '');
117			$addwords = false;
118
119			if (!is_array($values)) $values = array($values);
120
121			$val_idx = $this->getIndexKey($metaname.'_p', '', $pid);
122			if ($val_idx !== '') {
123			$val_idx = explode(':', $val_idx);
124			// -1 means remove, 0 keep, 1 add
125			$val_idx = array_combine($val_idx, array_fill(0, count($val_idx), -1));
126			} else {
127			$val_idx = array();
128			}
129
130			foreach ($values as $val) {
131			$val = (string)$val;
132			if ($val !== '') {
133			$id = array_search($val, $metawords, true);
134			if ($id === false) {
135			// didn't find $val, so we'll add it to the end of metawords
136			// and create a placeholder in metaidx
137			$id = count($metawords);
138			$metawords[$id] = $val;
139			$metaidx[$id] = '';
140			$addwords = true;
141			}
142			// test if value is already in the index
143			if (isset($val_idx[$id]) && $val_idx[$id] <= 0) {
144			$val_idx[$id] = 0;
145			} else { // else add it
146			$val_idx[$id] = 1;
147			}
148			}
149			}
150
151			if ($addwords) {
152			$this->saveIndex($metaname.'_w', '', $metawords);
153			}
154			$vals_changed = false;
155			foreach ($val_idx as $id => $action) {
156			if ($action == -1) {
157			$metaidx[$id] = $this->updateTuple($metaidx[$id], $pid, 0);
158			$vals_changed = true;
159			unset($val_idx[$id]);
160			} elseif ($action == 1) {
161			$metaidx[$id] = $this->updateTuple($metaidx[$id], $pid, 1);
162			$vals_changed = true;
163			}
164			}
165
166			if ($vals_changed) {
167			$this->saveIndex($metaname.'_i', '', $metaidx);
168			$val_idx = implode(':', array_keys($val_idx));
169			$this->saveIndexKey($metaname.'_p', '', $pid, $val_idx);
170			}
171
172			unset($metaidx);
173			unset($metawords);
174			}
175
176			if ($requireLock) $this->unlock();
177			return true;
178			}
179
180			/**
181			* Delete keys of the page from metadata index
182			*
183			* @param string $page a page name
184			* @param mixed $keys a key string or array of keys
185			* @param bool $requireLock should be false only if the caller is resposible for index lock
186			* @return bool If renaming the value has been successful, false on error
187			*
188			* @throws Exception\IndexLockException
189			* @author Satoshi Sahara <[email protected]>
190			* @author Tom N Harris <[email protected]>
191			*/
192			public function deleteMetaKeys($page, $keys = [], $requireLock = true)
193			{
194			// load known documents
195			$pid = $this->getPID($page);
196			if ($pid === false) {
197			return false;
198			}
199
200			if ($requireLock) $this->lock();
201
202			$knownKeys = $this->getIndex('metadata', '');
203			$knownKeys[] = 'title';
204
205			// remove all metadata keys of the page when $keys is empty
206			$keys = (empty($keys)) ? $knownKeys : (array)$keys;
207
208			foreach ($keys as $metaname) {
209			if ($metaname == 'title') {
210			// Special handling for titles so the index file is simpler
211			$this->saveIndexKey('title', '', $pid, '');
212			} elseif (in_array($metaname, $knownKeys)) {
213			$meta_idx = $this->getIndex($metaname.'_i', '');
214			$val_idx = explode(':', $this->getIndexKey($metaname.'_p', '', $pid));
215			foreach ($val_idx as $id) {
216			if ($id === '') continue;
217			$meta_idx[$id] = $this->updateTuple($meta_idx[$id], $pid, 0);
218			}
219			$this->saveIndex($metaname.'_i', '', $meta_idx);
220			$this->saveIndexKey($metaname.'_p', '', $pid, '');
221			}
222			}
223
224			if ($requireLock) $this->unlock();
225			return true;
226			}
227
228			/**
229			* Find pages containing a metadata key
230			*
231			* The metadata values are compared as case-sensitive strings. Pass a
232			* callback function that returns true or false to use a different
233			* comparison function. The function will be called with the $value being
234			* searched for as the first argument, and the word in the index as the
235			* second argument. The function preg_match can be used directly if the
236			* values are regexes.
237			*
238			* @param string $key name of the metadata key to look for
239			* @param string $value search term to look for, must be a string or array of strings
240			* @param callback $func comparison function
241			* @return array lists with page names, keys are query values if $value is array
242			*
243			* @author Tom N Harris <[email protected]>
244			* @author Michael Hamann <[email protected]>
245			*/
246			public function lookupKey($key, &$value, $func = null)
247			{
248			if (!is_array($value)) {
249			$value_array = array($value);
250			} else {
251			$value_array =& $value;
252			}
253
254			// the matching ids for the provided value(s)
255			$value_ids = array();
256
257			$metaname = $this->cleanName($key);
258
259			// get all words in order to search the matching ids
260			if ($key == 'title') {
261			$words = $this->getIndex('title', '');
262			} else {
263			$words = $this->getIndex($metaname.'_w', '');
264			}
265
266			if (!is_null($func)) {
267			foreach ($value_array as $val) {
268			foreach ($words as $i => $word) {
269			if (call_user_func_array($func, array($val, $word))) {
270			$value_ids[$i][] = $val;
271			}
272			}
273			}
274			} else {
275			foreach ($value_array as $val) {
276			$xval = $val;
277			$caret = '^';
278			$dollar = '$';
279			// check for wildcards
280			if (substr($xval, 0, 1) == '*') {
281			$xval = substr($xval, 1);
282			$caret = '';
283			}
284			if (substr($xval, -1, 1) == '*') {
285			$xval = substr($xval, 0, -1);
286			$dollar = '';
287			}
288			if (!$caret \|\| !$dollar) {
289			$re = $caret.preg_quote($xval, '/').$dollar;
290			foreach (array_keys(preg_grep('/'.$re.'/', $words)) as $i) {
291			$value_ids[$i][] = $val;
292			}
293			} else {
294			if (($i = array_search($val, $words, true)) !== false) {
295			$value_ids[$i][] = $val;
296			}
297			}
298			}
299			}
300
301			unset($words); // free the used memory
302
303			// initialize the result so it won't be null
304			$result = array();
305			foreach ($value_array as $val) {
306			$result[$val] = array();
307			}
308
309			$page_idx = $this->getIndex('page', '');
310
311			// Special handling for titles
312			if ($key == 'title') {
313			foreach ($value_ids as $pid => $val_list) {
314			$page = $page_idx[$pid];
315			foreach ($val_list as $val) {
316			$result[$val][] = $page;
317			}
318			}
319			} else {
320			// load all lines and pages so the used lines can be taken
321			// and matched with the pages
322			$lines = $this->getIndex($metaname.'_i', '');
323
324			foreach ($value_ids as $value_id => $val_list) {
325			// parse the tuples of the form page_id1:page2_id1 and so on,
326			// return value is an array with page_id => 1, page2_id => 1 etc.
327			// so take the keys only
328			$pages = array_keys($this->parseTuples($page_idx, $lines[$value_id]));
329			foreach ($val_list as $val) {
330			$result[$val] = array_merge($result[$val], $pages);
331			}
332			}
333			}
334			if (!is_array($value)) $result = $result[$value];
335			return $result;
336			}
337
338			/**
339			* Renames a meta value in the index
340			* This doesn't change the meta value in the pages, it assumes that
341			* all pages will be updated.
342			*
343			* @param string $key The metadata key of which a value shall be changed
344			* @param string $oldvalue The old value that shall be renamed
345			* @param string $newvalue The new value to which the old value shall be renamed,
346			* if exists values will be merged
347			* @return bool If renaming the value has been successful, false on error
348			* @throws Exception\IndexLockException
349			*/
350			public function renameMetaValue($key, $oldvalue, $newvalue)
351			{
352			$this->lock();
353
354			// change the relation references index
355			$metavalues = $this->getIndex($key, '_w');
356			$oldid = array_search($oldvalue, $metavalues, true);
357			if ($oldid !== false) {
358			$newid = array_search($newvalue, $metavalues, true);
359			if ($newid !== false) {
360			// free memory
361			unset($metavalues);
362
363			// okay, now we have two entries for the same value. we need to merge them.
364			$indexline = $this->getIndexKey($key.'_i', '', $oldid);
365			if ($indexline != '') {
366			$newindexline = $this->getIndexKey($key.'_i', '', $newid);
367			$pagekeys = $this->getIndex($key.'_p', '');
368			$parts = explode(':', $indexline);
369			foreach ($parts as $part) {
370			list($id, $count) = explode('*', $part);
371			$newindexline = $this->updateTuple($newindexline, $id, $count);
372
373			$keyline = explode(':', $pagekeys[$id]);
374			// remove old meta value
375			$keyline = array_diff($keyline, array($oldid));
376			// add new meta value when not already present
377			if (!in_array($newid, $keyline)) {
378			array_push($keyline, $newid);
379			}
380			$pagekeys[$id] = implode(':', $keyline);
381			}
382			$this->saveIndex($key.'_p', '', $pagekeys);
383			unset($pagekeys);
384			$this->saveIndexKey($key.'_i', '', $oldid, '');
385			$this->saveIndexKey($key.'_i', '', $newid, $newindexline);
386			}
387			} else {
388			$metavalues[$oldid] = $newvalue;
389			if (!$this->saveIndex($key.'_w', '', $metavalues)) {
390			$this->unlock();
391			return false;
392			}
393			}
394			}
395
396			$this->unlock();
397			return true;
398			}
399
400			/**
401			* Return a list of words or frequency sorted by number of times used
402			*
403			* @param int $min bottom frequency threshold
404			* @param int $max upper frequency limit. No limit if $max<$min
405			* @param int $minlen minimum length of words to count
406			* @param string $key metadata key to list. Uses the fulltext index if not given
407			* @return array list of words as the keys and frequency as values
408			*
409			* @author Tom N Harris <[email protected]>
410			*/
411			public function histogram($min=1, $max=0, $minlen=3, $key=null)
412			{
413			if ($min < 1) $min = 1;
414			if ($max < $min) $max = 0;
415
416			$result = array();
417
418			if ($key == 'title') {
419			$index = $this->getIndex('title', '');
420			$index = array_count_values($index);
421			foreach ($index as $val => $cnt) {
422			if ($cnt >= $min && (!$max \|\| $cnt <= $max) && strlen($val) >= $minlen) {
423			$result[$val] = $cnt;
424			}
425			}
426			} elseif (!is_null($key)) {
427			$metaname = $this->cleanName($key);
428			$index = $this->getIndex($metaname.'_i', '');
429			$val_idx = array();
430			foreach ($index as $wid => $line) {
431			$freq = $this->countTuples($line);
432			if ($freq >= $min && (!$max \|\| $freq <= $max)) {
433			$val_idx[$wid] = $freq;
434			}
435			}
436			if (!empty($val_idx)) {
437			$words = $this->getIndex($metaname.'_w', '');
438			foreach ($val_idx as $wid => $freq) {
439			if (strlen($words[$wid]) >= $minlen) {
440			$result[$words[$wid]] = $freq;
441			}
442			}
443			}
444			} else {
445			$FulltextIndex = FulltextIndex::getInstance();
446			$lengths = $FulltextIndex->listIndexLengths();
447			foreach ($lengths as $length) {
448			if ($length < $minlen) continue;
449			$index = $this->getIndex('i', $length);
450			$words = null;
451			foreach ($index as $wid => $line) {
452			$freq = $this->countTuples($line);
453			if ($freq >= $min && (!$max \|\| $freq <= $max)) {
454			if ($words === null) {
455			$words = $this->getIndex('w', $length);
456			}
457			$result[$words[$wid]] = $freq;
458			}
459			}
460			}
461			}
462
463			arsort($result);
464			return $result;
465			}
466
467			/**
468			* Clear the Metadata Index
469			*
470			* @param bool $requireLock should be false only if the caller is resposible for index lock
471			* @return bool If the index has been cleared successfully
472			* @throws Exception\IndexLockException
473			*/
474			public function clear($requireLock = true)
475			{
476			global $conf;
477
478			if ($requireLock) $this->lock();
479
480			$knownKeys = $this->getIndex('metadata', '');
481			foreach ($knownKeys as $metaname) {
482			@unlink($conf['indexdir'].'/'.$metaname.'_w.idx');
483			@unlink($conf['indexdir'].'/'.$metaname.'_i.idx');
484			@unlink($conf['indexdir'].'/'.$metaname.'_p.idx');
485			}
486			@unlink($conf['indexdir'].'/title.idx');
487			@unlink($conf['indexdir'].'/metadata.idx');
488
489			if ($requireLock) $this->unlock();
490			return true;
491			}
492
493			/**
494			* Returns the backlinks for a given page
495			*
496			* Uses the metadata index.
497			*
498			* @param string $id The id for which links shall be returned
499			* @param bool $ignore_perms Ignore the fact that pages are hidden or read-protected
500			* @return array The pages that contain links to the given page
501			*
502			* @author Andreas Gohr <[email protected]>
503			*/
504			public function backlinks($id, $ignore_perms = false)
505			{
506			$result = $this->lookupKey('relation_references', $id);
507
508			if (!count($result)) return $result;
509
510			// check ACL permissions
511			foreach (array_keys($result) as $idx) {
512			if (($ignore_perms !== true
513			&& (isHiddenPage($result[$idx]) \|\| auth_quickaclcheck($result[$idx]) < AUTH_READ)
514			) \|\| !page_exists($result[$idx], '', false)
515			) {
516			unset($result[$idx]);
517			}
518			}
519
520			sort($result);
521			return $result;
522			}
523
524			/**
525			* Returns the pages that use a given media file
526			*
527			* Uses the relation media metadata property and the metadata index.
528			*
529			* Note that before 2013-07-31 the second parameter was the maximum number
530			* of results and permissions were ignored. That's why the parameter is now
531			* checked to be explicitely set to true (with type bool) in order to be
532			* compatible with older uses of the function.
533			*
534			* @param string $id The media id to look for
535			* @param bool $ignore_perms Ignore hidden pages and acls (optional, default: false)
536			* @return array A list of pages that use the given media file
537			*
538			* @author Andreas Gohr <[email protected]>
539			*/
540			public function mediause($id, $ignore_perms = false)
541			{
542			$result = $this->lookupKey('relation_media', $id);
543
544			if (!count($result)) return $result;
545
546			// check ACL permissions
547			foreach (array_keys($result) as $idx) {
548			if (($ignore_perms !== true
549			&& (isHiddenPage($result[$idx]) \|\| auth_quickaclcheck($result[$idx]) < AUTH_READ)
550			) \|\| !page_exists($result[$idx], '', false)
551			) {
552			unset($result[$idx]);
553			}
554			}
555
556			sort($result);
557			return $result;
558			}
559			}
560

splitbrain / dokuwiki

Pull Request — master (#2943)

MetadataIndex::lookupKey() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like