RoutineLoaderHelper::updateSourceTypeHints() - Code Metrics - Inspection of "Align type hints." - DatabaseStratum/php-stratum-mysql - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( caf7cf...f71b04 )

by P.R.
created 2024-08-14 09:02 UTC
RoutineLoaderHelper::updateSourceTypeHints() D

↳ Parent: RoutineLoaderHelper
Complexity

Conditions	14
Paths	182
Size

Total Lines	124
Code Lines	84
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	210
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	14
eloc	84
c	1
b	0
f	0
nc	182
nop	0
dl	0
loc	124
ccs	0
cts	0
cp	0
crap	210
rs	4.8157
How to fix Long Method Complexity

<?php
declare(strict_types=1);

namespace SetBased\Stratum\MySql\Helper;

use SetBased\Exception\FallenException;
use SetBased\Helper\Cast;
use SetBased\Helper\InvalidCastException;
use SetBased\Stratum\Backend\StratumStyle;
use SetBased\Stratum\Common\DocBlock\DocBlockReflection;
use SetBased\Stratum\Common\Exception\RoutineLoaderException;
use SetBased\Stratum\Common\Helper\Util;
use SetBased\Stratum\Middle\Exception\ResultException;
use SetBased\Stratum\MySql\Exception\MySqlQueryErrorException;
use SetBased\Stratum\MySql\MySqlMetaDataLayer;
use Symfony\Component\Console\Formatter\OutputFormatter;

/**
 * Class for loading a single stored routine into a MySQL instance from pseudo SQL file.
 */
class RoutineLoaderHelper
{
  //--------------------------------------------------------------------------------------------------------------------
  /**
   * MySQL's and MariaDB's SQL/PSM syntax.
   */
  const SQL_PSM_SYNTAX = 1;

  /**
   * Oracle PL/SQL syntax.
   */
  const PL_SQL_SYNTAX = 2;

  /**
   * The revision of the metadata of the stored routines.
   */
  const METADATA_REVISION = '4';

  /**
   * The metadata of the table columns of the table for bulk insert.
   *
   * @var array[]
   */
  private array $bulkInsertColumns;

  /**
   * The keys in the nested array for bulk inserting data.
   *
   * @var string[]
   */
  private array $bulkInsertKeys;

  /**
   * The name of table for bulk insert.
   *
   * @var string
   */
  private string $bulkInsertTableName;

  /**
   * The default character set under which the stored routine will be loaded and run.
   *
   * @var string
   */
  private string $characterSet;

  /**
   * The default collate under which the stored routine will be loaded and run.
   *
   * @var string
   */
  private string $collate;

  /**
   * The designation type of the stored routine.
   *
   * @var string
   */
  private string $designationType;

  /**
   * The meta data layer.
   *
   * @var MySqlMetaDataLayer
   */
  private MySqlMetaDataLayer $dl;

  /**
   * The DocBlock reflection object.
   *
   * @var DocBlockReflection|null
   */
  private ?DocBlockReflection $docBlockReflection;

  /**
   * The last modification time of the source file.
   *
   * @var int
   */
  private int $filemtime;

  /**
   * The key or index columns (depending on the designation type) of the stored routine.
   *
   * @var string[]
   */
  private array $indexColumns;

  /**
   * The Output decorator.
   *
   * @var StratumStyle
   */
  private StratumStyle $io;

  /**
   * The metadata of the stored routine. Note: this data is stored in the metadata file and is generated by PhpStratum.
   *
   * @var array
   */
  private array $phpStratumMetadata;

  /**
   * The old metadata of the stored routine.  Note: this data comes from the metadata file.
   *
   * @var array
   */
  private array $phpStratumOldMetadata;

  /**
   * A map from all possible placeholders to their actual values.
   *
   * @var array
   */
  private array $placeholderPool;

  /**
   * A map from placeholders that are actually used in the stored routine to their values.
   *
   * @var array
   */
  private array $placeholders = [];

  /**
   * The old metadata of the stored routine. Note: this data comes from information_schema.ROUTINES.
   *
   * @var array
   */
  private array $rdbmsOldRoutineMetadata;

  /**
   * The return type of the stored routine (only if designation type singleton0, singleton1, or function).
   *
   * @var string|null
   */
  private ?string $returnType = null;

  /**
   * The name of the stored routine.
   *
   * @var string
   */
  private string $routineName;

