DairikiDiff.php

Go to the documentation of this file.

<?php
abstract class DiffOp {

    public $type;

    public $orig;

    public $closing;

    public function getType() {
        return $this->type;
    }

    public function getOrig() {
        return $this->orig;
    }

    public function getClosing( $i = null ) {
        if ( $i === null ) {
            return $this->closing;
        }
        if ( array_key_exists( $i, $this->closing ) ) {
            return $this->closing[$i];
        }
        return null;
    }

    abstract public function reverse();

    public function norig() {
        return $this->orig ? count( $this->orig ) : 0;
    }

    public function nclosing() {
        return $this->closing ? count( $this->closing ) : 0;
    }
}

class DiffOpCopy extends DiffOp {
    public $type = 'copy';

    public function __construct( $orig, $closing = false ) {
        if ( !is_array( $closing ) ) {
            $closing = $orig;
        }
        $this->orig = $orig;
        $this->closing = $closing;
    }

    public function reverse() {
        return new DiffOpCopy( $this->closing, $this->orig );
    }
}

class DiffOpDelete extends DiffOp {
    public $type = 'delete';

    public function __construct( $lines ) {
        $this->orig = $lines;
        $this->closing = false;
    }

    public function reverse() {
        return new DiffOpAdd( $this->orig );
    }
}

class DiffOpAdd extends DiffOp {
    public $type = 'add';

    public function __construct( $lines ) {
        $this->closing = $lines;
        $this->orig = false;
    }

    public function reverse() {
        return new DiffOpDelete( $this->closing );
    }
}

class DiffOpChange extends DiffOp {
    public $type = 'change';

    public function __construct( $orig, $closing ) {
        $this->orig = $orig;
        $this->closing = $closing;
    }

    public function reverse() {
        return new DiffOpChange( $this->closing, $this->orig );
    }
}

class Diff {

    public $edits;

    protected $bailoutComplexity = 0;

    public function __construct( $from_lines, $to_lines ) {
        $eng = new DiffEngine;
        $eng->setBailoutComplexity( $this->bailoutComplexity );
        $this->edits = $eng->diff( $from_lines, $to_lines );
    }

    public function getEdits() {
        return $this->edits;
    }

    public function reverse() {
        $rev = $this;
        $rev->edits = [];
        foreach ( $this->edits as $edit ) {
            $rev->edits[] = $edit->reverse();
        }

        return $rev;
    }

    public function isEmpty() {
        foreach ( $this->edits as $edit ) {
            if ( $edit->type != 'copy' ) {
                return false;
            }
        }

        return true;
    }

    public function lcs() {
        $lcs = 0;
        foreach ( $this->edits as $edit ) {
            if ( $edit->type == 'copy' ) {
                $lcs += count( $edit->orig );
            }
        }

        return $lcs;
    }

    public function orig() {
        $lines = [];

        foreach ( $this->edits as $edit ) {
            if ( $edit->orig ) {
                array_splice( $lines, count( $lines ), 0, $edit->orig );
            }
        }

        return $lines;
    }

    public function closing() {
        $lines = [];

        foreach ( $this->edits as $edit ) {
            if ( $edit->closing ) {
                array_splice( $lines, count( $lines ), 0, $edit->closing );
            }
        }

        return $lines;
    }
}

class HWLDFWordAccumulator extends MediaWiki\Diff\WordAccumulator {
}