Rename key to index

This will be less confusing in applications that deal with cryptography

Author: paragonie-security

src/Contract/KeyPolicyInterface.php src/Contract/IndexPolicyInterface.phpsrc/Contract/KeyPolicyInterface.php renamed to src/Contract/IndexPolicyInterface.php

@@ -2,11 +2,11 @@
 declare(strict_types=1);
 namespace ParagonIE\Ionizer\Contract;
 
-interface KeyPolicyInterface
+interface IndexPolicyInterface
 {
     /**
-     * @param array-key $key
+     * @param array-key $index
      * @return bool
      */
-    public function keyIsValid($key): bool;
+    public function indexIsValid($index): bool;
 }

src/Filter/ArrayFilter.php

@@ -2,7 +2,7 @@
 declare(strict_types=1);
 namespace ParagonIE\Ionizer\Filter;
 
-use ParagonIE\Ionizer\Contract\KeyPolicyInterface;
+use ParagonIE\Ionizer\Contract\IndexPolicyInterface;
 use ParagonIE\Ionizer\InputFilter;
 use ParagonIE\Ionizer\InvalidDataException;
 
@@ -23,19 +23,19 @@ class ArrayFilter extends InputFilter
     protected $type = 'array';
 
     /**
-     * @var ?KeyPolicyInterface $keyPolicy
+     * @var ?IndexPolicyInterface $indexPolicy
      */
-    protected $keyPolicy = null;
+    protected $indexPolicy = null;
 
     /**
      * Add restrictions to the keys allowed in this array
      *
-     * @param KeyPolicyInterface $keyPolicy
+     * @param IndexPolicyInterface $indexPolicy
      * @return $this
      */
-    public function setKeyPolicy(KeyPolicyInterface $keyPolicy): self
+    public function setIndexPolicy(IndexPolicyInterface $indexPolicy): self
     {
-        $this->keyPolicy = $keyPolicy;
+        $this->indexPolicy = $indexPolicy;
         return $this;
     }
 
@@ -58,10 +58,10 @@ public function process($data = null)
                 \sprintf('Expected an array (%s).', $this->index)
             );
         }
