/**
* Remove the 'at' keyword from -x-radial-gradient() for legacy implementations.
*/
function postalias_fix_radial_gradients($declaration_copies)
{
// Create new paren tokens based on the first prefixed declaration.
// Replace the new syntax with the legacy syntax.
static $fn_patt;
if (!$fn_patt) {
$fn_patt = Regex::make('~{{ LB }}{{ vendor }}(?:repeating-)?radial-gradient{{ parens }}~iS');
}
$original_parens = array();
$replacement_parens = array();
foreach (Regex::matchAll($fn_patt, $declaration_copies[0]->value) as $m) {
$original_parens[] = $m['parens'][0];
$replacement_parens[] = preg_replace('~\\bat +(top|left|bottom|right|center)\\b~i', '$1', $m['parens'][0]);
}
foreach ($declaration_copies as $prefixed_copy) {
$prefixed_copy->value = str_replace($original_parens, $replacement_parens, $prefixed_copy->value);
}
}
public function apply($str, \stdClass $context = null)
{
if (strpos($str, '(') === false) {
return $str;
}
if (!$this->pattern) {
$this->setPattern();
}
if (!preg_match($this->pattern, $str)) {
return $str;
}
$matches = Regex::matchAll($this->pattern, $str);
while ($match = array_pop($matches)) {
if (isset($match['function']) && $match['function'][1] !== -1) {
list($function, $offset) = $match['function'];
} else {
list($function, $offset) = $match['simple_function'];
}
if (!preg_match(Regex::$patt->parens, $str, $parens, PREG_OFFSET_CAPTURE, $offset)) {
continue;
}
$openingParen = $parens[0][1];
$closingParen = $openingParen + strlen($parens[0][0]);
$rawArgs = trim($parens['parens_content'][0]);
// Update the context function identifier.
if ($context) {
$context->function = $function;
}
$returns = '';
if (isset($this->register[$function])) {
$fn = $this->register[$function];
if (is_array($fn) && !empty($fn['parse_args'])) {
$returns = $fn['callback'](self::parseArgs($rawArgs), $context);
} else {
$returns = $fn($rawArgs, $context);
}
}
$str = substr_replace($str, $returns, $offset, $closingParen - $offset);
}
return $str;
}
protected function resolveInBlocks()
{
$matches = $this->string->matchAll('~@in\\s+(?<selectors>[^{]+)\\{~iS');
while ($match = array_pop($matches)) {
$selectorsMatch = trim($match['selectors'][0]);
$curlyMatch = new BalancedMatch($this->string, $match[0][1]);
if (!$curlyMatch->match || empty($selectorsMatch)) {
continue;
}
$rawSelectors = Util::splitDelimList($selectorsMatch);
foreach (Regex::matchAll(Regex::$patt->r_token, $curlyMatch->inside()) as $ruleMatch) {
Crush::$process->tokens->get($ruleMatch[0][0])->selectors->merge($rawSelectors);
}
$curlyMatch->unWrap();
}
}
public function collate()
{
$process = $this->process;
$options = $process->options;
$regex = Regex::$patt;
$input = $process->input;
$str = '';
// Keep track of all import file info for cache data.
$mtimes = array();
$filenames = array();
// Resolve main input; a string of css or a file.
if (isset($input->string)) {
$str .= $input->string;
$process->sources[] = 'Inline CSS';
} else {
$str .= file_get_contents($input->path);
$process->sources[] = $input->path;
}
// If there's a parsing error go no further.
if (!$this->prepareImport($str)) {
return $str;
}
// This may be set non-zero during the script if an absolute @import URL is encountered.
$search_offset = 0;
// Recurses until the nesting heirarchy is flattened and all import files are inlined.
while (preg_match($regex->import, $str, $match, PREG_OFFSET_CAPTURE, $search_offset)) {
$match_len = strlen($match[0][0]);
$match_start = $match[0][1];
$import = new \stdClass();
$import->url = $process->tokens->get($match[1][0]);
$import->media = trim($match[2][0]);
// Protocoled import urls are not processed. Stash for prepending to output.
if ($import->url->protocol) {
$str = substr_replace($str, '', $match_start, $match_len);
$process->absoluteImports[] = $import;
continue;
}
// Resolve import path information.
if ($import->url->isRooted) {
$import->path = realpath($process->docRoot . $import->url->value);
} else {
$import->path = realpath("{$input->dir}/{$import->url->value}");
}
$import->dir = dirname($import->path);
// If unsuccessful getting import contents continue with the import line removed.
$import->content = @file_get_contents($import->path);
if ($import->content === false) {
notice("Import file '{$import->url->value}' not found");
$str = substr_replace($str, '', $match_start, $match_len);
continue;
}
// Import file exists so register it.
$process->sources[] = $import->path;
$mtimes[] = filemtime($import->path);
$filenames[] = $import->url->value;
// If the import content doesn't pass syntax validation skip to next import.
if (!$this->prepareImport($import->content)) {
$str = substr_replace($str, '', $match_start, $match_len);
continue;
}
// Resolve a relative link between the import file and the host-file.
if ($import->url->isRooted) {
$import->relativeDir = Util::getLinkBetweenPaths($import->dir, $input->dir);
} else {
$import->relativeDir = dirname($import->url->value);
}
// Alter all embedded import URLs to be relative to the host-file.
foreach (Regex::matchAll($regex->import, $import->content) as $m) {
$nested_url = $process->tokens->get($m[1][0]);
// Resolve rooted paths.
if ($nested_url->isRooted) {
$link = Util::getLinkBetweenPaths(dirname($nested_url->getAbsolutePath()), $import->dir);
$nested_url->update($link . basename($nested_url->value));
} elseif (strlen($import->relativeDir)) {
$nested_url->prepend("{$import->relativeDir}/");
}
}
// Optionally rewrite relative url and custom function data-uri references.
if ($options->rewrite_import_urls) {
$this->rewriteImportedUrls($import);
}
if ($import->media) {
$import->content = "@media {$import->media} {{$import->content}}";
}
$str = substr_replace($str, $import->content, $match_start, $match_len);
}
// Save only if caching is on and the hostfile object is associated with a real file.
if ($input->path && $options->cache) {
$process->cacheData[$process->output->filename] = array('imports' => $filenames, 'datem_sum' => array_sum($mtimes) + $input->mtime, 'options' => $options->get());
$process->io->saveCacheData();
}
return $str;
}
public function matchAll($patt, $offset = 0)
{
return Regex::matchAll($patt, $this->raw, $offset);
}
