PHP Functions::parseArgs方法代码示例

function loop_resolve_list($list_text)
{
    // Resolve the list of items for iteration.
    // Either a generator function or a plain list.
    $items = array();
    $list_text = Crush::$process->functions->apply($list_text);
    $generator_func_patt = Regex::make('~(?<func>range|color-range) {{parens}}~ix');
    if (preg_match($generator_func_patt, $list_text, $m)) {
        $func = strtolower($m['func']);
        $args = Functions::parseArgs($m['parens_content']);
        switch ($func) {
            case 'range':
                $items = call_user_func_array('range', $args);
                break;
            default:
                $func = str_replace('-', '_', $func);
                if (function_exists("CssCrush\\loop_{$func}")) {
                    $items = call_user_func_array("CssCrush\\loop_{$func}", $args);
                }
        }
    } else {
        $items = Util::splitDelimList($list_text);
    }
    return $items;
}

 public static function expandAliases($str)
 {
     $process = Crush::$process;
     if (!$process->selectorAliases || !preg_match($process->selectorAliasesPatt, $str)) {
         return $str;
     }
     while (preg_match_all($process->selectorAliasesPatt, $str, $m, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
         $alias_call = end($m);
         $alias_name = strtolower($alias_call[1][0]);
         $start = $alias_call[0][1];
         $length = strlen($alias_call[0][0]);
         $args = array();
         // It's a function alias if a start paren is matched.
         if (isset($alias_call[2])) {
             // Parse argument list.
             if (preg_match(Regex::$patt->parens, $str, $parens, PREG_OFFSET_CAPTURE, $start)) {
                 $args = Functions::parseArgs($parens[2][0]);
                 // Amend offsets.
                 $paren_start = $parens[0][1];
                 $paren_len = strlen($parens[0][0]);
                 $length = $paren_start + $paren_len - $start;
             }
         }
         $str = substr_replace($str, $process->selectorAliases[$alias_name]($args), $start, $length);
     }
     return $str;
 }

 public function __invoke(array $args = null, $str = null)
 {
     $str = parent::__invoke($args);
     // Flatten all fragment calls within the template string.
     while (preg_match(Regex::$patt->fragmentInvoke, $str, $m, PREG_OFFSET_CAPTURE)) {
         $name = strtolower($m['name'][0]);
         $fragment = isset(Crush::$process->fragments[$name]) ? Crush::$process->fragments[$name] : null;
         $replacement = '';
         $start = $m[0][1];
         $length = strlen($m[0][0]);
         // Skip over same named fragments to avoid infinite recursion.
         if ($fragment && $name !== $this->name) {
             $args = array();
             if (isset($m['parens'][1])) {
                 $args = Functions::parseArgs($m['parens_content'][0]);
             }
             $replacement = $fragment($args);
         }
         $str = substr_replace($str, $replacement, $start, $length);
     }
     return $str;
 }

function fn__query($input, $context)
{
    $args = Functions::parseArgs($input);
    // Context property is required.
    if (!count($args) || !isset($context->property)) {
        return '';
    }
    list($target, $property, $fallback) = $args + array(null, $context->property, null);
    if (strtolower($property) === 'default') {
        $property = $context->property;
    }
    if (!preg_match(Regex::$patt->rooted_ident, $target)) {
        $target = Selector::makeReadable($target);
    }
    $targetRule = null;
    $references =& Crush::$process->references;
    switch (strtolower($target)) {
        case 'parent':
            $targetRule = $context->rule->parent;
            break;
        case 'previous':
            $targetRule = $context->rule->previous;
            break;
        case 'next':
            $targetRule = $context->rule->next;
            break;
        case 'top':
            $targetRule = $context->rule->parent;
            while ($targetRule && $targetRule->parent && ($targetRule = $targetRule->parent)) {
            }
            break;
        default:
            if (isset($references[$target])) {
                $targetRule = $references[$target];
            }
            break;
    }
    $result = '';
    if ($targetRule) {
        $targetRule->declarations->process();
        $targetRule->declarations->expandData('queryData', $property);
        if (isset($targetRule->declarations->queryData[$property])) {
            $result = $targetRule->declarations->queryData[$property];
        }
    }
    if ($result === '' && isset($fallback)) {
        $result = $fallback;
    }
    return $result;
}

function noise_generator($input, $defaults)
{
    $args = array_pad(Functions::parseArgs($input), 4, 'default');
    $type = $defaults['type'];
    // Color-fill and dimensions.
    $fill_color = 'transparent';
    $dimensions = $defaults['dimensions'];
    if (($arg = array_shift($args)) !== 'default') {
        // May be a color function so explode(' ', $value) is not sufficient.
        foreach (Functions::parseArgs($arg, true) as $part) {
            if (preg_match('~^(\\d+)x(\\d+)$~i', $part, $m)) {
                $dimensions = array_slice($m, 1);
            } else {
                $fill_color = $part;
            }
        }
    }
    // Frequency, octaves and sharpening.
    static $sharpen_modes = array('normal', 'sharpen');
    $frequency = $defaults['frequency'];
    $octaves = 1;
    $sharpen = $defaults['sharpen'];
    if (($arg = array_shift($args)) !== 'default') {
        foreach (explode(' ', $arg) as $index => $value) {
            switch ($index) {
                case 0:
                    // x and y frequency values can be specified by joining with a colon.
                    $frequency = str_replace(':', ',', $value);
                    break;
                case 1:
                case 2:
                    if (preg_match(Regex::$patt->rooted_number, $value)) {
                        $octaves = $value;
                    } elseif (in_array($value, $sharpen_modes)) {
                        $sharpen = $value;
                    }
            }
        }
    }
    // Blend-mode and fade.
    static $blend_modes = array('normal', 'multiply', 'screen', 'darken', 'lighten');
    $blend_mode = 'normal';
    $opacity = 1;
    if (($arg = array_shift($args)) !== 'default') {
        foreach (explode(' ', $arg) as $part) {
            if (ctype_alpha($part)) {
                if (in_array($part, $blend_modes)) {
                    $blend_mode = $part;
                }
            } else {
                $opacity = $part;
            }
        }
    }
    // Color filter.
    static $color_filters = array('saturate', 'hueRotate', 'luminanceToAlpha');
    $color_filter = null;
    if (($arg = array_shift($args)) !== 'default') {
        // Saturate by default.
        $color_filter = array('saturate', 1);
        foreach (explode(' ', $arg) as $part) {
            if (ctype_alpha($part)) {
                if (in_array($part, $color_filters)) {
                    $color_filter[0] = $part;
                }
            } else {
                $color_filter[1] = $part;
            }
        }
    }
    // Creating the svg.
    $svg = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{$dimensions[0]}\" height=\"{$dimensions[1]}\">";
    $svg .= '<defs>';
    $svg .= "<filter id=\"f\" x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">";
    $svg .= "<feTurbulence type=\"{$type}\" baseFrequency=\"{$frequency}\" numOctaves=\"{$octaves}\" result=\"f1\"/>";
    $component_adjustments = array();
    if ($sharpen === 'sharpen') {
        // It's more posterizing than sharpening, but it hits a sweet spot.
        $component_adjustments[] = "<feFuncR type=\"discrete\" tableValues=\"0 .5 1 1\"/>";
        $component_adjustments[] = "<feFuncG type=\"discrete\" tableValues=\"0 .5 1\"/>";
        // Some unpredictable results with this:
        // $component_adjustments[] = "<feFuncB type=\"discrete\" tableValues=\"0\"/>";
    }
    if ($opacity != '1') {
        $component_adjustments[] = "<feFuncA type=\"table\" tableValues=\"0 {$opacity}\"/>";
    }
    if ($component_adjustments) {
        $svg .= "<feComponentTransfer>";
        $svg .= implode('', $component_adjustments);
        $svg .= "</feComponentTransfer>";
    }
    if ($color_filter) {
        $svg .= "<feColorMatrix type=\"{$color_filter[0]}\" values=\"{$color_filter[1]}\"/>";
    }
    if ($blend_mode !== 'normal') {
        $svg .= "<feBlend mode=\"{$blend_mode}\" in=\"SourceGraphic\"/>";
    }
    $svg .= '</filter>';
    $svg .= '</defs>';
    $svg .= "<rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" fill=\"{$fill_color}\"/>";
//.........这里部分代码省略.........

 protected function minifyColors()
 {
     static $keywords_patt, $functions_patt;
     $minified_keywords = Color::getMinifyableKeywords();
     if (!$keywords_patt) {
         $keywords_patt = '~(?<![\\w-\\.#])(' . implode('|', array_keys($minified_keywords)) . ')(?![\\w-\\.#\\]])~iS';
         $functions_patt = Regex::make('~{{ LB }}(rgb|hsl)\\(([^\\)]{5,})\\)~iS');
     }
     $this->string->pregReplaceCallback($keywords_patt, function ($m) use($minified_keywords) {
         return $minified_keywords[strtolower($m[0])];
     });
     $this->string->pregReplaceCallback($functions_patt, function ($m) {
         $args = Functions::parseArgs(trim($m[2]));
         if (stripos($m[1], 'hsl') === 0) {
             $args = Color::cssHslToRgb($args);
         }
         return Color::rgbToHex($args);
     });
 }

function svg_fn_pattern($input, $element)
{
    $pid = 'p' . ++$GLOBALS['CSSCRUSH_SVG_UID'];
    // Get args in order with defaults.
    list($url, $transform_list, $width, $height, $x, $y) = Functions::parseArgs($input) + array('', '', 0, 0, 0, 0);
    $url = Crush::$process->tokens->get($url);
    if (!$url) {
        return '';
    }
    // If $width or $height is not specified get image dimensions the slow way.
    if (!$width || !$height) {
        $file = $url->getAbsolutePath();
        list($width, $height) = getimagesize($file);
    }
    // If a data-uri function has been used.
    if ($url->convertToData) {
        $url->toData();
    }
    $transform_list = $transform_list ? " patternTransform=\"{$transform_list}\"" : '';
    $generated_pattern = "<pattern id=\"{$pid}\" patternUnits=\"userSpaceOnUse\" width=\"{$width}\" height=\"{$height}\"{$transform_list}>";
    $generated_pattern .= "<image xlink:href=\"{$url->value}\" x=\"{$x}\" y=\"{$y}\" width=\"{$width}\" height=\"{$height}\"/>";
    $generated_pattern .= '</pattern>';
    $element->fills['patterns'][] = $generated_pattern;
    $element->svg_attrs['xmlns:xlink'] = "http://www.w3.org/1999/xlink";
    return 'url(#' . $pid . ')';
}

function create_svg_radial_gradient($input)
{
    static $position_keywords, $origin_patt;
    if (!$position_keywords) {
        $position_keywords = array('at top' => array('50%', '0%'), 'at right' => array('100%', '50%'), 'at bottom' => array('50%', '100%'), 'at left' => array('0%', '50%'), 'at center' => array('50%', '50%'), 'at top right' => array('100%', '0%'), 'at top left' => array('0%', '0%'), 'at bottom right' => array('100%', '100%'), 'at bottom left' => array('0%', '100%'));
        $position_keywords['at right top'] = $position_keywords['at top right'];
        $position_keywords['at left top'] = $position_keywords['at top left'];
        $position_keywords['at right bottom'] = $position_keywords['at bottom right'];
        $position_keywords['at left bottom'] = $position_keywords['at bottom left'];
        $origin_patt = Regex::make('~^({{number}}%?) +({{number}}%?)$~');
    }
    $args = Functions::parseArgs($input);
    // Default origin,
    $position = $position_keywords['at center'];
    // Parse origin coordinates from the first argument if it's an origin.
    $first_arg = $args[0];
    $first_arg_is_position = false;
    // Try to parse an origin value.
    if (preg_match($origin_patt, $first_arg, $m)) {
        $position = array($m[1], $m[2]);
        $first_arg_is_position = true;
    } elseif (isset($position_keywords[$first_arg])) {
        $position = $position_keywords[$first_arg];
        $first_arg_is_position = true;
    }
    // Shift off the first argument if it has been recognised as an origin.
    if ($first_arg_is_position) {
        array_shift($args);
    }
    // The remaining arguments are treated as color stops.
    // - Capture their color values and if specified color offset percentages.
    // - Only percentages are supported as SVG gradients to accept other length values
    //   for color stop offsets.
    $color_stops = parse_gradient_color_stops($args);
    // Create the gradient markup with a unique id.
    $uid = ++$GLOBALS['CSSCRUSH_SVG_GRADIENT_UID'];
    $gradient_id = "rg{$uid}";
    $gradient = "<radialGradient id=\"{$gradient_id}\" gradientUnits=\"userSpaceOnUse\"";
    $gradient .= " cx=\"{$position[0]}\" cy=\"{$position[1]}\" r=\"100%\">";
    $gradient .= $color_stops;
    $gradient .= '</radialGradient>';
    return array($gradient_id => $gradient);
}