// i was lazy when i started this project & kept (mainly) to two letter vars. sorry.

protected $mpl; // mustache pattern loader instance

protected $mfs; // mustache file system loader instance

protected $d; // data from data.json files

protected $sp; // source patterns dir

protected $pp; // public patterns dir

protected $ie; // extensions to ignore

protected $id; // directories to ignore

protected $contentSyncPort; // for populating the websockets template partial

protected $navSyncPort; // for populating the websockets template partial

protected $patternTypes; // a list of pattern types that match the directory structure

protected $patternPaths; // the paths to patterns for use with mustache partials

protected $patternLineages; // the list of patterns that make up a particular pattern

protected $patternTypesRegex; // the simple regex for the pattern types. used in getPath()

protected $navItems; // the items for the nav. includes view all links

protected $viewAllPaths; // the paths to the view all pages

protected $enableCSS; // decide if we'll enable CSS parsing

protected $patternCSS; // an array to hold the CSS generated for patterns

protected $cssRuleSaver; // where css rule saver will be initialized

protected $cacheBuster; // a timestamp used to bust the cache for static assets like CSS and JS

/**

public function __construct() {

// set-up the configuration options for patternlab

if (!($config = @parse_ini_file(__DIR__."/../../config/config.ini"))) {

// config.ini didn't exist so attempt to create it using the default file

if (!@copy(__DIR__."/../../config/config.ini.default", __DIR__."/../../config/config.ini")) {

print "Please make sure config.ini.default exists before trying to have Pattern Lab build the config.ini file automagically. Check permissions of config/.";

exit;

} else {

$config = parse_ini_file(__DIR__."/../../config/config.ini");

}

}

// populate some standard variables out of the config

foreach ($config as $key => $value) {

// if the variables are array-like make sure the properties are validated/trimmed/lowercased before saving

if (($key == "ie") || ($key == "id")) {

$values = explode(",",$value);

array_walk($values,'Buildr::trim');

$this->$key = $values;

} else {

$this->$key = $value;

}

}

// generate patternTypes as well as patternPaths

$this->gatherPatternPaths();

// generate patternLineages

$this->gatherLineages();

// get nav items

$this->gatherNavItems();

// provide the default for enable CSS. performance hog so it should be run infrequently

$this->enableCSS = false;

$this->patternCSS = array();

// set cache buster var

$this->setCacheBuster();

}

/**

protected function loadMustachePatternLoaderInstance() {

$this->mpl = new Mustache_Engine(array(

"loader" => new Mustache_Loader_PatternLoader(__DIR__.$this->sp,array("patternPaths" => $this->patternPaths)),

"partials_loader" => new Mustache_Loader_PatternLoader(__DIR__.$this->sp,array("patternPaths" => $this->patternPaths))

));

}

/**

protected function loadMustacheFileSystemLoaderInstance() {

$this->mfs = new Mustache_Engine(array(

"loader" => new Mustache_Loader_FilesystemLoader(__DIR__."/../../source/_patternlab-files/"),

"partials_loader" => new Mustache_Loader_FilesystemLoader(__DIR__."/../../source/_patternlab-files/partials/")

));

}

/**

protected function renderPattern($f) {

// if there is pattern-specific data make sure to override the default in $this->d

$d = $this->d;

if (isset($d->patternSpecific) && array_key_exists($f,$d->patternSpecific)) {

$d = (object) array_merge((array) $d, (array) $d->patternSpecific->$f);

}

return $this->mpl->render($f,$d);

}

/**

protected function generateMainPages() {

// make sure $this->mfs is refreshed

$this->loadMustacheFileSystemLoaderInstance();

// render out the main pages and move them to public

$this->navItems['contentsyncport'] = $this->contentSyncPort;

$this->navItems['navsyncport'] = $this->navSyncPort;

$this->navItems['patternpaths'] = json_encode($this->patternPaths);

$this->navItems['viewallpaths'] = json_encode($this->viewAllPaths);

$this->navItems['mqs'] = $this->gatherMQs();

// grab the partials into a data object for the style guide

$sd = $this->gatherPartials();

// sort partials by patternLink

usort($sd['partials'], "Buildr::sortPartials");

// render the "view all" pages

$this->generateViewAllPages();

// add cacheBuster info

$this->navItems['cacheBuster'] = $this->cacheBuster;

$sd['cacheBuster'] = $this->cacheBuster;

// render the index page and the style guide

$r = $this->mfs->render('index',$this->navItems);

file_put_contents(__DIR__."/../../public/index.html",$r);

$s = $this->mfs->render('styleguide',$sd);

file_put_contents(__DIR__."/../../public/styleguide/html/styleguide.html",$s);

}

/**

protected function generatePatterns() {

// make sure $this->mpl is refreshed

$this->loadMustachePatternLoaderInstance();

// loop over the pattern paths to generate patterns for each

foreach($this->patternPaths as $patternType) {

foreach($patternType as $pattern => $path) {

$r = $this->generatePatternFile($path.".mustache");

// if the pattern directory doesn't exist create it

$path = str_replace("/","-",$path);

if (!is_dir(__DIR__.$this->pp.$path)) {

mkdir(__DIR__.$this->pp.$path);

file_put_contents(__DIR__.$this->pp.$path."/".$path.".html",$r);

} else {

file_put_contents(__DIR__.$this->pp.$path."/".$path.".html",$r);

}

}

}

}

/**

private function generatePatternFile($f) {

$hr = file_get_contents(__DIR__.$this->sp."../_patternlab-files/pattern-header-footer/header.html");

$rf = $this->renderPattern($f);

$fr = file_get_contents(__DIR__.$this->sp."../_patternlab-files/pattern-header-footer/footer.html");

// find & replace the cacheBuster var in header and footer

$hr = str_replace("{{ cacheBuster }}",$this->cacheBuster,$hr);

$fr = str_replace("{{ cacheBuster }}",$this->cacheBuster,$fr);

// the footer isn't rendered as mustache but we have some variables there any way. find & replace.

$pp = $this->getPatternPartial($f);

$fr = str_replace("{{ patternPartial }}",$pp,$fr);

$fr = str_replace("{{ lineage }}",json_encode($this->patternLineages[$pp]),$fr);

$fr = str_replace("{{ patternHTML }}",$rf,$fr);

// set-up the mark-up for CSS Rule Saver so it can figure out which rules to save

if ($this->enableCSS) {

$this->cssRuleSaver->loadHTML($rf,false);

$patternCSS = $this->cssRuleSaver->saveRules();

$this->patternCSS[$pp] = $patternCSS;

$fr = str_replace("{{ patternCSS }}",$patternCSS,$fr);

}

return $hr."\n".$rf."\n".$fr;

}

/**

protected function generateViewAllPages() {

// make sure $this->mfs is refreshed on each generation of view all. for some reason the mustache instance dies

$this->loadMustacheFileSystemLoaderInstance();

// add view all to each list

$i = 0; $k = 0;

foreach ($this->navItems['buckets'] as $bucket) {

// make sure that the navItems index exists. catches issues with pages & templates

if (isset($bucket["navItems"])) {

foreach ($bucket["navItems"] as $navItem) {

// make sure the navSubItems index exists. catches issues with empty folders

if (isset($navItem["navSubItems"])) {

foreach ($navItem["navSubItems"] as $subItem) {

if ($subItem["patternName"] == "View All") {

// get the pattern parts

$patternType = $subItem["patternType"];

$patternSubType = $subItem["patternSubType"];

// get all the rendered partials that match

$sid = $this->gatherPartialsByMatch($patternType, $patternSubType);

$sid["patternPartial"] = $subItem["patternPartial"];

$sid["cacheBuster"] = $this->cacheBuster;

// render the viewall template

$v = $this->mfs->render('viewall',$sid);

// if the pattern directory doesn't exist create it

$patternPath = $patternType."-".$patternSubType;

if (!is_dir(__DIR__.$this->pp.$patternPath)) {

mkdir(__DIR__.$this->pp.$patternPath);

file_put_contents(__DIR__.$this->pp.$patternPath."/index.html",$v);

} else {

file_put_contents(__DIR__.$this->pp.$patternPath."/index.html",$v);

}

}

}

}

}

}

$i++;

$k = 0;

}

}

/**

protected function gatherData() {

// gather the data from the main source data.json

if (file_exists(__DIR__."/../../source/_data/_data.json")) {

$this->d = (object) array_merge(array(), (array) json_decode(file_get_contents(__DIR__."/../../source/_data/_data.json")));

}

// add list item data, makes 'listItems' a reserved word

if (file_exists(__DIR__."/../../source/_data/_listitems.json")) {

$listItems = (array) json_decode(file_get_contents(__DIR__."/../../source/_data/_listitems.json"));

$numbers = array("one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve");

$i = 0;

$k = 1;

$c = count($listItems)+1;

$this->d->listItems = new stdClass();

while ($k < $c) {

shuffle($listItems);

$itemsArray = array();

$this->d->listItems->$numbers[$k-1] = new stdClass();

while ($i < $k) {

$itemsArray[] = $listItems[$i];

$i++;

}

$this->d->listItems->$numbers[$k-1] = $itemsArray;

$i = 0;

$k++;

}

}

// add the link names for easy reference, makes 'link' a reserved word

$this->d->link = new stdClass();

foreach($this->patternPaths as $patternTypeName => $patterns) {

foreach($patterns as $pattern => $path) {

$patternName = $patternTypeName."-".$pattern;

$path = str_replace("/","-",$path);

$this->d->link->$patternName = "../../patterns/".$path."/".$path.".html";

}

}

// add pattern specific data so it can override when a pattern (not partial!) is rendered

// makes 'patternSpecific' a reserved word

$this->d->patternSpecific = new stdClass();

foreach($this->patternTypes as $patternType) {

// $this->d->patternSpecific["pattern-name-that-matches-render.mustache"] = array of data;

$patternTypeClean = $this->getPatternName($patternType,false);

// find pattern data for pattern subtypes*/

