PhpXmlRpc\Helper\XMLParser::parse()

Complexity

Conditions	26
Paths	> 20000

Size

Total Lines	142
Code Lines	90

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	82
CRAP Score	26.0679

Importance

Changes	3
Bugs	0	Features	1

<?php
    public function parse($data, $returnType = self::RETURN_XMLRPCVALS, $accept = 3, $options = array())
    {
        $this->_xh = array(
            'ac' => '',
            'stack' => array(),
            'valuestack' => array(),
            'lv' => 0,
            'isf' => 0,
            'isf_reason' => '',
            'value' => null,
            'method' => false, // so we can check later if we got a methodname or not
            'params' => false, // so we can check later if we got a params tag or not
            'pt' => array(),
            'rt' => '',
        );

        $len = strlen($data);

        // we test for empty documents here to save on resource allocation and simplify the chunked-parsing loop below
        if ($len == 0) {
            $this->_xh['isf'] = 3;
            $this->_xh['isf_reason'] = 'XML error 5: empty document';
            return $this->_xh;
        }

        $this->current_parsing_options = array('accept' => $accept);

        $mergedOptions = $this->parsing_options;
        foreach ($options as $key => $val) {
            $mergedOptions[$key] = $val;
        }

        foreach ($mergedOptions as $key => $val) {
            // q: can php be built without ctype? should we use a regexp?
            if (is_string($key) && !ctype_digit($key)) {
                /// @todo on invalid options, throw/error-out instead of logging an error message?
                switch($key) {
                    case 'target_charset':
                        if (function_exists('mb_convert_encoding')) {
                            $this->current_parsing_options['target_charset'] = $val;
                        } else {
                            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ": 'target_charset' option is unsupported without mbstring");
                        }
                        break;

                    case 'methodname_callback':
                        if (is_callable($val)) {
                            $this->current_parsing_options['methodname_callback'] = $val;
                        } else {
                            $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ": Callback passed as 'methodname_callback' is not callable");
                        }
                        break;

                    case 'xmlrpc_null_extension':
                    case 'xmlrpc_return_datetimes':
                    case 'xmlrpc_reject_invalid_values':
                        $this->current_parsing_options[$key] = $val;
                        break;

                    default:
                        $this->getLogger()->error('XML-RPC: ' . __METHOD__ . ": unsupported option: $key");
                }
                unset($mergedOptions[$key]);
            }
        }

        if (!isset($this->current_parsing_options['xmlrpc_null_extension'])) {
            $this->current_parsing_options['xmlrpc_null_extension'] = PhpXmlRpc::$xmlrpc_null_extension;
        }
        if (!isset($this->current_parsing_options['xmlrpc_return_datetimes'])) {
            $this->current_parsing_options['xmlrpc_return_datetimes'] = PhpXmlRpc::$xmlrpc_return_datetimes;
        }
        if (!isset($this->current_parsing_options['xmlrpc_reject_invalid_values'])) {
            $this->current_parsing_options['xmlrpc_reject_invalid_values'] = PhpXmlRpc::$xmlrpc_reject_invalid_values;
        }

        // NB: we use '' instead of null to force charset detection from the xml declaration
        $parser = xml_parser_create('');

        foreach ($mergedOptions as $key => $val) {
            xml_parser_set_option($parser, $key, $val);
        }

        // always set this, in case someone tries to disable it via options...
        xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 1);

        switch ($returnType) {
            case self::RETURN_PHP:
                xml_set_element_handler($parser, array($this, 'xmlrpc_se'), array($this, 'xmlrpc_ee_fast'));
                break;
            case self::RETURN_EPIVALS:
                xml_set_element_handler($parser, array($this, 'xmlrpc_se'), array($this, 'xmlrpc_ee_epi'));
                break;
            /// @todo log an error / throw / error-out on unsupported return type
            case XMLParser::RETURN_XMLRPCVALS:
            default:
                xml_set_element_handler($parser, array($this, 'xmlrpc_se'), array($this, 'xmlrpc_ee'));
        }

        xml_set_character_data_handler($parser, array($this, 'xmlrpc_cd'));
        xml_set_default_handler($parser, array($this, 'xmlrpc_dh'));

        try {
            // @see ticket #70 - we have to parse big xml docs in chunks to avoid errors
            for ($offset = 0; $offset < $len; $offset += $this->maxChunkLength) {
                $chunk = substr($data, $offset, $this->maxChunkLength);
                // error handling: xml not well formed
                if (!@xml_parse($parser, $chunk, $offset + $this->maxChunkLength >= $len)) {
                    $errCode = xml_get_error_code($parser);
                    $errStr = sprintf('XML error %s: %s at line %d, column %d', $errCode, xml_error_string($errCode),
                        xml_get_current_line_number($parser), xml_get_current_column_number($parser));
                    $this->_xh['isf'] = 3;
                    $this->_xh['isf_reason'] = $errStr;
                }
                // no need to parse further if we already have a fatal error
                if ($this->_xh['isf'] >= 2) {
                    break;
                }
            }
        /// @todo bump minimum php version to 5.5 and use a finally clause instead of doing cleanup 3 times
        } catch (\Exception $e) {
            xml_parser_free($parser);
            $this->current_parsing_options = array();
            /// @todo should we set $this->_xh['isf'] and $this->_xh['isf_reason'] ?
            throw $e;
        } catch (\Error $e) {
            xml_parser_free($parser);
            $this->current_parsing_options = array();
            //$this->accept = $prevAccept;
            /// @todo should we set $this->_xh['isf'] and $this->_xh['isf_reason'] ?
            throw $e;
        }

        xml_parser_free($parser);
        $this->current_parsing_options = array();

        // BC
        if ($this->_xh['params'] === false) {

The condition $this->_xh['params'] === false is always true.

            $this->_xh['params'] = array();
        }

        return $this->_xh;
    }