Drupal7Placeholder::entityLoad() - Code Metrics - Inspection of "Add Drupal 8 support" - BR0kEN-/TqExtension - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#16)

by Sergii

created 2017-02-08 09:21 UTC

Drupal7Placeholder::entityLoad() A

↳ Parent: Drupal7Placeholder

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	3
nc	2
nop	2

<?php
/**
 * @author Sergii Bondarenko, <[email protected]>
 */
namespace Drupal\TqExtension\Cores;

use Behat\Behat\Hook\Scope\BeforeFeatureScope;
use Drupal\TqExtension\Utils\Database\FetchField;

final class Drupal7Placeholder extends DrupalKernelPlaceholder
{
    /**
     * {@inheritdoc}
     */
    public static function beforeFeature(BeforeFeatureScope $scope)
    {
        // Set to "false", because the administration menu will not be rendered.
        // @see https://www.drupal.org/node/2023625#comment-8607207
        variable_set('admin_menu_cache_client', false);
    }

    /**
     * {@inheritdoc}
     */
    public static function t($string, array $arguments = [], array $options = [])
    {
        return t($string, $arguments, $options);
    }

    /**
     * {@inheritdoc}
     */
    public static function formatString($string, array $arguments = [])
    {
        return format_string($string, $arguments);
    }

    /**
     * {@inheritdoc}
     */
    public static function arg()
    {
        return arg();
    }

    /**
     * {@inheritdoc}
     */
    public static function tokenReplace($text, array $data = [], array $options = [])
    {
        return token_replace($text, $data, $options);
    }

    /**
     * {@inheritdoc}
     */
    public static function jsonEncode($data)
    {
        return drupal_json_encode($data);
    }

    /**
     * {@inheritdoc}
     *
     * @return \stdClass
     */
    public static function getCurrentUser()
    {
        return $GLOBALS['user'];
    }

    /**
     * {@inheritdoc}
     *
     * @param \stdClass $user
     */
    public static function setCurrentUser($user)
    {
        $GLOBALS['user'] = $user;
    }

    /**
     * {@inheritdoc}
     */
    public static function setCurrentPath($path)
    {
        $_GET['q'] = $path;
    }

    /**
     * {@inheritdoc}
     */
    public static function getUidByName($username)
    {
        return (int) (new FetchField('users', 'uid'))
            ->condition('name', $username)
            ->execute();
    }

    /**
     * {@inheritdoc}
     */
    public static function deleteUser($user_id)
    {
        user_delete($user_id);
    }

    /**
     * {@inheritdoc}
     *
     * @return \SelectQuery
     */
    public static function selectQuery($table, $alias = null, array $options = [])
    {
        return db_select($table, $alias, $options);
    }

    /**
     * {@inheritdoc}
     */
    public static function getFieldDefinitions($entityType, $bundle)
    {
        // Load entity properties because in Drupal 8 they are assumed as regular fields.
        $entityProperties = entity_get_property_info($entityType);
        $fieldInstances = field_info_instances($entityType, $bundle);
        $definitions = [];

        if (!empty($entityProperties['properties'])) {
            $fieldInstances += $entityProperties['properties'];
        }

        foreach ($fieldInstances as $name => $definition) {
            $definitions[$name] = [
                'label' => $definition['label'],
                'required' => !empty($definition['required']),
            ];
        }

        return $definitions;
    }

    /**
     * {@inheritdoc}
     */
    public static function getDatabaseConnectionInfo($connection)
    {
        return \Database::getConnectionInfo($connection);
    }

    /**
     * {@inheritdoc}
     */
    public static function entityCreate($entityType, array $values)
    {
        $entity = entity_create($entityType, $values);

        entity_save($entityType, $entity);
        list($entityId, , $bundle) = entity_extract_ids($entityType, $entity);

        return [$entityId, $entityType, $bundle];
    }

    /**
     * {@inheritdoc}
     */
    public static function entityLoad($entityType, $id)
    {
        $entities = entity_load($entityType, [$id]);

        return empty($entities) ? null : reset($entities);
    }

    /**
     * {@inheritdoc}
     */
    public static function entityHasField($entity, $fieldName)
    {
        return isset($entity->{$fieldName});
    }

