DateConvert.i

<?php
/**
 * @copyright HomeCu 05/2019
 *
 * Reference this class to validate and update the most used date string formats into
 * (almost) any format compatible with PHP DateTime. This class came to life from a
 * request to allow two digit year inputs for birthdate. Two digits . . . in what
 * century? Think about that a second . . . combined with the IBM solution and
 * some input options, this class proposes a solid reusable solution.
 *
 * Usage:
 * $dc = new DateConvert();
 * echo $dc->convertDateFromFormat([string $date], [optional string $requested_format], [optional int century);
 *
 * Supports slash, dash, or dot separators in American and European formats.
 * $requested_format will default to Y-m-d SQL format if omitted.
 * Four digit year will be used in any case (won't be overridden.)
 * For two digit year input, century will override the "40 year algo"
 *  used by IBM, see comments at setYear().
 */
class DateConvert
{
  /** @var string, default return format, may optionally be overridden by input */
  protected $requested_format = 'Y-m-d';

  /**
   * @var int, optional input param to set century.
   * See comments at setYear(), this overrides default if provided and > 0.
   */
  protected $century = 0;

  /** @var array these are the current formats we support. @TODO construct in a loop? */
  protected $formats = [
    // MM/DD/YYYY     M/DD/YYYY    M/D/YYYY     MM/D/YYYY
      'm/d/Y',        'n/d/Y',    'n/j/Y',     'm/j/Y',
    // MM/DD/YY       M/DD/YY      M/D/YY       MM/D/YY
      'm/d/y',        'n/d/y',    'n/j/y',     'm/j/y',
    // MM.DD.YYYY     M.DD.YYYY    M.D.YYYY     MM.D.YYYY
      'm.d.Y',        'n.d.Y',    'n.j.Y',     'm.j.Y',
    // MM.DD.YY       M.DD.YY      M.D.YY       MM.D.YY
      'm.d.y',        'n.d.y',    'n.j.y',     'm.j.y',
    // MM-DD-YYYY     M-DD-YYYY    M-D-YYYY     MM-D-YYYY
      'm-d-Y',        'n-d-Y',    'n-j-Y',     'm-j-Y',
    // MM-DD-YY       M-DD-YY      M-D-YY       MM-D-YY
      'm-d-y',        'n-d-y',    'n-j-y',     'm-j-y',
    // YYYY/MM/DD     YYYY/M/DD    YYYY/M/D     YYYY/MM/D
      'Y/m/d',        'Y/n/d',    'Y/n/j',     'Y/m/j',
    // YY/MM/DD       YY/M/DD      YY/M/D       YY/MM/D
      'y/m/d',        'y/n/d',    'y/n/j',     'y/m/j',
    // YYYY.MM.DD     YYYY.M.DD    YYYY.M.D     YYYY.MM.D
      'Y.m.d',        'Y.n.d',    'Y.n.j',     'Y.m.j',
    // YY.MM.DD       YY.M.DD      YY.M.D       YY.MM.D
      'y.m.d',        'y.n.d',    'y.n.j',     'y.m.j',
    // MM.DD.YYYY     M.DD.YYYY    MM.D.YYYY    M.D.YYYY
      'm.d.Y',        'n.d.Y',    'm.j.Y',     'n.j.Y',
    // MM.DD.YY       M.DD.YY      MM.D.YY      M.D.YY
      'm.d.y',        'n.d.y',    'm.j.y',     'n.j.y',
    // YYYY-MM-DD     YYYY-M-DD    YYYY-M-D     YYYY-MM-D
      'Y-m-d',        'Y-n-d',    'Y-n-j',     'Y-m-j',
    // YY-MM-DD       YY-M-DD      YY-M-D       YY-MM-D
      'y-m-d',        'y-n-d',    'y-n-j',     'y-m-j',
  ];

  /**
   * DateConvert constructor.
   * Nothing to do
   * @return void
   */
  public function __construct() {

  }

  /**
   * Entry point, see calling consumers/clients/apps for examples.
   * @param string $date
   * @param string $requested_format
   * @param int $century, overrides 40 year rule documented at setYear() below.
   * @return string
   * @throws Exception
   */
  public function ConvertDateFromFormat($date, $requested_format = '', $century = 0) {

    return $this
      ->SetRequestedFormat($requested_format)
      ->SetRequestedCentury($century)
      ->FindValidFormat($date);
  }

  /**
   * Set the requested format into the class property.
   * @param string $format
   * @return $this
   */
  protected function SetRequestedFormat($format) {

    if (! $this->IsValidRequestedFormat($format)) {
      return $this;
    }

    $this->requested_format = $format;

    return $this;
  }

  /**
   * If there is an optional requested output format, validate it and return a
   * message if it's not in the cool kids' club (formats property array.)
   * @param string $format
   * @return bool
   */
  protected function IsValidRequestedFormat($format = '') {

    if (empty($format) || ! in_array($format, $this->formats)) {
      return false;
    }

    return true;
  }

  /**
   * Set the optional requested century to override the 40 year rule documented at setYear() below.
   * @param int century
   * @return $this
   */
  protected function SetRequestedCentury($century = 0) {

    if (intval($century) > 0) {
      $this->century = intval($century);
    }

    return $this;
  }

  /**
   * Look up from a list of date formats and see if the input date string matches on
   * any of them. This kind of sucks, should be built dynamically but it works
   * (and allows us control over the date formats we want to support.)
   * @param string $date
   * @return string|false
   * @throws Exception
   */
  protected function FindValidFormat($date) {

    foreach ($this->formats as $fmt) {

      if ($this->IsValidDate($fmt, $date)) {

          // Ensure we have a 4 digit year, even if two is input.
          $date = $this->ConfirmFourDigitYear($fmt, $date);
          // Once it's 4 digit, it will break DateTime if the year format is still 'y'
          $fmt = preg_replace('/y/', 'Y', $fmt);

          return $this->CreateRequestedDate($fmt, $date);
      }
    }

    return false;
  }

