Update::generateReport() - Code Metrics - Inspection of "code review" - smalot/drush-cerbere - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d5e2fd...19e137 )

by Sebastien

created 2015-11-26 21:29 UTC

Update::generateReport() C

↳ Parent: Update

Complexity

Conditions	7
Paths	10

Size

Total Lines	41
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	1

Metric	Value
c	6
b	0
f	1
dl	0
loc	41
rs	6.7273
cc	7
eloc	27
nc	10
nop	3

<?php

/**
 * Drush Cerbere command line tools.
 * Copyright (C) 2015 - Sebastien Malot <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 Cerbere\Action;

use Cerbere\Event\CerbereDoActionEvent;
use Cerbere\Event\CerbereDoneActionEvent;
use Cerbere\Event\CerbereEvents;
use Cerbere\Event\CerbereReportActionEvent;
use Cerbere\Model\Project;
use Cerbere\Model\Release;
use Cerbere\Model\ReleaseHistory;
use Doctrine\Common\Cache\CacheProvider;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * Class Update
 * @package Cerbere\Action
 */
class Update implements ActionInterface
{
    /**
     * @var CacheProvider
     */
    protected $cache;

    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * Update constructor.
     */
    public function __construct()
    {

    }

    /**
     * @param EventSubscriberInterface $listener
     */
    public function addLoggerListener(EventSubscriberInterface $listener)
    {
        $this->getDispatcher()->addSubscriber($listener);
    }

    /**
     * Gets the dispatcher used by this library to dispatch events.
     *
     * @return EventDispatcherInterface
     */
    public function getDispatcher()
    {
        if (!isset($this->dispatcher)) {
            $this->dispatcher = new EventDispatcher();
        }

        return $this->dispatcher;
    }

    /**
     * Sets the dispatcher used by this library to dispatch events.
     *
     * @param EventDispatcherInterface $dispatcher
     *   The Symfony event dispatcher object.
     */
    public function setDispatcher(EventDispatcherInterface $dispatcher)
    {
        $this->dispatcher = $dispatcher;
    }

    /**
     * @return void
     */
    public function prepare()
    {
    }

    /**
     * @param Project[] $projects
     * @param array $options
     *
     * @return array
     */
    public function process(array $projects, $options = array())
    {
        $options += array('cache' => true, 'level' => 'all', 'flat' => false);
        $reports = array();

        $release_history = new ReleaseHistory($this->cache);

        /** @var Project $project */
        foreach ($projects as $project) {
            $event = new CerbereDoActionEvent($this, $project);
            $this->getDispatcher()->dispatch(CerbereEvents::CERBERE_DO_ACTION, $event);

            $release_history->prepare($project, $options['cache']);
            $release_history->compare($project);

            switch ($options['level']) {
                case 'security':
                    $level = ReleaseHistory::UPDATE_NOT_SECURE;
                    break;
                case 'unsupported':
                    $level = ReleaseHistory::UPDATE_NOT_SUPPORTED;
                    break;
                case 'update':
                    $level = ReleaseHistory::UPDATE_NOT_CURRENT;
                    break;
                default:
                    $level = ReleaseHistory::UPDATE_CURRENT;
            }

            if ($project->getStatus() <= $level) {
                $report = $this->generateReport($project, $release_history, $options['flat']);

                $event = new CerbereReportActionEvent($this, $project, $report, $options);
                $this->getDispatcher()->dispatch(CerbereEvents::CERBERE_REPORT_ACTION, $event);
                $report = $event->getReport();

                $reports[$project->getProject()] = $report;
            }

            $event = new CerbereDoneActionEvent($this, $project);
            $this->getDispatcher()->dispatch(CerbereEvents::CERBERE_DONE_ACTION, $event);
        }

        return $reports;
    }