    /**
     * {@inheritdoc}
     *
     * @param \EntityDrupalWrapper $entity
     */
    public static function entityFieldValue($entity, $fieldName)
    {
        if ($entity instanceof \EntityDrupalWrapper) {
            return $entity->{$fieldName}->value();
        }

        throw new \InvalidArgumentException(sprintf(
            'First argument for "%s" method must be of "%s" type.',
            __METHOD__,
            \EntityDrupalWrapper::class
        ));
    }

    /**
     * {@inheritdoc}
     */
    public static function switchMailSystem($useTesting)
    {
        static $original = [
            'default-system' => 'DefaultMailSystem',
        ];

        if ($useTesting) {
            // Store original mail system to restore it after scenario.
            $original = variable_get('mail_system', $original);
            // Set the mail system for testing. It will store an emails in
            // "drupal_test_email_collector" Drupal variable instead of sending.
            $value = array_merge($original, [
                'default-system' => 'TestingMailSystem',
            ]);
        } else {
            // Bring back the original mail system.
            $value = $original;
            // Flush the email buffer to be able to reuse it from scratch.
            // @see \TestingMailSystem
            variable_set('drupal_test_email_collector', []);
        }

        variable_set('mail_system', $value);
    }

    /**
     * {@inheritdoc}
     */
    public static function getEmailMessages()
    {
        // We can't use variable_get() because Behat has another bootstrapped
        // variable $conf that is not updated from cURL bootstrapped Drupal instance.
        $result = (new FetchField('variable', 'value'))
            ->condition('name', 'drupal_test_email_collector')
            ->execute();

        return empty($result) ? [] : unserialize($result);
    }

    /**
     * {@inheritdoc}
     */
    public static function getContentTypeName($contentType)
    {
        if (isset(node_type_get_types()[$contentType])) {
            return $contentType;
        }

        return (string) (new FetchField('node_type', 'type'))
            ->condition('name', $contentType)
            ->execute();
    }
}