foreach(glob(__DIR__.$this->sp.$patternType."/*/*.json") as $filename) {

$path = $this->getPath($filename,"j");

if (in_array($path,$this->patternPaths[$patternTypeClean])) {

$patternName = $path.".mustache";

$this->d->patternSpecific->$patternName = (array) json_decode(file_get_contents(__DIR__."/../../source/_patterns/".$path.".json"));

}

}

// find pattern data for pattern types that are flat (e.g. pages & templates)

foreach(glob(__DIR__.$this->sp.$patternType."/*.json") as $filename) {

$path = $this->getPath($filename,"j");

if (in_array($path,$this->patternPaths[$patternTypeClean])) {

$patternName = $path.".mustache";

$this->d->patternSpecific->$patternName = (array) json_decode(file_get_contents(__DIR__."/../../source/_patterns/".$path.".json"));

}

}

}

}

/**

protected function gatherLineages() {

$this->patternLineages = array();

foreach($this->patternPaths as $patternType => $patterns) {

foreach ($patterns as $pattern => $filename) {

$patternLineage = array();

$foundLineages = $this->getLineage($filename);

if (count($foundLineages) > 0) {

foreach ($foundLineages as $lineage) {

$patternBits = explode("-",$lineage,2); // BUG: this is making an assumption

$path = str_replace("/","-",$this->patternPaths[$patternBits[0]][$patternBits[1]]);

$patternLineage[] = array("lineagePattern" => $lineage, "lineagePath" => "../../patterns/".$path."/".$path.".html");

}

}

$this->patternLineages[$patternType."-".$pattern] = $patternLineage;

}

}

}

/**

protected function gatherMQs() {

$mqs = array();

foreach(glob(__DIR__."/../../source/css/*.css") as $filename) {

$data = file_get_contents($filename);

preg_match_all("/(min|max)-width:([ ]+)?(([0-9]{1,5})(\.[0-9]{1,20}|)(px|em))/",$data,$matches);

foreach ($matches[3] as $match) {

if (!in_array($match,$mqs)) {

$mqs[] = $match;

}

}

}

sort($mqs);

return $mqs;

}

/**

protected function gatherNavItems() {

$b = array("buckets" => array()); // the array that will contain the items

$bi = 0; // track the number for the bucket array

$ni = 0; // track the number for the nav items array

$incrementNavItem = true; // track nav item regeneration so we avoid rebuilding view all pages

// iterate through each pattern type and add them as buckets

foreach($this->patternTypes as $patternType) {

// get the bits for a bucket and check to see if the first bit is a number

$bucket = $this->getPatternName($patternType); // ok, it's not a pattern name but same functionality

// add a new bucket

$b["buckets"][$bi] = array("bucketNameLC" => strtolower($bucket),

"bucketNameUC" => ucwords($bucket));

// see if a pattern has subtypes

$patternSubTypes = glob(__DIR__.$this->sp.$patternType."/*",GLOB_ONLYDIR);

if (count($patternSubTypes) == 0) {

// find the patterns and add them to the nav

foreach(glob(__DIR__.$this->sp.$patternType."/*.mustache") as $pattern) {

$patternPathBits = explode("/",$pattern);

if ($patternPathBits[count($patternPathBits) - 1][0] != "_") {

// get the bits for a pattern and check to see if the first bit is a number

$patternClean = substr($pattern,strlen(__DIR__.$this->sp.$patternType."/"));

$patternClean = str_replace(".mustache","",$patternClean);

$patternFinal = $this->getPatternName($patternClean);

// add a new pattern

$b["buckets"][$bi]["patternItems"][] = array("patternPath" => $patternType."-".$patternClean."/".$patternType."-".$patternClean.".html",

"patternName" => ucwords($patternFinal),

"patternPartial" => str_replace(" ","-",$bucket)."-".str_replace(" ","-",$patternFinal));

}

}

// if all of the patterns for a given pattern type (e.g. atoms) were commented out we need to unset it

if (!isset($b["buckets"][$bi]["patternItems"])) {

unset($b["buckets"][$bi]);

$bi--;

}

} else {

// iterate over pattern sub-types

foreach($patternSubTypes as $dir) {

// NOTE: clean items still include directory numbers, final items DO NOT. made sense at the time i originally wrote it

// get the bits for a directory and check to see if the first bit is a number

$dirClean = substr($dir,strlen(__DIR__.$this->sp.$patternType."/"));

$dirFinal = $this->getPatternName($dirClean); // ok, it's not a pattern name but same functionality

// add a new section

$b["buckets"][$bi]["navItems"][$ni] = array("sectionNameLC" => strtolower($dirFinal),

"sectionNameUC" => ucwords($dirFinal));

// iterate over patterns

foreach(glob(__DIR__.$this->sp.$patternType."/".$dirClean."/*.mustache") as $pattern) {

$patternPathBits = explode("/",$pattern);

if ($patternPathBits[count($patternPathBits) - 1][0] != "_") {

// get the bits for a pattern and check to see if the first bit is a number

$patternClean = substr($pattern,strlen(__DIR__.$this->sp.$patternType."/".$dirClean."/"));

$patternClean = str_replace(".mustache","",$patternClean);

$patternFinal = $this->getPatternName($patternClean);

// add a new pattern

$b["buckets"][$bi]["navItems"][$ni]["navSubItems"][] = array("patternPath" => $patternType."-".$dirClean."-".$patternClean."/".$patternType."-".$dirClean."-".$patternClean.".html",

"patternName" => ucwords($patternFinal),

"patternPartial" => str_replace(" ","-",$bucket)."-".str_replace(" ","-",$patternFinal));

}

// if all of the patterns for a given sub-type were commented out we need to unset it

if (!isset($b["buckets"][$bi]["navItems"][$ni]["navSubItems"])) {

unset($b["buckets"][$bi]["navItems"][$ni]);

$incrementNavItem = false;

}

}

// add a view all for the section

if (isset($b["buckets"][$bi]["navItems"][$ni]["navSubItems"])) {

$subItemsCount = count($b["buckets"][$bi]["navItems"][$ni]["navSubItems"]);

$vaBucket = str_replace(" ","-",$bucket);

$vaDirFinal = str_replace(" ","-",$dirFinal);

$b["buckets"][$bi]["navItems"][$ni]["navSubItems"][$subItemsCount] = array("patternPath" => $patternType."-".$dirClean."/index.html",

"patternName" => "View All",

"patternType" => $patternType,

"patternSubType" => $dirClean,

"patternPartial" => "viewall-".$vaBucket."-".$vaDirFinal);

$this->viewAllPaths[$vaBucket][$vaDirFinal] = $patternType."-".$dirClean;

}

// this feels like such a hacky way of doing it

if (!$incrementNavItem) {

$incrementNavItem = true;

} else {

$ni++;

}

}

}

$bi++;

$ni = 0;

}

$this->navItems = $b;

}

/**

protected function gatherPatternPaths() {

// set-up vars

$this->patternPaths = array();

$this->patternTypes = array();

// get the pattern types

foreach(glob(__DIR__.$this->sp."/*",GLOB_ONLYDIR) as $patternType) {

$this->patternTypes[] = substr($patternType,strlen(__DIR__.$this->sp)+1);

}

// set-up the regex for getPath()

$this->getPatternTypesRegex();

// find the patterns for the types

foreach($this->patternTypes as $patternType) {

$patternTypePaths = array();

$patternTypeClean = $this->getPatternName($patternType, false);

// find pattern paths for pattern subtypes

foreach(glob(__DIR__.$this->sp.$patternType."/*/*.mustache") as $filename) {

