public function registerTagCombination($blogKey, $tags) { if (!is_array($tags)) { // Temporary warning for a change in how multi-tags // are specified. $log = $this->pieCrust->getEnvironment()->getLog(); if (strpos($tags, '/') !== false) { $log->warning("A link to tag {$tags} was specified in this page. " . "If this is a tag that contains a slash character ('/') then ignore this warning. " . "However, if this was intended to be a multi-tags link, you'll need to " . "now pass an array of tags like so: `{{pctagurl(['tag1', 'tag2'])}}`. " . "Your current link won't work!"); } return; } if ($blogKey == null) { $blogKey = PieCrustDefaults::DEFAULT_BLOG_KEY; } if (!array_key_exists($blogKey, $this->tagCombinations)) { $this->tagCombinations[$blogKey] = array(); } // Slugify tags and sort them alphabetically. $flags = $this->pieCrust->getConfig()->getValue('site/slugify_flags'); $tags = array_map(function ($t) use($flags) { return UriBuilder::slugify($t, $flags); }, $tags); sort($tags); // Only add combination if it's not already there. if (!in_array($tags, $this->tagCombinations[$blogKey])) { $this->tagCombinations[$blogKey][] = $tags; } }
/** * @dataProvider tagSlugifyDataProvider */ public function testTagSlugify($value, $expectedValue, $slugifyMode = null, $locale = null) { $fs = MockFileSystem::create(); if ($slugifyMode) { $fs->withConfig(array('site' => array('slugify' => $slugifyMode))); } $pc = $fs->getApp(); $flags = $pc->getConfig()->getValue('site/slugify_flags'); $actualValue = UriBuilder::slugify($value, $flags); $this->assertEquals($expectedValue, $actualValue); }
public function addPageClauses(IPage $page, array $userFilterInfo = null) { // If the current page is a tag/category page, add filtering // for that. $pageClause = null; $pieCrust = $page->getApp(); $flags = $pieCrust->getConfig()->getValue('site/slugify_flags'); switch ($page->getPageType()) { case IPage::TYPE_TAG: $pageKey = $page->getPageKey(); if (is_array($pageKey)) { $pageClause = new AndBooleanClause(); foreach ($pageKey as $k) { $pageClause->addClause(new HasFilterClause('tags', $k, function ($t) use($flags) { return UriBuilder::slugify($t, $flags); })); } } else { $pageClause = new HasFilterClause('tags', $pageKey, function ($t) use($flags) { return UriBuilder::slugify($t, $flags); }); } break; case IPage::TYPE_CATEGORY: $pageClause = new IsFilterClause('category', $page->getPageKey(), function ($c) use($flags) { return UriBuilder::slugify($c, $flags); }); break; } if ($pageClause != null) { // Combine the default page filters with some user filters, // if any. if ($userFilterInfo != null) { $combinedClause = new AndBooleanClause(); $combinedClause->addClause($pageClause); $this->addClausesRecursive($userFilterInfo, $combinedClause); $this->addClause($combinedClause); } else { $this->addClause($pageClause); } } }
protected function ensureLinksCache() { if ($this->linksCache === null) { try { $pieCrust = $this->page->getApp(); $pageRepository = $pieCrust->getEnvironment()->getPageRepository(); $this->linksCache = array(); $skipNames = array('Thumbs.db'); $it = new FilesystemIterator($this->baseDir); foreach ($it as $item) { $basename = $item->getBasename(); // Skip dot files, Thumbs.db, etc. if (!$basename or $basename[0] == '.') { continue; } if (in_array($item->getFilename(), $skipNames)) { continue; } if ($item->isDir()) { $linker = new Linker($this->page, $item->getPathname()); $this->linksCache[$basename . '_'] = $linker; // We add '_' at the end of the directory name to avoid // collisions with a possibly existing page with the same // name (since we strip out the '.html' extension). // This means the user must access directories with // 'link.dirname_' instead of 'link.dirname' but hey, if // you have a better idea, send me an email! } else { $path = $item->getPathname(); try { $relativePath = PageHelper::getRelativePath($this->page); $uri = UriBuilder::buildUri($relativePath); // To get the link's page, we need to be careful with the case // where that page is the currently rendering one. This is // because it could be rendering a sub-page -- but we would be // requesting the default first page, which would effectively // change the page number *while* we're rendering, which leads // to all kinds of bad things! // TODO: obviously, there needs to be some design changes to // prevent this kind of chaotic behaviour. if ($path == $this->page->getPath()) { $page = $this->page; } else { $page = $pageRepository->getOrCreatePage($uri, $path); } $key = str_replace('.', '_', $item->getBasename('.html')); $this->linksCache[$key] = array('uri' => $uri, 'name' => $key, 'is_dir' => false, 'is_self' => $basename == $this->selfName, 'page' => new PaginationData($page)); } catch (Exception $e) { throw new PieCrustException("Error while loading page '{$path}' for linking from '{$this->page->getUri()}': " . $e->getMessage(), 0, $e); } } } if ($this->sortByName) { if (false === usort($this->linksCache, array($this, 'sortByCustom'))) { throw new PieCrustException("Error while sorting pages with the specified setting: {$this->sortByName}"); } } if ($this->selfName != null) { // Add special stuff only for the original Linker // (the one directly created by the current page). if (PageHelper::isRegular($this->page)) { // Add a link to go up to the parent directory, but stay inside // the app's pages directory. $parentBaseDir = dirname($this->baseDir); if (strlen($parentBaseDir) >= strlen($pieCrust->getPagesDir())) { $linker = new Linker($this->page, dirname($this->baseDir)); $this->linksCache['_'] = $linker; } } else { if (PageHelper::isPost($this->page)) { // Add a link to go up to the parent directory, but stay inside // the app's posts directory. $parentBaseDir = dirname($this->baseDir); if (strlen($parentBaseDir) >= strlen($pieCrust->getPostsDir())) { $linker = new Linker($this->page, dirname($this->baseDir)); $this->linksCache['_'] = $linker; } } } if ($pieCrust->getPagesDir()) { // Add a shortcut to the pages directory. $linker = new Linker($this->page, $pieCrust->getPagesDir()); $this->linksCache['_pages_'] = $linker; } if ($pieCrust->getPostsDir()) { // Add a shortcut to the posts directory. $linker = new Linker($this->page, $pieCrust->getPostsDir()); $this->linksCache['_posts_'] = $linker; } } } catch (Exception $e) { throw new PieCrustException("Error while building the links from page '{$this->page->getUri()}': " . $e->getMessage(), 0, $e); } } }
private static function tryParseCategoryUri(IPieCrust $pieCrust, $blogKey, $uri, array &$pageInfo) { $blogKeyDir = ''; if ($blogKey != PieCrustDefaults::DEFAULT_BLOG_KEY) { $blogKeyDir = $blogKey . '/'; } $categoryPageName = array(); $themeCategoryPageName = array(); $autoFormats = $pieCrust->getConfig()->getValueUnchecked('site/auto_formats'); foreach ($autoFormats as $ext => $format) { $categoryPageName[] = $blogKeyDir . PieCrustDefaults::CATEGORY_PAGE_NAME . '.' . $ext; $themeCategoryPageName[] = PieCrustDefaults::CATEGORY_PAGE_NAME . '.' . $ext; } $path = PathHelper::getUserOrThemePath($pieCrust, $categoryPageName, $themeCategoryPageName); if ($path === false) { return false; } $flags = $pieCrust->getConfig()->getValueUnchecked('site/slugify_flags'); $categoryPattern = UriBuilder::buildCategoryUriPattern($pieCrust->getConfig()->getValueUnchecked($blogKey . '/category_url')); if (preg_match($categoryPattern, $uri, $matches)) { $cat = rawurldecode($matches['cat']); $cat = UriBuilder::slugify($cat, $flags); $pageInfo['type'] = IPage::TYPE_CATEGORY; $pageInfo['blogKey'] = $blogKey; $pageInfo['key'] = $cat; $pageInfo['path'] = $path; $pageInfo['was_path_checked'] = true; return true; } return false; }
protected function bakeTaxonomies() { // Get some global stuff we'll need. $slugifyFlags = $this->pieCrust->getConfig()->getValue('site/slugify_flags'); $pageRepository = $this->pieCrust->getEnvironment()->getPageRepository(); // Get the taxonomies. $taxonomies = array('tags' => array('multiple' => true, 'singular' => 'tag', 'page' => PieCrustDefaults::TAG_PAGE_NAME . '.html'), 'category' => array('multiple' => false, 'page' => PieCrustDefaults::CATEGORY_PAGE_NAME . '.html')); // Get which terms we need to bake. $allDirtyTaxonomies = $this->bakeRecord->getDirtyTaxonomies($taxonomies); $allUsedCombinations = $this->bakeRecord->getUsedTaxonomyCombinations($taxonomies); // Get the taxonomy listing pages, if they exist. $taxonomyPages = array(); $blogKeys = $this->pieCrust->getConfig()->getValue('site/blogs'); foreach ($taxonomies as $name => $taxonomyMetadata) { $taxonomyPages[$name] = array(); foreach ($blogKeys as $blogKey) { $prefix = ''; if ($blogKey != PieCrustDefaults::DEFAULT_BLOG_KEY) { $prefix = $blogKey . DIRECTORY_SEPARATOR; } $termPageName = $prefix . $taxonomyMetadata['page']; $themeTermPageName = $taxonomyMetadata['page']; $termPagePath = PathHelper::getUserOrThemePath($this->pieCrust, $termPageName, $themeTermPageName); $taxonomyPages[$name][$blogKey] = $termPagePath; } } foreach ($allDirtyTaxonomies as $name => $dirtyTerms) { $taxonomyMetadata = $taxonomies[$name]; foreach ($dirtyTerms as $blogKey => $dirtyTermsForBlog) { // Check that we have a term listing page to bake. $termPagePath = $taxonomyPages[$name][$blogKey]; if (!$termPagePath) { continue; } // We have the terms that need to be rebaked. $termsToBake = $dirtyTermsForBlog; // Look at the combinations of terms we need to consider. if ($taxonomyMetadata['multiple']) { // User-specified combinations. $forcedCombinations = array(); $forcedCombinationParameters = array($name . '_combinations'); if (isset($taxonomyMetadata['singular'])) { $forcedCombinationParameters[] = $taxonomyMetadata['singular'] . '_combinations'; } foreach ($forcedCombinationParameters as $param) { if (isset($this->parameters[$param])) { $forcedCombinations = $this->parameters[$param]; if (array_key_exists($blogKey, $forcedCombinations)) { $forcedCombinations = $forcedCombinations[$blogKey]; } elseif (count($blogKeys > 1)) { $forcedCombinations = array(); } break; } } // Collected combinations in use. $usedCombinations = array(); if (isset($allUsedCombinations[$name]) && isset($allUsedCombinations[$name][$blogKey])) { $usedCombinations = $allUsedCombinations[$name][$blogKey]; } // Get all the combinations together (forced and used) and keep // those that include a term that we have to rebake. $combinations = array_merge($forcedCombinations, $usedCombinations); if ($combinations) { $combinationsToBake = array(); foreach ($combinations as $comb) { if (count(array_intersect($comb, $termsToBake)) > 0) { $combinationsToBake[] = $comb; } } $termsToBake = array_merge($termsToBake, $combinationsToBake); } } // Order terms so it looks nice when we bake. usort($termsToBake, function ($t1, $t2) { if (is_array($t1)) { $t1 = implode('+', $t1); } if (is_array($t2)) { $t2 = implode('+', $t2); } return strcmp($t1, $t2); }); // Bake! foreach ($termsToBake as $term) { $start = microtime(true); if ($taxonomyMetadata['multiple'] && is_array($term)) { $slugifiedTerm = array_map(function ($t) use($slugifyFlags) { return UriBuilder::slugify($t, $slugifyFlags); }, $term); $formattedTerm = implode('+', array_map('rawurldecode', $term)); } else { $slugifiedTerm = UriBuilder::slugify($term, $slugifyFlags); $formattedTerm = rawurldecode($term); } if ($name == 'tags') { $uri = UriBuilder::buildTagUri($this->pieCrust, $blogKey, $slugifiedTerm, false); $pageType = IPage::TYPE_TAG; } else { if ($name == 'category') { $uri = UriBuilder::buildCategoryUri($this->pieCrust, $blogKey, $slugifiedTerm, false); $pageType = IPage::TYPE_CATEGORY; } } $page = $pageRepository->getOrCreatePage($uri, $termPagePath, $pageType, $blogKey); $page->setPageKey($slugifiedTerm); $this->callAssistants('onPageBakeStart', array($page)); $baker = $this->getPageBaker(); $baker->bake($page); $this->callAssistants('onPageBakeEnd', array($page, new BakeResult(true))); $pageCount = $baker->getPageCount(); $this->logger->info(self::formatTimed($start, "{$name}:{$formattedTerm}" . ($pageCount > 1 ? " [{$pageCount}]" : ""))); } } } }
protected function ensurePostsCached($blogKey) { if ($this->posts == null) { $this->posts = array(); } if (!isset($this->posts[$blogKey])) { $pageRepository = $this->getPageRepository(); $postInfos = $this->getPostInfos($blogKey); $postUrlFormat = $this->pieCrust->getConfig()->getValue($blogKey . '/post_url'); $posts = array(); foreach ($postInfos as $postInfo) { $uri = UriBuilder::buildPostUri($postUrlFormat, $postInfo); $page = $pageRepository->getOrCreatePage($uri, $postInfo['path'], IPage::TYPE_POST, $blogKey); $page->setDate(PageHelper::getPostDate($postInfo)); $posts[] = $page; } $this->posts[$blogKey] = $posts; } }
/** * Gets a tag listing page. */ public static function getTagPage(IPieCrust $pieCrust, $tag, $blogKey = null) { if ($blogKey == null) { $blogKeys = $pieCrust->getConfig()->getValueUnchecked('site/blogs'); $blogKey = $blogKeys[0]; } $pathPrefix = ''; if ($blogKey != PieCrustDefaults::DEFAULT_BLOG_KEY) { $pathPrefix = $blogKey . DIRECTORY_SEPARATOR; } $pageRepository = $pieCrust->getEnvironment()->getPageRepository(); $uri = UriBuilder::buildTagUri($pieCrust->getConfig()->getValue($blogKey . '/tag_url'), $tag); $path = $pieCrust->getPagesDir() . $pathPrefix . PieCrustDefaults::TAG_PAGE_NAME . '.html'; if (!is_file($path)) { return null; } $page = $pageRepository->getOrCreatePage($uri, $tagPagePath, IPage::TYPE_TAG, $blogKey, $tag); return $page; }
/** * Creates a new Page instance given a path. */ public static function createFromPath(IPieCrust $pieCrust, $path, $pageType = IPage::TYPE_REGULAR, $pageNumber = 1, $blogKey = null, $pageKey = null, $date = null) { if ($path == null) { throw new InvalidArgumentException("The given path is null."); } if (!is_file($path)) { throw new InvalidArgumentException("The given path does not exist: " . $path); } $relativePath = PieCrustHelper::getRelativePath($pieCrust, $path, true); $uri = UriBuilder::buildUri($relativePath); return new Page($pieCrust, $uri, $path, $pageType, $blogKey, $pageKey, $pageNumber, $date); }
/** * Gets the page's data for page rendering. * * It's better to call IPage::getData, which calls this function, because it * will also cache the results. It's useful for example when pagination * results needs to be re-used. */ public static function getPageData(IPage $page) { $pieCrust = $page->getApp(); $paginator = new Paginator($page); $assetor = new Assetor($page); $linker = new Linker($page); $recursiveLinker = new RecursiveLinkerIterator($linker); if ($page->getPaginationDataSource() != null) { $paginator->setPaginationDataSource($page->getPaginationDataSource()); } $data = array('page' => $page->getConfig()->get(), 'assets' => $assetor, 'pagination' => $paginator, 'siblings' => $linker, 'family' => $recursiveLinker); $data['page']['url'] = PieCrustHelper::formatUri($pieCrust, $page->getUri()); $data['page']['slug'] = $page->getUri(); $data['page']['timestamp'] = $page->getDate(true); $dateFormat = PageHelper::getConfigValueUnchecked($page, 'date_format', $page->getConfig()->getValueUnchecked('blog')); $data['page']['date'] = date($dateFormat, $page->getDate(true)); switch ($page->getPageType()) { case IPage::TYPE_TAG: if (is_array($page->getPageKey())) { $data['tag'] = implode(' + ', $page->getPageKey()); } else { $data['tag'] = $page->getPageKey(); } if (strpos($data['tag'], '-') >= 0) { // The tag may have been slugified. Let's cheat a bit by looking at // the first tag that matches in the first pagination post, and // using that instead. $paginationPosts = $paginator->posts(); if (count($paginationPosts) > 0) { $firstPost = $paginationPosts[0]; $firstPostTags = $firstPost['tags']; if (!is_array($firstPostTags)) { $firstPostTags = array($firstPostTags); } $flags = $pieCrust->getConfig()->getValue('site/slugify_flags'); if (is_array($page->getPageKey())) { $pageKey = $page->getPageKey(); foreach ($firstPostTags as $t) { $st = UriBuilder::slugify($t, $flags); foreach ($pageKey as &$pk) { if ($st == $pk) { $pk = $t; break; } } } if ($page->getPageKey() == null) { $page->setPageKey($pageKey); } $data['tag'] = implode(' + ', $pageKey); } else { foreach ($firstPostTags as $t) { if (UriBuilder::slugify($t, $flags) == $data['tag']) { if ($page->getPageKey() == null) { $page->setPageKey($t); } $data['tag'] = $t; break; } } } } } break; case IPage::TYPE_CATEGORY: $data['category'] = $page->getPageKey(); if (strpos($page->getPageKey(), '-') >= 0) { // Same remark as for tags. $paginationPosts = $paginator->posts(); if (count($paginationPosts) > 0) { $firstPost = $paginationPosts[0]; if ($page->getPageKey() == null) { $page->setPageKey($firstPost['category']); } $data['category'] = $firstPost['category']; } } break; } $extraData = $page->getExtraPageData(); if ($extraData) { if (is_array($extraData)) { $data = Configuration::mergeArrays($data, $extraData); } else { $data['extra'] = $extraData; } } return $data; }
private function findPages($context, $pages, $fromBlog = false) { $logger = $context->getLog(); $pieCrust = $context->getApp(); $result = $context->getResult(); $rootDir = $pieCrust->getRootDir(); $rootDir = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $rootDir); $exact = $result->command->options['exact']; $pattern = $result->command->args['pattern']; $fullPath = $result->command->options['full_path']; $returnComponents = $result->command->options['page_components']; $foundAny = false; foreach ($pages as $page) { if ($result->command->options['no_special']) { // Skip special pages. if ($page->getUri() == PieCrustDefaults::CATEGORY_PAGE_NAME or $page->getUri() == PieCrustDefaults::TAG_PAGE_NAME) { continue; } } if ($exact) { // Match the path exactly, or pass. if (str_replace('\\', '/', $pattern) != str_replace('\\', '/', $page->getPath())) { continue; } } else { if ($pattern) { // Match the regex, or pass. if (!preg_match($pattern, $page->getUri())) { continue; } } } $path = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $page->getPath()); if (!$fullPath) { if (substr($path, 0, strlen($rootDir)) == $rootDir) { $path = PieCrustHelper::getRelativePath($pieCrust, $path); } } if ($returnComponents) { $components = array('path' => $path, 'type' => 'page', 'uri' => $page->getUri(), 'slug' => $page->getUri()); if (PageHelper::isPost($page)) { $timestamp = $page->getDate(true); $components['type'] = 'post'; $components['year'] = date('Y', $timestamp); $components['month'] = date('m', $timestamp); $components['day'] = date('d', $timestamp); $components['hour'] = date('H', $timestamp); $components['minute'] = date('i', $timestamp); $components['second'] = date('s', $timestamp); $matches = array(); $postsPattern = UriBuilder::buildPostUriPattern($pieCrust->getConfig()->getValue($fromBlog . '/post_url'), $fromBlog); if (preg_match($postsPattern, $page->getUri(), $matches)) { $components['slug'] = $matches['slug']; } } foreach ($components as $k => $v) { $logger->info("{$k}: {$v}"); } $logger->info(""); $foundAny = true; } else { $logger->info($path); $foundAny = true; } } return $foundAny; }
protected function ensurePostsCached($blogKey) { if ($this->posts == null) { $this->posts = array(); } if (!isset($this->posts[$blogKey])) { $this->getLog()->debug("Indexing '{$blogKey}' posts..."); $fs = $this->getFileSystem(); $postInfos = $fs->getPostFiles($blogKey); $this->getLog()->debug("Creating '{$blogKey}' posts..."); $pageRepository = $this->getPageRepository(); $posts = array(); foreach ($postInfos as $postInfo) { $uri = UriBuilder::buildPostUri($this->pieCrust, $blogKey, $postInfo); $page = $pageRepository->getOrCreatePage($uri, $postInfo->path, IPage::TYPE_POST, $blogKey); $page->setDate(PageHelper::getPostDate($postInfo)); $posts[] = $page; } $this->posts[$blogKey] = $posts; } }
protected function load() { try { $pieCrust = $this->page->getApp(); $pageRepository = $pieCrust->getEnvironment()->getPageRepository(); $items = array(); $skipNames = array('Thumbs.db'); $it = new FilesystemIterator($this->baseDir); foreach ($it as $item) { $filename = $item->getFilename(); // Skip dot files, Thumbs.db, etc. if (!$filename or $filename[0] == '.') { continue; } if (in_array($filename, $skipNames)) { continue; } if ($item->isDir()) { // Skip "asset" directories. if (preg_match('/\\-assets$/', $filename)) { continue; } $linker = new Linker($this->page, $item->getPathname()); $items[$filename . '_'] = $linker; // We add '_' at the end of the directory name to avoid // collisions with a possibly existing page with the same // name (since we strip out the file extension). // This means the user must access directories with // 'link.dirname_' instead of 'link.dirname' but hey, if // you have a better idea, send me an email! } else { $path = $item->getPathname(); try { // To get the link's page, we need to be careful with the case // where that page is the currently rendering one. This is // because it could be rendering a sub-page -- but we would be // requesting the default first page, which would effectively // change the page number *while* we're rendering, which leads // to all kinds of bad things! // TODO: obviously, there needs to be some design changes to // prevent this kind of chaotic behaviour. if (str_replace('\\', '/', $path) == str_replace('\\', '/', $this->page->getPath())) { $page = $this->page; } else { $relativePath = PathHelper::getRelativePath($pieCrust->getPagesDir(), $path); $uri = UriBuilder::buildUri($pieCrust, $relativePath); $page = $pageRepository->getOrCreatePage($uri, $path); } $key = preg_replace('/\\.[a-zA-Z0-9]+$/', '', $filename); $key = str_replace('.', '_', $key); $items[$key] = new LinkData($page, array('name' => $key, 'is_dir' => false, 'is_self' => $page == $this->page)); } catch (Exception $e) { throw new PieCrustException("Error while loading page '{$path}' for linking from '{$this->page->getUri()}': " . $e->getMessage(), 0, $e); } } } if ($this->sortByName) { if (false === usort($items, array($this, 'sortByCustom'))) { throw new PieCrustException("Error while sorting pages with the specified setting: {$this->sortByName}"); } } return $items; } catch (Exception $e) { throw new PieCrustException("Error while building the links from page '{$this->page->getUri()}': " . $e->getMessage(), 0, $e); } }
/** * Builds the URL of a category listing. */ public static function buildCategoryUri(IPieCrust $pieCrust, $blogKey, $category, $slugify = true) { $categoryUrlFormat = $pieCrust->getConfig()->getValue($blogKey . '/category_url'); if ($slugify) { $flags = $pieCrust->getConfig()->getValue('site/slugify_flags'); $category = UriBuilder::slugify($category, $flags); } return str_replace('%category%', $category, $categoryUrlFormat); }
public function getCategoryUrl($value, $blogKey = null) { $blogKey = $this->getSafeBlogKey($blogKey); return PieCrustHelper::formatUri($this->pieCrust, UriBuilder::buildCategoryUri($this->pieCrust, $blogKey, $value)); }
protected function bakeCategories() { if ($this->bakeRecord == null) { throw new PieCrustException("Can't bake categories without a bake-record active."); } $blogKeys = $this->pieCrust->getConfig()->getValueUnchecked('site/blogs'); foreach ($blogKeys as $blogKey) { // Check that there is a category listing page to bake. $prefix = ''; if ($blogKey != PieCrustDefaults::DEFAULT_BLOG_KEY) { $prefix = $blogKey . DIRECTORY_SEPARATOR; } $categoryPageName = $prefix . PieCrustDefaults::CATEGORY_PAGE_NAME . '.html'; $categoryPagePath = PathHelper::getUserOrThemeOrResPath($this->pieCrust, $categoryPageName); if ($categoryPagePath === false) { continue; } // Order categories so it looks nicer when we bake. $categoriesToBake = $this->bakeRecord->getCategoriesToBake($blogKey); sort($categoriesToBake); // Bake! $pageRepository = $this->pieCrust->getEnvironment()->getPageRepository(); foreach ($categoriesToBake as $category) { $start = microtime(true); $postInfos = $this->bakeRecord->getPostsInCategory($blogKey, $category); if (count($postInfos) > 0) { $uri = UriBuilder::buildCategoryUri($this->pieCrust->getConfig()->getValue($blogKey . '/category_url'), $category); $page = $pageRepository->getOrCreatePage($uri, $categoryPagePath, IPage::TYPE_CATEGORY, $blogKey, $category); $baker = new PageBaker($this->getBakeDir(), $this->getPageBakerParameters()); $baker->bake($page); $pageCount = $baker->getPageCount(); $this->logger->info(self::formatTimed($start, 'category:' . $category . ($pageCount > 1 ? " [{$pageCount}]" : ""))); } } } }
private static function tryParseCategoryUri(IPieCrust $pieCrust, $blogKey, $uri, array &$pageInfo) { $blogKeyDir = ''; if ($blogKey != PieCrustDefaults::DEFAULT_BLOG_KEY) { $blogKeyDir = $blogKey . '/'; } $relativeTagPage = $blogKeyDir . PieCrustDefaults::CATEGORY_PAGE_NAME . '.html'; $path = PathHelper::getUserOrThemeOrResPath($pieCrust, $relativeTagPage); if ($path === false) { return false; } $categoryPattern = UriBuilder::buildCategoryUriPattern($pieCrust->getConfig()->getValueUnchecked($blogKey . '/category_url')); if (preg_match($categoryPattern, $uri, $matches)) { $pageInfo['type'] = IPage::TYPE_CATEGORY; $pageInfo['blogKey'] = $blogKey; $pageInfo['key'] = $matches['cat']; $pageInfo['path'] = $path; $pageInfo['was_path_checked'] = true; return true; } return false; }
public function getCategoryUrl($value, $blogKey = null) { $format = $blogKey == null ? $this->categoryUrlFormat : $pieCrust->getConfig()->getValueUnchecked($blogKey . '/category_url'); return PieCrustHelper::formatUri($this->pieCrust, UriBuilder::buildCategoryUri($format, $value)); }
/** * @dataProvider buildCategoryUriDataProvider */ public function testBuildCategoryUri($category, $expectedUri) { $uri = UriBuilder::buildCategoryUri('/%category%', $category); $this->assertEquals($expectedUri, $uri); }