ExportVariable::getFields() - Code Metrics - boboldehampsink/export - Measure and Improve Code Quality continuously with Scrutinizer

ExportVariable::getFields() A
last analyzed 2016-03-02 09:25 UTC

↳ Parent: ExportVariable

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	2	Features	2

Metric	Value
c	5
b	2
f	2
dl	0
loc	18
rs	9.4285
cc	2
eloc	7
nc	2
nop	2

<?php

namespace Craft;

/**
 * Export variable.
 *
 * Acts as a bridge between services and templates.
 *
 * @author    Bob Olde Hampsink <[email protected]>
 * @copyright Copyright (c) 2015, Bob Olde Hampsink
 * @license   MIT
 *
 * @link      http://github.com/boboldehampsink
 */
class ExportVariable
{
    /**
     * Return "groups" (section, groups, etc.).
     *
     * @param string $elementType
     *
     * @return array|bool
     */
    public function getGroups($elementType)
    {
        // Check if elementtype can be imported
        if ($service = craft()->export->getService($elementType)) {

            // Return "groups" (section, groups, etc.)

            return $service->getGroups();
        }

        return false;
    }

    /**
     * Get template for service.
     *
     * @param string $elementType
     *
     * @return array|bool
     */
    public function getTemplate($elementType)
    {
        // Check if elementtype can be imported
        if ($service = craft()->export->getService($elementType)) {

            // Return template
            return $service->getTemplate();
        }

        return false;
    }

    /**
     * Get fields of elementType.
     *
     * @param string $elementType
     * @param bool   $reset
     *
     * @return array
     */
    public function getFields($elementType, $reset)
    {
        // Get export vars
        $export = craft()->request->getParam('export');

        // Unset non-map settings
        unset($export['limit'], $export['offset']);
        ksort($export);

        // Check if elementtype can be imported
        if ($service = craft()->export->getService($elementType)) {

            // Return fields of elementType
            return $service->getFields($export, $reset);
        }

        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Get path to fieldtype's custom table row template.
     *
     * @param string $fieldHandle
     *
     * @return string
     */
    public function customTableRow($fieldHandle)
    {
        // Return custom <tr> for template
        return craft()->export->getCustomTableRow($fieldHandle);
    }
}


1			<?php
2
3			namespace Craft;
4
5			/**
6			* Export variable.
7			*
8			* Acts as a bridge between services and templates.
9			*
10			* @author Bob Olde Hampsink <[email protected]>
11			* @copyright Copyright (c) 2015, Bob Olde Hampsink
12			* @license MIT
13			*
14			* @link http://github.com/boboldehampsink
15			*/
16			class ExportVariable
17			{
18			/**
19			* Return "groups" (section, groups, etc.).
20			*
21			* @param string $elementType
22			*
23			* @return array\|bool
24			*/
25			public function getGroups($elementType)
26			{
27			// Check if elementtype can be imported
28			if ($service = craft()->export->getService($elementType)) {
29
30			// Return "groups" (section, groups, etc.)
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-02-23 14:15 UTC by Report Bug Copy Issue Report `40%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
31			return $service->getGroups();
32			}
33
34			return false;
35			}
36
37			/**
38			* Get template for service.
39			*
40			* @param string $elementType
41			*
42			* @return array\|bool
43			*/
44			public function getTemplate($elementType)
45			{
46			// Check if elementtype can be imported
47			if ($service = craft()->export->getService($elementType)) {
48
49			// Return template
50			return $service->getTemplate();
51			}
52
53			return false;
54			}
55
56			/**
57			* Get fields of elementType.
58			*
59			* @param string $elementType
60			* @param bool $reset
61			*
62			* @return array
63			*/
64			public function getFields($elementType, $reset)
65			{
66			// Get export vars
67			$export = craft()->request->getParam('export');
68
69			// Unset non-map settings
70			unset($export['limit'], $export['offset']);
71			ksort($export);
72
73			// Check if elementtype can be imported
74			if ($service = craft()->export->getService($elementType)) {
75
76			// Return fields of elementType
77			return $service->getFields($export, $reset);
78			}
79
80			return false;
			0 ignored issues – show Bug Best Practice introduced 2016-02-23 14:15 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type documented by `Craft\ExportVariable::getFields` of type `array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
81			}
82
83			/**
84			* Get path to fieldtype's custom table row template.
85			*
86			* @param string $fieldHandle
87			*
88			* @return string
89			*/
90			public function customTableRow($fieldHandle)
91			{
92			// Return custom <tr> for template
93			return craft()->export->getCustomTableRow($fieldHandle);
94			}
95			}
96

boboldehampsink / export

GitHub Access Token became invalid

ExportVariable::getFields() A last analyzed 2016-03-02 09:25 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ExportVariable::getFields() A
last analyzed 2016-03-02 09:25 UTC