PHP SMW\DIProperty类代码示例

 public function testCorrectInversePrefixForPredefinedProperty()
 {
     $property = new DIProperty('_SOBJ', true);
     $this->assertTrue($property->isInverse());
     $label = $property->getLabel();
     $this->assertEquals('-', $label[0]);
 }

 public function testPredefinedProperty()
 {
     $instance = new HashBuilder();
     $property = new DIProperty('_MDAT');
     $dataItem = $property->getDiWikiPage();
     $this->assertEquals($dataItem, $instance->newDiWikiPageFromHash($instance->getHashIdForDiWikiPage($dataItem)));
     $this->assertEquals($dataItem, $instance->newDiWikiPageFromHash($instance->createHashIdFromSegments($property->getKey(), SMW_NS_PROPERTY)));
 }

 private function findBasePropertyToRedirectFor($label)
 {
     $property = new DIProperty(PropertyRegistry::getInstance()->findPropertyIdByLabel($label));
     if ($property->getLabel() !== '' && $label !== $property->getLabel()) {
         $outputPage = $this->getContext()->getOutput();
         $outputPage->redirect($property->getDiWikiPage()->getTitle()->getFullURL());
     }
 }

 public function testAddUserDefinedBlobPropertyAsObjectToSemanticDataForStorage()
 {
     $property = new DIProperty('SomeBlobProperty');
     $property->setPropertyTypeId('_txt');
     $this->subjects[] = $subject = DIWikiPage::newFromTitle(Title::newFromText(__METHOD__));
     $semanticData = new SemanticData($subject);
     $semanticData->addPropertyObjectValue($property, new DIBlob('SomePropertyBlobValue'));
     $this->getStore()->updateData($semanticData);
     $this->assertArrayHasKey($property->getKey(), $this->getStore()->getSemanticData($subject)->getProperties());
 }

 /**
  * @since 2.4
  *
  * @param DIProperty $property
  * @param array|string $errorMsg
  *
  * @return DIContainer
  */
 public function getContainerFor(DIProperty $property = null, $errorMsg = '')
 {
     if ($property !== null && $property->isInverse()) {
         $property = new DIProperty($property->getKey());
     }
     $errorMsg = is_array($errorMsg) ? implode(' ', $errorMsg) : $errorMsg;
     $subject = new DIWikiPage($this->subject->getDBkey(), $this->subject->getNamespace(), $this->subject->getInterwiki(), '_ERR' . md5(($property !== null ? $property->getKey() : 'UNKNOWN') . $errorMsg));
     // Encode brackets to avoid an annotion is created/included
     return $this->newDiContainer($subject, $property, InTextAnnotationParser::obscureAnnotation($errorMsg));
 }

 public function testDescendingOrderedQueryResult()
 {
     $expectedSubjects = array(new DIWikiPage('AA', NS_MAIN), new DIWikiPage('AB', NS_MAIN), new DIWikiPage('AC', NS_MAIN));
     $property = new DIProperty('SomeDescendingPageProperty');
     $property->setPropertyTypeId('_wpg');
     $query = $this->createQueryForSamplePagesThatContain($property, $expectedSubjects);
     $query->sort = true;
     $query->sortkeys = array($property->getKey() => 'DESC');
     $query->setUnboundLimit(50);
     $this->assertResultOrder(array_reverse($expectedSubjects), $this->getStore()->getQueryResult($query)->getResults());
 }

 public function testUserDefinedPropertyUsedForInvalidValueAssignment()
 {
     $property = new DIProperty('SomePropertyWithInvalidValueAssignment');
     $property->setPropertyTypeId('_tem');
     $dataValue = $this->dataValueFactory->newDataValueByProperty($property, '1 Jan 1970');
     $semanticData = $this->semanticDataFactory->newEmptySemanticData(__METHOD__);
     $semanticData->addDataValue($dataValue);
     $this->getStore()->updateData($semanticData);
     $this->assertEquals(0, $this->searchForResultsThatCompareEqualToOnlySingularPropertyOf($property)->getCount());
     $this->subjectsToBeCleared = array($semanticData->getSubject());
 }

 /**
  * @since 2.4
  *
  * @param DIProperty $property
  *
  * @return DataItem|false
  */
 public function tryToFindAtLeastOneReferenceForProperty(DIProperty $property)
 {
     $dataItem = $property->getDiWikiPage();
     $sid = $this->store->getObjectIds()->getSMWPageID($dataItem->getDBkey(), $dataItem->getNamespace(), $dataItem->getInterwiki(), '');
     // Lets see if we have some lower/upper case matching for
     // when wgCapitalLinks setting was involved
     if (!$this->usesCapitalLinks && $sid == 0) {
         $sid = $this->store->getObjectIds()->getSMWPageID(lcfirst($dataItem->getDBkey()), $dataItem->getNamespace(), $dataItem->getInterwiki(), '');
     }
     return $this->tryToFindAtLeastOneReferenceForId($sid);
 }

 /**
  * @since 2.4
  *
  * @param DIWikiPage $subject
  * @param DIProperty $property
  * @param RequestOptions|null $requestOptions
  *
  * @return array
  */
 public function getPropertyValues(DIWikiPage $subject, DIProperty $property, RequestOptions $requestOptions = null)
 {
     $key = $property->getKey() . ':' . $subject->getSubobjectName() . ':' . ($requestOptions !== null ? $requestOptions->getHash() : null);
     $container = $this->blobStore->read($this->getRootHashFrom($subject));
     if ($container->has($key)) {
         return $container->get($key);
     }
     $dataItems = $this->store->getPropertyValues($subject, $property, $requestOptions);
     $container->set($key, $dataItems);
     $this->blobStore->save($container);
     return $dataItems;
 }

 /**
  * Create some initial DB entries for important built-in properties. Having the DB contents predefined
  * allows us to safe DB calls when certain data is needed. At the same time, the entries in the DB
  * make sure that DB-based functions work as with all other properties.
  */
 private function doCheckInternalPropertyIndices($connection)
 {
     $this->messageReporter->reportMessage("\nSetting up internal property indices ...\n");
     $this->doCheckPredefinedPropertyBorder($connection);
     // now write actual properties; do that each time, it is cheap enough and we can update sortkeys by current language
     $this->messageReporter->reportMessage("   ... writing entries for internal properties ...\n");
     foreach (SMWSql3SmwIds::$special_ids as $prop => $id) {
         $property = new DIProperty($prop);
         $connection->replace(SQLStore::ID_TABLE, array('smw_id'), array('smw_id' => $id, 'smw_title' => $property->getKey(), 'smw_namespace' => SMW_NS_PROPERTY, 'smw_iw' => $this->store->getObjectIds()->getPropertyInterwiki($property), 'smw_subobject' => '', 'smw_sortkey' => $property->getCanonicalLabel()), __METHOD__);
     }
     $this->messageReporter->reportMessage("   ... done.\n");
 }

 public function testFindSubpropertyList()
 {
     $property = new DIProperty('Foo');
     $store = $this->getMockBuilder('\\SMW\\Store')->disableOriginalConstructor()->getMockForAbstractClass();
     $store->expects($this->once())->method('getPropertySubjects')->with($this->equalTo(new DIProperty('_SUBP')), $this->equalTo($property->getDiWikiPage()), $this->anything())->will($this->returnValue(array(DIWikiPage::newFromText('Bar', SMW_NS_PROPERTY))));
     $cache = $this->getMockBuilder('\\Onoi\\Cache\\Cache')->disableOriginalConstructor()->getMock();
     $cache->expects($this->once())->method('contains')->will($this->returnValue(false));
     $cache->expects($this->once())->method('save')->with($this->equalTo('_SUBP#Foo#-1#0##1##1#'), $this->anything());
     $instance = new PropertyHierarchyLookup($store, $cache);
     $expected = array(DIWikiPage::newFromText('Bar', SMW_NS_PROPERTY));
     $this->assertEquals($expected, $instance->findSubpropertListFor($property));
 }

 /**
  * @since 2.5
  *
  * {@inheritDoc}
  */
 public function addResourceValue(ExpData $expData, DIProperty $property, DataItem $dataItem)
 {
     $diSubject = $expData->getSubject()->getDataItem();
     if ($diSubject === null) {
         return;
     }
     $expNsResource = $this->exporter->getSpecialPropertyResource($property->getKey(), $diSubject->getNamespace());
     $expElement = $this->exporter->getDataItemExpElement($dataItem);
     if ($expElement === null || $expNsResource === null) {
         return;
     }
     $expData->addPropertyObjectValue($expNsResource, $expElement);
     $this->addResourceHelperValue($expData, $property, $dataItem);
 }

 private function newDataValueForPagePropertyValue($property, $value)
 {
     $property = DIProperty::newFromUserLabel($property);
     $property->setPropertyTypeId('_wpg');
     $dataItem = new DIWikiPage($value, NS_MAIN, '');
     return $this->dataValueFactory->newDataItemValue($dataItem, $property);
 }

 public function testCreatePropertyFromLabelThatContainsInverseMarker()
 {
     $property = DIProperty::newFromUserLabel('-Foo');
     $property->setInterwiki('bar');
     $this->assertTrue($property->isInverse());
     $this->assertEquals(new DiWikiPage('Foo', SMW_NS_PROPERTY, 'bar'), $property->getDiWikiPage());
 }

 public function testRegister()
 {
     $instance = new PropertyRegistry();
     $instance->register();
     $this->assertNotEmpty(DIProperty::findPropertyLabel(PropertyRegistry::SBL_PARENTPAGE));
     $this->assertSame(SBL_PROP_PARENTPAGE, DIProperty::findPropertyLabel(PropertyRegistry::SBL_PARENTPAGE));
 }