adding domain modifiers functions

Author: nyamsprod

CHANGELOG.md

@@ -10,11 +10,17 @@ All Notable changes to `PHP Domain Parser` **5.x** series will be documented in
 - `Pdp\Domain::getContent` returns the Domain name value replaces `Pdp\Domain::getDomain`
 - `Pdp\Domain` implements the `Countable` interface.
 - `Pdp\Domain::withPublicSuffix` returns a new Domain object with a different Public Suffix
+- `Pdp\PublicSuffix::createFromDomain` returns a new `Pdp\PublicSuffix` object from a `Pdp\Domain`object
+- `Pdp\append` append a host to a domain name
+- `Pdp\prepend` prepend a host to a domain name
+- `Pdp\replace` replace a label from the domain name
+- `Pdp\public_suffix_replace` replace the domain name public suffix
 
 ### Fixed
 
 - `Pdp\Domain` domain part computation (public suffix, registrable domain and sub domain)
 - `Pdp\Domain` and `Pdp\PublicSuffix` host validation compliance to RFC improved
+- Improved `Pdp\Converter` and `Pdp\Manager` class to better report error on IDN conversion.
 
 ### Deprecated
 

composer.json

@@ -55,7 +55,8 @@
     "autoload": {
         "psr-4": {
             "Pdp\\": "src/"
-        }
+        },
+        "files": ["src/functions_include.php"]
     },
     "autoload-dev": {
         "psr-4": {

phpunit.xml.dist

@@ -22,6 +22,7 @@
             <directory suffix=".php">src</directory>
             <exclude>
                 <directory suffix="Installer.php">src</directory>
+                <directory suffix="include.php">src</directory>
             </exclude>
             <exclude>src/Installer</exclude>
         </whitelist>

src/PublicSuffix.php

@@ -53,6 +53,26 @@ public static function __set_state(array $properties): self
         return new self($properties['publicSuffix'], $properties['section']);
     }
 
+    /**
+     * Create an new instance from a Domain object
+     *
+     * @param Domain $domain
+     *
+     * @return self
+     */
+    public static function createFromDomain(Domain $domain): self
+    {
+        if (!$domain->isKnown()) {
+            return new self($domain->getPublicSuffix());
+        }
+
+        if ($domain->isICANN()) {
+            return new self($domain->getPublicSuffix(), Rules::ICANN_DOMAINS);
+        }
+
+        return new self($domain->getPublicSuffix(), Rules::PRIVATE_DOMAINS);
+    }
+
     /**
      * New instance.
      *

src/functions.php

@@ -0,0 +1,183 @@
+<?php
+/**
+ * PHP Domain Parser: Public Suffix List based URL parsing.
+ *
+ * @see http://github.com/jeremykendall/php-domain-parser for the canonical source repository
+ *
+ * @copyright Copyright (c) 2017 Jeremy Kendall (http://jeremykendall.net)
+ * @license   http://github.com/jeremykendall/php-domain-parser/blob/master/LICENSE MIT License
+ */
+declare(strict_types=1);
+
+namespace Pdp;
+
+/**
+ * Append a domain name to another domain name.
+ *
+ * @param mixed $host
+ * @param mixed $subject
+ *
+ * @return Domain
+ */
+function append($host, $subject): Domain
+{
+    if (!$subject instanceof Domain) {
+        $subject = new Domain($subject);
+    }
+
+    if (!$host instanceof DomainInterface) {
+        $host = new Domain($host);
+    }
+
+    if (null === $host->getContent()) {
+        return $subject;
+    }
+
+    static $pattern = '/[^\x20-\x7f]/';
+    $dContent = $subject->getContent();
+    $host = preg_match($pattern, $dContent) ? $host->toUnicode() : $host->toAscii();
+    $domain = new Domain($dContent.'.'.$host->getContent());
+
+    if ($host instanceof PublicSuffix) {
+        return $domain->withPublicSuffix($host);
+    }
+
+    if ($host instanceof Domain) {
+        return $domain->withPublicSuffix(PublicSuffix::createFromDomain($host));
+    }
+
+    return $domain;
+}
+
+/**
+ * Prepend a domain name to another domain name.
+ *
+ * @param mixed $host
+ * @param mixed $subject
+ *
+ * @return Domain
+ */
+function prepend($host, $subject): Domain
+{
+    if (!$subject instanceof Domain) {
+        $subject = new Domain($subject);
+    }
+
+    if (!$host instanceof DomainInterface) {
+        $host = new PublicSuffix($host);
+    }
+
+    if (null === $host->getContent()) {
+        return $subject;
+    }
+
+    $dContent = $subject->getContent();
+    static $pattern = '/[^\x20-\x7f]/';
+    $host = preg_match($pattern, $dContent) ? $host->toUnicode() : $host->toAscii();
+
+    return new Domain($host->getContent().'.'.$dContent, PublicSuffix::createFromDomain($subject));
+}
+
+/**
+ * Replace a label from the domain with a domain name
+ *
+ * @param int   $key
+ * @param mixed $label
+ * @param mixed $subject
+ *
+ * @return Domain
+ */
+function replace(int $key, $label, $subject): Domain
+{
+    if (!$subject instanceof Domain) {
+        $subject = new Domain($subject);
+    }
+
+    if (!$label instanceof DomainInterface) {
+        $label = new Domain($label);
+    }
+
+    if (null === $label->getContent()) {
+        return $subject;
+    }
+
+    $nb_labels = count($subject);
+    $offset = filter_var($key, FILTER_VALIDATE_INT, ['options' => ['min_range' => - $nb_labels, 'max_range' => $nb_labels - 1]]);
+    if (false === $offset) {
+        throw new Exception(sprintf('no label was found for the given key `%s`', $key));
+    }
+
+    if ($offset < 0) {
+        $offset = $nb_labels + $offset;
+    }
+
+    static $pattern = '/[^\x20-\x7f]/';
+    $label = preg_match($pattern, $subject->getContent()) ? $label->toUnicode() : $label->toAscii();
+    if ($label->getContent() === $subject->getLabel($offset)) {
+        return $subject;
+    }
+
+    $labels = iterator_to_array($subject, false);
+    $labels[$offset] = $label->getContent();
+    $domain = new Domain(implode('.', array_reverse($labels)));
+
+    $subjectPS = PublicSuffix::createFromDomain($subject);
+    if ($key >= count($subjectPS)) {
+        return $domain->withPublicSuffix($subjectPS);
+    }
+
+    if ($key !== 0) {
+        return $domain;
+    }
+
+    if ($label instanceof PublicSuffix) {
+        return $domain->withPublicSuffix($label);
+    }
+
+    if ($label instanceof Domain) {
+        return $domain->withPublicSuffix(PublicSuffix::createFromDomain($label));
+    }
+
+    return $domain->withPublicSuffix(new PublicSuffix($label->getContent()));
+}
+
+/**
+ * Replace the public suffix for a given Domain name.
+ *
+ * If the domain has no information regarding its public suffix
+ * its last label will be considered as its public suffix label and will
+ * be replaced.
+ *
+ * @param mixed $publicSuffix
+ * @param mixed $subject
+ *
+ * @return Domain
+ */
+function public_suffix_replace($publicSuffix, $subject): Domain
+{
+    if (!$subject instanceof Domain) {
+        $subject = new Domain($subject);
+        $subject = $subject->withPublicSuffix(new PublicSuffix($subject->getLabel(0)));
+    }
+
+    if (!$publicSuffix instanceof PublicSuffix) {
+        $publicSuffix = new PublicSuffix($publicSuffix);
+    }
+
+    if (null === $publicSuffix->getContent()) {
+        return $subject->withPublicSuffix($publicSuffix);
+    }
+
+    $dContent = $subject->getContent();
+    $dPublicSuffix = $subject->getPublicSuffix();
+
+    static $pattern = '/[^\x20-\x7f]/';
+    $publicSuffix = preg_match($pattern, $dContent) ? $publicSuffix->toUnicode() : $publicSuffix->toAscii();
+
+    $psContent = $publicSuffix->getContent();
+    if ($dPublicSuffix === $psContent) {
+        return $subject;
+    }
+
+    return new Domain(substr($dContent, 0, - strlen($dPublicSuffix)).$psContent, $publicSuffix);
+}

src/functions_include.php

@@ -0,0 +1,6 @@
+<?php
+
+// Don't redefine the functions if included multiple times.
+if (!function_exists('Pdp\append')) {
+    require __DIR__.'/functions.php';
+}