ObjectToPreview - Code Metrics - Inspection of "Transform category key to display value" - cyrrill/apai-io - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a59b2c...523153 )

by Cyril

created 2017-08-01 15:13 UTC

ObjectToPreview C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	230
Duplicated Lines	9.13 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

Importance

Changes	6
Bugs	0	Features	0

Metric	Value
wmc	55
c	6
b	0
f	0
lcom	1
cbo	1
dl	21
loc	230
ccs	0
cts	178
cp	0
rs	6.8

5 Methods

Rating	Name	Duplication	Size	Complexity
B	transform()	0	30	4
A	getItems()	8	8	3
B	getCategories()	0	13	6
D	categoryValue()	0	106	34
C	set()	10	25	8

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like ObjectToPreview often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use ObjectToPreview, and based on these observations, apply Extract Interface, too.

<?php
namespace ApaiIO\ResponseTransformer;

class ObjectToPreview extends ObjectToArray implements ResponseTransformerInterface
{
    /**
     *
     * @var array
     */
    protected $data = [];

    /**
     *
     * @var array
     */
    protected $items = [];

    /**
     *
     * @var array
     */
    protected $categories = [];

    /**
     *
     * @param string $response
     * @return array
     */
    public function transform($response)
    {
        $response = parent::transform($response);

        if (!$this->getItems($response)) {
            return [];
        }

        $this->getCategories($response);

        $c = count($this->items);
        for ($i = 0; $i < $c; $i++) {
            $this->set($i, 'asin', 'ASIN');
            if (!$this->set($i, 'category', 'BrowseNodes', 'BrowseNode', 'Name')) {
                $this->set($i, 'category', 'BrowseNodes', 'BrowseNode', 0, 'Name');
            }
            $this->set($i, 'sales_rank', 'SalesRank');
            $this->set($i, 'title', 'ItemAttributes', 'Title');
            $this->set($i, 'url', 'DetailPageURL');
            $this->set($i, 'manufacturer', 'ItemAttributes', 'Manufacturer');
            $this->set($i, 'large_image', 'LargeImage', 'URL');
            $this->set($i, 'medium_image', 'MediumImage', 'URL');
            $this->set($i, 'small_image', 'SmallImage', 'URL');
        }

        return [
            'items' => $this->data,
            'categories' => $this->categories
        ];
    }

    /**
     *
     * @param type $response
     * @return mixed
     */
    protected function getItems($response)

    {
        if (isset($response['Items']['Item']) AND is_array($response['Items']['Item'])) {
// 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);
            return $this->items = $response['Items']['Item'];
        } else {
            return false;
        }
    }

    /**
     *
     * @param array $response
     */
    protected function getCategories($response)
    {
        if (isset($response['Items']['SearchBinSets']['SearchBinSet']['Bin'])) {
            foreach ($response['Items']['SearchBinSets']['SearchBinSet']['Bin'] as $bin) {
                if (isset($bin['BinParameter']['Name']) && $bin['BinParameter']['Name'] == 'SearchIndex') {
                    $this->categories[] = $this->categoryValue($bin['BinParameter']['Value']);
                }
                if (count($this->categories) >= 10) {
                    return;
                }
            }
        }
    }

    protected function categoryValue($value)
    {
        switch ($value) {
            case 'All':
                return ['key' => $value, 'value' => 'All Departments'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'ArtsAndCrafts':
                return ['key' => $value, 'value' => 'Arts, Crafts & Sewing'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Collectibles':
                return ['key' => $value, 'value' => 'Collectibles & Fine Arts'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Fashion':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'FashionBaby':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry - Baby'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'FashionBoys':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry - Boys'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'FashionGirls':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry - Girls'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'FashionMen':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry - Men'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'FashionWomen':
                return ['key' => $value, 'value' => 'Clothing, Shoes & Jewelry - Women'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'GiftCards':
                return ['key' => $value, 'value' => 'Gift Cards'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Grocery':
                return ['key' => $value, 'value' => 'Grocery & Gourmet Food'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'HealthPersonalCare':
                return ['key' => $value, 'value' => 'Health & Personal Care'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'HomeGarden':
                return ['key' => $value, 'value' => 'Home & Kitchen'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Industrial':
                return ['key' => $value, 'value' => 'Industrial & Scientific'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'KindleStore':
                return ['key' => $value, 'value' => 'Kindle Store'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'LawnAndGarden':
                return ['key' => $value, 'value' => 'Patio, Lawn & Garden'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Luggage':
                return ['key' => $value, 'value' => 'Luggage & Travel Gear'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Magazines':
                return ['key' => $value, 'value' => 'Magazine Subscriptions'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'MobileApps':
                return ['key' => $value, 'value' => 'Apps & Games'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Movies':
                return ['key' => $value, 'value' => 'Movies & TV'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'MP3Downloads':
                return ['key' => $value, 'value' => 'Digital Music'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Music':
                return ['key' => $value, 'value' => 'CDs & Vinyl'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'MusicalInstruments':
                return ['key' => $value, 'value' => 'Musical Instruments'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'OfficeProducts':
                return ['key' => $value, 'value' => 'Office Products'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Pantry':
                return ['key' => $value, 'value' => 'Prime Pantry'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'PCHardware':
                return ['key' => $value, 'value' => 'Computers'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'PetSupplies':
                return ['key' => $value, 'value' => 'Pet Supplies'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'SportingGoods':
                return ['key' => $value, 'value' => 'Sports & Outdoors'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Tools':
                return ['key' => $value, 'value' => 'Tools & Home Improvement'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Toys':
                return ['key' => $value, 'value' => 'Toys & Games'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'UnboxVideo':
                return ['key' => $value, 'value' => 'Amazon Instant Video'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'VideoGames':
                return ['key' => $value, 'value' => 'Video Games'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'Wireless':
                return ['key' => $value, 'value' => 'Cell Phones & Accessories'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            default:
                return ['key' => $value, 'value' => $value];
        }
    }

    /**
     *
     * @param int $i
     * @param string $data
     * @param string $key1
     * @param string $key2
     * @param string $key3
     * @param string $key4
     */
    protected function set($i, $data, $key1, $key2 = null, $key3 = null, $key4 = null)
    {
        if ($key4 !== null) {
            if (isset($this->items[$i][$key1][$key2][$key3][$key4])) {

                $this->data[$i][$data] = $this->items[$i][$key1][$key2][$key3][$key4];
                return true;
            }
        } elseif ($key3 !== null) {

            if (isset($this->items[$i][$key1][$key2][$key3])) {
                $this->data[$i][$data] = $this->items[$i][$key1][$key2][$key3];
                return true;
            }
        } elseif ($key2 !== null) {
            if (isset($this->items[$i][$key1][$key2])) {
                $this->data[$i][$data] = $this->items[$i][$key1][$key2];
                return true;
            }
        } else {
            if (isset($this->items[$i][$key1])) {
                $this->data[$i][$data] = $this->items[$i][$key1];
                return true;
            }
        }
        return false;
    }
}


cyrrill / apai-io