  /**
   * Core date validation, leverage the DateTime object.
   * @param string $format
   * @param string $date
   * @return bool
   */
  protected function IsValidDate($format, $date) {

    $obj = DateTime::createFromFormat($format, $date);
    return $obj && $obj->format($format) == $date;
  }

  /**
   * Make sure our years are expressed in 4 digits, and hopefully in the right century. We're
   * going to get a little messy now, like rubbing two sticks together messy. The DateTime
   * class assumes we aren't going to do something dumb like ask it for a two digit year
   * date. If asked, a string of 10/13/60 will return 10/13/2060. So what we have to do
   * is deconstruct the date string old school and determine which century we need it
   * in using the IBM algo. If that doesn't suffice, we also have the century param
   * that will override the century calculation if needed.
   *
   * @param string $format
   * @param string $date
   * @return string
   * @throws Exception
   */
  protected function ConfirmFourDigitYear($format, $date) {

    $date_arr = $this->SplitDateOnDelimiter($format, $date);

    if (strlen($date_arr['y']) >= 4) {
      return $date;
    }

    $y      = $this->SetFourDigitYear($date_arr['y']);
    // Breaks DateTime format if it's still a y after changing to 4 digits.
    $format = preg_replace('/y/', 'Y', $format);
    $obj    = new DateTime;

    $obj->setDate($y, $date_arr['m'], $date_arr['d']);

    return $obj->format($format);
  }

  /**
   * The rubbing two sticks together part. Split up a date string and create an
   * array associated with keys m, d, y. Why are we doing this? To ensure a two
   * digit year gets **properly** assigned as a 4 digit year. DateTime alone
   * would always return 2060 if provided the year "60" which in most cases
   * means 1960.
   * @param string $format
   * @param string $date
   * @return array
   */
  protected function SplitDateOnDelimiter($format, $date) {

    $arr    = [];
    $delim  = $this->DetectDelimiter($format);

    $keys = explode($delim, $format);
    $vals = explode($delim, $date);

    for ($i = 0; $i < count($keys); $i++) {

      if (in_array(strtolower($keys[$i]), ['m', 'n'])) {
        $arr['m'] = $vals[$i];
      }
      if (in_array(strtolower($keys[$i]), ['d', 'j'])) {
        $arr['d'] = $vals[$i];
      }
      if (strtolower($keys[$i]) == 'y') {
        $arr['y'] = $vals[$i];
      }
    }

    return $arr;
  }

  /**
   * Extract the delimiter from the format string we found from the input date.
   * @param $format
   * @return string|null
   */
  protected function DetectDelimiter($format) {

    $supported = ['/', '.', '-'];

    foreach ($supported as $delim) {
      if (preg_match("|$delim|", $format)) {
        return $delim;
      }
    }

    return null;
  }

  /**
   * Set a four digit year from a two digit year. If you're parsing a four digit
   * year, you shouldn't be here, it will have already returned the date, but
   * including the guard pattern anyway. :-)
   * @param int $year
   * @return int|string
   * @throws Exception
   */
  protected function SetFourDigitYear($year = 0) {

    $this->ValidateYearInput($year);

    if (strlen($year) >= 4) {
      return $year;
    }

    return $this->SetYear(intval($year));
  }

  /**
   * Validate year
   * @param int $year
   * @return string|null
   * @throws Exception
   */
  protected function ValidateYearInput($year = 0) {

    if (intval($year) < 0) {
      throw new Exception("Please enter a numeric year." . PHP_EOL);
    }

    if (intval($year) > 99) {
       throw new Exception("Please enter a two digit year." . PHP_EOL);
    }

    return null;
  }

  /**
   * Set a four digit year from a two digit year based on an optional provided century or year
   * alone. From IBM:
   *
   * "When you are moving or comparing 2-digit years to 4-digit years or centuries, or comparing
   * 4-digit years or centuries to 2-digit years, ILE COBOL first converts the 2-digit year using
   * a windowing algorithm. The default windowing algorithm used is as follows:
   *
   * "If a 2-digit year is moved to a 4-digit year, the century (1st 2 digits of the year) are
   * chosen as follows: If the 2-digit year is greater than or equal to 40, the century used is
   * 1900. In other words, 19 becomes the first 2 digits of the 4-digit year.
   *
   * If the 2-digit year is less than 40, the century used is 2000. In other words, 20 becomes
   * the first 2 digits of the 4-digit year."
   *
   * https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_72/rzase/yrconv.htm
   *
   * In our case we have added the optional param $century [int > 1000] so it can be customized
   * by consumers (consumers being the apps calling this class.)
   *
   * @param int $year
   * @return int
   */
  protected function SetYear($year = 0) {

    // PHP will automagically cast these, but in the interest of specificity . . .
    $year     = intval($year);
    $century  = intval($this->century);

    if ($century < 1) {
      $century = ($year >= 40)? 1900 : 2000;
    }

    // Probably fine but guard against typos or other abuse. We want
    // a round century number. Nuke a sloppy century.
    $century = intdiv($century, 100) * 100;

    return $year += $century;
  }

  /**
   * Leverage the DateTime object and create a date string formatted as requested from original.
   * @param string $current_format
   * @param string $date
   * @return bool
   */
  protected function CreateRequestedDate($current_format, $date) {

    $obj = DateTime::createFromFormat($current_format, $date);
    return $obj->format($this->requested_format);
  }

}