-        if (!is_null($this->keyPolicy)) {
+        if (!is_null($this->indexPolicy)) {
             $keys = array_keys($data);
             foreach ($keys as $arrayKey) {
-                if (!$this->keyPolicy->keyIsValid($arrayKey)) {
+                if (!$this->indexPolicy->indexIsValid($arrayKey)) {
                     throw new \TypeError(
                         \sprintf("Invalid key (%s) in violation of key policy", $arrayKey)
                     );

src/IndexPolicy/AnyIndex.php

@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+namespace ParagonIE\Ionizer\IndexPolicy;
+
+use ParagonIE\Ionizer\Contract\IndexPolicyInterface;
+
+class AnyIndex implements IndexPolicyInterface
+{
+    /**
+     * Any integer or string index is valid.
+     *
+     * @param array-key $index
+     * @return bool
+     */
+    public function indexIsValid($index): bool
+    {
+        return is_string($index) || is_int($index);
+    }
+}

src/KeyPolicy/KeyAllowList.php src/IndexPolicy/IndexAllowList.phpsrc/KeyPolicy/KeyAllowList.php renamed to src/IndexPolicy/IndexAllowList.php

@@ -1,10 +1,10 @@
 <?php
 declare(strict_types=1);
-namespace ParagonIE\Ionizer\KeyPolicy;
+namespace ParagonIE\Ionizer\IndexPolicy;
 
-use ParagonIE\Ionizer\Contract\KeyPolicyInterface;
+use ParagonIE\Ionizer\Contract\IndexPolicyInterface;
 
-class KeyAllowList implements KeyPolicyInterface
+class IndexAllowList implements IndexPolicyInterface
 {
     /** @var array-key[] $allowed */
     private $allowed = [];
@@ -20,11 +20,11 @@ public function __construct(...$allowed)
     /**
      * Any integer or string key is valid.
      *
-     * @param array-key $key
+     * @param array-key $index
      * @return bool
      */
-    public function keyIsValid($key): bool
+    public function indexIsValid($index): bool
     {
-        return in_array($key, $this->allowed, true);
+        return in_array($index, $this->allowed, true);
     }
 }

src/IndexPolicy/IntegersOnly.php

@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+namespace ParagonIE\Ionizer\IndexPolicy;
+
+use ParagonIE\Ionizer\Contract\IndexPolicyInterface;
+
+class IntegersOnly implements IndexPolicyInterface
+{
+    /**
+     * Any integer key is valid.
+     *
+     * @param array-key $index
+     * @return bool
+     */
+    public function indexIsValid($index): bool
+    {
+        return is_int($index);
+    }
+}

src/IndexPolicy/StringsOnly.php

@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+namespace ParagonIE\Ionizer\IndexPolicy;
+
+use ParagonIE\Ionizer\Contract\IndexPolicyInterface;
+
+class StringsOnly implements IndexPolicyInterface
+{
+    /**
+     * Any integer or string key is valid.
+     *
+     * @param array-key $index
+     * @return bool
+     */
+    public function indexIsValid($index): bool
+    {
+        return is_string($index);
+    }
+}

src/KeyPolicy/AnyKeys.php

@@ -0,0 +1,66 @@
+<?php
+declare(strict_types=1);
+namespace ParagonIE\Ionizer\Test;
+
+use ParagonIE\Ionizer\IndexPolicy\{
+    AnyIndex,
+    IntegersOnly,
+    IndexAllowList,
+    StringsOnly
+};
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+
+
+#[CoversClass(AnyIndex::class)]
+#[CoversClass(IntegersOnly::class)]
+#[CoversClass(IndexAllowList::class)]
+#[CoversClass(StringsOnly::class)]
+class IndexPolicyTest extends TestCase
+{
+    public function testAnyKeys()
+    {
+        $any = new AnyIndex();
+        $this->assertTrue($any->indexIsValid('foo'));
+        $this->assertTrue($any->indexIsValid(1));
+        $this->assertFalse($any->indexIsValid(1.2));
+        $this->assertFalse($any->indexIsValid([]));
+        $this->assertFalse($any->indexIsValid(null));
+    }
+
+    public function testIntegersOnly()
+    {
+        $int = new IntegersOnly();
+        $this->assertTrue($int->indexIsValid(0));
+        $this->assertTrue($int->indexIsValid(1));
+        $this->assertTrue($int->indexIsValid(-1));
+        $this->assertFalse($int->indexIsValid('1'));
+        $this->assertFalse($int->indexIsValid(1.0));
+        $this->assertFalse($int->indexIsValid('foo'));
+    }
+
+    public function testKeyAllowList()
+    {
+        $allow = new IndexAllowList('foo', 'bar', 'baz');
+        $this->assertTrue($allow->indexIsValid('foo'));
+        $this->assertTrue($allow->indexIsValid('bar'));
+        $this->assertTrue($allow->indexIsValid('baz'));
+        $this->assertFalse($allow->indexIsValid('qux'));
+
+        $allow = new IndexAllowList(1, 2, 3);
+        $this->assertTrue($allow->indexIsValid(1));
+        $this->assertTrue($allow->indexIsValid(2));
+        $this->assertTrue($allow->indexIsValid(3));
+        $this->assertFalse($allow->indexIsValid(4));
+        $this->assertFalse($allow->indexIsValid('1'));
+    }
+
+    public function testStringsOnly()
+    {
+        $str = new StringsOnly();
+        $this->assertTrue($str->indexIsValid('foo'));
+        $this->assertTrue($str->indexIsValid('1'));
+        $this->assertFalse($str->indexIsValid(1));
+        $this->assertFalse($str->indexIsValid(1.0));
+    }
+}