FOS\ElasticaBundle\Persister\PagerPersister

Complexity

Total Complexity

13

Size/Duplication

Total Lines	93
Duplicated Lines	29.03 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	insert()	7	41	8
A	filterObjects()	20	20	4

<?php

namespace FOS\ElasticaBundle\Persister;

use FOS\ElasticaBundle\Provider\Indexable;
use Pagerfanta\Pagerfanta;
use Elastica\Exception\Bulk\ResponseException as BulkResponseException;

class PagerPersister
{
    /**
     * @var ObjectPersisterInterface
     */
    private $objectPersister;

    /**
     * @var Indexable
     */
    private $indexable;

    /**
     * PagerPersister constructor.
     * @param ObjectPersisterInterface $objectPersister
     * @param Indexable $indexable
     */
    public function __construct(ObjectPersisterInterface $objectPersister, Indexable $indexable)
    {
        $this->objectPersister = $objectPersister;
        $this->indexable = $indexable;
    }

    public function insert(Pagerfanta $pager, \Closure $loggerClosure = null, array $options = array())
    {
        $nbObjects = $pager->getNbResults();
        $pager->setCurrentPage(1);
        while (true) {
            if ($pager->getNextPage()) {
                return;
            }

            $sliceSize = $options['batch_size'];
            try {
                $objects = $objects = $pager->getCurrentPageResults();
                $sliceSize = count($objects);
                $objects = $this->filterObjects($options, $objects);

It seems like $objects can also be of type object<Traversable>; however, FOS\ElasticaBundle\Persister\PagerPersister::filterObjects() does only seem to accept array, maybe add an additional type check?

                if (!empty($objects)) {
                    $this->objectPersister->insertMany($objects);
                }
            } catch (BulkResponseException $e) {
                if (!$options['ignore_errors']) {
                    throw $e;
                }

                if (null !== $loggerClosure) {
                    $loggerClosure(
                        $options['batch_size'],
                        $nbObjects,
                        sprintf('<error>%s</error>', $e->getMessage())
                    );
                }
            }

            if (null !== $loggerClosure) {
                $loggerClosure($sliceSize, $nbObjects);
            }

            $pager->setCurrentPage($pager->getNextPage());

            usleep($options['sleep']);
        }
    }

    /**
     * Filters objects away if they are not indexable.
     *
     * @param array $options
     * @param array $objects
     * @return array
     */
    protected function filterObjects(array $options, array $objects)
    {
        if ($options['skip_indexable_check']) {
            return $objects;
        }

        $index = $options['indexName'];
        $type = $options['typeName'];

        $return = array();
        foreach ($objects as $object) {
            if (!$this->indexable->isObjectIndexable($index, $type, $object)) {
                continue;
            }

            $return[] = $object;
        }

        return $return;
    }
}