Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 48
CRAP
0.00% covered (danger)
0.00%
0 / 643
diff
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 11
1722
0.00% covered (danger)
0.00%
0 / 141
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
 get_diff
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 count_added_lines
0.00% covered (danger)
0.00%
0 / 1
20
0.00% covered (danger)
0.00%
0 / 12
 count_deleted_lines
0.00% covered (danger)
0.00%
0 / 1
20
0.00% covered (danger)
0.00%
0 / 12
 reverse
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 17
 is_empty
0.00% covered (danger)
0.00%
0 / 1
132
0.00% covered (danger)
0.00%
0 / 24
 lcs
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 12
 get_original
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 12
 get_final
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 12
 trim_newlines
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 _check
0.00% covered (danger)
0.00%
0 / 1
56
0.00% covered (danger)
0.00%
0 / 30
mapped_diff
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
42
0.00% covered (danger)
0.00%
0 / 23
 __construct
0.00% covered (danger)
0.00%
0 / 1
42
0.00% covered (danger)
0.00%
0 / 23
diff_op
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 3
30
0.00% covered (danger)
0.00%
0 / 9
 reverse
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 norig
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 3
 nfinal
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 3
diff_op_copy
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 2
12
0.00% covered (danger)
0.00%
0 / 12
 __construct
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 8
 reverse
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
diff_op_delete
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 2
6
0.00% covered (danger)
0.00%
0 / 8
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
 reverse
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
diff_op_add
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 2
6
0.00% covered (danger)
0.00%
0 / 8
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
 reverse
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
diff_op_change
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 2
6
0.00% covered (danger)
0.00%
0 / 8
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
 reverse
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 4
diff3
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 8
1722
0.00% covered (danger)
0.00%
0 / 166
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 7
 get_num_conflicts
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 12
 get_conflicts_content
0.00% covered (danger)
0.00%
0 / 1
42
0.00% covered (danger)
0.00%
0 / 24
 merged_output
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 merged_new_output
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 16
 merged_orig_output
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 16
 get_conflicts
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 12
 _diff3
0.00% covered (danger)
0.00%
0 / 1
462
0.00% covered (danger)
0.00%
0 / 76
diff3_op
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 6
5402
0.00% covered (danger)
0.00%
0 / 211
 __construct
0.00% covered (danger)
0.00%
0 / 1
20
0.00% covered (danger)
0.00%
0 / 5
 merged
0.00% covered (danger)
0.00%
0 / 1
30
0.00% covered (danger)
0.00%
0 / 24
 is_conflict
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 3
 solve_prepare
0.00% covered (danger)
0.00%
0 / 1
182
0.00% covered (danger)
0.00%
0 / 21
 _compare_conflict_seq
0.00% covered (danger)
0.00%
0 / 1
72
0.00% covered (danger)
0.00%
0 / 33
 solve_conflict
0.00% covered (danger)
0.00%
0 / 1
1722
0.00% covered (danger)
0.00%
0 / 125
diff3_op_copy
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 3
20
0.00% covered (danger)
0.00%
0 / 11
 __construct
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 5
 merged
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 is_conflict
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
diff3_block_builder
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 8
210
0.00% covered (danger)
0.00%
0 / 42
 __construct
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 input
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 6
 out1
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 6
 out2
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 6
 is_empty
0.00% covered (danger)
0.00%
0 / 1
12
0.00% covered (danger)
0.00%
0 / 3
 finish