  /**
   * The routine parameters.
   *
   * @var RoutineParametersHelper|null
   */
  private ?RoutineParametersHelper $routineParameters = null;

  /**
   * The source code as a single string of the stored routine.
   *
   * @var string
   */
  private string $routineSourceCode;

  /**
   * The source code as an array of lines string of the stored routine.
   *
   * @var array
   */
  private array $routineSourceCodeLines;

  /**
   * The source filename holding the stored routine.
   *
   * @var string
   */
  private string $sourceFilename;

  /**
   * The SQL mode helper object.
   *
   * @var SqlModeHelper
   */
  private SqlModeHelper $sqlModeHelper;

  /**
   * The syntax of the stored routine. Either SQL_PSM_SYNTAX or PL_SQL_SYNTAX.
   *
   * @var int
   */
  private int $syntax;

  /**
   * A map from all possible table and column names to their actual column type.
   *
   * @var array
   */
  private array $typeHintPool;

  /**
   * A map from the table and column names that are actually use as type hint in the stored routine to their actual
   * column type.
   *
   * @var array
   */
  private array $typeHints = [];

  //--------------------------------------------------------------------------------------------------------------------

  /**
   * Object constructor.
   *
   * @param MySqlMetaDataLayer $dl                      The meta data layer.
   * @param StratumStyle       $io                      The output for log messages.
   * @param SqlModeHelper      $sqlModeHelper
   * @param string             $routineFilename         The filename of the source of the stored routine.
   * @param array              $phpStratumMetadata      The metadata of the stored routine from PhpStratum.
   * @param array              $placeholderPool         A map from placeholders to their actual values.
   * @param array              $typeHintPool            A map from type hints to their actual types.
   * @param array              $rdbmsOldRoutineMetadata The old metadata of the stored routine from MySQL.
   * @param string             $characterSet            The default character set under which the stored routine will
   *                                                    be loaded and run.
   * @param string             $collate                 The key or index columns (depending on the designation type) of
   *                                                    the stored routine.
   */
  public function __construct(MySqlMetaDataLayer $dl,
                              StratumStyle       $io,
                              SqlModeHelper      $sqlModeHelper,
                              string             $routineFilename,
                              array              $phpStratumMetadata,
                              array              $placeholderPool,
                              array              $typeHintPool,
                              array              $rdbmsOldRoutineMetadata,
                              string             $characterSet,
                              string             $collate)
  {
    $this->dl                      = $dl;
    $this->io                      = $io;
    $this->sqlModeHelper           = $sqlModeHelper;
    $this->sourceFilename          = $routineFilename;
    $this->phpStratumMetadata      = $phpStratumMetadata;
    $this->placeholderPool         = $placeholderPool;
    $this->typeHintPool            = $typeHintPool;
    $this->rdbmsOldRoutineMetadata = $rdbmsOldRoutineMetadata;
    $this->characterSet            = $characterSet;
    $this->collate                 = $collate;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extract column metadata from the rows returned by the SQL statement 'describe table'.
   *
   * @param array $description The description of the table.
   *
   * @return array
   *
   * @throws InvalidCastException
   */
  private static function extractColumnsFromTableDescription(array $description): array
  {
    $ret = [];

    foreach ($description as $column)
    {
      preg_match('/^(?<data_type>\w+)(?<extra>.*)?$/', $column['Type'], $parts1);

      $tmp = ['column_name'       => $column['Field'],
              'data_type'         => $parts1['data_type'],
              'numeric_precision' => null,
              'numeric_scale'     => null,
              'dtd_identifier'    => $column['Type']];

      switch ($parts1[1])
      {
        case 'tinyint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 4);
          $tmp['numeric_scale']     = 0;
          break;

        case 'smallint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 6);
          $tmp['numeric_scale']     = 0;
          break;

        case 'mediumint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 9);
          $tmp['numeric_scale']     = 0;
          break;

        case 'int':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 11);
          $tmp['numeric_scale']     = 0;
          break;

        case 'bigint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 20);
          $tmp['numeric_scale']     = 0;
          break;

        case 'year':
          // Nothing to do.
          break;

        case 'float':
          $tmp['numeric_precision'] = 12;
          break;

        case 'double':
          $tmp['numeric_precision'] = 22;
          break;

        case 'binary':
        case 'char':
        case 'varbinary':
        case 'varchar':
          // Nothing to do (binary) strings.
          break;

        case 'decimal':
          preg_match('/^\((?<precision>\d+),(<?scale>\d+)\)$/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 65);
          $tmp['numeric_scale']     = Cast::toManInt($parts2['scale'] ?? 0);
          break;

        case 'time':
        case 'timestamp':
        case 'date':
        case 'datetime':
          // Nothing to do date and time.
          break;

        case 'enum':
        case 'set':
          // Nothing to do sets.
          break;

        case 'bit':
          preg_match('/^\((?<precision>\d+)\)$/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision']);
          break;

        case 'tinytext':
        case 'text':
        case 'mediumtext':
        case 'longtext':
        case 'tinyblob':
        case 'blob':
        case 'mediumblob':
        case 'longblob':
          // Nothing to do CLOBs and BLOBs.
          break;

        default:
          throw new FallenException('data type', $parts1[1]);
      }

      $ret[] = $tmp;
    }

    return $ret;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Loads the stored routine into the instance of MySQL and returns the metadata of the stored routine.
   *
   * @return array
   *
   * @throws RoutineLoaderException
   * @throws MySqlQueryErrorException
   * @throws ResultException
   * @throws InvalidCastException
   */
  public function loadStoredRoutine(): array
  {
    $this->routineName           = pathinfo($this->sourceFilename, PATHINFO_FILENAME);
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    $this->phpStratumOldMetadata = $this->phpStratumMetadata;
    $this->filemtime             = filemtime($this->sourceFilename);

    $load = $this->mustLoadStoredRoutine();
    if ($load)
    {
      $this->io->text(sprintf('Loading routine <dbo>%s</dbo>', OutputFormatter::escape($this->routineName)));

      $this->readSourceCode();
      $this->updateSourceTypeHints();
      $this->extractPlaceholders();
      $this->extractDesignationType();
      $this->extractReturnType();
      $this->extractRoutineTypeAndName();
      $this->extractSyntax();
      $this->validateReturnType();
      $this->loadRoutineFile();
      $this->extractBulkInsertTableColumnsInfo();
      $this->extractParameters();
      $this->updateMetadata();
    }

    return $this->phpStratumMetadata;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Drops the stored routine if it exists.
   *
   * @throws MySqlQueryErrorException
   */
  private function dropRoutineIfExists(): void
  {
    if (!empty($this->rdbmsOldRoutineMetadata))
    {
      $this->dl->dropRoutine($this->rdbmsOldRoutineMetadata['routine_type'], $this->routineName);
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   *  Extracts the column names and column types of the current table for bulk insert.
   *
   * @throws InvalidCastException
   * @throws MySqlQueryErrorException
   * @throws ResultException
   * @throws RoutineLoaderException
   */
  private function extractBulkInsertTableColumnsInfo(): void
  {
    // Return immediately if designation type is not appropriate for this method.
    if ($this->designationType!=='bulk_insert')
    {
      return;
    }

    // Check if table is a temporary table or a non-temporary table.
    $isTemporaryTable = !$this->dl->checkTableExists($this->bulkInsertTableName);

    // Create temporary table if table is a temporary table.
    if ($isTemporaryTable)
    {
      $this->dl->callProcedure($this->routineName);
    }

    // Get information about the columns of the table.
    $description = $this->dl->describeTable($this->bulkInsertTableName);

    // Drop temporary table if table is temporary.
    if ($isTemporaryTable)
    {
      $this->dl->dropTemporaryTable($this->bulkInsertTableName);
    }

    // Check number of columns in the table match the number of fields given in the designation type.
    $n1 = sizeof($this->bulkInsertKeys);
    $n2 = sizeof($description);
    if ($n1!=$n2)
    {
      throw new RoutineLoaderException("Number of fields %d and number of columns %d don't match.", $n1, $n2);
    }

    $this->bulkInsertColumns = self::extractColumnsFromTableDescription($description);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the designation type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function extractDesignationType(): void
  {
    $tags = $this->docBlockReflection->getTags('type');
    if (count($tags)===0)
    {
      throw new RoutineLoaderException('Tag @type not found in DocBlock.');
    }
    elseif (count($tags)>1)
    {
      throw new RoutineLoaderException('Multiple @type tags found in DocBlock.');
    }

    $tag                   = $tags[0];
    $this->designationType = $tag['arguments']['type'];
    switch ($this->designationType)
    {
      case 'bulk_insert':
        $tag['arguments']['table']   = $tag['arguments']['ex1'];
        $tag['arguments']['columns'] = $tag['arguments']['ex2'];
        if ($tag['arguments']['table']==='' || $tag['arguments']['columns']==='' || $tag['description'][0]!='')
        {
          throw new RoutineLoaderException('Invalid @type tag. Expected: @type bulk_insert <table_name> <columns>');
        }
        $this->bulkInsertTableName = $tag['arguments']['table'];
        $this->bulkInsertKeys      = explode(',', $tag['arguments']['columns']);
        break;

      case 'rows_with_key':
      case 'rows_with_index':
        $tag['arguments']['columns'] = $tag['arguments']['ex1'];
        if ($tag['arguments']['columns']==='' || $tag['arguments']['ex2']!=='')
        {
          throw new RoutineLoaderException('Invalid @type tag. Expected: @type %s <columns>', $this->designationType);
        }
        $this->indexColumns = explode(',', $tag['arguments']['columns']);
        break;

      default:
        if ($tag['arguments']['ex1']!=='' || $tag['arguments']['ex2']!=='')
        {
          throw new RoutineLoaderException('Error: Expected: @type %s', $this->designationType);
        }
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts DocBlock parts to be used by the wrapper generator.
   */
  private function extractDocBlockPartsWrapper(): array
  {
    return ['short_description' => $this->docBlockReflection->getShortDescription(),
            'long_description'  => $this->docBlockReflection->getLongDescription(),
            'parameters'        => $this->routineParameters->extractDocBlockPartsWrapper()];
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts routine parameters.
   *
   * @throws MySqlQueryErrorException
   * @throws RoutineLoaderException
   */
  private function extractParameters(): void
  {
    $this->routineParameters = new RoutineParametersHelper($this->dl,
                                                           $this->io,
                                                           $this->docBlockReflection,
                                                           $this->routineName);

    $this->routineParameters->extractRoutineParameters();
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the placeholders from the stored routine source.
   *
   * @throws RoutineLoaderException
   */
  private function extractPlaceholders(): void
  {
    $unknown = [];

    preg_match_all('(@[A-Za-z0-9_.]+(%(type|sort))?@)', $this->routineSourceCode, $matches);
    if (!empty($matches[0]))
    {
      foreach ($matches[0] as $placeholder)
      {
        if (isset($this->placeholderPool[strtoupper($placeholder)]))
        {
          $this->placeholders[$placeholder] = $this->placeholderPool[strtoupper($placeholder)];
        }
        else
        {
          $unknown[] = $placeholder;
        }
      }
    }

    $this->logUnknownPlaceholders($unknown);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the return type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function extractReturnType(): void
  {
    $tags = $this->docBlockReflection->getTags('return');

    switch ($this->designationType)
    {
      case 'function':
      case 'singleton0':
      case 'singleton1':
        if (count($tags)===0)
        {
          throw new RoutineLoaderException('Tag @return not found in DocBlock.');
        }
        $tag = $tags[0];
        if ($tag['arguments']['type']==='')
        {
          throw new RoutineLoaderException('Invalid return tag. Expected: @return <type>.');
        }
        $this->returnType = $tag['arguments']['type'];
        break;

      default:
        if (count($tags)!==0)
        {
          throw new RoutineLoaderException('Redundant @type tag found in DocBlock.');
        }
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the name of the stored routine and the stored routine type (i.e. procedure or function) source.
   *
   * @throws RoutineLoaderException
   */
  private function extractRoutineTypeAndName(): void
  {
    $n = preg_match('/create\\s+(procedure|function)\\s+([a-zA-Z0-9_]+)/i', $this->routineSourceCode, $matches);
    if ($n==1)
    {
      if ($this->routineName!=$matches[2])
      {
        throw new RoutineLoaderException("Stored routine name '%s' does not correspond with filename.", $matches[2]);
      }
    }
    else
    {
      throw new RoutineLoaderException('Unable to find the stored routine name and type.');
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Detects the syntax of the stored procedure. Either SQL/PSM or PL/SQL.
   */
  private function extractSyntax(): void
  {
    if ($this->sqlModeHelper->hasOracleMode())
    {
      $key1 = $this->findFirstMatchingLine('/^\s*(as|is)\s*$/i');
      $key2 = $this->findFirstMatchingLine('/^\s*begin\s*$/i');

      if ($key1!==null && $key2!==null && $key1<$key2)
      {
        $this->syntax = self::PL_SQL_SYNTAX;
      }
      else
      {
        $this->syntax = self::SQL_PSM_SYNTAX;
      }
    }
    else
    {
      $this->syntax = self::SQL_PSM_SYNTAX;
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns the key of the source line that match a regex pattern.
   *
   * @param string $pattern The regex pattern.
   *
   * @return int|null
   */
  private function findFirstMatchingLine(string $pattern): ?int
  {
    foreach ($this->routineSourceCodeLines as $key => $line)
    {
      if (preg_match($pattern, $line)===1)
      {
        return $key;
      }
    }

    return null;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Loads the stored routine into the database.
   *
   * @throws MySqlQueryErrorException
   */
  private function loadRoutineFile(): void
  {
    if ($this->syntax===self::PL_SQL_SYNTAX)
    {
      $this->sqlModeHelper->addIfRequiredOracleMode();
    }
    else
    {
      $this->sqlModeHelper->removeIfRequiredOracleMode();
    }

    $routineSource = $this->substitutePlaceHolders();
    $this->dropRoutineIfExists();
    $this->dl->setCharacterSet($this->characterSet, $this->collate);
    $this->dl->loadRoutine($routineSource);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Logs the unknown placeholder (if any).
   *
   * @param array $unknown The unknown placeholders.
   *
   * @throws RoutineLoaderException
   */
  private function logUnknownPlaceholders(array $unknown): void
  {
    // Return immediately if there are no unknown placeholders.
    if (empty($unknown))
    {
      return;
    }

    sort($unknown);
    $this->io->text('Unknown placeholder(s):');
    $this->io->listing($unknown);

    $replace = [];
    foreach ($unknown as $placeholder)
    {
      $replace[$placeholder] = '<error>'.$placeholder.'</error>';
    }
    $code = strtr(OutputFormatter::escape($this->routineSourceCode), $replace);

    $this->io->text(explode(PHP_EOL, $code));

    throw new RoutineLoaderException('Unknown placeholder(s) found.');
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns whether the source file must be load or reloaded.
   *
   * @return bool
   */
  private function mustLoadStoredRoutine(): bool
  {
    // If this is the first time we see the source file it must be loaded.
    if (empty($this->phpStratumOldMetadata))
    {
      return true;
    }

    // If the source file has changed the source file must be loaded.
    if ($this->phpStratumOldMetadata['timestamp']!==$this->filemtime)
    {
      return true;
    }

    // If the value of a placeholder has changed the source file must be loaded.
    foreach ($this->phpStratumOldMetadata['placeholders'] as $placeHolder => $oldValue)
    {
      if (!isset($this->placeholderPool[strtoupper($placeHolder)]) || $this->placeholderPool[strtoupper($placeHolder)]!==$oldValue)
      {
        return true;
      }
    }

    // If the value of a type has changed the source file must be loaded.
    foreach ($this->phpStratumOldMetadata['type_hints'] as $typeHint => $oldValue)
    {
      if (!isset($this->typeHintPool[$typeHint]) || $this->typeHintPool[$typeHint]!==$oldValue)
      {
        return true;
      }
    }

    // If stored routine not exists in database the source file must be loaded.
    if (empty($this->rdbmsOldRoutineMetadata))
    {
      return true;
    }

    // If current sql-mode is different the source file must reload.
    if (!$this->sqlModeHelper->compare($this->rdbmsOldRoutineMetadata['sql_mode']))
    {
      return true;
    }

    // If current character set is different the source file must reload.
    if ($this->rdbmsOldRoutineMetadata['character_set_client']!==$this->characterSet)
    {
      return true;
    }

    // If current collation is different the source file must reload.
    if ($this->rdbmsOldRoutineMetadata['collation_connection']!==$this->collate)
    {
      return true;
    }

    return false;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Reads the source code of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function readSourceCode(): void
  {
    $this->routineSourceCode      = file_get_contents($this->sourceFilename);
    $this->routineSourceCodeLines = explode(PHP_EOL, $this->routineSourceCode);

    if ($this->routineSourceCodeLines===false)
    {
      throw new RoutineLoaderException('Source file is empty.');
    }

    $start = $this->findFirstMatchingLine('/^\s*\/\*\*\s*$/');
    $end   = $this->findFirstMatchingLine('/^\s*\*\/\s*$/');
    if ($start!==null && $end!==null && $start<$end)
    {
      $lines    = array_slice($this->routineSourceCodeLines, $start, $end - $start + 1);
      $docBlock = implode(PHP_EOL, $lines);
    }
    else
    {
      $docBlock = '';
    }

    DocBlockReflection::setTagParameters('param', ['name']);
    DocBlockReflection::setTagParameters('type', ['type', 'ex1', 'ex2']);
    DocBlockReflection::setTagParameters('return', ['type']);
    DocBlockReflection::setTagParameters('paramAddendum', ['name', 'type', 'delimiter', 'enclosure', 'escape']);

    $this->docBlockReflection = new DocBlockReflection($docBlock);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns the source of the routine with all placeholders substituted with their values.
   *
   * @return string
   */
  private function substitutePlaceHolders(): string
  {
    $realpath = realpath($this->sourceFilename);

    $this->placeholders['__FILE__']    = "'".$this->dl->realEscapeString($realpath)."'";
    $this->placeholders['__ROUTINE__'] = "'".$this->routineName."'";
    $this->placeholders['__DIR__']     = "'".$this->dl->realEscapeString(dirname($realpath))."'";

    $lines         = explode(PHP_EOL, $this->routineSourceCode);
    $routineSource = [];
    foreach ($lines as $i => $line)
    {
      $this->placeholders['__LINE__'] = $i + 1;
      $routineSource[$i]              = strtr($line, $this->placeholders);
    }
    $routineSource = implode(PHP_EOL, $routineSource);

    unset($this->placeholders['__FILE__']);
    unset($this->placeholders['__ROUTINE__']);
    unset($this->placeholders['__DIR__']);
    unset($this->placeholders['__LINE__']);

    return $routineSource;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Updates the metadata for the stored routine.
   */
  private function updateMetadata(): void
  {
    $this->phpStratumMetadata['routine_name'] = $this->routineName;
    $this->phpStratumMetadata['designation']  = $this->designationType;
    $this->phpStratumMetadata['return']       = $this->returnType;
    $this->phpStratumMetadata['parameters']   = $this->routineParameters->getParameters();
    $this->phpStratumMetadata['timestamp']    = $this->filemtime;
    $this->phpStratumMetadata['placeholders'] = $this->placeholders;
    $this->phpStratumMetadata['type_hints']   = $this->typeHints;
    $this->phpStratumMetadata['phpdoc']       = $this->extractDocBlockPartsWrapper();

    if (in_array($this->designationType, ['rows_with_index', 'rows_with_key']))
    {
      $this->phpStratumMetadata['index_columns'] = $this->indexColumns;
    }

    if ($this->designationType==='bulk_insert')
    {
      $this->phpStratumMetadata['bulk_insert_table_name'] = $this->bulkInsertTableName;
      $this->phpStratumMetadata['bulk_insert_columns']    = $this->bulkInsertColumns;
      $this->phpStratumMetadata['bulk_insert_keys']       = $this->bulkInsertKeys;
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Updates the source of the stored routine based on the values of type hints.
   *
   * @throws RoutineLoaderException
   */
  private function updateSourceTypeHints(): void
  {
    $types   = ['int',
                'smallint',
                'tinyint',
                'mediumint',
                'bigint',
                'decimal',
                'float',
                'double',
                'bit',
                'date',
                'datetime',
                'timestamp',
                'time',
                'year',
                'char',
                'varchar',
                'binary',
                'varbinary',
                'enum',
                'set',
                'inet4',
                'inet6',
                'tinyblob',
                'blob',
                'mediumblob',
                'longblob',
                'tinytext',
                'text',
                'mediumtext',
                'longtext'];
    $parts   = ['whitespace' => '(?<whitespace>\s+)',
                'type_list'  => str_replace('type-list',
                                            implode('|', $types),
                                            '(?<datatype>(type-list).*)'),
                'nullable'   => '(?<nullable>not\s+null)?',
                'hint'       => '(?<hint>\s+--\s+type:\s+(\w+\.)?\w+\.\w+\s*)'];
    $pattern = '/'.implode('', $parts).'$/i';

    foreach ($this->routineSourceCodeLines as $index => $line)
    {
      if (preg_match('/'.$parts['hint'].'/i', $line))
      {
        $n = preg_match($pattern, $line, $matches);
        if ($n===0)
        {
          throw new RoutineLoaderException("Found a type hint at line %d, but unable to find data type.", $index + 1);
        }

        $hint = trim(preg_replace('/\s+--\s+type:\s+/i', '', $matches['hint']));
        if (!isset($this->typeHintPool[$hint]))
        {
          throw new RoutineLoaderException("Unknown type hint '%s' found at line %d.", $hint, $index + 1);
        }

        if (preg_match('/(?<punctuation>\s*[;,]\s*)$/', $matches['datatype'], $other))
        {
          $punctuation = $other['punctuation'];
        }
        else
        {
          $punctuation = '';
        }

        $actualType             = $this->typeHintPool[$hint];
        $newLine                = sprintf('%s%s%s%s%s%s',
                                          mb_substr($line, 0, -mb_strlen($matches[0])),
                                          $matches['whitespace'],
                                          $actualType, // <== the real replacement
                                          $matches['nullable'],
                                          $punctuation,
                                          $matches['hint']);
        $this->typeHints[$hint] = $actualType;

        if (str_replace(' ', '', $line)!==str_replace(' ', '', $newLine))
        {
          $this->routineSourceCodeLines[$index] = $newLine;
        }
      }
    }

    $blocks = [];
    $start  = null;
    $length = 0;
    foreach ($this->routineSourceCodeLines as $index => $line)
    {
      $n = preg_match('/--\s+type:\s+.*$/', $line, $matches);
      if ($n!==0)
      {
        if ($start===null)
        {
          $start = $index;
        }
        $length = max($length, mb_strlen($line) - mb_strlen($matches[0]) + 2);
      }
      else
      {
        if ($start!==null)
        {
          $blocks[] = ['first' => $start, 'last' => $index, 'length' => $length];
          $start    = null;
          $length   = 0;
        }
      }
    }

    foreach ($blocks as $block)
    {
      for ($index = $block['first']; $index<$block['last']; $index++)
      {
        preg_match('/\s+type:\s+.*$/', $this->routineSourceCodeLines[$index], $matches);
        $leftPart = mb_substr($this->routineSourceCodeLines[$index], 0, -mb_strlen($matches[0]));
        $leftPart = $leftPart.str_repeat(' ', $block['length'] - mb_strlen($leftPart) + 1);

        $this->routineSourceCodeLines[$index] = $leftPart.ltrim($matches[0]);
      }
    }

    $routineSourceCode = implode(PHP_EOL, $this->routineSourceCodeLines);
    if ($this->routineSourceCode!==$routineSourceCode)
    {
      $this->routineSourceCode = $routineSourceCode;
      Util::writeTwoPhases($this->sourceFilename, $this->routineSourceCode, $this->io);
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Validates the specified return type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function validateReturnType(): void
  {
    // Return immediately if designation type is not appropriate for this method.
    if (!in_array($this->designationType, ['function', 'singleton0', 'singleton1']))
    {
      return;
    }

    $types = explode('|', $this->returnType);
    $types = explode('|', /** @scrutinizer ignore-type */ $this->returnType);
    $diff  = array_diff($types, ['string', 'int', 'float', 'double', 'bool', 'null']);

    if (!($this->returnType=='mixed' || $this->returnType=='bool' || empty($diff)))
    {
      throw new RoutineLoaderException("Return type must be 'mixed', 'bool', or a combination of 'int', 'float', 'string', and 'null'.");
    }

    // The following tests are applicable for singleton0 routines only.
    if ($this->designationType!=='singleton0')
    {
      return;
    }

    // Return mixed is OK.
    if (in_array($this->returnType, ['bool', 'mixed']))
    {
      return;
    }

    // In all other cases return type must contain null.
    $parts = explode('|', $this->returnType);
    $key   = in_array('null', $parts);
    if ($key===false)
    {
      throw new RoutineLoaderException("Return type must be 'mixed', 'bool', or contain 'null' (with a combination of 'int', 'float', and 'string').");
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
}

//----------------------------------------------------------------------------------------------------------------------

DatabaseStratum / php-stratum-mysql

Push — master ( caf7cf...f71b04 )

RoutineLoaderHelper::updateSourceTypeHints() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