preg_match('/\/([A-z0-9-_]{1,})\.mustache$/',$filename,$matches);

$pattern = $this->getPatternName($matches[1], false);

if (($pattern[0] != "_") && (!isset($patternTypePaths[$pattern]))) {

$patternTypePaths[$pattern] = $this->getPath($filename);

}

}

// find pattern paths for pattern types that are flat (e.g. pages & templates)

foreach(glob(__DIR__.$this->sp.$patternType."/*.mustache") as $filename) {

preg_match('/\/([A-z0-9-_]{1,})\.mustache$/',$filename,$matches);

$pattern = $this->getPatternName($matches[1], false);

if (($pattern[0] != "_") && (!isset($patternTypePaths[$pattern]))) {

$patternTypePaths[$pattern] = $this->getPath($filename);

}

}

$this->patternPaths[$patternTypeClean] = $patternTypePaths;

}

}

/**

protected function gatherPartials() {

// make sure $this->mpl is refreshed

$this->loadMustachePatternLoaderInstance();

$p = array("partials" => array());

// loop through pattern paths

foreach($this->patternPaths as $patternType => $patternTypeValues) {

foreach($patternTypeValues as $pattern => $path) {

if (substr_count($path,"/") == 2) {

// double-check the file exists

if (file_exists(__DIR__."/".$this->sp.$path.".mustache")) {

// create the pattern name & link, render the partial, and stick it all into the pattern array

$patternParts = explode("/",$path);

$patternName = $this->getPatternName($patternParts[2]);

$patternLink = str_replace("/","-",$path)."/".str_replace("/","-",$path).".html";

$patternCode = $this->renderPattern($path.".mustache");

$patternPartial = $this->getPatternPartial($path);

$patternLineageExists = (count($this->patternLineages[$patternPartial]) > 0) ? true : false;

$patternLineages = $this->patternLineages[$patternPartial];

$patternCSSExists = $this->enableCSS;

$patternCSS = ($this->enableCSS) ? $this->patternCSS[$patternPartial] : "";

$p["partials"][] = array("patternName" => ucwords($patternName),

"patternLink" => $patternLink,

"patternPartialPath" => $patternType."-".$pattern,

"patternPartial" => $patternCode,

"patternCSS" => $patternCSS,

"patternLineageExists" => $patternLineageExists,

"patternLineages" => $patternLineages,

"patternCSSExists" => $patternCSSExists,

"patternCSS" => $patternCSS

);

}

}

}

}

return $p;

}

/**

protected function gatherPartialsByMatch($patternType, $patternSubType) {

// make sure $this->mpl is refreshed

$this->loadMustachePatternLoaderInstance();

$p = array("partials" => array());

$patternTypeClean = $this->getPatternName($patternType);

// get matches based on pattern type and pattern sub-type

foreach(glob(__DIR__.$this->sp.$patternType."/".$patternSubType."/*.mustache") as $filename) {

// get the directory match of the pattern

$path = $this->getPath($filename);

// because we're globbing we need to check again to see if the pattern should be ignored

$patternParts = explode("/",$path);

if ($patternParts[2][0] != "_") {

// create the pattern name & link, render the partial, and stick it all into the pattern array

$patternName = $this->getPatternName($patternParts[2]);

$patternLink = str_replace("/","-",$path)."/".str_replace("/","-",$path).".html";

$patternCode = $this->renderPattern($path.".mustache");

$patternPartial = $this->getPatternPartial($path);

$patternLineages = $this->patternLineages[$patternPartial];

$patternLineageExists = (count($patternLineages) > 0) ? true : false;

$patternCSSExists = $this->enableCSS;

$patternCSS = ($this->enableCSS) ? $this->patternCSS[$patternPartial] : "";

$p["partials"][] = array("patternName" => ucwords($patternName),

"patternLink" => $patternLink,

"patternPartialPath" => str_replace(" ","-",$patternTypeClean)."-".str_replace(" ","-",$patternName),

"patternPartial" => $patternCode,

"patternCSS" => $patternCSS,

"patternLineageExists" => $patternLineageExists,

"patternLineages" => $patternLineages,

"patternCSSExists" => $patternCSSExists,

"patternCSS" => $patternCSS

);

}

}

return $p;

}

/**

protected function getLineage($filename) {

$data = file_get_contents(__DIR__.$this->sp.$filename.".mustache");

if (preg_match_all('/{{>([ ]+)?([A-Za-z0-9-]+)([ ]+)?}}/',$data,$matches)) {

return $matches[2];

}

return array();

}

/**

protected function getPath($filepath,$type = "m") {

$file = ($type == 'm') ? '\.mustache' : '\.json';

if (preg_match('/\/('.$this->patternTypesRegex.'\/(([A-z0-9-]{1,})\/|)([A-z0-9-]{1,}))'.$file.'$/',$filepath,$matches)) {

return $matches[1];

}

}

/**

protected function getPatternName($pattern, $clean = true) {

$patternBits = explode("-",$pattern,2);

$patternName = (((int)$patternBits[0] != 0) || ($patternBits[0] == '00')) ? $patternBits[1] : $pattern;

return ($clean) ? (str_replace("-"," ",$patternName)) : $patternName;

}

/**

protected function getPatternPartial($fileName) {

$fileName = str_replace(".mustache","",$fileName);

foreach($this->patternPaths as $patternTypeKey => $patternTypeVals) {

foreach($patternTypeVals as $pattern => $path) {

if ($path == $fileName) {

return $patternTypeKey."-".$pattern;

}

}

}

return false;

}

/**

protected function getPatternTypesRegex() {

$i = 0;

$regex = "(";

foreach($this->patternTypes as $patternType) {

$regex .= ($i != 0) ? "|".$patternType : $patternType;

$i++;

}

$regex .= ")";

$this->patternTypesRegex = $regex;

}

/**

protected function setCacheBuster() {

$this->cacheBuster = time();

}

/**

protected function updateChangeTime() {

if (is_dir(__DIR__."/../../public/")) {

file_put_contents(__DIR__."/../../public/latest-change.txt",time());

} else {

print "Either the public directory for Pattern Lab doesn't exist or the builder is in the wrong location. Please fix.";

exit;

}

}

/**

protected function cleanPublic() {

// find all of the patterns in public/. sort by the children first

$objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(__DIR__."/../../public/patterns/"), RecursiveIteratorIterator::CHILD_FIRST);

// make sure dots are skipped

$objects->setFlags(FilesystemIterator::SKIP_DOTS);

// for each file figure out what to do with it

foreach($objects as $name => $object) {

if ($object->isDir()) {

// if this is a directory remove it

rmdir($name);

} else if ($object->isFile() && ($object->getFilename() != "README")) {

// if this is a file remove it

unlink($name);

}

}

// scan source/ & public/ to figure out what directories might need to be cleaned up

$sourceDirs = glob(__DIR__."/../../source/*",GLOB_ONLYDIR);

$publicDirs = glob(__DIR__."/../../public/*",GLOB_ONLYDIR);

// make sure some directories aren't deleted

$ignoreDirs = array("listeners","styleguide");

foreach ($ignoreDirs as $ignoreDir) {

$key = array_search(__DIR__."/../../public/".$ignoreDir,$publicDirs);

if ($key !== false){

unset($publicDirs[$key]);

}

}

// compare source dirs against public. remove those dirs w/ an underscore in source/ from the public/ list

foreach ($sourceDirs as $sourceDir) {

$cleanDir = str_replace(__DIR__."/../../source/","",$sourceDir);

if ($cleanDir[0] == "_") {

$key = array_search(__DIR__."/../../public/".str_replace("_","",$cleanDir),$publicDirs);

if ($key !== false){

unset($publicDirs[$key]);

}

}

}

// for the remaining dirs in public delete them and their files

foreach ($publicDirs as $dir) {

$objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir), RecursiveIteratorIterator::CHILD_FIRST);

// make sure dots are skipped

$objects->setFlags(FilesystemIterator::SKIP_DOTS);

foreach($objects as $name => $object) {

if ($object->isDir()) {

rmdir($name);

} else if ($object->isFile()) {

unlink($name);

}

}

rmdir($dir);

}

}

/**

protected function moveFile($s,$p) {

if (file_exists(__DIR__."/../../source/".$s)) {

copy(__DIR__."/../../source/".$s,__DIR__."/../../public/".$p);

}

}

/**

protected function moveStaticFile($fileName,$copy = "", $find = "", $replace = "") {

$this->moveFile($fileName,str_replace($find, $replace, $fileName));

$this->updateChangeTime();

if ($copy != "") {

print $fileName." ".$copy."...\n";

}

}

/**

protected function ignoreDir($fileName) {

foreach($this->id as $dir) {

$pos = strpos(DIRECTORY_SEPARATOR.$fileName,DIRECTORY_SEPARATOR.$dir.DIRECTORY_SEPARATOR);

if ($pos !== false) {

return true;

}

}

return false;

}

/**

protected function initializeCSSRuleSaver() {

$this->cssRuleSaver = new cssRuleSaver;

foreach(glob(__DIR__."/../../source/css/*.css") as $filename) {

$this->cssRuleSaver->loadCSS($filename);

}

}

/**

public function printData() {

print_r($this->d);

}

/**

public function trim(&$v) {

$v = trim($v);

}

/**

public function sortPartials($a,$b) {

return strcmp($a["patternLink"],$b["patternLink"]);

}

/**

public function strtolower(&$v) {

$v = strtolower($v);

}