Showing 207 of 222 total issues
File Condition.php
has 333 lines of code (exceeds 250 allowed). Consider refactoring. Open
<?php
declare(strict_types=1);
namespace Atk4\Data\Model\Scope;
- Create a ticketCreate a ticket
Function initQueryFields
has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring. Open
public function initQueryFields(Model $model, Query $query, ?array $fields = null): void
{
// init fields
if ($fields !== null) {
// set of fields is strictly defined, so we will ignore even system fields
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Expression
has 31 functions (exceeds 20 allowed). Consider refactoring. Open
abstract class Expression implements Expressionable, \ArrayAccess
{
use DiContainerTrait;
/** "[]" in template, escape as parameter */
- Create a ticketCreate a ticket
Sql
has 31 functions (exceeds 20 allowed). Consider refactoring. Open
class Sql extends Persistence
{
use Sql\BinaryTypeCompatibilityTypecastTrait;
public const HOOK_INIT_SELECT_QUERY = self::class . '@initSelectQuery';
- Create a ticketCreate a ticket
File Array_.php
has 326 lines of code (exceeds 250 allowed). Consider refactoring. Open
<?php
declare(strict_types=1);
namespace Atk4\Data\Persistence;
- Create a ticketCreate a ticket
Function getDb
has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring. Open
public function getDb(?array $tableNames = null, bool $noId = false): array
{
if ($tableNames === null) {
$tableNames = [];
foreach ($this->createdMigrators as $migrator) {
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method normalize
has 92 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function normalize($value)
{
try {
if ($this->issetOwner() && $this->getOwner()->hook(Model::HOOK_NORMALIZE, [$this, $value]) === false) {
return $value;
- Create a ticketCreate a ticket
Function valueToWords
has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring. Open
protected function valueToWords(Model $model, $value): string
{
if ($value === null) {
return $this->operator
? 'empty'
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method _copy
has 84 lines of code (exceeds 25 allowed). Consider refactoring. Open
protected function _copy(Model $source, Model $destination, array $references, array $exclusions, array $transforms): Model
{
try {
$sourceTable = $source->getModel()->table;
- Create a ticketCreate a ticket
Consider simplifying this complex logical expression. Open
if ($matches[3] === 'BOOLEAN' && ($types[$k] === ParameterType::BOOLEAN || $types[$k] === ParameterType::INTEGER)
&& (is_bool($params[$k]) || $params[$k] === '0' || $params[$k] === '1')
) {
$types[$k] = ParameterType::BOOLEAN;
$params[$k] = (bool) $params[$k];
- Create a ticketCreate a ticket
Function escapeStringLiteral
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
protected function escapeStringLiteral(string $value): string
{
$platform = $this->connection->getDatabasePlatform();
if ($platform instanceof PostgreSQLPlatform || $platform instanceof SQLServerPlatform) {
$dummyPersistence = new Persistence\Sql($this->connection);
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function listSequences
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
protected function listSequences(): array
{
if (version_compare(Connection::getDriverVersion(), '3.37') < 0) {
$listAllSchemasSql = (new Query())
->table('pragma_database_list')
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _typecastPreField
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
private function _typecastPreField(Field $field, $value, bool $fromLoad)
{
if (is_string($value)) {
switch ($field->type) {
case 'boolean':
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File Field.php
has 302 lines of code (exceeds 250 allowed). Consider refactoring. Open
<?php
declare(strict_types=1);
namespace Atk4\Data;
- Create a ticketCreate a ticket
Method __construct
has 80 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function __construct(array $data = [])
{
if (count($data) > 0 && !is_array(reset($data))) {
$dataOrig = $data;
$data = [];
- Create a ticketCreate a ticket
Method action
has 75 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function action(Model $model, string $type, array $args = [])
{
switch ($type) {
case 'select':
$query = $this->initQuery($model);
- Create a ticketCreate a ticket
Function _renderConditionBinary
has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring. Open
#[\Override]
protected function _renderConditionBinary(string $operator, string $sqlLeft, string $sqlRight): string
{
/** @var bool */
$allowCastLeft = true;
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method save
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function save(array $data = [])
{
$this->getModel()->assertIsWriteable();
$this->getModel()->assertHasPersistence();
- Create a ticketCreate a ticket
Function __construct
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public function __construct($field, $operator = null, $value = null)
{
if ($field instanceof AbstractScope) {
throw new Exception('Only Scope can contain another conditions');
} elseif ($field instanceof Field) { // for BC
- Read upRead up
- Create a ticketCreate a ticket
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
File Reference.php
has 281 lines of code (exceeds 250 allowed). Consider refactoring. Open
<?php
declare(strict_types=1);
namespace Atk4\Data;
- Create a ticketCreate a ticket