0.00% covered (danger)
0.00%
0 / 1
6
0.00% covered (danger)
0.00%
0 / 12
 _init
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
 _append
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 3
<?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited <https://www.phpbb.com>
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/
/**
* @ignore
*/
if (!defined('IN_PHPBB'))
{
    exit;
}
/**
* Code from pear.php.net, Text_Diff-1.1.0 package
* http://pear.php.net/package/Text_Diff/
*
* Modified by phpBB Limited to meet our coding standards
* and being able to integrate into phpBB
*
* General API for generating and formatting diffs - the differences between
* two sequences of strings.
*
* Copyright 2004 Geoffrey T. Dairiki <dairiki@dairiki.org>
* Copyright 2004-2008 The Horde Project (http://www.horde.org/)
*
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*/
class diff
{
    /**
    * Array of changes.
    * @var array
    */
    var $_edits;
    /**
    * Computes diffs between sequences of strings.
    *
    * @param array    &$from_content    An array of strings. Typically these are lines from a file.
    * @param array    &$to_content    An array of strings.
    * @param bool    $preserve_cr    If true, \r is replaced by a new line in the diff output
    */
    function __construct(&$from_content, &$to_content, $preserve_cr = true)
    {
        $diff_engine = new diff_engine();
        $this->_edits = $diff_engine->diff($from_content, $to_content, $preserve_cr);
    }
    /**
    * Returns the array of differences.
    */
    function get_diff()
    {
        return $this->_edits;
    }
    /**
    * returns the number of new (added) lines in a given diff.
    *
    * @since Text_Diff 1.1.0
    *
    * @return integer The number of new lines
    */
    function count_added_lines()
    {
        $count = 0;
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if (is_a($edit, 'diff_op_add') || is_a($edit, 'diff_op_change'))
            {
                $count += $edit->nfinal();
            }
        }
        return $count;
    }
    /**
    * Returns the number of deleted (removed) lines in a given diff.
    *
    * @since Text_Diff 1.1.0
    *
    * @return integer The number of deleted lines
    */
    function count_deleted_lines()
    {
        $count = 0;
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if (is_a($edit, 'diff_op_delete') || is_a($edit, 'diff_op_change'))
            {
                $count += $edit->norig();
            }
        }
        return $count;
    }
    /**
    * Computes a reversed diff.
    *
    * Example:
    * <code>
    * $diff = new diff($lines1, $lines2);
    * $rev = $diff->reverse();
    * </code>
    *
    * @return diff  A Diff object representing the inverse of the original diff.
    *               Note that we purposely don't return a reference here, since
    *               this essentially is a clone() method.
    */
    function reverse()
    {
        if (version_compare(zend_version(), '2', '>'))
        {
            $rev = clone($this);
        }
        else
        {
            $rev = $this;
        }
        $rev->_edits = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            $rev->_edits[] = $edit->reverse();
        }
        return $rev;
    }
    /**
    * Checks for an empty diff.
    *
    * @return boolean  True if two sequences were identical.
    */
    function is_empty()
    {
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            // skip diff_op_copy
            if (is_a($edit, 'diff_op_copy'))
            {
                continue;
            }
            if (is_a($edit, 'diff_op_delete') || is_a($edit, 'diff_op_add'))
            {
                $orig = $edit->orig;
                $final = $edit->final;
                // We can simplify one case where the array is usually supposed to be empty...
                if (count($orig) == 1 && trim($orig[0]) === '') $orig = array();
                if (count($final) == 1 && trim($final[0]) === '') $final = array();
                if (!$orig && !$final)
                {
                    continue;
                }
                return false;
            }
            return false;
        }
        return true;
    }
    /**
    * Computes the length of the Longest Common Subsequence (LCS).
    *
    * This is mostly for diagnostic purposes.
    *
    * @return integer  The length of the LCS.
    */
    function lcs()
    {
        $lcs = 0;
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if (is_a($edit, 'diff_op_copy'))
            {
                $lcs += count($edit->orig);
            }
        }
        return $lcs;
    }
    /**
    * Gets the original set of lines.
    *
    * This reconstructs the $from_lines parameter passed to the constructor.
    *
    * @return array  The original sequence of strings.
    */
    function get_original()
    {
        $lines = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->orig)
            {
                array_splice($lines, count($lines), 0, $edit->orig);
            }
        }
        return $lines;
    }
    /**
    * Gets the final set of lines.
    *
    * This reconstructs the $to_lines parameter passed to the constructor.
    *
    * @return array  The sequence of strings.
    */
    function get_final()
    {
        $lines = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->final)
            {
                array_splice($lines, count($lines), 0, $edit->final);
            }
        }
        return $lines;
    }
    /**
    * Removes trailing newlines from a line of text. This is meant to be used with array_walk().
    *
    * @param string &$line  The line to trim.
    * @param integer $key  The index of the line in the array. Not used.
    */
    function trim_newlines(&$line, $key)
    {
        $line = str_replace(array("\n", "\r"), '', $line);
    }
    /**
    * Checks a diff for validity.
    *
    * This is here only for debugging purposes.
    */
    function _check($from_lines, $to_lines)
    {
        if (serialize($from_lines) != serialize($this->get_original()))
        {
            trigger_error("[diff] Reconstructed original doesn't match", E_USER_ERROR);
        }
        if (serialize($to_lines) != serialize($this->get_final()))
        {
            trigger_error("[diff] Reconstructed final doesn't match", E_USER_ERROR);
        }
        $rev = $this->reverse();
        if (serialize($to_lines) != serialize($rev->get_original()))
        {
            trigger_error("[diff] Reversed original doesn't match", E_USER_ERROR);
        }
        if (serialize($from_lines) != serialize($rev->get_final()))
        {
            trigger_error("[diff] Reversed final doesn't match", E_USER_ERROR);
        }
        $prevtype = null;
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($prevtype == get_class($edit))
            {
                trigger_error("[diff] Edit sequence is non-optimal", E_USER_ERROR);
            }
            $prevtype = get_class($edit);
        }
        return true;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*/
