vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/UnderscoreNamingStrategy.php line 62

Open in your IDE?
  1. <?php
  3. /*
  4.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15.  *
  16.  * This software consists of voluntary contributions made by many individuals
  17.  * and is licensed under the MIT license. For more information, see
  18.  * <http://www.doctrine-project.org>.
  19.  */
  21. namespace Doctrine\ORM\Mapping;
  23. use function preg_replace;
  24. use function strpos;
  25. use function strrpos;
  26. use function strtolower;
  27. use function strtoupper;
  28. use function substr;
  29. use function trigger_error;
  31. use const CASE_LOWER;
  32. use const CASE_UPPER;
  33. use const E_USER_DEPRECATED;
  35. /**
  36.  * Naming strategy implementing the underscore naming convention.
  37.  * Converts 'MyEntity' to 'my_entity' or 'MY_ENTITY'.
  38.  *
  39.  * @link    www.doctrine-project.org
  40.  */
  41. class UnderscoreNamingStrategy implements NamingStrategy
  42. {
  43.     private const DEFAULT_PATTERN      = '/(?<=[a-z])([A-Z])/';
  44.     private const NUMBER_AWARE_PATTERN = '/(?<=[a-z0-9])([A-Z])/';
  46.     /** @var int */
  47.     private $case;
  49.     /** @var string */
  50.     private $pattern;
  52.     /**
  53.      * Underscore naming strategy construct.
  54.      *
  55.      * @param int $case CASE_LOWER | CASE_UPPER
  56.      */
  57.     public function __construct($case = CASE_LOWER, bool $numberAware = false)
  58.     {
  59.         if (! $numberAware) {
  60.             @trigger_error(
  61.                 'Creating ' . self::class . ' without making it number aware is deprecated and will be removed in Doctrine ORM 3.0.',
  62.                 E_USER_DEPRECATED
  63.             );
  64.         }
  66.         $this->case    = $case;
  67.         $this->pattern = $numberAware ? self::NUMBER_AWARE_PATTERN : self::DEFAULT_PATTERN;
  68.     }
  70.     /**
  71.      * @return int CASE_LOWER | CASE_UPPER
  72.      */
  73.     public function getCase()
  74.     {
  75.         return $this->case;
  76.     }
  78.     /**
  79.      * Sets string case CASE_LOWER | CASE_UPPER.
  80.      * Alphabetic characters converted to lowercase or uppercase.
  81.      *
  82.      * @param int $case
  83.      *
  84.      * @return void
  85.      */
  86.     public function setCase($case)
  87.     {
  88.         $this->case = $case;
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function classToTableName($className)
  95.     {
  96.         if (strpos($className, '\\') !== false) {
  97.             $className = substr($className, strrpos($className, '\\') + 1);
  98.         }
  100.         return $this->underscore($className);
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      */
  106.     public function propertyToColumnName($propertyName, $className = null)
  107.     {
  108.         return $this->underscore($propertyName);
  109.     }
  111.     /**
  112.      * {@inheritdoc}
  113.      */
  114.     public function embeddedFieldToColumnName($propertyName, $embeddedColumnName, $className = null, $embeddedClassName = null)
  115.     {
  116.         return $this->underscore($propertyName) . '_' . $embeddedColumnName;
  117.     }
  119.     /**
  120.      * {@inheritdoc}
  121.      */
  122.     public function referenceColumnName()
  123.     {
  124.         return $this->case === CASE_UPPER ?  'ID' : 'id';
  125.     }
  127.     /**
  128.      * {@inheritdoc}
  129.      */
  130.     public function joinColumnName($propertyName, $className = null)
  131.     {
  132.         return $this->underscore($propertyName) . '_' . $this->referenceColumnName();
  133.     }
  135.     /**
  136.      * {@inheritdoc}
  137.      */
  138.     public function joinTableName($sourceEntity, $targetEntity, $propertyName = null)
  139.     {
  140.         return $this->classToTableName($sourceEntity) . '_' . $this->classToTableName($targetEntity);
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      */
  146.     public function joinKeyColumnName($entityName, $referencedColumnName = null)
  147.     {
  148.         return $this->classToTableName($entityName) . '_' .
  149.                 ($referencedColumnName ?: $this->referenceColumnName());
  150.     }
  152.     private function underscore(string $string): string
  153.     {
  154.         $string = preg_replace($this->pattern, '_$1', $string);
  156.         if ($this->case === CASE_UPPER) {
  157.             return strtoupper($string);
  158.         }
  160.         return strtolower($string);
  161.     }
  162. }