    /**
     * @param Project $project
     * @param ReleaseHistory $release_history
     * @param boolean $flat
     * @return array
     */
    protected function generateReport(Project $project, ReleaseHistory $release_history, $flat = false)
    {
        $report = array(
          'project'        => $project->getProject(),
          'type'           => $project->getProjectType(),
          'version'        => $project->getVersion(),
          'version_date'   => $project->getDatestamp(),
          'recommended'    => null,
          'dev'            => null,
          'also_available' => array(),
          'status'         => $project->getStatus(),
          'status_label'   => ReleaseHistory::getStatusLabel($project->getStatus()),
          'reason'         => '',
        );

        if ($flat) {
            $report['recommended'] = $project->getRecommended();
            $report['dev'] = $project->getDevVersion();
            $report['also_available'] = implode(',', $project->getAlsoAvailable());
        } else {
            if ($release = $release_history->getRelease($project->getRecommended())) {
                $report['recommended'] = $this->getReportFromRelease($release);
            }

            if ($release = $release_history->getRelease($project->getDevVersion())) {
                $report['dev'] = $this->getReportFromRelease($release);
            }

            foreach ($project->getAlsoAvailable() as $version) {
                if ($release = $project->getRelease($version)) {
                    $report['also_available'][] = $this->getReportFromRelease($release);
                }
            }
        }

        if ($reason = $project->getReason()) {
            $report['reason'] = $reason;
        }

        return $report;
    }

    /**
     * @param Release $release
     * @return array
     */
    protected function getReportFromRelease(Release $release)
    {
        return array(
          'version'       => $release->getVersion(),
          'datestamp'     => $release->getDatestamp(),
          'release_link'  => $release->getReleaseLink(),
          'download_link' => $release->getDownloadLink(),
          'filesize'      => $release->getFilesize(),
        );
    }

    /**
     * @return CacheProvider
     */
    public function getCache()
    {
        return $this->cache;
    }

    /**
     * @param CacheProvider $cache
     */
    public function setCache(CacheProvider $cache)
    {
        $this->cache = $cache;
    }

    /**
     * @return string
     */
    public function getCode()
    {
        return 'update';
    }
}


