No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Collections/BaseCollection.php b/src/Collections/BaseCollection.php
	index bbb4913..594652c 100644
	--- a/src/Collections/BaseCollection.php
	+++ b/src/Collections/BaseCollection.php
	@@ -1,26 +1,28 @@
	<?php
	declare(strict_types=1);

	namespace Keruald\OmniTools\Collections;

	interface BaseCollection {

	///
	/// Constructors
	///

	public static function from (iterable $items) : static;

	///
	/// Getters
	///

	public function toArray () : array;

	///
	/// Properties
	///

	public function count () : int;

	+ public function isEmpty () : bool;
	+
	}
	diff --git a/src/Collections/HashMap.php b/src/Collections/HashMap.php
	index 980f1de..0a06b9e 100644
	--- a/src/Collections/HashMap.php
	+++ b/src/Collections/HashMap.php
	@@ -1,167 +1,171 @@
	<?php
	declare(strict_types=1);

	namespace Keruald\OmniTools\Collections;

	use Keruald\OmniTools\Reflection\CallableElement;

	use InvalidArgumentException;

	/**
	* An associative array allowing the use of chained
	*
	*
	* This class can be used as a service container,
	* an application context, to store configuration.
	*/
	class HashMap implements BaseCollection, BaseMap {

	///
	/// Properties
	///

	private array $map;

	///
	/// Constructor
	///

	public function __construct (iterable $iterable = []) {
	if (is_array($iterable)) {
	$this->map = (array)$iterable;
	return;
	}

	foreach ($iterable as $key => $value) {
	$this->map[$key] = $value;
	}
	}

	public static function from (iterable $items) : static {
	return new self($items);
	}

	///
	/// Interact with map content at key level
	///

	public function get (mixed $key) : mixed {
	if (!array_key_exists($key, $this->map)) {
	throw new InvalidArgumentException("Key not found.");
	}

	return $this->map[$key];
	}

	public function getOr (mixed $key, mixed $defaultValue) : mixed {
	return $this->map[$key] ?? $defaultValue;
	}

	public function set (mixed $key, mixed $value) : static {
	$this->map[$key] = $value;

	return $this;
	}

	public function has (mixed $key) : bool {
	return array_key_exists($key, $this->map);
	}

	public function contains (mixed $value) : bool {
	return in_array($value, $this->map);
	}

	///
	/// Interact with collection content at collection level
	///

	public function count () : int {
	return count($this->map);
	}

	+ public function isEmpty () : bool {
	+ return $this->count() === 0;
	+ }
	+
	public function clear () : self {
	$this->map = [];

	return $this;
	}

	/**
	* Merge the specified map with the current map.
	*
	* If a key already exists, the value already set is kept.
	*
	* @see update() when you need to update with the new value.
	*/
	public function merge (iterable $iterable) : self {
	foreach ($iterable as $key => $value) {
	$this->map[$key] ??= $value;
	}

	return $this;
	}

	/**
	* Merge the specified map with the current bag.
	*
	* If a key already exists, the value is updated with the new one.
	*
	* @see merge() when you need to keep old value.
	*/
	public function update (iterable $iterable) : self {
	foreach ($iterable as $key => $value) {
	$this->map[$key] = $value;
	}

	return $this;
	}

	/**
	* Gets a copy of the internal map.
	*
	* Scalar values (int, strings) are cloned.
	* Objects are references to a specific objet, not a clone.
	*
	* @return array<string, mixed>
	*/
	public function toArray () : array {
	return $this->map;
	}

	///
	/// HOF
	///

	public function map (callable $callable) : self {
	return new self(array_map($callable, $this->map));
	}

	public function filter (callable $callable) : self {
	$argc = (new CallableElement($callable))->countArguments();
	if ($argc === 0) {
	throw new InvalidArgumentException(
	"Callback should have at least one argument"
	);
	}
	$mode = (int)($argc > 1);

	return new self(
	array_filter($this->map, $callable, $mode)
	);
	}

	public function mapKeys (callable $callable) : self {
	$mappedMap = [];
	foreach ($this->map as $key => $value) {
	$mappedMap[$callable($key)] = $value;
	}

	return new self($mappedMap);
	}

	public function filterKeys (callable $callable) : self {
	return new self(
	array_filter($this->map, $callable, ARRAY_FILTER_USE_KEY)
	);
	}

	}
	diff --git a/src/Collections/Vector.php b/src/Collections/Vector.php
	index dad21fb..c8c3733 100644
	--- a/src/Collections/Vector.php
	+++ b/src/Collections/Vector.php
	@@ -1,206 +1,210 @@
	<?php
	declare(strict_types=1);

	namespace Keruald\OmniTools\Collections;

	use Keruald\OmniTools\Reflection\CallableElement;
	use Keruald\OmniTools\Strings\Multibyte\OmniString;

	use InvalidArgumentException;

	class Vector implements BaseCollection {

	///
	/// Properties
	///

	private array $items;

	///
	/// Constructors
	///

	public function __construct (iterable $items = []) {
	if (is_array($items)) {
	$this->items = $items;
	return;
	}

	foreach ($items as $item) {
	$this->items[] = $item;
	}
	}

	public static function from (iterable $items) : static {
	return new self($items);
	}

	///
	/// Specialized constructors
	///

	/**
	* Constructs a new instance of a vector by exploding a string
	* according a specified delimiter.
	*
	* @param string $delimiter The substring to find for explosion
	* @param string $string The string to explode
	* @param int $limit If specified, the maximum count of vector elements
	* @return static
	*/
	public static function explode (string $delimiter, string $string,
	int $limit = PHP_INT_MAX) : self {
	// There is some discussion to know if this method belongs
	// to Vector or OmniString.
	//
	// The advantage to keep it here is we can have constructs like:
	// Vector::explode(",", "1,1,2,3,5,8,13")
	// ->toIntegers()
	// >map(function($n) { return $n * $n; })
	// ->toArray();
	//
	// In this chaining, it is clear we manipulate Vector methods.

	return (new OmniString($string))
	->explode($delimiter, $limit);
	}

	///
	/// Interact with collection content at key level
	///

	public function get (int $key) : mixed {
	if (!array_key_exists($key, $this->items)) {
	throw new InvalidArgumentException("Key not found.");
	}

	return $this->items[$key];
	}

	public function getOr (int $key, mixed $defaultValue) : mixed {
	return $this->items[$key] ?? $defaultValue;
	}

	public function set (int $key, mixed $value) : static {
	$this->items[$key] = $value;

	return $this;
	}

	public function contains (mixed $value) : bool {
	return in_array($value, $this->items);
	}


	///
	/// Interact with collection content at collection level
	///

	public function count () : int {
	return count($this->items);
	}

	+ public function isEmpty () : bool {
	+ return $this->count() === 0;
	+ }
	+
	public function clear () : self {
	$this->items = [];

	return $this;
	}

	/**
	* Append all elements of the specified iterable
	* to the current vector.
	*
	* If a value already exists, the value is still added
	* as a duplicate.
	*
	* @see update() when you need to only add unique values.
	*/
	public function append (iterable $iterable) : self {
	foreach ($iterable as $value) {
	$this->items[] = $value;
	}

	return $this;
	}

	/**
	* Append all elements of the specified iterable
	* to the current vector.
	*
	* If a value already exists, it is skipped.
	*
	* @see append() when you need to always add everything.
	*/
	public function update (iterable $iterable) : self {
	foreach ($iterable as $value) {
	if (!$this->contains($value)) {
	$this->items[] = $value;
	}
	}

	return $this;
	}

	/**
	* Gets a copy of the internal vector.
	*
	* Scalar values (int, strings) are cloned.
	* Objects are references to a specific objet, not a clone.
	*
	* @return array
	*/
	public function toArray () : array {
	return $this->items;
	}

	///
	/// HOF :: generic
	///

	public function map (callable $callable) : self {
	return new self(array_map($callable, $this->items));
	}

	public function filter (callable $callable) : self {
	$argc = (new CallableElement($callable))->countArguments();

	if ($argc === 0) {
	throw new InvalidArgumentException(
	"Callback should have at least one argument"
	);
	}

	$mode = (int)($argc > 1);
	return new self(array_filter($this->items, $callable, $mode));
	}

	public function mapKeys (callable $callable) : self {
	$mappedVector = [];
	foreach ($this->items as $key => $value) {
	$mappedVector[$callable($key)] = $value;
	}

	return new self($mappedVector);
	}

	public function filterKeys (callable $callable) : self {
	return new self(
	array_filter($this->items, $callable, ARRAY_FILTER_USE_KEY)
	);
	}

	///
	/// HOF :: specialized
	///

	public function toIntegers () : self {
	array_walk($this->items, ArrayUtilities::toIntegerCallback());

	return $this;
	}

	public function implode(string $delimiter) : OmniString {
	return new OmniString(implode($delimiter, $this->items));
	}

	}
	diff --git a/tests/Collections/HashMapTest.php b/tests/Collections/HashMapTest.php
	index e33178f..d815ad4 100644
	--- a/tests/Collections/HashMapTest.php
	+++ b/tests/Collections/HashMapTest.php
	@@ -1,273 +1,279 @@
	<?php

	namespace Keruald\OmniTools\Tests\Collections;

	use Keruald\OmniTools\Collections\HashMap;

	use PHPUnit\Framework\TestCase;

	use InvalidArgumentException;
	use IteratorAggregate;
	use Traversable;

	class HashMapTest extends TestCase {

	///
	/// Test set up
	///

	private HashMap $map;

	const MAP_CONTENT = [
	// Some sci-fi civilizations and author
	"The Culture" => "Iain Banks",
	"Radchaai Empire" => "Ann Leckie",
	"Barrayar" => "Lois McMaster Bujold",
	"Hainish" => "Ursula K. Le Guin",
	];

	protected function setUp () : void {
	$this->map = new HashMap(self::MAP_CONTENT);
	}

	///
	/// Constructors
	///

	public function testConstructorWithArray () {
	$this->assertSame(self::MAP_CONTENT, $this->map->toArray());
	}

	public function testConstructorWithTraversable () {
	$expected = [
	"color" => "blue",
	"material" => "glass",
	"shape" => "sphere",
	];

	$iterable = new class implements IteratorAggregate {
	function getIterator () : Traversable {
	yield "color" => "blue";
	yield "material" => "glass";
	yield "shape" => "sphere";
	}
	};

	$map = new HashMap($iterable);
	$this->assertSame($expected, $map->toArray());
	}

	public function testFrom () {
	$map = HashMap::from(self::MAP_CONTENT);
	$this->assertSame(self::MAP_CONTENT, $map->toArray());
	}

	///
	/// Getters and setters
	///

	public function testGet () {
	$this->assertSame("Iain Banks", $this->map->get("The Culture"));
	}

	public function testGetWhenKeyIsNotFound () {
	$this->expectException(InvalidArgumentException::class);

	$this->map->get("Quuxians");
	}

	public function testGetOr () {
	$actual = $this->map
	->getOr("The Culture", "Another author");

	$this->assertSame("Iain Banks", $actual);
	}

	public function testGetOrWhenKeyIsNotFound () {
	$actual = $this->map
	->getOr("Quuxians", "Another author");

	$this->assertSame("Another author", $actual);
	}

	public function testSetWithNewKey () {
	$this->map->set("Thélème", "François Rabelais");

	$this->assertSame("François Rabelais",
	$this->map->get("Thélème"));
	}

	public function testSetWithExistingKey () {
	$this->map->set("The Culture", "Iain M. Banks");

	$this->assertSame("Iain M. Banks",
	$this->map->get("The Culture"));
	}

	public function testHas () {
	$this->assertTrue($this->map->has("The Culture"));
	$this->assertFalse($this->map->has("Not existing key"));
	}

	public function testContains () {
	$this->assertTrue($this->map->contains("Iain Banks"));
	$this->assertFalse($this->map->contains("Not existing value"));
	}

	///
	/// Collection method
	///

	public function testCount () {
	$this->assertSame(4, $this->map->count());
	}

	public function testClear () {
	$this->map->clear();
	$this->assertSame(0, $this->map->count());
	}

	+ public function testIsEmpty () : void {
	+ $this->map->clear();
	+
	+ $this->assertTrue($this->map->isEmpty());
	+ }
	+
	public function testMerge () {
	$iterable = [
	"The Culture" => "Iain M. Banks", // existing key
	"Thélème" => "François Rabelais", // new key
	];

	$expected = [
	// The original map
	"The Culture" => "Iain Banks", // Old value should be kept
	"Radchaai Empire" => "Ann Leckie",
	"Barrayar" => "Lois McMaster Bujold",
	"Hainish" => "Ursula K. Le Guin",

	// The entries with a new key
	"Thélème" => "François Rabelais",
	];

	$this->map->merge($iterable);
	$this->assertSame($expected, $this->map->toArray());
	}

	public function testUpdate () {
	$iterable = [
	"The Culture" => "Iain M. Banks", // existing key
	"Thélème" => "François Rabelais", // new key
	];

	$expected = [
	// The original map
	"The Culture" => "Iain M. Banks", // Old value should be updated
	"Radchaai Empire" => "Ann Leckie",
	"Barrayar" => "Lois McMaster Bujold",
	"Hainish" => "Ursula K. Le Guin",

	// The entries with a new key
	"Thélème" => "François Rabelais",
	];

	$this->map->update($iterable);
	$this->assertSame($expected, $this->map->toArray());
	}

	public function testToArray () {
	$this->assertEquals(self::MAP_CONTENT, $this->map->toArray());
	}

	///
	/// High order functions
	///

	public function testMap () {
	$callback = function ($value) {
	return "author='" . $value . "'";
	};

	$expected = [
	"The Culture" => "author='Iain Banks'",
	"Radchaai Empire" => "author='Ann Leckie'",
	"Barrayar" => "author='Lois McMaster Bujold'",
	"Hainish" => "author='Ursula K. Le Guin'",
	];

	$actual = $this->map->map($callback)->toArray();
	$this->assertEquals($expected, $actual);
	}

	public function testMapKeys () {
	$callback = function ($key) {
	return "civ::" . $key;
	};

	$expected = [
	// Some sci-fi civilizations and author
	"civ::The Culture" => "Iain Banks",
	"civ::Radchaai Empire" => "Ann Leckie",
	"civ::Barrayar" => "Lois McMaster Bujold",
	"civ::Hainish" => "Ursula K. Le Guin",
	];

	$actual = $this->map->mapKeys($callback)->toArray();
	$this->assertEquals($expected, $actual);
	}

	public function testFilter () {
	// Let's filter to keep names with 3 parts or more

	$callback = function ($value) : bool {
	return str_word_count($value) > 2;
	};

	$expected = [
	// Some sci-fi civilizations and author
	"Barrayar" => "Lois McMaster Bujold",
	"Hainish" => "Ursula K. Le Guin",
	];

	$actual = $this->map->filter($callback)->toArray();
	$this->assertEquals($expected, $actual);
	}

	public function testFilterWithKeyValueCallback () {
	// Let's find civilization AND author with e inside

	$expected = [
	// Some sci-fi civilizations and author
	"Radchaai Empire" => "Ann Leckie",
	];

	$callback = function ($key, $value) : bool {
	return str_contains($key, "e") && str_contains($value, "e");
	};

	$actual = $this->map->filter($callback)->toArray();
	$this->assertEquals($expected, $actual);
	}

	public function testFilterWithCallbackWithoutArgument() {
	$this->expectException(InvalidArgumentException::class);

	$callback = function () : bool { // No argument
	return true;
	};

	$this->map->filter($callback);
	}

	public function testFilterKeys () {
	// Let's filter to keep short civilization names

	$callback = function ($key) : bool {
	return str_word_count($key) == 1;
	};

	$expected = [
	// Some sci-fi civilizations and author
	"Barrayar" => "Lois McMaster Bujold",
	"Hainish" => "Ursula K. Le Guin",
	];

	$actual = $this->map->filterKeys($callback)->toArray();
	$this->assertEquals($expected, $actual);
	}

	}
	diff --git a/tests/Collections/VectorTest.php b/tests/Collections/VectorTest.php
	index f3bc7ce..e3b3ea4 100644
	--- a/tests/Collections/VectorTest.php
	+++ b/tests/Collections/VectorTest.php
	@@ -1,171 +1,177 @@
	<?php
	declare(strict_types=1);

	namespace Keruald\OmniTools\Tests\Collections;

	use Keruald\OmniTools\Collections\Vector;

	use PHPUnit\Framework\TestCase;

	use InvalidArgumentException;
	use IteratorAggregate;
	use Traversable;

	class VectorTest extends TestCase {

	private Vector $vector;

	protected function setUp () : void {
	$this->vector = new Vector([1, 2, 3, 4, 5]);
	}

	public function testConstructorWithIterable () : void {
	$iterable = new class implements IteratorAggregate {
	public function getIterator () : Traversable {
	yield 42;
	yield 100;
	}
	};

	$vector = new Vector($iterable);
	$this->assertEquals([42, 100], $vector->toArray());
	}

	public function testFrom () : void {
	$this->assertEquals([42, 100], Vector::from([42, 100])->toArray());
	}

	public function testGet () : void {
	$vector = new Vector(["a", "b", "c"]);

	$this->assertEquals("b", $vector->get(1));
	}

	public function testGetOverflow () : void {
	$this->expectException(InvalidArgumentException::class);

	$this->vector->get(800);
	}

	public function testGetOr () : void {
	$vector = new Vector(["a", "b", "c"]);

	$this->assertEquals("X", $vector->getOr(800, "X"));
	}

	public function testSet () : void {
	$vector = new Vector(["a", "b", "c"]);
	$vector->set(1, "x"); // should replace "b"

	$this->assertEquals(["a", "x", "c"], $vector->toArray());
	}

	public function testContains () : void {
	$this->assertTrue($this->vector->contains(2));
	$this->assertFalse($this->vector->contains(666));
	}

	public function testCount () : void {
	$this->assertEquals(5, $this->vector->count());
	$this->assertEquals(0, (new Vector)->count());
	}

	public function testClear () : void {
	$this->vector->clear();

	$this->assertEquals(0, $this->vector->count());
	}

	+ public function testIsEmpty () : void {
	+ $this->vector->clear();
	+
	+ $this->assertTrue($this->vector->isEmpty());
	+ }
	+
	public function testAppend () : void {
	$this->vector->append([6, 7, 8]);

	$this->assertEquals([1, 2, 3, 4, 5, 6, 7 ,8], $this->vector->toArray());
	}

	public function testUpdate () : void {
	$this->vector->update([5, 5, 5, 6, 7, 8]); // 5 already exists

	$this->assertEquals([1, 2, 3, 4, 5, 6, 7 ,8], $this->vector->toArray());
	}


	public function testMap () : void {
	$actual = $this->vector
	->map(function ($x) { return $x * $x; })
	->toArray();

	$this->assertEquals([1, 4, 9, 16, 25], $actual);
	}

	public function testMapKeys () : void {
	$vector = new Vector(["foo", "bar", "quux", "xizzy"]);

	$filter = function ($key) {
	return 0; // Let's collapse our array
	};

	$actual = $vector->mapKeys($filter)->toArray();
	$this->assertEquals(["xizzy"], $actual);

	}

	public function testFilter () : void {
	$vector = new Vector(["foo", "bar", "quux", "xizzy"]);

	$filter = function ($item) {
	return strlen($item) === 3; // Let's keep 3-letters words
	};

	$actual = $vector->filter($filter)->toArray();
	$this->assertEquals(["foo", "bar"], $actual);
	}

	public function testFilterWithBadCallback () : void {
	$this->expectException(InvalidArgumentException::class);

	$badFilter = function () {};

	$this->vector->filter($badFilter);
	}

	public function testFilterKeys () : void {
	$filter = function ($key) {
	return $key % 2 === 0; // Let's keep even indices
	};

	$actual = $this->vector
	->filterKeys($filter)
	->toArray();

	$this->assertEquals([0, 2, 4], array_keys($actual));
	}

	public function testImplode() : void {
	$actual = (new Vector(["a", "b", "c"]))
	->implode(".")
	->__toString();

	$this->assertEquals("a.b.c", $actual);
	}

	public function testImplodeWithoutDelimiter() : void {
	$actual = (new Vector(["a", "b", "c"]))
	->implode("")
	->__toString();

	$this->assertEquals("abc", $actual);
	}

	public function testExplode() : void {
	$actual = Vector::explode(".", "a.b.c");

	$this->assertEquals(["a", "b", "c"], $actual->toArray());
	}

	public function testExplodeWithoutDelimiter() : void {
	$actual = Vector::explode("", "a.b.c");

	$this->assertEquals(["a.b.c"], $actual->toArray());
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Dec 26, 16:12 (8 h, 23 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2315153
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions