SemanticMediaWiki/includes/SMW_ParseData.php

Go to the documentation of this file.

<?php
class SMWParseData {

        static public function stripMagicWords( &$text, Parser $parser ) {
                $words = array();
                $mw = MagicWord::get( 'SMW_NOFACTBOX' );

                if ( $mw->matchAndRemove( $text ) ) {
                        $words[] = 'SMW_NOFACTBOX';
                }

                $mw = MagicWord::get( 'SMW_SHOWFACTBOX' );

                if ( $mw->matchAndRemove( $text ) ) {
                        $words[] = 'SMW_SHOWFACTBOX';
                }

                $output = $parser->getOutput();
                $output->mSMWMagicWords = $words;

                return $words;
        }

        static public function getSMWdata( $parser ) {
                $output = $parser->getOutput();
                $title = $parser->getTitle();

                // No parsing, create error.
                if ( !isset( $output ) || !isset( $title ) ) {
                        return null;
                }

                // No data container yet.
                if ( !isset( $output->mSMWData ) ) {
                        $output->mSMWData = new SMWSemanticData( new SMWDIWikiPage( $title->getDBkey(), $title->getNamespace(), $title->getInterwiki() ) );
                }

                return $output->mSMWData;
        }

        static public function clearStorage( Parser $parser ) {
                $output = $parser->getOutput();
                $title = $parser->getTitle();

                if ( !isset( $output ) || !isset( $title ) ) {
                        return;
                }

                $output->mSMWData = new SMWSemanticData( new SMWDIWikiPage( $title->getDBkey(), $title->getNamespace(), $title->getInterwiki() ) );
        }

        static public function addProperty( $propertyName, $value, $caption, Parser $parser, $storeAnnotation = true ) {
                wfProfileIn( 'SMWParseData::addProperty (SMW)' );

                // See if this property is a special one, such as e.g. "has type".
                $propertyDv = SMWPropertyValue::makeUserProperty( $propertyName );
                
                if ( !$propertyDv->isValid() ) {
                        return $propertyDv;
                }
                
                $propertyDi = $propertyDv->getDataItem();
                
                // FIXME: this solves the issue of bug 29438, but is probably not what we want to do.
                if ( $propertyDi instanceof SMWDIError ) {
                        return $propertyDv;
                }
                
                $semandticData = self::getSMWData( $parser );

                $result = SMWDataValueFactory::newPropertyObjectValue(
                        $propertyDi,
                        $value,
                        $caption,
                        $semandticData->getSubject()
                );

                if ( $propertyDi->isInverse() ) {
                        $result->addError( wfMsgForContent( 'smw_noinvannot' ) );
                } elseif ( $storeAnnotation && !is_null( self::getSMWData( $parser ) ) ) {
                        $semandticData->addPropertyObjectValue( $propertyDi, $result->getDataItem() );
                        
                        // Take note of the error for storage (do this here and not in storage, thus avoiding duplicates).
                        if ( !$result->isValid() ) {
                                $semandticData->addPropertyObjectValue(
                                        new SMWDIProperty( '_ERRP' ),
                                        $propertyDi->getDiWikiPage()
                                );
                        }
                }

                wfProfileOut( 'SMWParseData::addProperty (SMW)' );

                return $result;
        }

        static public function storeData( $parseroutput, Title $title, $makejobs = true ) {
                global $smwgEnableUpdateJobs, $smwgDeclarationProperties, $smwgPageSpecialProperties;

                $semdata = $parseroutput->mSMWData;
                $namespace = $title->getNamespace();
                $processSemantics = smwfIsSemanticsProcessed( $namespace );

                if ( !isset( $semdata ) ) { // no data at all?
                        $semdata = new SMWSemanticData( SMWDIWikiPage::newFromTitle( $title ) );
                }

                if ( $processSemantics ) {
                        $props = array();

                        foreach ( $smwgPageSpecialProperties as $propId ) {
                                // Do not calculate the same property again.
                                if ( array_key_exists( $propId, $props ) ) {
                                        continue;
                                }
                                
                                // Remember the property is processed.
                                $props[ $propId ] = true;              
                                $prop = new SMWDIProperty( $propId );
                                
                                if ( count( $semdata->getPropertyValues( $prop ) ) > 0  ) {
                                        continue;
                                }
                                
                                // Calculate property value.
                                $value = null;
                                
                                switch ( $propId ) {
                                        case '_MDAT' :
                                                $timestamp =  Revision::getTimeStampFromID( $title, $title->getLatestRevID() );
                                                $value = self::getDataItemFromMWTimestamp( $timestamp );
                                                break;
                                        case '_CDAT' :
                                                $timestamp = $title->getFirstRevision()->getTimestamp();
                                                $value = self::getDataItemFromMWTimestamp( $timestamp );
                                                break;
                                        case '_NEWP' :
                                                $value = new SMWDIBoolean( $title->isNewPage() );
                                                break;
                                        case '_LEDT' :
                                                $revision = Revision::newFromId( $title->getLatestRevID() );
                                                $user = User::newFromId( $revision->getUser() );
                                                $value = SMWDIWikiPage::newFromTitle( $user->getUserPage() );
                                                break;
                                }
                                
                                if ( !is_null( $value ) ) {
                                        $semdata->addPropertyObjectValue( $prop, $value );    
                                } // Issue error or warning?
                                
                        } // foreach
                } else { // data found, but do all operations as if it was empty
                        $semdata = new SMWSemanticData( $semdata->getSubject() );
                }

                // Check if the semantic data has been changed.
                // Sets the updateflag to true if so.
                // Careful: storage access must happen *before* the storage update;
                // even finding uses of a property fails after its type was changed.
                $updatejobflag = false;
                $jobs = array();

                if ( $makejobs && $smwgEnableUpdateJobs && ( $namespace == SMW_NS_PROPERTY ) ) {
                        // If it is a property, then we need to check if the type or the allowed values have been changed.
                        $ptype = new SMWDIProperty( '_TYPE' );
                        $oldtype = smwfGetStore()->getPropertyValues( $semdata->getSubject(), $ptype );
                        $newtype = $semdata->getPropertyValues( $ptype );

                        if ( !self::equalDatavalues( $oldtype, $newtype ) ) {
                                $updatejobflag = true;
                        } else {
                                foreach ( $smwgDeclarationProperties as $prop ) {
                                        $pv = new SMWDIProperty( $prop );
                                        $oldvalues = smwfGetStore()->getPropertyValues( $semdata->getSubject(), $pv );
                                        $newvalues = $semdata->getPropertyValues( $pv );
                                        $updatejobflag = !self::equalDatavalues( $oldvalues, $newvalues );
                                }
                        }

                        if ( $updatejobflag ) {
                                $prop = new SMWDIProperty( $title->getDBkey() );
                                $subjects = smwfGetStore()->getAllPropertySubjects( $prop );

                                foreach ( $subjects as $subject ) {
                                        $subjectTitle = $subject->getTitle();
                                        if ( !is_null( $subjectTitle ) ) {
                                                $jobs[] = new SMWUpdateJob( $subjectTitle );
                                        }
                                }
                                wfRunHooks( 'smwUpdatePropertySubjects', array( &$jobs ) );

                                $subjects = smwfGetStore()->getPropertySubjects( new SMWDIProperty( '_ERRP' ), $semdata->getSubject() );

                                foreach ( $subjects as $subject ) {
                                        $subjectTitle = $subject->getTitle();
                                        
                                        if ( !is_null( $subjectTitle ) ) {
                                                $jobs[] = new SMWUpdateJob( $subjectTitle );
                                        }
                                }
                        }
                } elseif ( $makejobs && $smwgEnableUpdateJobs && ( $namespace == SMW_NS_TYPE ) ) {
                        // if it is a type we need to check if the conversion factors have been changed
                        $pconv = new SMWDIProperty( '_CONV' );
                        $ptype = new SMWDIProperty( '_TYPE' );

                        $oldfactors = smwfGetStore()->getPropertyValues( $semdata->getSubject(), $pconv );
                        $newfactors = $semdata->getPropertyValues( $pconv );
                        $updatejobflag = !self::equalDatavalues( $oldfactors, $newfactors );

                        if ( $updatejobflag ) {
                                $store = smwfGetStore();

                                $dv = SMWDataValueFactory::newTypeIdValue( '__typ', $title->getDBkey() );
                                $proppages = $store->getPropertySubjects( $ptype, $dv );

                                foreach ( $proppages as $proppage ) {
                                        $propertyTitle = $proppage->getTitle();
                                        
                                        if ( !is_null( $propertyTitle ) ) {
                                                $jobs[] = new SMWUpdateJob( $propertyTitle );
                                        }
                                        
                                        $prop = new SMWDIProperty( $proppage->getDBkey() );
                                        $subjects = $store->getAllPropertySubjects( $prop );

                                        foreach ( $subjects as $subject ) {
                                                $subjectTitle = $subject->getTitle();
                                                
                                                if ( !is_null( $subjectTitle ) ) {
                                                        $jobs[] = new SMWUpdateJob( $subjectTitle );
                                                }
                                        }

                                        $subjects = smwfGetStore()->getPropertySubjects(
                                                new SMWDIProperty( '_ERRP' ),
                                                $prop->getWikiPageValue()
                                        );

                                        foreach ( $subjects as $subject ) {
                                                $subjectTitle = $subject->getTitle();
                                                
                                                if ( !is_null( $subjectTitle ) ) {
                                                        $jobs[] = new SMWUpdateJob( $subject->getTitle() );
                                                }
                                        }
                                }
                        }
                }

                // Actually store semantic data, or at least clear it if needed
                if ( $processSemantics ) {
                        smwfGetStore()->updateData( $semdata );
                } else {
                        smwfGetStore()->clearData( $semdata->getSubject() );
                }

                // Finally trigger relevant Updatejobs if necessary
                if ( $updatejobflag ) {
                        Job::batchInsert( $jobs ); 
                }

                return true;
        }

        static public function equalDatavalues( $dv1, $dv2 ) {
                // The hashes of all values of both arrays are taken, then sorted
                // and finally concatenated, thus creating one long hash out of each
                // of the data value arrays. These are compared.
                $values = array();
                foreach ( $dv1 as $v ) {
                        $values[] = $v->getHash();
                }

                sort( $values );
                $dv1hash = implode( '___', $values );

                $values = array();
                foreach ( $dv2 as $v ) {
                        $values[] = $v->getHash();
                }

                sort( $values );
                $dv2hash = implode( '___', $values );

                return ( $dv1hash == $dv2hash );
        }

        static public function onParserAfterTidy( &$parser, &$text ) {
                global $smwgUseCategoryHierarchy, $smwgCategoriesAsInstances;

                if ( is_null( self::getSMWData( $parser ) ) ) {
                        return true;
                }

                $categories = $parser->mOutput->getCategoryLinks();
                foreach ( $categories as $catname ) {
                        if ( $smwgCategoriesAsInstances && ( self::getSMWData( $parser )->getSubject()->getNamespace() != NS_CATEGORY ) ) {
                                $pinst = new SMWDIProperty( '_INST' );
                                $categoryDi = new SMWDIWikiPage( $catname, NS_CATEGORY, '' );
                                self::getSMWData( $parser )->addPropertyObjectValue( $pinst, $categoryDi );
                        }

                        if ( $smwgUseCategoryHierarchy && ( self::getSMWData( $parser )->getSubject()->getNamespace() == NS_CATEGORY ) ) {
                                $psubc = new SMWDIProperty( '_SUBC' );
                                $categoryDi = new SMWDIWikiPage( $catname, NS_CATEGORY, '' );
                                self::getSMWData( $parser )->addPropertyObjectValue( $psubc, $categoryDi );
                        }
                }

                $sortkey = $parser->mDefaultSort ? $parser->mDefaultSort :
                            str_replace( '_', ' ', self::getSMWData( $parser )->getSubject()->getDBkey() );
                $pskey = new SMWDIProperty( '_SKEY' );
                try {
                        $sortkeyDi = new SMWDIString( $sortkey );
                } catch (SMWStringLengthException $e) { // cut it down to a reasonable length; no further bytes should be needed for sorting
                        $sortkey = substr( $sortkey, 0, $e->getMaxLength() );
                        $sortkeyDi = new SMWDIString( $sortkey );
                }
                self::getSMWData( $parser )->addPropertyObjectValue( $pskey, $sortkeyDi );

                return true;
        }

        static public function onNewRevisionFromEditComplete( /* WikiPage */ $article, Revision $rev, $baseID, User $user ) {
                global $smwgPageSpecialProperties;
                
                if ( ( $article->mPreparedEdit ) && ( $article->mPreparedEdit->output instanceof ParserOutput ) ) {
                        $output = $article->mPreparedEdit->output;
                        $title = $article->getTitle();

                        if ( !isset( $title ) ) {
                                return true; // nothing we can do
                        }
                        if ( !isset( $output->mSMWData ) ) { // no data container yet, make one
                                $output->mSMWData = new SMWSemanticData( new SMWDIWikiPage( $title->getDBkey(), $title->getNamespace(), $title->getInterwiki() ) );
                        }

                        $semdata = $output->mSMWData;
                } else { // give up, just keep the old data
                        return true;
                }

                if ( in_array( '_MDAT', $smwgPageSpecialProperties ) ) {
                        $timestamp = $article->getTimestamp();
                        $di = self::getDataItemFromMWTimestamp( $timestamp );
                        
                        if ( !is_null( $di ) ) {
                                $semdata->addPropertyObjectValue( new SMWDIProperty( '_MDAT' ), $di );
                        }
                }
                
                if ( in_array( '_LEDT', $smwgPageSpecialProperties ) ) {
                        $di = SMWDIWikiPage::newFromTitle( $user->getUserPage() );
                        
                        if ( !is_null( $di ) ) {
                                $semdata->addPropertyObjectValue( new SMWDIProperty( '_LEDT' ), $di );
                        }
                }
                
                if ( in_array( '_NEWP', $smwgPageSpecialProperties ) ) {
                        $semdata->addPropertyObjectValue(
                                new SMWDIProperty( '_NEWP' ), 
                                new SMWDIBoolean( is_null( $rev->getParentId() ) )
                        );
                }

                return true;
        }

        static public function onLinksUpdateConstructed( $links_update ) {
                self::storeData( $links_update->mParserOutput, $links_update->mTitle, true );
                return true;
        }

        static public function onArticleDelete( &$article, &$user, &$reason ) {
                smwfGetStore()->deleteSubject( $article->getTitle() );
                return true; // always return true, in order not to stop MW's hook processing!
        }

        static public function onTitleMoveComplete( &$old_title, &$new_title, &$user, $pageid, $redirid ) {
                smwfGetStore()->changeTitle( $old_title, $new_title, $pageid, $redirid );
                return true; // always return true, in order not to stop MW's hook processing!
        }

        static protected function getDataItemFromMWTimestamp( $timestamp ) {
                $year  = intval( substr( $timestamp, 0, 4 ) );
                $month = intval( substr( $timestamp, 4, 2 ) );
                $day   = intval( substr( $timestamp, 6, 2 ) );
                $hour  = intval( substr( $timestamp, 8, 2 ) );
                $min   = intval( substr( $timestamp, 10, 2 ) );
                $sec   = intval( substr( $timestamp, 12, 2 ) );
                try {
                        return new SMWDITime( SMWDITime::CM_GREGORIAN, $year, $month, $day, $hour, $min, $sec );
                } catch ( SMWDataItemException $e ) {
                        // we rely on MW timestamp format above -- if it ever changes,
                        // exceptions might possibly occur but this should not prevent editing
                        trigger_error( $e->getMessage(), E_USER_NOTICE );
                        return null;
                }
        }

}

---