class mapped_diff extends diff
{
    /**
    * Computes a diff between sequences of strings.
    *
    * This can be used to compute things like case-insensitve diffs, or diffs
    * which ignore changes in white-space.
    *
    * @param array $from_lines         An array of strings.
    * @param array $to_lines           An array of strings.
    * @param array $mapped_from_lines  This array should have the same size number of elements as $from_lines.
    *                                  The elements in $mapped_from_lines and $mapped_to_lines are what is actually
    *                                  compared when computing the diff.
    * @param array $mapped_to_lines    This array should have the same number of elements as $to_lines.
    */
    function __construct(&$from_lines, &$to_lines, &$mapped_from_lines, &$mapped_to_lines)
    {
        if (count($from_lines) != count($mapped_from_lines) || count($to_lines) != count($mapped_to_lines))
        {
            return false;
        }
        parent::__construct($mapped_from_lines, $mapped_to_lines);
        $xi = $yi = 0;
        for ($i = 0; $i < count($this->_edits); $i++)
        {
            $orig = &$this->_edits[$i]->orig;
            if (is_array($orig))
            {
                $orig = array_slice($from_lines, $xi, count($orig));
                $xi += count($orig);
            }
            $final = &$this->_edits[$i]->final;
            if (is_array($final))
            {
                $final = array_slice($to_lines, $yi, count($final));
                $yi += count($final);
            }
        }
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff_op
{
    var $orig;
    var $final;
    function &reverse()
    {
        trigger_error('[diff] Abstract method', E_USER_ERROR);
    }
    function norig()
    {
        return ($this->orig) ? count($this->orig) : 0;
    }
    function nfinal()
    {
        return ($this->final) ? count($this->final) : 0;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff_op_copy extends diff_op
{
    function __construct($orig, $final = false)
    {
        if (!is_array($final))
        {
            $final = $orig;
        }
        $this->orig = $orig;
        $this->final = $final;
    }
    function &reverse()
    {
        $reverse = new diff_op_copy($this->final, $this->orig);
        return $reverse;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff_op_delete extends diff_op
{
    function __construct($lines)
    {
        $this->orig = $lines;
        $this->final = false;
    }
    function &reverse()
    {
        $reverse = new diff_op_add($this->orig);
        return $reverse;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff_op_add extends diff_op
{
    function __construct($lines)
    {
        $this->final = $lines;
        $this->orig = false;
    }
    function &reverse()
    {
        $reverse = new diff_op_delete($this->final);
        return $reverse;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff_op_change extends diff_op
{
    function __construct($orig, $final)
    {
        $this->orig = $orig;
        $this->final = $final;
    }
    function &reverse()
    {
        $reverse = new diff_op_change($this->final, $this->orig);
        return $reverse;
    }
}
/**
* A class for computing three way diffs.
*
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*/
class diff3 extends diff
{
    /**
    * Conflict counter.
    * @var integer
    */
    var $_conflicting_blocks = 0;
    /**
    * Computes diff between 3 sequences of strings.
    *
    * @param array &$orig        The original lines to use.
    * @param array &$final1        The first version to compare to.
    * @param array &$final2        The second version to compare to.
    * @param bool $preserve_cr    If true, \r\n and bare \r are replaced by a new line
    *                            in the diff output
    */
    function __construct(&$orig, &$final1, &$final2, $preserve_cr = true)
    {
        $diff_engine = new diff_engine();
        $diff_1 = $diff_engine->diff($orig, $final1, $preserve_cr);
        $diff_2 = $diff_engine->diff($orig, $final2, $preserve_cr);
        unset($diff_engine);
        $this->_edits = $this->_diff3($diff_1, $diff_2);
    }
    /**
    * Return number of conflicts
    */
    function get_num_conflicts()
    {
        $conflicts = 0;
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->is_conflict())
            {
                $conflicts++;
            }
        }
        return $conflicts;
    }
    /**
    * Get conflicts content for download. This is generally a merged file, but preserving conflicts and adding explanations to it.
    * A user could then go through this file, search for the conflicts and changes the code accordingly.
    *
    * @param string $label1 the cvs file version/label from the original set of lines
    * @param string $label2 the cvs file version/label from the new set of lines
    * @param string $label_sep the explanation between label1 and label2 - more of a helper for the user
    *
    * @return mixed the merged output
    */
    function get_conflicts_content($label1 = 'CURRENT_FILE', $label2 = 'NEW_FILE', $label_sep = 'DIFF_SEP_EXPLAIN')
    {
        global $user;
        $label1 = (!empty($user->lang[$label1])) ? $user->lang[$label1] : $label1;
        $label2 = (!empty($user->lang[$label2])) ? $user->lang[$label2] : $label2;
        $label_sep = (!empty($user->lang[$label_sep])) ? $user->lang[$label_sep] : $label_sep;
        $lines = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->is_conflict())
            {
                // Start conflict label
                $label_start    = array('<<<<<<< ' . $label1);
                $label_mid        = array('======= ' . $label_sep);
                $label_end        = array('>>>>>>> ' . $label2);
                $lines = array_merge($lines, $label_start, $edit->final1, $label_mid, $edit->final2, $label_end);
                $this->_conflicting_blocks++;
            }
            else
            {
                $lines = array_merge($lines, $edit->merged());
            }
        }
        return $lines;
    }
    /**
    * Return merged output (used by the renderer)
    *
    * @return mixed the merged output
    */
    function merged_output()
    {
        return $this->get_conflicts_content();
    }
    /**
    * Merge the output and use the new file code for conflicts
    */
    function merged_new_output()
    {
        $lines = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->is_conflict())
            {
                $lines = array_merge($lines, $edit->final2);
            }
            else
            {
                $lines = array_merge($lines, $edit->merged());
            }
        }
        return $lines;
    }
    /**
    * Merge the output and use the original file code for conflicts
    */
    function merged_orig_output()
    {
        $lines = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->is_conflict())
            {
                $lines = array_merge($lines, $edit->final1);
            }
            else
            {
                $lines = array_merge($lines, $edit->merged());
            }
        }
        return $lines;
    }
    /**
    * Get conflicting block(s)
    */
    function get_conflicts()
    {
        $conflicts = array();
        for ($i = 0, $size = count($this->_edits); $i < $size; $i++)
        {
            $edit = $this->_edits[$i];
            if ($edit->is_conflict())
            {
                $conflicts[] = array($edit->final1, $edit->final2);
            }
        }
        return $conflicts;
    }
    /**
    * @access private
    */
    function _diff3(&$edits1, &$edits2)
    {
        $edits = array();
        $bb = new diff3_block_builder();
        $e1 = current($edits1);
        $e2 = current($edits2);
        while ($e1 || $e2)
        {
            if ($e1 && $e2 && is_a($e1, 'diff_op_copy') && is_a($e2, 'diff_op_copy'))
            {
                // We have copy blocks from both diffs. This is the (only) time we want to emit a diff3 copy block.
                // Flush current diff3 diff block, if any.
                if ($edit = $bb->finish())
                {
                    $edits[] = $edit;
                }
                $ncopy = min($e1->norig(), $e2->norig());
                $edits[] = new diff3_op_copy(array_slice($e1->orig, 0, $ncopy));
                if ($e1->norig() > $ncopy)
                {
                    array_splice($e1->orig, 0, $ncopy);
                    array_splice($e1->final, 0, $ncopy);
                }
                else
                {
                    $e1 = next($edits1);
                }
                if ($e2->norig() > $ncopy)
                {
                    array_splice($e2->orig, 0, $ncopy);
                    array_splice($e2->final, 0, $ncopy);
                }
                else
                {
                    $e2 = next($edits2);
                }
            }
            else
            {
                if ($e1 && $e2)
                {
                    if ($e1->orig && $e2->orig)
                    {
                        $norig = min($e1->norig(), $e2->norig());
                        $orig = array_splice($e1->orig, 0, $norig);
                        array_splice($e2->orig, 0, $norig);
                        $bb->input($orig);
                    }
                    else
                    {
                        $norig = 0;
                    }
                    if (is_a($e1, 'diff_op_copy'))
                    {
                        $bb->out1(array_splice($e1->final, 0, $norig));
                    }
                    if (is_a($e2, 'diff_op_copy'))
                    {
                        $bb->out2(array_splice($e2->final, 0, $norig));
                    }
                }
                if ($e1 && ! $e1->orig)
                {
                    $bb->out1($e1->final);
                    $e1 = next($edits1);
                }
                if ($e2 && ! $e2->orig)
                {
                    $bb->out2($e2->final);
                    $e2 = next($edits2);
                }
            }
        }
        if ($edit = $bb->finish())
        {
            $edits[] = $edit;
        }
        return $edits;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff3_op
{
    function __construct($orig = false, $final1 = false, $final2 = false)
    {
        $this->orig = $orig ? $orig : array();
        $this->final1 = $final1 ? $final1 : array();
        $this->final2 = $final2 ? $final2 : array();
    }
    function merged()
    {
        if (!isset($this->_merged))
        {
            // Prepare the arrays before we compare them. ;)
            $this->solve_prepare();
            if ($this->final1 === $this->final2)
            {
                $this->_merged = &$this->final1;
            }
            else if ($this->final1 === $this->orig)
            {
                $this->_merged = &$this->final2;
            }
            else if ($this->final2 === $this->orig)
            {
                $this->_merged = &$this->final1;
            }
            else
            {
                // The following tries to aggressively solve conflicts...
                $this->_merged = false;
                $this->solve_conflict();
            }
        }
        return $this->_merged;
    }
    function is_conflict()
    {
        return ($this->merged() === false) ? true : false;
    }
    /**
    * Function to prepare the arrays for comparing - we want to skip over newline changes
    * @author acydburn
    */
    function solve_prepare()
    {
        // We can simplify one case where the array is usually supposed to be empty...
        if (count($this->orig) == 1 && trim($this->orig[0]) === '') $this->orig = array();
        if (count($this->final1) == 1 && trim($this->final1[0]) === '') $this->final1 = array();
        if (count($this->final2) == 1 && trim($this->final2[0]) === '') $this->final2 = array();
        // Now we only can have the case where the only difference between arrays are newlines, so compare all cases
        // First, some strings we can compare...
        $orig = $final1 = $final2 = '';
        foreach ($this->orig as $null => $line) $orig .= trim($line);
        foreach ($this->final1 as $null => $line) $final1 .= trim($line);
        foreach ($this->final2 as $null => $line) $final2 .= trim($line);
        // final1 === final2
        if ($final1 === $final2)
        {
            // We preserve the part which will be used in the merge later
            $this->final2 = $this->final1;
        }
        // final1 === orig
        else if ($final1 === $orig)
        {
            // Here it does not really matter what we choose, but we will use the new code
            $this->orig = $this->final1;
        }
        // final2 === orig
        else if ($final2 === $orig)
        {
            // Here it does not really matter too (final1 will be used), but we will use the new code
            $this->orig = $this->final2;
        }
    }
    /**
    * Find code portions from $orig in $final1 and use $final2 as merged instance if provided
    * @author acydburn
    */
    function _compare_conflict_seq($orig, $final1, $final2 = false)
    {
        $result = array('merge_found' => false, 'merge' => array());
        $_orig = &$this->$orig;
        $_final1 = &$this->$final1;
        // Ok, we basically search for $orig in $final1
        $compare_seq = count($_orig);
        // Go through the conflict code
        for ($i = 0, $j = 0, $size = count($_final1); $i < $size; $i++, $j = $i)
        {
            $line = $_final1[$i];
            $skip = 0;
            for ($x = 0; $x < $compare_seq; $x++)
            {
                // Try to skip all matching lines
                if (trim($line) === trim($_orig[$x]))
                {
                    $line = (++$j < $size) ? $_final1[$j] : $line;
                    $skip++;
                }
            }
            if ($skip === $compare_seq)
            {
                $result['merge_found'] = true;
                if ($final2 !== false)
                {
                    $result['merge'] = array_merge($result['merge'], $this->$final2);
                }
                $i += ($skip - 1);
            }
            else if ($final2 !== false)
            {
                $result['merge'][] = $line;
            }
        }
        return $result;
    }
    /**
    * Tries to solve conflicts aggressively based on typical "assumptions"
    * @author acydburn
    */
    function solve_conflict()
    {
        $this->_merged = false;
        // CASE ONE: orig changed into final2, but modified/unknown code in final1.
        // IF orig is found "as is" in final1 we replace the code directly in final1 and populate this as final2/merge
        if (count($this->orig) && count($this->final2))
        {
            $result = $this->_compare_conflict_seq('orig', 'final1', 'final2');
            if ($result['merge_found'])
            {
                $this->final2 = $result['merge'];
                $this->_merged = &$this->final2;
                return;
            }
            $result = $this->_compare_conflict_seq('final2', 'final1');
            if ($result['merge_found'])
            {
                $this->_merged = &$this->final1;
                return;
            }
            // Try to solve $Id$ issues. ;)
            if (count($this->orig) == 1 && count($this->final1) == 1 && count($this->final2) == 1)
            {
                $match = '#^' . preg_quote('* @version $Id: ', '#') . '[a-z\._\- ]+[0-9]+ [0-9]{4}-[0-9]{2}-[0-9]{2} [0-9\:Z]+ [a-z0-9_\- ]+\$$#';
                if (preg_match($match, $this->orig[0]) && preg_match($match, $this->final1[0]) && preg_match($match, $this->final2[0]))
                {
                    $this->_merged = &$this->final2;
                    return;
                }
            }
            $second_run = false;
            // Try to solve issues where the only reason why the above did not work is a newline being removed in the final1 code but exist in the orig/final2 code
            if (trim($this->orig[0]) === '' && trim($this->final2[0]) === '')
            {
                unset($this->orig[0], $this->final2[0]);
                $this->orig = array_values($this->orig);
                $this->final2 = array_values($this->final2);
                $second_run = true;
            }
            // The same is true for a line at the end. ;)
            if (count($this->orig) && count($this->final2) && count($this->orig) === count($this->final2) && trim($this->orig[count($this->orig)-1]) === '' && trim($this->final2[count($this->final2)-1]) === '')
            {
                unset($this->orig[count($this->orig)-1], $this->final2[count($this->final2)-1]);
                $this->orig = array_values($this->orig);
                $this->final2 = array_values($this->final2);
                $second_run = true;
            }
            if ($second_run)
            {
                $result = $this->_compare_conflict_seq('orig', 'final1', 'final2');
                if ($result['merge_found'])
                {
                    $this->final2 = $result['merge'];
                    $this->_merged = &$this->final2;
                    return;
                }
                $result = $this->_compare_conflict_seq('final2', 'final1');
                if ($result['merge_found'])
                {
                    $this->_merged = &$this->final1;
                    return;
                }
            }
            return;
        }
        // CASE TWO: Added lines from orig to final2 but final1 had added lines too. Just merge them.
        if (!count($this->orig) && $this->final1 !== $this->final2 && count($this->final1) && count($this->final2))
        {
            $result = $this->_compare_conflict_seq('final2', 'final1');
            if ($result['merge_found'])
            {
                $this->final2 = $this->final1;
                $this->_merged = &$this->final1;
            }
            else
            {
                $result = $this->_compare_conflict_seq('final1', 'final2');
                if (!$result['merge_found'])
                {
                    $this->final2 = array_merge($this->final1, $this->final2);
                    $this->_merged = &$this->final2;
                }
                else
                {
                    $this->final2 = $this->final1;
                    $this->_merged = &$this->final1;
                }
            }
            return;
        }
        // CASE THREE: Removed lines (orig has the to-remove line(s), but final1 has additional lines which does not need to be removed). Just remove orig from final1 and then use final1 as final2/merge
        if (!count($this->final2) && count($this->orig) && count($this->final1) && $this->orig !== $this->final1)
        {
            $result = $this->_compare_conflict_seq('orig', 'final1');
            if (!$result['merge_found'])
            {
                return;
            }
            // First of all, try to find the code in orig in final1. ;)
            $compare_seq = count($this->orig);
            $begin = $end = -1;
            $j = 0;
            for ($i = 0, $size = count($this->final1); $i < $size; $i++)
            {
                $line = $this->final1[$i];
                if (trim($line) === trim($this->orig[$j]))
                {
                    // Mark begin
                    if ($begin === -1)
                    {
                        $begin = $i;
                    }
                    // End is always $i, the last found line
                    $end = $i;
                    if (isset($this->orig[$j+1]))
                    {
                        $j++;
                    }
                }
            }
            if ($begin !== -1 && $begin + ($compare_seq - 1) == $end)
            {
                foreach ($this->final1 as $i => $line)
                {
                    if ($i < $begin || $i > $end)
                    {
                        $merged[] = $line;
                    }
                }
                $this->final2 = $merged;
                $this->_merged = &$this->final2;
            }
            return;
        }
        return;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff3_op_copy extends diff3_op
{
    function __construct($lines = false)
    {
        $this->orig = $lines ? $lines : array();
        $this->final1 = &$this->orig;
        $this->final2 = &$this->orig;
    }
    function merged()
    {
        return $this->orig;
    }
    function is_conflict()
    {
        return false;
    }
}
/**
* @package diff
* @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
*
* @access private
*/
class diff3_block_builder
{
    function __construct()
    {
        $this->_init();
    }
    function input($lines)
    {
        if ($lines)
        {
            $this->_append($this->orig, $lines);
        }
    }
    function out1($lines)
    {
        if ($lines)
        {
            $this->_append($this->final1, $lines);
        }
    }
    function out2($lines)
    {
        if ($lines)
        {
            $this->_append($this->final2, $lines);
        }
    }
    function is_empty()
    {
        return !$this->orig && !$this->final1 && !$this->final2;
    }
    function finish()
    {
        if ($this->is_empty())
        {
            return false;
        }
        else
        {
            $edit = new diff3_op($this->orig, $this->final1, $this->final2);
            $this->_init();
            return $edit;
        }
    }
    function _init()
    {
        $this->orig = $this->final1 = $this->final2 = array();
    }
    function _append(&$array, $lines)
    {
        array_splice($array, count($array), 0, $lines);
    }
}