Tag: PHP

The basic structure is as follows:

• Everything is in parentheses ({...})
• The next character can be one ?to define it as optional
• Then the name of the "object" arrives
• In brackets you can specify the length. Lengths can be a single number (to mean "just as long"), an interval (2-5) or an interval without upper limit (2+).
• You can say the type you want. It can be an integer, a 0-integer, a lowercase letter, a capital letter, and (if not specified) a case.

This function converts the information there into a regular expression that can be used with preg_match,

 repeated names in capturing groups (the J modifier is only for PHP 7.2+)
    static $regex = '@(?J){
        (?P?)? #defined if it is optional
        (?P(a-z)w*) #item name
        (?:(
            (?P(1-9)d*) # fixed length (default), or minimum length
            (?P
                + # no maximum length
                |-(1-9)d* # specific maximum length
            )?
        ))?
        (?:
            # types are used as :
            :(?P
                (?:0-)?int(?:eger)? # treats as an integer (starting from 0 or 1)
                |num(?:ber)? # same as 0-int
                |(lu)c(?:ase)? # (l)ower or (u)pper case
                |(?:low|upp)er(?:case)? # lower, upper, lowercase, uppercase
            )
        )?
    }
    |(?P
        * # any case insensitive text
    )@x';

    // default options
    static $default = array(
        'optional' => '',
        'item' => '*',
        'type' => 'ci',
        'length' => 0,
        'length_max' => 0
    );

    // types to be used on {name:type}
    static $types = array(
        '0-int' => 'd',
        'int' => '(1-9)',
        'ci' => '(wW)',
        'lc' => '(a-zd-_W)',
        'uc' => '(A-Zd-_W)',
    );

    // alternative names for $types
    static $types_map = array(
        '' => 'ci',
        'integer' => 'int',
        '0-integer' => '0-int',
        'num' => '0-int',
        'number' => '0-int',
        'lcase' => 'lc',
        'lower' => 'lc',
        'lowercase' => 'lc',
        'ucase' => 'uc',
        'upper' => 'uc',
        'uppercase' => 'uc'
    );

    // will contain all the into about the {items}
    $items = array();

    $format = preg_replace_callback($regex, function($matches)use(&$default, &$types, &$types_map, &$items){
        $item = array_merge($default, $matches);

        // the default is to select any text
        if($item('item') === $default('item'))
        {
            $items() = '.*?';

            // return %s to be used later with sprintf
            return '%s';
        }

        $regex = '(?P<' . $item('item') . '>';
        $piece = isset($types_map($item('type')))
            ? $types($types_map($item('type')))
            : $types($item('type'));

        if($item('type') === 'int')
        {
            if($item('length') >= 2)
            {
                // must subtract 1 from length and length_max to compensate for the (1-9) (1 char) at the beginning
                $piece .= 'd{' . ($item('length') - 1) . (
                    $item('length_max')
                        ? ',' . (
                            $item('length_max') !== '+'
                                ? abs($item('length_max') - 1)
                                : ''
                        )
                        : ''
                    ) . '}';
            }
            else
            {
                /*
                    if a length exists, it must be lower than 2 (1 char)
                        so, nothing else needs to be done ($piece contains (1-9), which matches 1 char)

                    if no length is provided, match all the numbers ahead
                */
                $piece .= $item('length') ? '' : 'd*';
            }
        }
        else if($item('length') >= 2 || ($item('length_max') && $item('length_max') !== '+'))
        {
            /*
                only give it a length specification if and only if the length is 2 or higher
                    or if there's a maximum length
                this means that (1) and (1+) are skipped, but (1-5) returns {1,5} (regex)
            */
            $piece .= '{' . $item('length') . (
                $item('length_max')
                    ? ',' . (
                        $item('length_max') !== '+'
                            ? abs($item('length_max'))
                            : ''
                    )
                    : ''
                ) . '}';
        }
        else if(!$item('length') || ($item('length') === '1' && $item('length_max') === '+'))
        {
            // if no length is specified (or is 1+), it means "all"
            $piece .= '+';
        }
        /*
            length of 1 doesn't need any treatment
            this is because $piece contains the specification for 1 character already
        */

        $regex .= $piece . ')';

        $items() = $item('optional') ? '(?:' . $regex . ')?' : $regex;

        // returns %s to be used with sprintf
        return '%s';
    }, $path);

    // all arguments must be in the same array, can't do $format, $items
    $new_regex = call_user_func_array(
        'sprintf',
        array_merge(
            array(preg_quote($format, '@')), // protects special chars, like periods and slashes
            $items
        )
    );

    return '@^(?J)' . str_replace(')?/', '/)?', $new_regex) . '$@';
}

It's pretty complicated and pretty massive.

I've decided not to implement a memo schema because this feature is part of a larger project and is cached outside.

This function works, as far as I can tell, as intended.

Can I improve on this feature?