HighlightProcessor.php

<?php
/*
Copyright (C) 2014, Siemens AG
Authors: Andreas Würl, Steffen Weber

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/

namespace Fossology\Lib\View;

use Fossology\Lib\Dao\LicenseDao;
use Fossology\Lib\Data\Highlight;
use Fossology\Lib\Data\License;
use Fossology\Lib\Data\SplitPosition;

class HighlightProcessor
{
  const LEVEL = 'level';
  const ACTION = 'action';
  const ENTRY = 'entry';
  const REF_TEXT_MAX_LENGTH = 100;

  private $licenseDao;

  public function __construct(LicenseDao $licenseDao)
  {
    $this->licenseDao = $licenseDao;
  }

  public function addReferenceTexts(&$highlights, $groupId=null)
  {
    $licenses = array();
    foreach ($highlights as &$highlight) {
      if ($highlight->hasLicenseId()) {
        $licenseId = $highlight->getLicenseId();

        if (!array_key_exists($licenseId, $licenses)) {
          $licenses[$licenseId] = $this->licenseDao->getLicenseById($licenseId, $groupId);
        }
        $license = $licenses[$licenseId];
        $licenseReferenceText = ": '" . $this->getReferenceText($license, $highlight) . "'";
        $includeReferenceText = $highlight->getType() != Highlight::MATCH && $highlight->getRefLength() > 0;
        $infoText = $license->getShortName() . ($includeReferenceText ? $licenseReferenceText : "");
        $highlight->setInfoText($infoText);
      }
    }
  }

  protected function getReferenceText(License $license, Highlight $highlight)
  {
    $referenceText = substr($license->getText(), $highlight->getRefStart(), min($highlight->getRefLength(), self::REF_TEXT_MAX_LENGTH));
    return $referenceText . ($highlight->getRefLength() > self::REF_TEXT_MAX_LENGTH ? " ... " : "");
  }


  public function calculateSplitPositions($highlights)
  {
    if (empty($highlights)) {
      return array();
    }
    $this->sortHighlights($highlights);

    $splitPositions = $this->getSplitPositions($highlights);

    $this->filterMultipleAtomEntries($splitPositions);

    $this->sortSplitPositionEntries($splitPositions);

    return $splitPositions;
  }

  public function flattenHighlights(&$highlights, $excludedTypes=array())
  {
    $excludedTypesSet = array();
    foreach ($excludedTypes as $type) {
      $excludedTypesSet[$type] = $type;
    }

    $highlights = array_unique($highlights, SORT_REGULAR);
    $this->sortHighlights($highlights);

    $currentPosition = 0;
    foreach ($highlights as $key => $highlight) {
      $isExcludedType = array_key_exists($highlight->getType(), $excludedTypesSet);
      if ($isExcludedType) {
        continue;
      }
      if ($highlight->getEnd() > $currentPosition) {
        $startPosition = max($highlight->getStart(), $currentPosition);
        $highlights[$key] = new Highlight($startPosition, $highlight->getEnd(), "any", $highlight->getRefStart(), $highlight->getRefEnd(), $highlight->getInfoText());
        $currentPosition = $highlight->getEnd();
      } else {
        unset($highlights[$key]);
      }
    }
  }

  public function sortHighlights(&$highlights)
  {
    if (isset($highlights)) {
      usort($highlights, array(get_class($this), 'startAndLengthFirstSorter'));
    }
  }

  private function getSplitPositions($highlightInfos)
  {
    $splitPositions = array();
    $level = 0;
    do {
      $this->addHighlightingLayer($highlightInfos, $splitPositions, $level++);
    } while (!empty($highlightInfos));

    return $splitPositions;
  }

  private function addHighlightingLayer(&$highlightEntries, &$splitPositions, $level)
  {
    $currentPosition = 0;
    foreach ($highlightEntries as $key => &$highlightEntry) {
      $start = $highlightEntry->getStart();
      $end = $highlightEntry->getEnd();

      if ($start >= $currentPosition) {
        $this->addAllSplitPositions($splitPositions, $level, $highlightEntry);

        ksort($splitPositions);
        $currentPosition = $end;

        unset($highlightEntries[$key]);
      }
    }
  }


  private function addAllSplitPositions(&$splitPositions, $level, $highlightEntry)
  {
    $start = $highlightEntry->getStart();
    $end = $highlightEntry->getEnd();

    $splitStart = $start;
    foreach ($splitPositions as $splitPosition => $dummy) {
      if ($start < $splitPosition && $splitPosition < $end) {
        $this->addSingleSectionSplitPositions($splitPositions, $splitStart, $splitPosition, $level, $highlightEntry);
        $splitStart = $splitPosition;
      }
    }
    $this->addSingleSectionSplitPositions($splitPositions, $splitStart, $end, $level, $highlightEntry);
  }

  private function addSingleSectionSplitPositions(&$splitPositions, $start, $end,
    $level, $highlightEntry)
  {
    if ($start == $end) {
      $splitPositions[$start][] = new SplitPosition($level, SplitPosition::ATOM, $highlightEntry);
    } else {
      $splitPositions[$start][] = new SplitPosition($level, SplitPosition::START, $highlightEntry);
      $splitPositions[$end][] = new SplitPosition($level, SplitPosition::END, $highlightEntry);
    }
  }

  private function startAndLengthFirstSorter(Highlight $a, Highlight $b)
  {
    if ($a->getStart() < $b->getStart()) {
      return - 1;
    } else if ($a->getStart() > $b->getStart()) {
      return 1;
    } else if ($a->getEnd() > $b->getEnd()) {
      return -1;
    }
    return ($a->getEnd() == $b->getEnd()) ? 0 : 1;
  }

  private function splitPositionEntrySorter(SplitPosition $a, SplitPosition $b)
  {
    $leftAction = $a->getAction();
    $rightAction = $b->getAction();
    $leftAction = $leftAction == SplitPosition::ATOM ? SplitPosition::START : $leftAction;
    $rightAction = $rightAction == SplitPosition::ATOM ? SplitPosition::START : $rightAction;

    if ($leftAction != $rightAction) {
      return strcasecmp($leftAction, $rightAction);
    } else {
      return ($leftAction == SplitPosition::START ? 1 : -1) * $this->compare($a->getLevel(), $b->getLevel());
    }
  }

  private function compare($a, $b)
  {
    if ($a == $b) {
      return 0;
    }
    return ($a < $b) ? -1 : 1;
  }

  private function filterMultipleAtomEntries(&$splitPositions)
  {
    foreach ($splitPositions as &$splitPositionEntries) {
      $atomFound = false;

      foreach ($splitPositionEntries as $key => $entry) {
        if ($entry->getAction() == SplitPosition::ATOM) {
          if ($atomFound) {
            unset($splitPositionEntries[$key]);
          } else {
            $atomFound = true;
          }
        }
      }
    }
    unset($splitPositionEntries);
  }

  private function sortSplitPositionEntries(&$splitPositions)
  {
    foreach ($splitPositions as &$splitPositionEntries) {
      usort($splitPositionEntries, array(get_class($this), 'splitPositionEntrySorter'));
    }
    unset($splitPositionEntries);
  }
}