SnifferReport\Controller\MainController

Complexity

Total Complexity

10

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	9

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
C	processSniff()	0	66	10

<?php

namespace SnifferReport\Controller;

use Silex\Application;
use SnifferReport\Exception\SnifferReportException;
use SnifferReport\Model\Sniff;
use SnifferReport\Service\Validator;
use SnifferReport\Service\FilesHandler;
use SnifferReport\Service\GitHandler;
use SnifferReport\Service\Sniffer;
use SnifferReport\Service\SniffParser;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\Request;
use \Exception;

class MainController
{

  /**
   * Processes the POSTed data.
   *
   * @param Application $app
   * @param Request $request
   *
   * @return Sniff
   *
   * @throws SnifferReportException
   */
    public static function processSniff(Application $app, Request $request)

The parameter $app is not used and could be removed.

    {
        $file = $request->files->get('file');
        $git_url = $request->get('git_url');
        $options = $request->get('options');

        $valid_git_url = (is_null($git_url) || !Validator::isGitUrl($git_url));
        if ($valid_git_url && is_null($file)) {
            throw new SnifferReportException('File or Git URL required', 400);
        }

        if (!is_null($file)) {
            $file_name = $file->getClientOriginalName();
            $file->move(FILES_DIRECTORY_ROOT, $file_name);
            $files = FilesHandler::handle($file_name, $file->getClientMimeType());
        } else {
            try {
                $files = GitHandler::handle($git_url);
            } catch (Exception $e) {
                throw new SnifferReportException("Error when trying to clone git repository: {$e->getMessage()}", 500);
            }
        }

        // @fixme Temporary
        if (empty($options)) {
            throw new SnifferReportException(
                'Missing options',
                400
            );
        }

        $options = json_decode($options);

        if (!Validator::areStandardsValid($options->standards)) {
            throw new SnifferReportException(
                'One or more standards are not valid. Please try again with different values',
                400
            );
        }

        if (!Validator::areExtensionsValid($options->extensions)) {
            throw new SnifferReportException(
                'One or more extensions are not valid. Please try again with different values',
                400
            );
        }

        $standards = implode(',', $options->standards);
        $extensions = implode(',', $options->extensions);

        $sniff_result = Sniffer::sniffFiles($files, $standards, $extensions);

        // Delete all files that were generated in this request.
        $fs = new Filesystem();
        $fs->remove(FILES_DIRECTORY_ROOT);

        try {
            // @todo: Make class abstract
            $sniffParser = new SniffParser();
            $response = $sniffParser->parseSniff($sniff_result);
        } catch (\PDOException $e) {
            throw new SnifferReportException("Error when trying to save sniff: {$e->getMessage()}", 500);
        }

        return $response;
    }
}