public function execute()
{
if (!$this->execute_condition()) {
// Check any condition to execute this
return;
}
$fullpath = $this->task->get_taskbasepath();
// We MUST have one fullpath here, else, error
if (empty($fullpath)) {
throw new restore_step_exception('restore_structure_step_undefined_fullpath');
}
// Append the filename to the fullpath
$fullpath = rtrim($fullpath, '/') . '/' . $this->filename;
// And it MUST exist
if (!file_exists($fullpath)) {
// Shouldn't happen ever, but...
throw new restore_step_exception('missing_moodle_backup_xml_file', $fullpath);
}
// Get restore_path elements array adapting and preparing it for processing
$structure = $this->define_structure();
if (!is_array($structure)) {
throw new restore_step_exception('restore_step_structure_not_array', $this->get_name());
}
$this->prepare_pathelements($structure);
// Create parser and processor
$xmlparser = new progressive_parser();
$xmlparser->set_file($fullpath);
$xmlprocessor = new restore_structure_parser_processor($this->task->get_courseid(), $this);
$this->contentprocessor = $xmlprocessor;
// Save the reference to the contentprocessor
// as far as we are going to need it out
// from parser (blame serialized data!)
$xmlparser->set_processor($xmlprocessor);
// Add pathelements to processor
foreach ($this->pathelements as $element) {
$xmlprocessor->add_path($element->get_path(), $element->is_grouped());
}
// And process it, dispatch to target methods in step will start automatically
$xmlparser->process();
// Have finished, launch the after_execute method of all the processing objects
$this->launch_after_execute_methods();
}
/**
* Load and format all the needed information from moodle_backup.xml
*
* This function loads and process all the moodle_backup.xml
* information, composing a big information structure that will
* be the used by the plan builder in order to generate the
* appropiate tasks / steps / settings
*/
public static function get_backup_information($tempdir)
{
global $CFG;
$info = new stdclass();
// Final information goes here
$moodlefile = $CFG->tempdir . '/backup/' . $tempdir . '/moodle_backup.xml';
if (!file_exists($moodlefile)) {
// Shouldn't happen ever, but...
throw new backup_helper_exception('missing_moodle_backup_xml_file', $moodlefile);
}
// Load the entire file to in-memory array
$xmlparser = new progressive_parser();
$xmlparser->set_file($moodlefile);
$xmlprocessor = new restore_moodlexml_parser_processor();
$xmlparser->set_processor($xmlprocessor);
$xmlparser->process();
$infoarr = $xmlprocessor->get_all_chunks();
if (count($infoarr) !== 1) {
// Shouldn't happen ever, but...
throw new backup_helper_exception('problem_parsing_moodle_backup_xml_file');
}
$infoarr = $infoarr[0]['tags'];
// for commodity
// Let's build info
$info->moodle_version = $infoarr['moodle_version'];
$info->moodle_release = $infoarr['moodle_release'];
$info->backup_version = $infoarr['backup_version'];
$info->backup_release = $infoarr['backup_release'];
$info->backup_date = $infoarr['backup_date'];
$info->mnet_remoteusers = $infoarr['mnet_remoteusers'];
$info->original_wwwroot = $infoarr['original_wwwroot'];
$info->original_site_identifier_hash = $infoarr['original_site_identifier_hash'];
$info->original_course_id = $infoarr['original_course_id'];
$info->original_course_fullname = $infoarr['original_course_fullname'];
$info->original_course_shortname = $infoarr['original_course_shortname'];
$info->original_course_startdate = $infoarr['original_course_startdate'];
$info->original_course_contextid = $infoarr['original_course_contextid'];
$info->original_system_contextid = $infoarr['original_system_contextid'];
// Moodle backup file don't have this option before 2.3
if (!empty($infoarr['include_file_references_to_external_content'])) {
$info->include_file_references_to_external_content = 1;
} else {
$info->include_file_references_to_external_content = 0;
}
$info->type = $infoarr['details']['detail'][0]['type'];
$info->format = $infoarr['details']['detail'][0]['format'];
$info->mode = $infoarr['details']['detail'][0]['mode'];
// Build the role mappings custom object
$rolemappings = new stdclass();
$rolemappings->modified = false;
$rolemappings->mappings = array();
$info->role_mappings = $rolemappings;
// Some initially empty containers
$info->sections = array();
$info->activities = array();
// Now the contents
$contentsarr = $infoarr['contents'];
if (isset($contentsarr['course']) && isset($contentsarr['course'][0])) {
$info->course = new stdclass();
$info->course = (object) $contentsarr['course'][0];
$info->course->settings = array();
}
if (isset($contentsarr['sections']) && isset($contentsarr['sections']['section'])) {
$sectionarr = $contentsarr['sections']['section'];
foreach ($sectionarr as $section) {
$section = (object) $section;
$section->settings = array();
$sections[basename($section->directory)] = $section;
}
$info->sections = $sections;
}
if (isset($contentsarr['activities']) && isset($contentsarr['activities']['activity'])) {
$activityarr = $contentsarr['activities']['activity'];
foreach ($activityarr as $activity) {
$activity = (object) $activity;
$activity->settings = array();
$activities[basename($activity->directory)] = $activity;
}
$info->activities = $activities;
}
$info->root_settings = array();
// For root settings
// Now the settings, putting each one under its owner
$settingsarr = $infoarr['settings']['setting'];
foreach ($settingsarr as $setting) {
switch ($setting['level']) {
case 'root':
$info->root_settings[$setting['name']] = $setting['value'];
break;
case 'course':
$info->course->settings[$setting['name']] = $setting['value'];
break;
case 'section':
$info->sections[$setting['section']]->settings[$setting['name']] = $setting['value'];
break;
case 'activity':
$info->activities[$setting['activity']]->settings[$setting['name']] = $setting['value'];
break;
default:
// Shouldn't happen
throw new backup_helper_exception('wrong_setting_level_moodle_backup_xml_file', $setting['level']);
}
}
return $info;
}
/**
* Function that will look for any grouped
* parent for the given path, returning it if found,
* false if not
*/
protected function grouped_parent_exists($path)
{
$parentpath = progressive_parser::dirname($path);
while ($parentpath != '/') {
if ($this->path_is_grouped($parentpath)) {
return $parentpath;
}
$parentpath = progressive_parser::dirname($parentpath);
}
return false;
}
/**
* Load the needed questions.xml file to backup_ids table for future reference
*/
public static function load_categories_and_questions_to_tempids($restoreid, $questionsfile)
{
if (!file_exists($questionsfile)) {
// Shouldn't happen ever, but...
throw new backup_helper_exception('missing_questions_xml_file', $questionsfile);
}
// Let's parse, custom processor will do its work, sending info to DB
$xmlparser = new progressive_parser();
$xmlparser->set_file($questionsfile);
$xmlprocessor = new restore_questions_parser_processor($restoreid);
$xmlparser->set_processor($xmlprocessor);
$xmlparser->process();
}
protected function end_tag($parser, $tag)
{
// Ending rencently started tag, add value to current tag
if ($this->level == $this->prevlevel) {
$this->currtag['cdata'] = $this->postprocess_cdata($this->accum);
$this->topush['tags'][$this->currtag['name']] = $this->currtag;
$this->currtag = array();
}
// Leaving one level, publish all the information available
if ($this->level < $this->prevlevel) {
if (!empty($this->topush['tags'])) {
$this->publish($this->topush);
}
$this->currtag = array();
$this->topush = array();
}
// For the records
$this->prevlevel = $this->level;
// Inform processor we have finished one tag
$this->inform_end($this->path);
// Normal update of parser internals
$this->level--;
$this->path = progressive_parser::dirname($this->path);
}
/**
* Get one chunk of parsed data and make it simpler
* adding attributes as tags and delegating to
* dispatch_chunk() the procesing of the resulting chunk
*/
public function process_chunk($data)
{
// Precalculate some vars for readability
$path = $data['path'];
$parentpath = progressive_parser::dirname($path);
$tag = basename($path);
// If the path is a registered parent one, store all its tags
// so, we'll be able to find attributes later when processing
// (child) registered paths (to get attributes if present)
if ($this->path_is_selected_parent($path)) {
// if path is parent
if (isset($data['tags'])) {
// and has tags, save them
$this->parentsinfo[$path] = $data['tags'];
}
}
// If the path is a registered one, let's process it
if ($this->path_is_selected($path)) {
// First of all, look for attributes available at parentsinfo
// in order to get them available as normal tags
if (isset($this->parentsinfo[$parentpath][$tag]['attrs'])) {
$data['tags'] = array_merge($this->parentsinfo[$parentpath][$tag]['attrs'], $data['tags']);
unset($this->parentsinfo[$parentpath][$tag]['attrs']);
}
// Now, let's simplify the tags array, ignoring tag attributtes and
// reconverting to simpler name => value array. At the same time,
// check for all the tag values being whitespace-string values, if all them
// are whitespace strings, we aren't going to postprocess/dispatch the chunk
$alltagswhitespace = true;
foreach ($data['tags'] as $key => $value) {
// If the value is already a single value, do nothing
// surely was added above from parentsinfo attributes,
// so we'll process the chunk always
if (!is_array($value)) {
$alltagswhitespace = false;
continue;
}
// If the path including the tag name matches another selected path
// (registered or parent) and is null or begins with linefeed, we know it's part
// of another chunk, delete it, another chunk will contain that info
if ($this->path_is_selected($path . '/' . $key) || $this->path_is_selected_parent($path . '/' . $key)) {
if (!isset($value['cdata']) || substr($value['cdata'], 0, 1) === "\n") {
unset($data['tags'][$key]);
continue;
}
}
// Convert to simple name => value array
$data['tags'][$key] = isset($value['cdata']) ? $value['cdata'] : null;
// Check $alltagswhitespace continues being true
if ($alltagswhitespace && strlen($data['tags'][$key]) !== 0 && trim($data['tags'][$key]) !== '') {
$alltagswhitespace = false;
// Found non-whitespace value
}
}
// Arrived here, if the chunk has tags and not all tags are whitespace,
// send it to postprocess filter that will decide about dispatching. Else
// skip the chunk completely
if (!empty($data['tags']) && !$alltagswhitespace) {
return $this->postprocess_chunk($data);
} else {
$this->chunks--;
// Chunk skipped
}
} else {
$this->chunks--;
// Chunk skipped
}
return true;
}
/**
*/
function test_grouped_at_empty_node()
{
global $CFG;
// Instantiate progressive_parser.
$pp = new progressive_parser();
// Instantiate grouped_parser_processor.
$pr = new mock_grouped_parser_processor();
$this->assertTrue($pr instanceof progressive_parser_processor);
// Add interesting paths - moodle1 style.
$pr->add_path('/test/MOODLE_BACKUP/COURSE/FORMATDATA', true);
$pr->add_path('/test/MOODLE_BACKUP/COURSE/FORMATDATA/WEEKS/WEEK');
$pr->add_path('/test/MOODLE_BACKUP/COURSE/EMPTYGROUPED', true);
$pr->add_path('/test/MOODLE_BACKUP/COURSE/SECONDGROUPED', true);
$pr->add_path('/test/MOODLE_BACKUP/COURSE/SECONDGROUPED/SUBS/SUB');
// Add interesting paths - moodle2 style.
$pr->add_path('/test/moodle2/grouped', true);
$pr->add_path('/test/moodle2/grouped/subs/sub');
$pr->add_path('/test/moodle2/groupedemptywithattr', true);
$pr->add_path('/test/moodle2/groupednonemptywithattr', true);
$pr->add_path('/test/moodle2/groupednonemptywithattr/subs/sub');
// Assign processor to parser.
$pp->set_processor($pr);
// Set file from fixtures.
$pp->set_file($CFG->dirroot . '/backup/util/xml/parser/tests/fixtures/test6.xml');
// Process the file.
$pp->process();
// Get all the simplified chunks and perform various validations.
$chunks = $pr->get_chunks();
$this->assertEquals(count($chunks), 6);
// All grouped elements.
// Check some random data.
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/FORMATDATA', $chunks[0]['path']);
$this->assertEquals(2, $chunks[0]['tags']['WEEKS']['WEEK'][1]['SECTION']);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/EMPTYGROUPED', $chunks[1]['path']);
$this->assertEquals(array(), $chunks[1]['tags']);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/SECONDGROUPED', $chunks[2]['path']);
$this->assertEquals('Unit tests rock!', $chunks[2]['tags']['SUBS']['SUB'][0]['PROP']);
$this->assertEquals('/test/moodle2/grouped', $chunks[3]['path']);
$this->assertFalse(isset($chunks[3]['tags']['id']));
// No final elements, this should be fixed one day.
$this->assertEquals(34, $chunks[3]['tags']['subs']['sub'][0]['id']);
// We have final element so this is parsed.
$this->assertEquals('Oh yeah', $chunks[3]['tags']['subs']['sub'][0]['prop']);
$this->assertEquals('/test/moodle2/groupednonemptywithattr', $chunks[4]['path']);
$this->assertEquals(78, $chunks[4]['tags']['id']);
// We have final element so this is parsed.
$this->assertEquals('Go baby go', $chunks[4]['tags']['prop']);
$this->assertEquals(89, $chunks[4]['tags']['subs']['sub'][0]['id']);
$this->assertEquals('http://moodle.org', $chunks[4]['tags']['subs']['sub'][0]['prop']);
$this->assertEquals('/test/moodle2/groupedemptywithattr', $chunks[5]['path']);
$this->assertFalse(isset($chunks[5]['tags']['attr']));
// No final elements, this should be fixed one day.
// Now check start notifications.
$snotifs = $pr->get_start_notifications();
// Check we have received the correct number of notifications.
$this->assertEquals(count($snotifs), 6);
// Check the order of notifications (in order they appear in test6.xml).
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/FORMATDATA', $snotifs[0]);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/EMPTYGROUPED', $snotifs[1]);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/SECONDGROUPED', $snotifs[2]);
$this->assertEquals('/test/moodle2/grouped', $snotifs[3]);
$this->assertEquals('/test/moodle2/groupednonemptywithattr', $snotifs[4]);
$this->assertEquals('/test/moodle2/groupedemptywithattr', $snotifs[5]);
// Now check end notifications.
$enotifs = $pr->get_end_notifications();
// Check we have received the correct number of notifications.
$this->assertEquals(count($enotifs), 6);
// Check the order of notifications (in order they appear in test6.xml).
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/FORMATDATA', $enotifs[0]);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/EMPTYGROUPED', $enotifs[1]);
$this->assertEquals('/test/MOODLE_BACKUP/COURSE/SECONDGROUPED', $enotifs[2]);
$this->assertEquals('/test/moodle2/grouped', $enotifs[3]);
$this->assertEquals('/test/moodle2/groupednonemptywithattr', $enotifs[4]);
$this->assertEquals('/test/moodle2/groupedemptywithattr', $enotifs[5]);
// Now verify that the start/process/end order is correct.
$allnotifs = $pr->get_all_notifications();
$this->assertEquals(count($allnotifs), count($snotifs) + count($enotifs) + count($chunks));
// Check integrity of the notifications.
$errcount = $this->helper_check_notifications_order_integrity($allnotifs);
$this->assertEquals(0, $errcount);
}
/**
* test how the grouped processor and the order of start/process/end events happens
* with one real fragment of one backup 1.9 file, where some problems
* were found by David, hence we honor him in the name of the test ;-)
*/
function test_grouped_david_backup19_file_fragment()
{
global $CFG;
// Instantiate progressive_parser
$pp = new progressive_parser();
// Instantiate grouped_parser_processor
$pr = new mock_grouped_parser_processor();
// Add interesting paths
$pr->add_path('/MOODLE_BACKUP/COURSE');
$pr->add_path('/MOODLE_BACKUP/COURSE/SECTIONS/SECTION', true);
$pr->add_path('/MOODLE_BACKUP/COURSE/SECTIONS/SECTION/MODS/MOD');
$pr->add_path('/MOODLE_BACKUP/COURSE/SECTIONS/SECTION/MODS/MOD/ROLES_OVERRIDES');
$this->assertTrue($pr instanceof progressive_parser_processor);
// Assign processor to parser
$pp->set_processor($pr);
// Set file from fixtures
$pp->set_file($CFG->dirroot . '/backup/util/xml/parser/simpletest/fixtures/test5.xml');
// Process the file
$pp->process();
// Get all the simplified chunks and perform various validations
$chunks = $pr->get_chunks();
$this->assertEqual(count($chunks), 1);
// Only 1, the SECTION one
// Now check start notifications
$snotifs = $pr->get_start_notifications();
// Check we have received the correct number of notifications
$this->assertEqual(count($snotifs), 2);
// Check first and last notifications
$this->assertEqual($snotifs[0], '/MOODLE_BACKUP/COURSE');
$this->assertEqual($snotifs[1], '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION');
// Now check end notifications
$enotifs = $pr->get_end_notifications();
// Check we have received the correct number of notifications
$this->assertEqual(count($snotifs), 2);
// End tags are dispatched for empties (ROLES_OVERRIDES)
// Check first, and last notifications
$this->assertEqual($enotifs[0], '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION');
$this->assertEqual($enotifs[1], '/MOODLE_BACKUP/COURSE');
// Check start and end notifications are balanced
sort($snotifs);
sort($enotifs);
$this->assertEqual($snotifs, $enotifs);
// Now verify that the start/process/end order is correct
$allnotifs = $pr->get_all_notifications();
$this->assertEqual(count($allnotifs), count($snotifs) + count($enotifs) + count($chunks));
// The count
// Check integrity of the notifications
$errcount = $this->helper_check_notifications_order_integrity($allnotifs);
$this->assertEqual($errcount, 0);
// No errors found, plz
}
function test_grouped_parser_results()
{
global $CFG;
// Instantiate progressive_parser
$pp = new progressive_parser();
// Instantiate grouped_parser_processor
$pr = new mock_grouped_parser_processor();
// Add interesting paths
$pr->add_path('/activity');
$pr->add_path('/activity/glossary', true);
$pr->add_path('/activity/glossary/entries/entry');
$pr->add_path('/activity/glossary/entries/entry/aliases/alias');
$pr->add_path('/activity/glossary/entries/entry/ratings/rating');
$pr->add_path('/activity/glossary/categories/category');
$pr->add_path('/activity/glossary/onetest');
$pr->add_path('/activity/glossary/othertest');
$this->assertTrue($pr instanceof progressive_parser_processor);
// Assign processor to parser
$pp->set_processor($pr);
// Set file from fixtures
$pp->set_file($CFG->dirroot . '/backup/util/xml/parser/simpletest/fixtures/test4.xml');
// Process the file
$pp->process();
// Get processor debug info
$debug = $pr->debug_info();
$this->assertTrue(is_array($debug));
$this->assertTrue(array_key_exists('chunks', $debug));
// Check the number of chunks is correct for the file
$this->assertEqual($debug['chunks'], 2);
// Get all the simplified chunks and perform various validations
$chunks = $pr->get_chunks();
// Check we have received the correct number of chunks
$this->assertEqual(count($chunks), 2);
// chunk[0] (/activity) tests
$this->assertEqual(count($chunks[0]), 3);
$this->assertEqual($chunks[0]['path'], '/activity');
$this->assertEqual($chunks[0]['level'], '2');
$tags = $chunks[0]['tags'];
$this->assertEqual(count($tags), 4);
$this->assertEqual($tags['id'], 1);
$this->assertEqual($tags['moduleid'], 5);
$this->assertEqual($tags['modulename'], 'glossary');
$this->assertEqual($tags['contextid'], 26);
$this->assertEqual($chunks[0]['level'], '2');
// chunk[1] (grouped /activity/glossary tests)
$this->assertEqual(count($chunks[1]), 3);
$this->assertEqual($chunks[1]['path'], '/activity/glossary');
$this->assertEqual($chunks[1]['level'], '3');
$tags = $chunks[1]['tags'];
$this->assertEqual(count($tags), 27);
$this->assertEqual($tags['id'], 1);
$this->assertEqual($tags['intro'], '<p>One simple glossary to test backup & restore. Here it\'s the standard image:</p>' . "\n" . '<p><img src="@@PLUGINFILE@@/88_31.png" alt="pwd by moodle" width="88" height="31" /></p>');
$this->assertEqual($tags['timemodified'], 1275639747);
$this->assertTrue(!isset($tags['categories']));
$this->assertTrue(isset($tags['entries']));
$this->assertTrue(isset($tags['onetest']));
$this->assertTrue(isset($tags['othertest']));
// Various tests under the entries
$entries = $chunks[1]['tags']['entries']['entry'];
$this->assertEqual(count($entries), 2);
// First entry
$entry1 = $entries[0];
$this->assertEqual(count($entry1), 17);
$this->assertEqual($entry1['id'], 1);
$this->assertEqual($entry1['userid'], 2);
$this->assertEqual($entry1['concept'], 'dog');
$this->assertEqual($entry1['definition'], '<p>Traditional enemies of cats</p>');
$this->assertTrue(isset($entry1['aliases']));
$this->assertTrue(isset($entry1['ratings']));
// aliases of first entry
$aliases = $entry1['aliases']['alias'];
$this->assertEqual(count($aliases), 1);
// first alias
$alias1 = $aliases[0];
$this->assertEqual(count($alias1), 2);
$this->assertEqual($alias1['id'], 1);
$this->assertEqual($alias1['alias_text'], 'dogs');
// ratings of first entry
$ratings = $entry1['ratings']['rating'];
$this->assertEqual(count($ratings), 1);
// first rating
$rating1 = $ratings[0];
$this->assertEqual(count($rating1), 6);
$this->assertEqual($rating1['id'], 2);
$this->assertEqual($rating1['value'], 6);
$this->assertEqual($rating1['timemodified'], '1275639797');
// Second entry
$entry2 = $entries[1];
$this->assertEqual(count($entry2), 17);
$this->assertEqual($entry2['id'], 2);
$this->assertEqual($entry2['userid'], 2);
$this->assertEqual($entry2['concept'], 'cat');
$this->assertEqual($entry2['definition'], '<p>traditional enemies of dogs</p>');
$this->assertTrue(isset($entry2['aliases']));
$this->assertTrue(isset($entry2['ratings']));
// aliases of first entry
$aliases = $entry2['aliases']['alias'];
$this->assertEqual(count($aliases), 2);
// first alias
$alias1 = $aliases[0];
$this->assertEqual(count($alias1), 2);
$this->assertEqual($alias1['id'], 2);
$this->assertEqual($alias1['alias_text'], 'cats');
// second alias
$alias2 = $aliases[1];
$this->assertEqual(count($alias2), 2);
$this->assertEqual($alias2['id'], 3);
$this->assertEqual($alias2['alias_text'], 'felines');
// ratings of first entry
$ratings = $entry2['ratings']['rating'];
$this->assertEqual(count($ratings), 1);
// first rating
$rating1 = $ratings[0];
$this->assertEqual(count($rating1), 6);
$this->assertEqual($rating1['id'], 1);
$this->assertEqual($rating1['value'], 5);
$this->assertEqual($rating1['scaleid'], 10);
// Onetest test (only 1 level nested)
$onetest = $tags['onetest'];
$this->assertEqual(count($onetest), 2);
$this->assertEqual(count($onetest[0]), 2);
$this->assertEqual($onetest[0]['name'], 1);
$this->assertEqual($onetest[0]['value'], 1);
$this->assertEqual(count($onetest[1]), 2);
$this->assertEqual($onetest[1]['name'], 2);
$this->assertEqual($onetest[1]['value'], 2);
// Other test (0 level nested, only last one is retrieved)
$othertest = $tags['othertest'];
$this->assertEqual(count($othertest), 1);
$this->assertEqual(count($othertest[0]), 2);
$this->assertEqual($othertest[0]['name'], 4);
$this->assertEqual($othertest[0]['value'], 5);
// Now check start notifications
$snotifs = $pr->get_start_notifications();
// Check we have received the correct number of notifications
$this->assertEqual(count($snotifs), 2);
// Check first and last notifications
$this->assertEqual($snotifs[0], '/activity');
$this->assertEqual($snotifs[1], '/activity/glossary');
// Now check end notifications
$enotifs = $pr->get_end_notifications();
// Check we have received the correct number of notifications
$this->assertEqual(count($snotifs), 2);
// Check first, and last notifications
$this->assertEqual($enotifs[0], '/activity/glossary');
$this->assertEqual($enotifs[1], '/activity');
// Check start and end notifications are balanced
sort($snotifs);
sort($enotifs);
$this->assertEqual($snotifs, $enotifs);
}
protected function end_tag($parser, $tag)
{
// Ending rencently started tag, add value to current tag
if ($this->level == $this->prevlevel) {
$this->currtag['cdata'] = $this->postprocess_cdata($this->accum);
// We always add the last not-empty repetition. Empty ones are ignored.
if (isset($this->topush['tags'][$this->currtag['name']]) && trim($this->currtag['cdata']) === '') {
// Do nothing, the tag already exists and the repetition is empty
} else {
$this->topush['tags'][$this->currtag['name']] = $this->currtag;
}
$this->currtag = array();
}
// Leaving one level, publish all the information available
if ($this->level < $this->prevlevel) {
if (!empty($this->topush['tags'])) {
$this->publish($this->topush);
}
$this->currtag = array();
$this->topush = array();
}
// For the records
$this->prevlevel = $this->level;
// Inform processor we have finished one tag
$this->inform_end($this->path);
// Normal update of parser internals
$this->level--;
$this->path = progressive_parser::dirname($this->path);
}
/**
* Get the parent path using a local cache for performance.
*
* @param $path string The pathname you wish to obtain the parent name for.
* @return string The parent pathname.
*/
protected function get_parent_path($path)
{
if (!isset($this->parentcache[$path])) {
$this->parentcache[$path] = progressive_parser::dirname($path);
$this->parentcacheavailablesize--;
if ($this->parentcacheavailablesize < 0) {
// Older first is cheaper than LRU. We use 10% as items are grouped together and the large quiz
// restore from MDL-40585 used only 600 parent paths. This is an XML heirarchy, so common paths
// are grouped near each other. eg; /question_bank/question_category/question/element. After keeping
// question_bank paths in the cache when we move to another area and the question_bank cache is not
// useful any longer.
$this->parentcache = array_slice($this->parentcache, 200, null, true);
$this->parentcacheavailablesize += 200;
}
}
return $this->parentcache[$path];
}