DuckDuckGo::run() - Code Metrics - aszone/search-hacking - Measure and Improve Code Quality continuously with Scrutinizer

DuckDuckGo::run() C
last analyzed 2016-10-21 02:13 UTC

↳ Parent: DuckDuckGo

Complexity

Conditions	13
Paths	85

Size

Total Lines	81
Code Lines	55

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	81
rs	5.0112
c	0
b	0
f	0
cc	13
eloc	55
nc	85
nop	0

How to fix Long Method Complexity

<?php
/**
 * Created by PhpStorm.
 * User: lenon
 * Date: 23/04/16
 * Time: 01:43.
 */

namespace Aszone\SearchHacking\Engines;

use Aszone\SearchHacking\Utils;

class DuckDuckGo extends Engine
{
    public function run()
    {
        $exit = false;
        $count = 0;
        $numPaginator = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $countProxyVirgin = rand(0, count($this->listOfVirginProxies) - 1);
        $resultFinal = array();
        $countError = 0;

        $numberForUrl = $this->getNumberForUrl();

        while ($exit == false) {

            switch ($count) {
                case 0:
                    $numPaginator = 0;
                    break;
                case 1:
                    $numPaginator = 30;
                    break;
                case 2:
                    $numPaginator = 80;
                    break;
                case 3:
                    $numPaginator = 130;
                    break;
                case 4:
                    $numPaginator = 180;
                    break;
                default:
                    $numPaginator = 230;
                    break;

            }

            $urlOfSearch = 'https://duckduckgo.com/d.js?q='.urlencode($this->commandData['dork']).'&ct=BR&ss_mkt=us&sp=1&l=wt-wt&vqd='.$numberForUrl.'&p=1&s='.$numPaginator;

            $this->output('Page '.$count."\n");

            if ($this->commandData['virginProxies']) {
                $body = Utils::getBodyByVirginProxies($urlOfSearch, $this->listOfVirginProxies[$countProxyVirgin], $this->proxy);

                $arrLinks = $this->getLinks($body);

                if ($this->checkReturnError($body)) {
                    $this->output("You has a problem with proxy, probaly you stress the engenier ...\n");
                    --$count;
                    ++$countError;
                    if ($countError == 4) {
                        $exit = true;
                    }
                } else {
                    $countError = 0;
                }

                //Check if next virgin proxy or repeat of 0
                if ($countProxyVirgin == count($this->listOfVirginProxies) - 1) {
                    $countProxyVirgin = 0;
                } else {
                    ++$countProxyVirgin;
                }
            } else {
                $body = Utils::getBody($urlOfSearch, $this->proxy);

                $arrLinks = $this->getLinks($body);
            }

            $this->output("\n".$urlOfSearch."\n");

            $results = $this->sanitazeLinks($arrLinks);

            if ((count($results) == 0 and $body != 'repeat')) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                $exit = true;
            }

            $resultFinal = array_merge($resultFinal, $results);

            ++$count;
        }

        return $resultFinal;
    }

    private function getNumberForUrl()
    {
        $firstUrlOfSearch = 'https://duckduckgo.com/?q='.urlencode($this->commandData['dork']).'&search_plus_one=form&ia=web';
        $body = Utils::getBody($firstUrlOfSearch, $this->proxy);

        $validXmlrpc = preg_match("/','.*&vqd=(.*?)&/", $body, $matches, PREG_OFFSET_CAPTURE);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if (isset($matches[1][0])) {
            return $matches[1][0];
        }

        return false;
    }

    public function sanitazeLinks($links = array())

    {
        $hrefs = array();

        if (!empty($links)) {
            foreach ($links as $keyLink => $valueLink) {
                $validResultOfBlackList = Utils::checkBlacklist($valueLink);
                if (!$validResultOfBlackList and $valueLink) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                    $hrefs[] = $valueLink;
                }
            }

            $hrefs = array_unique($hrefs);
        }

        return $hrefs;
    }

    public function getLinks($body)
    {
        $result = [];
        $validXmlrpc = preg_match("/DDG\.Data\.languages\.resultLanguages', (.*?)\);if/", $body, $matches, PREG_OFFSET_CAPTURE);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if (isset($matches[1][0])) {
            $resultJson = json_decode($matches[1][0]);
            foreach ($resultJson as $resultsByLanguage) {
                foreach ($resultsByLanguage as $resultByLanguage) {
                    $result[] = $resultByLanguage;
                }
            }
        }

        return $result;
    }

    public function checkReturnError($body)
    {
        $valid = preg_match("/Dvar q=window\.location\.href\.indexOf/", $body, $matches, PREG_OFFSET_CAPTURE);

        if ($valid) {
            return true;
        }

        return false;
    }
}


DuckDuckGo::run() C
last analyzed 2016-10-21 02:13 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

aszone / search-hacking

DuckDuckGo::run() C last analyzed 2016-10-21 02:13 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

DuckDuckGo::run() C
last analyzed 2016-10-21 02:13 UTC