1			<?php
2
3			/**
4			* Drush Cerbere command line tools.
5			* Copyright (C) 2015 - Sebastien Malot <[email protected]>
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License along
18			* with this program; if not, write to the Free Software Foundation, Inc.,
19			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20			*/
21
22			namespace Cerbere\Action;
23
24			use Cerbere\Event\CerbereDoActionEvent;
25			use Cerbere\Event\CerbereDoneActionEvent;
26			use Cerbere\Event\CerbereEvents;
27			use Cerbere\Event\CerbereReportActionEvent;
28			use Cerbere\Model\Project;
29			use Cerbere\Model\Release;
30			use Cerbere\Model\ReleaseHistory;
31			use Doctrine\Common\Cache\CacheProvider;
32			use Symfony\Component\EventDispatcher\EventDispatcher;
33			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
34			use Symfony\Component\EventDispatcher\EventSubscriberInterface;
35
36			/**
37			* Class Update
38			* @package Cerbere\Action
39			*/
40			class Update implements ActionInterface
41			{
42			/**
43			* @var CacheProvider
44			*/
45			protected $cache;
46
47			/**
48			* @var EventDispatcherInterface
49			*/
50			protected $dispatcher;
51
52			/**
53			* Update constructor.
54			*/
55			public function __construct()
56			{
57
58			}
59
60			/**
61			* @param EventSubscriberInterface $listener
62			*/
63			public function addLoggerListener(EventSubscriberInterface $listener)
64			{
65			$this->getDispatcher()->addSubscriber($listener);
66			}
67
68			/**
69			* Gets the dispatcher used by this library to dispatch events.
70			*
71			* @return EventDispatcherInterface
72			*/
73			public function getDispatcher()
74			{
75			if (!isset($this->dispatcher)) {
76			$this->dispatcher = new EventDispatcher();
77			}
78
79			return $this->dispatcher;
80			}
81
82			/**
83			* Sets the dispatcher used by this library to dispatch events.
84			*
85			* @param EventDispatcherInterface $dispatcher
86			* The Symfony event dispatcher object.
87			*/
88			public function setDispatcher(EventDispatcherInterface $dispatcher)
89			{
90			$this->dispatcher = $dispatcher;
91			}
92
93			/**
94			* @return void
95			*/
96			public function prepare()
97			{
98			}
99
100			/**
101			* @param Project[] $projects
102			* @param array $options
103			*
104			* @return array
105			*/
106			public function process(array $projects, $options = array())
107			{
108			$options += array('cache' => true, 'level' => 'all', 'flat' => false);
109			$reports = array();
110
111			$release_history = new ReleaseHistory($this->cache);
112
113			/** @var Project $project */
114			foreach ($projects as $project) {
115			$event = new CerbereDoActionEvent($this, $project);
116			$this->getDispatcher()->dispatch(CerbereEvents::CERBERE_DO_ACTION, $event);
117
118			$release_history->prepare($project, $options['cache']);
119			$release_history->compare($project);
120
121			switch ($options['level']) {
122			case 'security':
123			$level = ReleaseHistory::UPDATE_NOT_SECURE;
124			break;
125			case 'unsupported':
126			$level = ReleaseHistory::UPDATE_NOT_SUPPORTED;
127			break;
128			case 'update':
129			$level = ReleaseHistory::UPDATE_NOT_CURRENT;
130			break;
131			default:
132			$level = ReleaseHistory::UPDATE_CURRENT;
133			}
134
135			if ($project->getStatus() <= $level) {
136			$report = $this->generateReport($project, $release_history, $options['flat']);
137
138			$event = new CerbereReportActionEvent($this, $project, $report, $options);
139			$this->getDispatcher()->dispatch(CerbereEvents::CERBERE_REPORT_ACTION, $event);
140			$report = $event->getReport();
141
142			$reports[$project->getProject()] = $report;
143			}
144
145			$event = new CerbereDoneActionEvent($this, $project);
146			$this->getDispatcher()->dispatch(CerbereEvents::CERBERE_DONE_ACTION, $event);
147			}
148
149			return $reports;
150			}
151
152			/**
153			* @param Project $project
154			* @param ReleaseHistory $release_history
155			* @param boolean $flat
156			* @return array
157			*/
158			protected function generateReport(Project $project, ReleaseHistory $release_history, $flat = false)
159			{
160			$report = array(
161			'project' => $project->getProject(),
162			'type' => $project->getProjectType(),
163			'version' => $project->getVersion(),
164			'version_date' => $project->getDatestamp(),
165			'recommended' => null,
166			'dev' => null,
167			'also_available' => array(),
168			'status' => $project->getStatus(),
169			'status_label' => ReleaseHistory::getStatusLabel($project->getStatus()),
170			'reason' => '',
171			);
172
173			if ($flat) {
174			$report['recommended'] = $project->getRecommended();
175			$report['dev'] = $project->getDevVersion();
176			$report['also_available'] = implode(',', $project->getAlsoAvailable());
177			} else {
178			if ($release = $release_history->getRelease($project->getRecommended())) {
179			$report['recommended'] = $this->getReportFromRelease($release);
180			}
181
182			if ($release = $release_history->getRelease($project->getDevVersion())) {
183			$report['dev'] = $this->getReportFromRelease($release);
184			}
185
186			foreach ($project->getAlsoAvailable() as $version) {
187			if ($release = $project->getRelease($version)) {
188			$report['also_available'][] = $this->getReportFromRelease($release);
189			}
190			}
191			}
192
193			if ($reason = $project->getReason()) {
194			$report['reason'] = $reason;
195			}
196
197			return $report;
198			}
199
200			/**
201			* @param Release $release
202			* @return array
203			*/
204			protected function getReportFromRelease(Release $release)
205			{
206			return array(
207			'version' => $release->getVersion(),
208			'datestamp' => $release->getDatestamp(),
209			'release_link' => $release->getReleaseLink(),
210			'download_link' => $release->getDownloadLink(),
211			'filesize' => $release->getFilesize(),
212			);
213			}
214
215			/**
216			* @return CacheProvider
217			*/
218			public function getCache()
219			{
220			return $this->cache;
221			}
222
223			/**
224			* @param CacheProvider $cache
225			*/
226			public function setCache(CacheProvider $cache)
227			{
228			$this->cache = $cache;
229			}
230
231			/**
232			* @return string
233			*/
234			public function getCode()
235			{
236			return 'update';
237			}
238			}
239

smalot / drush-cerbere

Push — master ( d5e2fd...19e137 )

Update::generateReport() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like