PHP Utils::contains方法代码示例

 public function testContains()
 {
     $this->assertTrue(Utils::contains('english', 'nglis'));
     $this->assertTrue(Utils::contains('EngliSh', 'gliSh'));
     $this->assertTrue(Utils::contains('ENGLISH', 'ENGLI'));
     $this->assertTrue(Utils::contains('ENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISH', 'ENGLISH'));
     $this->assertFalse(Utils::contains('EngliSh', 'GLI'));
     $this->assertFalse(Utils::contains('EngliSh', 'English'));
     $this->assertFalse(Utils::contains('ENGLISH', 'SCH'));
     $this->assertFalse(Utils::contains('ENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISHENGLISH', 'DEUSTCH'));
 }

 public function init()
 {
     $this->shortcode->getHandlers()->add('ui-animated-text', function (ShortcodeInterface $sc) {
         // Add assets
         $this->shortcode->addAssets('css', 'plugin://shortcode-ui/css/ui-atext.css');
         $this->shortcode->addAssets('js', 'plugin://shortcode-ui/js/ui-atext.js');
         $content = $sc->getContent();
         $animation = $sc->getParameter('animation', 'rotate-1');
         $words = $sc->getParameter('words', 'cool, funky, fresh');
         $visible = $sc->getParameter('visible', 1);
         if (Utils::contains($content, '%WORDS%')) {
             $content = explode('%WORDS%', $content);
         } else {
             $content = (array) $content;
         }
         if (intval($visible) > count($words)) {
             $visible = 1;
         }
         $output = $this->twig->processTemplate('partials/ui-atext.html.twig', ['content' => $content, 'words' => explode(',', $words), 'animation' => $animation, 'element' => $sc->getParameter('element', 'h1'), 'wrapper_extra' => Utils::contains($animation, 'type') ? ' waiting' : '', 'visible' => $visible]);
         return $output;
     });
 }

 /**
  * Twig process that renders the site layout. This is the main twig process that renders the overall
  * page and handles all the layout for the site display.
  *
  * @param string $format Output format (defaults to HTML).
  * @return string the rendered output
  * @throws \RuntimeException
  */
 public function processSite($format = null)
 {
     // set the page now its been processed
     $this->grav->fireEvent('onTwigSiteVariables');
     $pages = $this->grav['pages'];
     $page = $this->grav['page'];
     $content = $page->content();
     $config = $this->grav['config'];
     $twig_vars = $this->twig_vars;
     $twig_vars['pages'] = $pages->root();
     $twig_vars['page'] = $page;
     $twig_vars['header'] = $page->header();
     $twig_vars['content'] = $content;
     $ext = '.' . ($format ? $format : 'html') . TWIG_EXT;
     // determine if params are set, if so disable twig cache
     $params = $this->grav['uri']->params(null, true);
     if (!empty($params)) {
         $this->twig->setCache(false);
     }
     // Get Twig template layout
     $template = $this->template($page->template() . $ext);
     try {
         $output = $this->twig->render($template, $twig_vars);
     } catch (\Twig_Error_Loader $e) {
         // If loader error, and not .html.twig, try it as fallback
         if (Utils::contains($e->getMessage(), $template)) {
             $inflector = new Inflector();
             $error_msg = 'The template file for this page: "' . $template . '" is not provided by the theme: "' . $inflector->titleize($config->get('system.pages.theme')) . '"';
         } else {
             $error_msg = $e->getMessage();
         }
         // Try html version of this template if initial template was NOT html
         if ($ext != '.html' . TWIG_EXT) {
             try {
                 $output = $this->twig->render($page->template() . '.html' . TWIG_EXT, $twig_vars);
             } catch (\Twig_Error_Loader $e) {
                 throw new \RuntimeException($error_msg, 400, $e);
             }
         } else {
             throw new \RuntimeException($error_msg, 400, $e);
         }
     }
     return $output;
 }

 /**
  * Recursive function to load & build page relationships.
  *
  * @param string    $directory
  * @param Page|null $parent
  *
  * @return Page
  * @throws \RuntimeException
  * @internal
  */
 protected function recurse($directory, Page &$parent = null)
 {
     $directory = rtrim($directory, DS);
     $page = new Page();
     /** @var Config $config */
     $config = $this->grav['config'];
     /** @var Language $language */
     $language = $this->grav['language'];
     // stuff to do at root page
     if ($parent === null) {
         // Fire event for memory and time consuming plugins...
         if ($config->get('system.pages.events.page')) {
             $this->grav->fireEvent('onBuildPagesInitialized');
         }
     }
     $page->path($directory);
     if ($parent) {
         $page->parent($parent);
     }
     $page->orderDir($config->get('system.pages.order.dir'));
     $page->orderBy($config->get('system.pages.order.by'));
     // Add into instances
     if (!isset($this->instances[$page->path()])) {
         $this->instances[$page->path()] = $page;
         if ($parent && $page->path()) {
             $this->children[$parent->path()][$page->path()] = ['slug' => $page->slug()];
         }
     } else {
         throw new \RuntimeException('Fatal error when creating page instances.');
     }
     $content_exists = false;
     $pages_found = new \GlobIterator($directory . '/*' . CONTENT_EXT);
     $page_found = null;
     $page_extension = '';
     if ($pages_found && count($pages_found) > 0) {
         $page_extensions = $language->getFallbackPageExtensions();
         foreach ($page_extensions as $extension) {
             foreach ($pages_found as $found) {
                 if ($found->isDir()) {
                     continue;
                 }
                 $regex = '/^[^\\.]*' . preg_quote($extension) . '$/';
                 if (preg_match($regex, $found->getFilename())) {
                     $page_found = $found;
                     $page_extension = $extension;
                     break 2;
                 }
             }
         }
     }
     if ($parent && !empty($page_found)) {
         $page->init($page_found, $page_extension);
         $content_exists = true;
         if ($config->get('system.pages.events.page')) {
             $this->grav->fireEvent('onPageProcessed', new Event(['page' => $page]));
         }
     }
     // set current modified of page
     $last_modified = $page->modified();
     $iterator = new \FilesystemIterator($directory);
     /** @var \DirectoryIterator $file */
     foreach ($iterator as $file) {
         $name = $file->getFilename();
         // Ignore all hidden files if set.
         if ($this->ignore_hidden) {
             if ($name && $name[0] == '.') {
                 continue;
             }
         }
         if ($file->isFile()) {
             // Update the last modified if it's newer than already found
             if (!in_array($file->getBasename(), $this->ignore_files) && ($modified = $file->getMTime()) > $last_modified) {
                 $last_modified = $modified;
             }
         } elseif ($file->isDir() && !in_array($file->getFilename(), $this->ignore_folders)) {
             // if folder contains separator, continue
             if (Utils::contains($file->getFilename(), $config->get('system.param_sep', ':'))) {
                 continue;
             }
             if (!$page->path()) {
                 $page->path($file->getPath());
             }
             $path = $directory . DS . $name;
             $child = $this->recurse($path, $page);
             if (Utils::startsWith($name, '_')) {
                 $child->routable(false);
             }
             $this->children[$page->path()][$child->path()] = ['slug' => $child->slug()];
             if ($config->get('system.pages.events.page')) {
                 $this->grav->fireEvent('onFolderProcessed', new Event(['page' => $page]));
//.........这里部分代码省略.........

 /**
  * Searches for a list of Packages in the repository
  * @param  array $searches An array of either slugs or names
  * @return array Array of found Packages
  *                        Format: ['total' => int, 'not_found' => array, <found-slugs>]
  */
 public function findPackages($searches = [])
 {
     $packages = ['total' => 0, 'not_found' => []];
     foreach ($searches as $search) {
         $repository = '';
         // if this is an object, get the search data from the key
         if (is_object($search)) {
             $search = (array) $search;
             $key = key($search);
             $repository = $search[$key];
             $search = $key;
         }
         if ($found = $this->findPackage($search)) {
             // set override respository if provided
             if ($repository) {
                 $found->override_repository = $repository;
             }
             if (!isset($packages[$found->package_type])) {
                 $packages[$found->package_type] = [];
             }
             $packages[$found->package_type][$found->slug] = $found;
             $packages['total']++;
         } else {
             // make a best guess at the type based on the repo URL
             if (Utils::contains($repository, '-theme')) {
                 $type = 'themes';
             } else {
                 $type = 'plugins';
             }
             $not_found = new \stdClass();
             $not_found->name = Inflector::camelize($search);
             $not_found->slug = $search;
             $not_found->package_type = $type;
             $not_found->install_path = str_replace('%name%', $search, $this->install_paths[$type]);
             $not_found->override_repository = $repository;
             $packages['not_found'][$search] = $not_found;
         }
     }
     return $packages;
 }

 protected function processFrontmatter()
 {
     // Quick check for twig output tags in frontmatter if enabled
     if (Utils::contains($this->frontmatter, '{{')) {
         $process_fields = $this->file()->header();
         $ignored_fields = [];
         foreach ((array) Grav::instance()['config']->get('system.pages.frontmatter.ignore_fields') as $field) {
             if (isset($process_fields[$field])) {
                 $ignored_fields[$field] = $process_fields[$field];
                 unset($process_fields[$field]);
             }
         }
         $text_header = Grav::instance()['twig']->processString(json_encode($process_fields), ['page' => $this]);
         $this->header((object) (json_decode($text_header, true) + $ignored_fields));
     }
 }

 public function getTimestamp($asset = null)
 {
     if (is_array($asset)) {
         if ($asset['remote'] === false) {
             if (Utils::contains($asset['asset'], '?')) {
                 return str_replace('?', '&', $this->timestamp);
             } else {
                 return $this->timestamp;
             }
         }
     } elseif (empty($asset)) {
         return $this->timestamp;
     }
 }

 /**
  * Try to guess the package type from the source files
  *
  * @param $source
  * @return bool|string
  */
 protected function getPackageType($source)
 {
     if (file_exists($source . 'system/defines.php') && file_exists($source . 'system/config/system.yaml')) {
         return 'grav';
     } else {
         // must have a blueprint
         if (!file_exists($source . 'blueprints.yaml')) {
             return false;
         }
         // either theme or plugin
         $name = basename($source);
         if (Utils::contains($name, 'theme')) {
             return 'theme';
         } elseif (Utils::contains($name, 'plugin')) {
             return 'plugin';
         }
         foreach (glob($source . "*.php") as $filename) {
             $contents = file_get_contents($filename);
             if (Utils::contains($contents, 'Grav\\Common\\Theme')) {
                 return 'theme';
             } elseif (Utils::contains($contents, 'Grav\\Common\\Plugin')) {
                 return 'plugin';
             }
         }
         // Assume it's a theme
         return 'theme';
     }
 }