+global\Net_IDNA2::decode()

Complexity

Conditions	22
Paths	105

Size

Total Lines

81

Duplication

Lines	12
Ratio	14.81 %

Importance

Changes

0

<?php
    public function decode($input, $one_time_encoding = false)
    {
        // Optionally set
        if ($one_time_encoding) {

The expression $one_time_encoding of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            switch ($one_time_encoding) {
                case 'utf8':
                case 'ucs4_string':
                case 'ucs4_array':
                    break;
                default:
                    throw new InvalidArgumentException('Unknown encoding ' . $one_time_encoding);
            }
        }
        // Make sure to drop any newline characters around
        $input = trim($input);

        // Negotiate input and try to determine, wether it is a plain string,
        // an email address or something like a complete URL
        if (strpos($input, '@')) { // Maybe it is an email address
            // No no in strict mode
            if ($this->_strict_mode) {
                throw new InvalidArgumentException('Only simple domain name parts can be handled in strict mode');
            }
            list($email_pref, $input) = explode('@', $input, 2);
            $arr = explode('.', $input);
            foreach ($arr as $k => $v) {
                $conv = $this->_decode($v);
                if ($conv) {

The expression $conv of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

                    $arr[$k] = $conv;
                }
            }
            $return = $email_pref . '@' . join('.', $arr);
        } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
            // No no in strict mode
            if ($this->_strict_mode) {
                throw new InvalidArgumentException('Only simple domain name parts can be handled in strict mode');
            }

            $parsed = parse_url($input);
            if (isset($parsed['host'])) {
                $arr = explode('.', $parsed['host']);
                foreach ($arr as $k => $v) {
                    $conv = $this->_decode($v);
                    if ($conv) {

The expression $conv of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

                        $arr[$k] = $conv;
                    }
                }
                $parsed['host'] = join('.', $arr);
                if (isset($parsed['scheme'])) {
                    $parsed['scheme'] .= (strtolower($parsed['scheme']) == 'mailto') ? ':' : '://';
                }
                $return = $this->_unparse_url($parsed);

It seems like $parsed defined by parse_url($input) on line 2453 can also be of type false; however, Net_IDNA2::_unparse_url() does only seem to accept array, did you maybe forget to handle an error condition?

            } else { // parse_url seems to have failed, try without it
                $arr = explode('.', $input);
                foreach ($arr as $k => $v) {
                    $conv = $this->_decode($v);
                    if ($conv) {

The expression $conv of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

                        $arr[$k] = $conv;
                    }
                }
                $return = join('.', $arr);
            }
        } else { // Otherwise we consider it being a pure domain name string
            $return = $this->_decode($input);
        }
        // The output is UTF-8 by default, other output formats need conversion here
        // If one time encoding is given, use this, else the objects property
        switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
            case 'utf8':
                return $return;
                break;

break is not strictly necessary here and could be removed.

            case 'ucs4_string':
                return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
                break;

break is not strictly necessary here and could be removed.

            case 'ucs4_array':
                return $this->_utf8_to_ucs4($return);

The return type of return $this->_utf8_to_ucs4($return); (array) is incompatible with the return type documented by Net_IDNA2::decode of type string.

                break;

break is not strictly necessary here and could be removed.

            default:
                throw new InvalidArgumentException('Unsupported output format');
        }
    }