FOS\ElasticaBundle\Persister\InPlacePagerPersister

Complexity

Total Complexity

7

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	insert()	0	57	6

<?php

namespace FOS\ElasticaBundle\Persister;

use FOS\ElasticaBundle\Persister\Event\Events;
use FOS\ElasticaBundle\Persister\Event\OnExceptionEvent;
use FOS\ElasticaBundle\Persister\Event\PostInsertObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PostPersistEvent;
use FOS\ElasticaBundle\Persister\Event\PreFetchObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PreInsertObjectsEvent;
use FOS\ElasticaBundle\Persister\Event\PrePersistEvent;
use FOS\ElasticaBundle\Provider\PagerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

final class InPlacePagerPersister implements PagerPersisterInterface
{
    /**
     * @var PersisterRegistry
     */
    private $registry;
    
    /**
     * @var EventDispatcherInterface
     */
    private $dispatcher;

    /**
     * @param PersisterRegistry $registry
     * @param EventDispatcherInterface $dispatcher
     */
    public function __construct(PersisterRegistry $registry, EventDispatcherInterface $dispatcher)
    {
        $this->registry = $registry;
        $this->dispatcher = $dispatcher;
    }

    /**
     * {@inheritdoc}
     */
    public function insert(PagerInterface $pager, array $options = array())
    {
        $objectPersister = $this->registry->getPersister($options['indexName'], $options['typeName']);

        $event = new PrePersistEvent($pager, $objectPersister, $options);
        $this->dispatcher->dispatch(Events::PRE_PERSIST, $event);
        $pager = $event->getPager();
        $options = $event->getOptions();

        $pager->setMaxPerPage($options['batch_size']);

        $page = $pager->getCurrentPage();
        while ($page <= $pager->getNbPages()) {
            try {
                $pager->setCurrentPage($page);

                $event = new PreFetchObjectsEvent($pager, $objectPersister, $options);
                $this->dispatcher->dispatch(Events::PRE_FETCH_OBJECTS, $event);
                $pager = $event->getPager();
                $options = $event->getOptions();

                $objects = $pager->getCurrentPageResults();

                if ($objects instanceof \Traversable) {
                    $objects = iterator_to_array($objects);
                }

                $event = new PreInsertObjectsEvent($pager, $objectPersister, $objects, $options);
                $this->dispatcher->dispatch(Events::PRE_INSERT_OBJECTS, $event);
                $pager = $event->getPager();
                $options = $event->getOptions();
                $objects = $event->getObjects();

                if (!empty($objects)) {
                    $objectPersister->insertMany($objects);
                }

                $event = new PostInsertObjectsEvent($pager, $objectPersister, $objects, $options);
                $this->dispatcher->dispatch(Events::POST_INSERT_OBJECTS, $event);
            } catch (\Exception $e) {
                $event = new OnExceptionEvent($pager, $objectPersister, $e, $options);
                $this->dispatcher->dispatch(Events::ON_EXCEPTION, $event);

                if (false == $event->isIgnored()) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

                    $e = $event->getException();

                    throw $e;
                }
            }

            $pager->setCurrentPage($page++);
        }

        $event = new PostPersistEvent($pager, $objectPersister, $options);
        $this->dispatcher->dispatch(Events::POST_PERSIST, $event);

    }
}