1			<?php
2			/**
3			* @author Sergii Bondarenko, <[email protected]>
4			*/
5			namespace Drupal\TqExtension\Cores;
6
7			use Behat\Behat\Hook\Scope\BeforeFeatureScope;
8			use Drupal\TqExtension\Utils\Database\FetchField;
9
10			final class Drupal7Placeholder extends DrupalKernelPlaceholder
11			{
12			/**
13			* {@inheritdoc}
14			*/
15			public static function beforeFeature(BeforeFeatureScope $scope)
16			{
17			// Set to "false", because the administration menu will not be rendered.
18			// @see https://www.drupal.org/node/2023625#comment-8607207
19			variable_set('admin_menu_cache_client', false);
20			}
21
22			/**
23			* {@inheritdoc}
24			*/
25			public static function t($string, array $arguments = [], array $options = [])
26			{
27			return t($string, $arguments, $options);
28			}
29
30			/**
31			* {@inheritdoc}
32			*/
33			public static function formatString($string, array $arguments = [])
34			{
35			return format_string($string, $arguments);
36			}
37
38			/**
39			* {@inheritdoc}
40			*/
41			public static function arg()
42			{
43			return arg();
44			}
45
46			/**
47			* {@inheritdoc}
48			*/
49			public static function tokenReplace($text, array $data = [], array $options = [])
50			{
51			return token_replace($text, $data, $options);
52			}
53
54			/**
55			* {@inheritdoc}
56			*/
57			public static function jsonEncode($data)
58			{
59			return drupal_json_encode($data);
60			}
61
62			/**
63			* {@inheritdoc}
64			*
65			* @return \stdClass
66			*/
67			public static function getCurrentUser()
68			{
69			return $GLOBALS['user'];
70			}
71
72			/**
73			* {@inheritdoc}
74			*
75			* @param \stdClass $user
76			*/
77			public static function setCurrentUser($user)
78			{
79			$GLOBALS['user'] = $user;
80			}
81
82			/**
83			* {@inheritdoc}
84			*/
85			public static function setCurrentPath($path)
86			{
87			$_GET['q'] = $path;
88			}
89
90			/**
91			* {@inheritdoc}
92			*/
93			public static function getUidByName($username)
94			{
95			return (int) (new FetchField('users', 'uid'))
96			->condition('name', $username)
97			->execute();
98			}
99
100			/**
101			* {@inheritdoc}
102			*/
103			public static function deleteUser($user_id)
104			{
105			user_delete($user_id);
106			}
107
108			/**
109			* {@inheritdoc}
110			*
111			* @return \SelectQuery
112			*/
113			public static function selectQuery($table, $alias = null, array $options = [])
114			{
115			return db_select($table, $alias, $options);
116			}
117
118			/**
119			* {@inheritdoc}
120			*/
121			public static function getFieldDefinitions($entityType, $bundle)
122			{
123			// Load entity properties because in Drupal 8 they are assumed as regular fields.
124			$entityProperties = entity_get_property_info($entityType);
125			$fieldInstances = field_info_instances($entityType, $bundle);
126			$definitions = [];
127
128			if (!empty($entityProperties['properties'])) {
129			$fieldInstances += $entityProperties['properties'];
130			}
131
132			foreach ($fieldInstances as $name => $definition) {
133			$definitions[$name] = [
134			'label' => $definition['label'],
135			'required' => !empty($definition['required']),
136			];
137			}
138
139			return $definitions;
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public static function getDatabaseConnectionInfo($connection)
146			{
147			return \Database::getConnectionInfo($connection);
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153			public static function entityCreate($entityType, array $values)
154			{
155			$entity = entity_create($entityType, $values);
156
157			entity_save($entityType, $entity);
158			list($entityId, , $bundle) = entity_extract_ids($entityType, $entity);
159
160			return [$entityId, $entityType, $bundle];
161			}
162
163			/**
164			* {@inheritdoc}
165			*/
166			public static function entityLoad($entityType, $id)
167			{
168			$entities = entity_load($entityType, [$id]);
169
170			return empty($entities) ? null : reset($entities);
171			}
172
173			/**
174			* {@inheritdoc}
175			*/
176			public static function entityHasField($entity, $fieldName)
177			{
178			return isset($entity->{$fieldName});
179			}
180
181			/**
182			* {@inheritdoc}
183			*
184			* @param \EntityDrupalWrapper $entity
185			*/
186			public static function entityFieldValue($entity, $fieldName)
187			{
188			if ($entity instanceof \EntityDrupalWrapper) {
189			return $entity->{$fieldName}->value();
190			}
191
192			throw new \InvalidArgumentException(sprintf(
193			'First argument for "%s" method must be of "%s" type.',
194			__METHOD__,
195			\EntityDrupalWrapper::class
196			));
197			}
198
199			/**
200			* {@inheritdoc}
201			*/
202			public static function switchMailSystem($useTesting)
203			{
204			static $original = [
205			'default-system' => 'DefaultMailSystem',
206			];
207
208			if ($useTesting) {
209			// Store original mail system to restore it after scenario.
210			$original = variable_get('mail_system', $original);
211			// Set the mail system for testing. It will store an emails in
212			// "drupal_test_email_collector" Drupal variable instead of sending.
213			$value = array_merge($original, [
214			'default-system' => 'TestingMailSystem',
215			]);
216			} else {
217			// Bring back the original mail system.
218			$value = $original;
219			// Flush the email buffer to be able to reuse it from scratch.
220			// @see \TestingMailSystem
221			variable_set('drupal_test_email_collector', []);
222			}
223
224			variable_set('mail_system', $value);
225			}
226
227			/**
228			* {@inheritdoc}
229			*/
230			public static function getEmailMessages()
231			{
232			// We can't use variable_get() because Behat has another bootstrapped
233			// variable $conf that is not updated from cURL bootstrapped Drupal instance.
234			$result = (new FetchField('variable', 'value'))
235			->condition('name', 'drupal_test_email_collector')
236			->execute();
237
238			return empty($result) ? [] : unserialize($result);
239			}
240
241			/**
242			* {@inheritdoc}
243			*/
244			public static function getContentTypeName($contentType)
245			{
246			if (isset(node_type_get_types()[$contentType])) {
247			return $contentType;
248			}
249
250			return (string) (new FetchField('node_type', 'type'))
251			->condition('name', $contentType)
252			->execute();
253			}
254			}
255

BR0kEN- / TqExtension

Pull Request — master (#16)

Drupal7Placeholder::entityLoad() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like