PHP Settings::newFromGlobals方法代码示例

 private function registerSettings()
 {
     $this->applicationFactory->registerObject('Settings', Settings::newFromGlobals($this->globalVars));
     if (CompatibilityMode::extensionNotEnabled()) {
         CompatibilityMode::disableSemantics();
     }
 }

 /**
  * Returns a static instance with an invoked global settings array
  *
  * @par Example:
  * @code
  *  \SMW\NamespaceExaminer::getInstance()->isSemanticEnabled( NS_MAIN )
  * @endcode
  *
  * @note Used in smwfIsSemanticsProcessed
  *
  * @since 1.9
  *
  * @return NamespaceExaminer
  */
 public static function getInstance()
 {
     if (self::$instance === null) {
         self::$instance = self::newFromArray(Settings::newFromGlobals()->get('smwgNamespacesWithSemanticLinks'));
     }
     return self::$instance;
 }

 /**
  * @since  1.9
  */
 protected function loadAtInstantiation()
 {
     /**
      * Settings object definition
      *
      * @since  1.9
      *
      * @return Settings
      */
     $this->registerObject('Settings', function () {
         return Settings::newFromGlobals();
     }, DependencyObject::SCOPE_SINGLETON);
     /**
      * Store object definition
      *
      * @since  1.9
      *
      * @return Store
      */
     $this->registerObject('Store', function (DependencyBuilder $builder) {
         return StoreFactory::getStore($builder->newObject('Settings')->get('smwgDefaultStore'));
     }, DependencyObject::SCOPE_SINGLETON);
     /**
      * CacheHandler object definition
      *
      * @since  1.9
      *
      * @return CacheHandler
      */
     $this->registerObject('CacheHandler', function (DependencyBuilder $builder) {
         return CacheHandler::newFromId($builder->newObject('Settings')->get('smwgCacheType'));
     }, DependencyObject::SCOPE_SINGLETON);
 }

 /**
  * @since  1.9
  */
 protected function loadAtInstantiation()
 {
     /**
      * Settings object definition
      *
      * @since  1.9
      *
      * @return Settings
      */
     $this->registerObject('Settings', function () {
         return Settings::newFromGlobals();
     }, DependencyObject::SCOPE_SINGLETON);
     /**
      * Store object definition
      *
      * @since  1.9
      *
      * @return Store
      */
     $this->registerObject('Store', function (DependencyBuilder $builder) {
         return StoreFactory::getStore($builder->newObject('Settings')->get('smwgDefaultStore'));
     }, DependencyObject::SCOPE_SINGLETON);
     /**
      * @since  1.9
      *
      * @return Cache
      */
     $this->registerObject('Cache', function (DependencyBuilder $builder) {
         return ApplicationFactory::getInstance()->newCacheFactory()->newMediaWikiCompositeCache();
     }, DependencyObject::SCOPE_SINGLETON);
 }

 public function testGetDefaultStore()
 {
     $instance = StoreFactory::getStore();
     $this->assertInstanceOf(Settings::newFromGlobals()->get('smwgDefaultStore'), $instance);
     $this->assertSame(StoreFactory::getStore(), $instance);
     StoreFactory::clear();
     $this->assertNotSame(StoreFactory::getStore(), $instance);
 }

 /**
  * Factory method that creates a CacheHandler instance and instantiate a
  * BagOStuff object from available settings ($smwgCacheType) while
  * invoking additional parameters ($wgCachePrefix etc.)
  *
  * @par Example:
  * @code
  *  $cache = new CacheHandler::newFromId()->setkey( new CachIdGenerator( 'Foo' ) )
  *
  *  $cache->set( 'CacheableObject' )
  *  $cache->get() returns 'CacheableObject'
  *  $cache->delete() deletes 'CacheableObject'
  * @endcode
  *
  * @note If a BagOStuff instance is not available setCacheEnabled() is
  * disabled by default which prevents to run into unintended behaviour
  * while trying to access BagOStuff methods.
  *
  * @note This method is exposed to $wgObjectCaches, $wgCachePrefix globals
  * which can't and shouldn't be accessed otherwise. It is the task of this
  * method alone to invoke globals and avoid leakage into the object
  * life cycle.
  *
  * @note This method serves invoked instances from a static variable due to
  * the fact that the actual working object is being accessed through
  * getCache() and therefore not in direct conflict with its testability.
  *
  * @since 1.9
  *
  * @param string $id Ids available in wgObjectCaches
  *
  * @return CacheHandler
  */
 public static function newFromId($id = false)
 {
     $cacheType = $id ? $id : Settings::newFromGlobals()->get('smwgCacheType');
     if (!isset(self::$instance[$cacheType])) {
         if ($cacheType && array_key_exists($cacheType, $GLOBALS['wgObjectCaches'])) {
             $cache = new self(ObjectCache::getInstance($cacheType));
         } else {
             $cache = new self();
         }
         $cache->setCacheEnabled(true);
         self::$instance[$cacheType] = $cache;
     }
     return self::$instance[$cacheType];
 }

 private function registerCallbackHandlers($callbackLoader)
 {
     $callbackLoader->registerExpectedReturnType('Settings', '\\SMW\\Settings');
     $callbackLoader->registerCallback('Settings', function () use($callbackLoader) {
         return Settings::newFromGlobals();
     });
     $callbackLoader->registerExpectedReturnType('Store', '\\SMW\\Store');
     $callbackLoader->registerCallback('Store', function () use($callbackLoader) {
         return StoreFactory::getStore($callbackLoader->singleton('Settings')->get('smwgDefaultStore'));
     });
     $callbackLoader->registerExpectedReturnType('Cache', '\\Onoi\\Cache\\Cache');
     $callbackLoader->registerCallback('Cache', function () {
         return ApplicationFactory::getInstance()->newCacheFactory()->newMediaWikiCompositeCache();
     });
     $callbackLoader->registerCallback('NamespaceExaminer', function () use($callbackLoader) {
         return NamespaceExaminer::newFromArray($callbackLoader->singleton('Settings')->get('smwgNamespacesWithSemanticLinks'));
     });
     $callbackLoader->registerExpectedReturnType('ParserData', '\\SMW\\ParserData');
     $callbackLoader->registerCallback('ParserData', function (\Title $title, \ParserOutput $parserOutput) {
         return new ParserData($title, $parserOutput);
     });
     $callbackLoader->registerCallback('MessageFormatter', function (\Language $language) {
         return new MessageFormatter($language);
     });
     $callbackLoader->registerExpectedReturnType('PageCreator', '\\SMW\\MediaWiki\\PageCreator');
     $callbackLoader->registerCallback('PageCreator', function () {
         return new PageCreator();
     });
     $callbackLoader->registerExpectedReturnType('TitleCreator', '\\SMW\\MediaWiki\\TitleCreator');
     $callbackLoader->registerCallback('TitleCreator', function () {
         return new TitleCreator();
     });
     $callbackLoader->registerExpectedReturnType('WikiPage', '\\WikiPage');
     $callbackLoader->registerCallback('WikiPage', function (\Title $title) {
         return \WikiPage::factory($title);
     });
     $callbackLoader->registerExpectedReturnType('ContentParser', '\\SMW\\ContentParser');
     $callbackLoader->registerCallback('ContentParser', function (\Title $title) {
         return new ContentParser($title);
     });
     $callbackLoader->registerExpectedReturnType('JobFactory', '\\SMW\\MediaWiki\\Jobs\\JobFactory');
     $callbackLoader->registerCallback('JobFactory', function () {
         return new JobFactory();
     });
     $callbackLoader->registerExpectedReturnType('FactboxFactory', '\\SMW\\Factbox\\FactboxFactory');
     $callbackLoader->registerCallback('FactboxFactory', function () {
         return new FactboxFactory();
     });
 }

 public function testCanonicalNames()
 {
     $this->mwHooksHandler->deregisterListedHooks();
     $count = 0;
     $index = NamespaceManager::buildNamespaceIndex(Settings::newFromGlobals()->get('smwgNamespaceIndex'));
     $names = NamespaceManager::getCanonicalNames();
     $this->assertInternalType('array', $names);
     $this->assertInternalType('array', $index);
     foreach ($index as $ns => $idx) {
         $mwNamespace = MWNamespace::getCanonicalName($idx);
         if ($mwNamespace && isset($names[$idx])) {
             $this->assertEquals($mwNamespace, $names[$idx]);
             $count++;
         }
     }
     $this->assertCount($count, $names, "Asserts that expected amount of cannonical names have been verified");
 }

 /**
  * @dataProvider globalsSettingsProvider
  *
  * @since 1.9
  */
 public function testNewFromGlobals(array $settings)
 {
     $instance = Settings::newFromGlobals();
     $this->assertInstanceOf($this->getClass(), $instance);
     // Assert that newFromGlobals is a static instance
     $this->assertTrue($instance === Settings::newFromGlobals());
     // Reset instance
     $instance->clear();
     $this->assertTrue($instance !== Settings::newFromGlobals());
     foreach ($settings as $key => $value) {
         $this->assertTrue($instance->has($key), "Failed asserting that {$key} exists");
     }
 }

 private static function getConfiguration()
 {
     return Settings::newFromGlobals();
 }

 private function registerCallbackHandlers($callbackLoader)
 {
     $callbackLoader->registerExpectedReturnType('Settings', '\\SMW\\Settings');
     $callbackLoader->registerCallback('Settings', function () use($callbackLoader) {
         return Settings::newFromGlobals();
     });
     $callbackLoader->registerExpectedReturnType('Store', '\\SMW\\Store');
     $callbackLoader->registerCallback('Store', function ($store = null) use($callbackLoader) {
         return StoreFactory::getStore($store !== null ? $store : $callbackLoader->singleton('Settings')->get('smwgDefaultStore'));
     });
     $callbackLoader->registerExpectedReturnType('Cache', '\\Onoi\\Cache\\Cache');
     $callbackLoader->registerCallback('Cache', function ($cacheType = null) use($callbackLoader) {
         return $callbackLoader->load('CacheFactory')->newMediaWikiCompositeCache($cacheType);
     });
     $callbackLoader->registerCallback('NamespaceExaminer', function () use($callbackLoader) {
         return NamespaceExaminer::newFromArray($callbackLoader->singleton('Settings')->get('smwgNamespacesWithSemanticLinks'));
     });
     $callbackLoader->registerExpectedReturnType('ParserData', '\\SMW\\ParserData');
     $callbackLoader->registerCallback('ParserData', function (\Title $title, \ParserOutput $parserOutput) {
         return new ParserData($title, $parserOutput);
     });
     $callbackLoader->registerCallback('MessageFormatter', function (\Language $language) {
         return new MessageFormatter($language);
     });
     $callbackLoader->registerCallback('MediaWikiNsContentReader', function () use($callbackLoader) {
         $callbackLoader->registerExpectedReturnType('MediaWikiNsContentReader', '\\SMW\\MediaWiki\\MediaWikiNsContentReader');
         return new MediaWikiNsContentReader();
     });
     $callbackLoader->registerExpectedReturnType('PageCreator', '\\SMW\\MediaWiki\\PageCreator');
     $callbackLoader->registerCallback('PageCreator', function () {
         return new PageCreator();
     });
     $callbackLoader->registerCallback('JobQueueLookup', function (Database $connection) use($callbackLoader) {
         $callbackLoader->registerExpectedReturnType('JobQueueLookup', '\\SMW\\MediaWiki\\JobQueueLookup');
         return new JobQueueLookup($connection);
     });
     $callbackLoader->registerCallback('ManualEntryLogger', function () use($callbackLoader) {
         $callbackLoader->registerExpectedReturnType('ManualEntryLogger', '\\SMW\\MediaWiki\\ManualEntryLogger');
         return new ManualEntryLogger();
     });
     $callbackLoader->registerExpectedReturnType('TitleCreator', '\\SMW\\MediaWiki\\TitleCreator');
     $callbackLoader->registerCallback('TitleCreator', function () {
         return new TitleCreator();
     });
     $callbackLoader->registerExpectedReturnType('ContentParser', '\\SMW\\ContentParser');
     $callbackLoader->registerCallback('ContentParser', function (\Title $title) {
         return new ContentParser($title);
     });
     $callbackLoader->registerExpectedReturnType('DeferredCallableUpdate', '\\SMW\\DeferredCallableUpdate');
     $callbackLoader->registerCallback('DeferredCallableUpdate', function (\Closure $callback) {
         return new DeferredCallableUpdate($callback);
     });
     /**
      * @var InMemoryPoolCache
      */
     $callbackLoader->registerCallback('InMemoryPoolCache', function () use($callbackLoader) {
         $callbackLoader->registerExpectedReturnType('InMemoryPoolCache', '\\SMW\\InMemoryPoolCache');
         return InMemoryPoolCache::getInstance();
     });
     /**
      * @var PropertyAnnotatorFactory
      */
     $callbackLoader->registerCallback('PropertyAnnotatorFactory', function () use($callbackLoader) {
         $callbackLoader->registerExpectedReturnType('PropertyAnnotatorFactory', '\\SMW\\PropertyAnnotatorFactory');
         return new PropertyAnnotatorFactory();
     });
 }

 private function registerSettings()
 {
     $this->applicationFactory->registerObject('Settings', Settings::newFromGlobals($this->globalVars));
 }

 protected function doListConfigurationSettings()
 {
     $this->printRawOutput(function ($instance) {
         print '<pre>' . $instance->encodeJson(Settings::newFromGlobals()->toArray()) . '</pre>';
     });
 }

 public function getStatistics()
 {
     $statisticsCollector = new StatisticsCollector($this, wfGetDB(DB_SLAVE), Settings::newFromGlobals());
     return $statisticsCollector->getResults();
 }