Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
1 | <?php |
||
26 | class Website |
||
27 | { |
||
28 | /** |
||
29 | * The location of where the compiled website will be written to. |
||
30 | * |
||
31 | * @var Folder |
||
32 | */ |
||
33 | private $outputDirectory; |
||
34 | |||
35 | /** |
||
36 | * The main configuration to be used to build the specified website. |
||
37 | * |
||
38 | * @var Configuration |
||
39 | */ |
||
40 | private $configuration; |
||
41 | |||
42 | /** |
||
43 | * When set to true, the Stakx website will be built without a configuration file. |
||
44 | * |
||
45 | * @var bool |
||
46 | */ |
||
47 | private $confLess; |
||
48 | |||
49 | /** |
||
50 | * When set to true, Twig templates will not have access to filters or functions which provide access to the |
||
51 | * filesystem. |
||
52 | * |
||
53 | * @var bool |
||
54 | */ |
||
55 | private $safeMode; |
||
56 | |||
57 | /** |
||
58 | * When set to true, Stakx will not clean the _site folder after a rebuild. |
||
59 | * |
||
60 | * @var bool |
||
61 | */ |
||
62 | private $noClean; |
||
63 | |||
64 | /** |
||
65 | * @var StakxLogger |
||
66 | */ |
||
67 | private $output; |
||
68 | |||
69 | /** |
||
70 | * @var AssetManager |
||
71 | */ |
||
72 | private $am; |
||
|
|||
73 | |||
74 | /** |
||
75 | * @var CollectionManager |
||
76 | */ |
||
77 | private $cm; |
||
78 | |||
79 | /** |
||
80 | * @var DataManager |
||
81 | */ |
||
82 | private $dm; |
||
83 | |||
84 | /** |
||
85 | * @var Filesystem |
||
86 | */ |
||
87 | private $fs; |
||
88 | |||
89 | /** @var MenuManager */ |
||
90 | private $mm; |
||
91 | |||
92 | /** |
||
93 | * @var PageManager |
||
94 | */ |
||
95 | private $pm; |
||
96 | |||
97 | /** |
||
98 | * @var ThemeManager |
||
99 | */ |
||
100 | private $tm; |
||
101 | |||
102 | /** @var Compiler */ |
||
103 | private $compiler; |
||
104 | |||
105 | /** |
||
106 | * Website constructor. |
||
107 | * |
||
108 | * @param OutputInterface $output |
||
109 | */ |
||
110 | public function __construct(OutputInterface $output) |
||
111 | { |
||
112 | $this->output = new StakxLogger($output); |
||
113 | $this->cm = new CollectionManager(); |
||
114 | $this->dm = new DataManager(); |
||
115 | $this->mm = new MenuManager(); |
||
116 | $this->pm = new PageManager(); |
||
117 | $this->fs = new Filesystem(); |
||
118 | } |
||
119 | |||
120 | /** |
||
121 | * Compile the website. |
||
122 | * |
||
123 | * @param bool $tracking Whether or not to keep track of files as they're compiled to save time in 'watch' |
||
124 | */ |
||
125 | public function build($tracking = false) |
||
126 | { |
||
127 | Service::setParameter(BuildableCommand::WATCHING, $tracking); |
||
128 | |||
129 | // Configure the environment |
||
130 | $this->createFolderStructure(!$this->noClean); |
||
131 | |||
132 | // Our output directory |
||
133 | $this->outputDirectory = new Folder($this->getConfiguration()->getTargetFolder()); |
||
134 | $this->outputDirectory->setTargetDirectory($this->getConfiguration()->getBaseUrl()); |
||
135 | |||
136 | // Parse DataItems |
||
137 | $this->dm->setLogger($this->output); |
||
138 | $this->dm->enableTracking($tracking); |
||
139 | $this->dm->parseDataItems($this->getConfiguration()->getDataFolders()); |
||
140 | $this->dm->parseDataSets($this->getConfiguration()->getDataSets()); |
||
141 | |||
142 | // Prepare Collections |
||
143 | $this->cm->setLogger($this->output); |
||
144 | $this->cm->enableTracking($tracking); |
||
145 | $this->cm->parseCollections($this->getConfiguration()->getCollectionsFolders()); |
||
146 | |||
147 | // Handle PageViews |
||
148 | $this->pm->setLogger($this->output); |
||
149 | $this->pm->enableTracking($tracking); |
||
150 | $this->pm->setCollections($this->cm->getCollections()); |
||
151 | $this->pm->parsePageViews($this->getConfiguration()->getPageViewFolders()); |
||
152 | |||
153 | // Handle the site's menu |
||
154 | $this->mm->setLogger($this->output); |
||
155 | $this->mm->buildFromPageViews($this->pm->getStaticPageViews()); |
||
156 | |||
157 | // Configure our Twig environment |
||
158 | $theme = $this->configuration->getTheme(); |
||
159 | $twigEnv = new TwigManager(); |
||
160 | $twigEnv->configureTwig($this->getConfiguration(), array( |
||
161 | 'safe' => $this->safeMode, |
||
162 | 'globals' => array( |
||
163 | array('name' => 'site', 'value' => $this->getConfiguration()->getConfiguration()), |
||
164 | array('name' => 'collections', 'value' => $this->cm->getJailedCollections()), |
||
165 | array('name' => 'menu', 'value' => $this->mm->getSiteMenu()), |
||
166 | array('name' => 'pages', 'value' => $this->pm->getJailedStaticPageViews()), |
||
167 | array('name' => 'data', 'value' => $this->dm->getDataItems()), |
||
168 | ), |
||
169 | )); |
||
170 | |||
171 | // Compile everything |
||
172 | $this->compiler = new Compiler(); |
||
173 | $this->compiler->setLogger($this->output); |
||
174 | $this->compiler->setRedirectTemplate($this->getConfiguration()->getRedirectTemplate()); |
||
175 | $this->compiler->setPageViews($this->pm->getPageViews(), $this->pm->getPageViewsFlattened()); |
||
176 | $this->compiler->setTargetFolder($this->outputDirectory); |
||
177 | $this->compiler->setThemeName($theme); |
||
178 | $this->compiler->compileAll(); |
||
179 | |||
180 | // At this point, we are looking at static files to copy over meaning we need to ignore all of the files that |
||
181 | // make up the source of a stakx website |
||
182 | $assetsToIgnore = array_merge( |
||
183 | Configuration::$stakxSourceFiles, |
||
184 | $this->getConfiguration()->getExcludes() |
||
185 | ); |
||
186 | |||
187 | // |
||
188 | // Theme Management |
||
189 | // |
||
190 | if (!is_null($theme)) |
||
191 | { |
||
192 | $this->output->notice("Looking for '${theme}' theme..."); |
||
193 | |||
194 | $this->tm = new ThemeManager($theme); |
||
195 | $this->tm->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore); |
||
196 | $this->tm->setLogger($this->output); |
||
197 | $this->tm->enableTracking($tracking); |
||
198 | $this->tm->setFolder($this->outputDirectory); |
||
199 | $this->tm->copyFiles(); |
||
200 | } |
||
201 | |||
202 | // |
||
203 | // Static file management |
||
204 | // |
||
205 | $this->am = new AssetManager(); |
||
206 | $this->am->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore); |
||
207 | $this->am->setLogger($this->output); |
||
208 | $this->am->setFolder($this->outputDirectory); |
||
209 | $this->am->enableTracking($tracking); |
||
210 | $this->am->copyFiles(); |
||
211 | } |
||
212 | |||
213 | public function watch() |
||
214 | { |
||
215 | $this->output->writeln('Building website...'); |
||
216 | $this->build(true); |
||
217 | $this->output->writeln(sprintf('Watching %s', getcwd())); |
||
218 | |||
219 | $fileExplorer = FileExplorer::create( |
||
220 | getcwd(), |
||
221 | array_merge($this->getConfiguration()->getExcludes(), array( |
||
222 | $this->getConfiguration()->getTargetFolder(), |
||
223 | )), |
||
224 | $this->getConfiguration()->getIncludes() |
||
225 | ); |
||
226 | |||
227 | $newWatcher = Watcher::create(getcwd()); |
||
228 | $newWatcher->setExcludePatterns(array_merge( |
||
229 | $this->getConfiguration()->getExcludes(), |
||
230 | array( |
||
231 | $this->getConfiguration()->getTargetFolder() . DIRECTORY_SEPARATOR, |
||
232 | ) |
||
233 | )); |
||
234 | $newWatcher->addListener(Modify::NAME, function ($e) |
||
235 | { |
||
236 | $filePath = $this->fs->getRelativePath($e->filename); |
||
237 | |||
238 | try |
||
239 | { |
||
240 | $this->modificationWatcher($filePath); |
||
241 | } |
||
242 | catch (\Exception $e) |
||
243 | { |
||
244 | $this->output->error(sprintf('Your website failed to build with the following error: %s', |
||
245 | $e->getMessage() |
||
246 | )); |
||
247 | } |
||
248 | }); |
||
249 | |||
250 | $this->output->writeln('Watch started successfully'); |
||
251 | |||
252 | $newWatcher->start(); |
||
253 | } |
||
254 | |||
255 | /** |
||
256 | * @return Configuration |
||
257 | */ |
||
258 | public function getConfiguration() |
||
259 | { |
||
260 | return $this->configuration; |
||
261 | } |
||
262 | |||
263 | /** |
||
264 | * @param string $configFile |
||
265 | * |
||
266 | * @throws \LogicException |
||
267 | */ |
||
268 | public function setConfiguration($configFile) |
||
269 | { |
||
270 | if (!$this->fs->exists($configFile) && !$this->isConfLess()) |
||
271 | { |
||
272 | $this->output->error('You are trying to build a website in a directory without a configuration file. Is this what you meant to do?'); |
||
273 | $this->output->error("To build a website without a configuration, use the '--no-conf' option"); |
||
274 | |||
275 | throw new \LogicException('Cannot build a website without a configuration when not in Configuration-less mode'); |
||
276 | } |
||
277 | |||
278 | if ($this->isConfLess()) |
||
279 | { |
||
280 | $configFile = ''; |
||
281 | } |
||
282 | |||
283 | $this->configuration = new Configuration(); |
||
284 | $this->configuration->setLogger($this->output); |
||
285 | $this->configuration->parse($configFile); |
||
286 | } |
||
287 | |||
288 | /** |
||
289 | * Get whether or not the website is being built in Configuration-less mode. |
||
290 | * |
||
291 | * @return bool True when being built with no configuration file |
||
292 | */ |
||
293 | public function isConfLess() |
||
294 | { |
||
295 | return $this->confLess; |
||
296 | } |
||
297 | |||
298 | /** |
||
299 | * Set whether or not the website should be built with a configuration. |
||
300 | * |
||
301 | * @param bool $status True when a website should be built without a configuration |
||
302 | */ |
||
303 | public function setConfLess($status) |
||
304 | { |
||
305 | $this->confLess = $status; |
||
306 | } |
||
307 | |||
308 | /** |
||
309 | * Get whether or not the website is being built in safe mode. |
||
310 | * |
||
311 | * Safe mode is defined as disabling file system access from Twig and disabling user Twig extensions |
||
312 | * |
||
313 | * @return bool True when the website is being built in safe mode |
||
314 | */ |
||
315 | public function isSafeMode() |
||
316 | { |
||
317 | return $this->safeMode; |
||
318 | } |
||
319 | |||
320 | /** |
||
321 | * Set whether a website should be built in safe mode. |
||
322 | * |
||
323 | * @param bool $bool True if a website should be built in safe mode |
||
324 | */ |
||
325 | public function setSafeMode($bool) |
||
326 | { |
||
327 | $this->safeMode = $bool; |
||
328 | } |
||
329 | |||
330 | /** |
||
331 | * @return bool |
||
332 | */ |
||
333 | public function isNoClean() |
||
334 | { |
||
335 | return $this->noClean; |
||
336 | } |
||
337 | |||
338 | /** |
||
339 | * @param bool $noClean |
||
340 | */ |
||
341 | public function setNoClean($noClean) |
||
342 | { |
||
343 | $this->noClean = $noClean; |
||
344 | } |
||
345 | |||
346 | private function creationWatcher($filePath) |
||
347 | { |
||
348 | $this->output->writeln(sprintf('File creation detected: %s', $filePath)); |
||
349 | |||
350 | if ($this->pm->isHandled($filePath)) |
||
351 | { |
||
352 | $this->pm->createNewItem($filePath); |
||
353 | $this->pm->refreshItem($filePath); |
||
354 | } |
||
355 | elseif ($this->cm->isHandled($filePath)) |
||
356 | { |
||
357 | $contentItem = $this->cm->createNewItem($filePath); |
||
358 | TwigManager::getInstance()->addGlobal('collections', $this->cm->getCollections()); |
||
359 | |||
360 | $this->pm->trackNewContentItem($contentItem); |
||
361 | $this->compiler->compileContentItem($contentItem); |
||
362 | $this->compiler->compileSome(array( |
||
363 | 'namespace' => 'collections', |
||
364 | 'dependency' => $contentItem->getCollection(), |
||
365 | )); |
||
366 | } |
||
367 | View Code Duplication | elseif ($this->dm->isHandled($filePath)) |
|
368 | { |
||
369 | $change = $this->dm->createNewItem($filePath); |
||
370 | TwigManager::getInstance()->addGlobal('data', $this->dm->getDataItems()); |
||
371 | |||
372 | $this->compiler->compileSome(array( |
||
373 | 'namespace' => 'data', |
||
374 | 'dependency' => $change, |
||
375 | )); |
||
376 | } |
||
377 | elseif (!is_null($this->tm) && $this->tm->isHandled($filePath)) |
||
378 | { |
||
379 | $this->tm->createNewItem($filePath); |
||
380 | } |
||
381 | elseif ($this->am->isHandled($filePath)) |
||
382 | { |
||
383 | $this->am->createNewItem($filePath); |
||
384 | } |
||
385 | } |
||
386 | |||
387 | private function modificationWatcher($filePath) |
||
388 | { |
||
389 | $this->output->writeln(sprintf('File change detected: %s', $filePath)); |
||
390 | |||
391 | if ($this->compiler->isParentTemplate($filePath)) |
||
392 | { |
||
393 | TwigManager::getInstance()->clearTemplateCache(); |
||
394 | $this->compiler->refreshParent($filePath); |
||
395 | } |
||
396 | elseif ($this->pm->isTracked($filePath)) |
||
397 | { |
||
398 | $change = $this->pm->refreshItem($filePath); |
||
399 | |||
400 | TwigManager::getInstance()->clearTemplateCache(); |
||
401 | $this->compiler->compilePageView($change); |
||
402 | } |
||
403 | elseif ($this->cm->isTracked($filePath)) |
||
404 | { |
||
405 | $contentItem = &$this->cm->getContentItem($filePath); |
||
406 | $contentItem->refreshFileContent(); |
||
407 | |||
408 | $this->compiler->compileContentItem($contentItem); |
||
409 | $this->compiler->compileSome(array( |
||
410 | 'namespace' => 'collections', |
||
411 | 'dependency' => $contentItem->getCollection(), |
||
412 | )); |
||
413 | } |
||
414 | View Code Duplication | elseif ($this->dm->isTracked($filePath)) |
|
415 | { |
||
416 | $change = $this->dm->refreshItem($filePath); |
||
417 | TwigManager::getInstance()->addGlobal('data', $this->dm->getDataItems()); |
||
418 | |||
419 | $this->compiler->compileSome(array( |
||
420 | 'namespace' => 'data', |
||
421 | 'dependency' => $change, |
||
422 | )); |
||
423 | } |
||
424 | elseif (!is_null($this->tm) && $this->tm->isTracked($filePath)) |
||
425 | { |
||
426 | $this->tm->refreshItem($filePath); |
||
427 | } |
||
428 | elseif ($this->am->isTracked($filePath)) |
||
429 | { |
||
430 | $this->am->refreshItem($filePath); |
||
431 | } |
||
432 | } |
||
433 | |||
434 | /** |
||
435 | * Prepare the Stakx environment by creating necessary cache folders. |
||
436 | * |
||
437 | * @param bool $cleanDirectory Clean the target directory |
||
438 | */ |
||
439 | private function createFolderStructure($cleanDirectory) |
||
452 | } |
||
453 |
Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum.