Create Lottery.php

src/Contracts/DeferrableProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Hypervel\Support\Contracts;
+
+interface DeferrableProvider
+{
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides();
+}

src/Lottery.php

@@ -0,0 +1,271 @@
+<?php
+
+namespace Hypervel\Support;
+
+use RuntimeException;
+
+class Lottery
+{
+    /**
+     * The number of expected wins.
+     *
+     * @var int|float
+     */
+    protected $chances;
+
+    /**
+     * The number of potential opportunities to win.
+     *
+     * @var int|null
+     */
+    protected $outOf;
+
+    /**
+     * The winning callback.
+     *
+     * @var null|callable
+     */
+    protected $winner;
+
+    /**
+     * The losing callback.
+     *
+     * @var null|callable
+     */
+    protected $loser;
+
+    /**
+     * The factory that should be used to generate results.
+     *
+     * @var callable|null
+     */
+    protected static $resultFactory;
+
+    /**
+     * Create a new Lottery instance.
+     *
+     * @param  int|float  $chances
+     * @param  int|null  $outOf
+     * @return void
+     */
+    public function __construct($chances, $outOf = null)
+    {
+        if ($outOf === null && is_float($chances) && $chances > 1) {
+            throw new RuntimeException('Float must not be greater than 1.');
+        }
+
+        $this->chances = $chances;
+
+        $this->outOf = $outOf;
+    }
+
+    /**
+     * Create a new Lottery instance.
+     *
+     * @param  int|float  $chances
+     * @param  int|null  $outOf
+     * @return static
+     */
+    public static function odds($chances, $outOf = null)
+    {
+        return new static($chances, $outOf);
+    }
+
+    /**
+     * Set the winner callback.
+     *
+     * @param  callable  $callback
+     * @return $this
+     */
+    public function winner($callback)
+    {
+        $this->winner = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Set the loser callback.
+     *
+     * @param  callable  $callback
+     * @return $this
+     */
+    public function loser($callback)
+    {
+        $this->loser = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Run the lottery.
+     *
+     * @param  mixed  ...$args
+     * @return mixed
+     */
+    public function __invoke(...$args)
+    {
+        return $this->runCallback(...$args);
+    }
+
+    /**
+     * Run the lottery.
+     *
+     * @param  null|int  $times
+     * @return mixed
+     */
+    public function choose($times = null)
+    {
+        if ($times === null) {
+            return $this->runCallback();
+        }
+
+        $results = [];
+
+        for ($i = 0; $i < $times; $i++) {
+            $results[] = $this->runCallback();
+        }
+
+        return $results;
+    }
+
+    /**
+     * Run the winner or loser callback, randomly.
+     *
+     * @param  mixed  ...$args
+     * @return callable
+     */
+    protected function runCallback(...$args)
+    {
+        return $this->wins()
+            ? ($this->winner ?? fn () => true)(...$args)
+            : ($this->loser ?? fn () => false)(...$args);
+    }
+
+    /**
+     * Determine if the lottery "wins" or "loses".
+     *
+     * @return bool
+     */
+    protected function wins()
+    {
+        return static::resultFactory()($this->chances, $this->outOf);
+    }
+
+    /**
+     * The factory that determines the lottery result.
+     *
+     * @return callable
+     */
+    protected static function resultFactory()
+    {
+        return static::$resultFactory ?? fn ($chances, $outOf) => $outOf === null
+            ? random_int(0, PHP_INT_MAX) / PHP_INT_MAX <= $chances
+            : random_int(1, $outOf) <= $chances;
+    }
+
+    /**
+     * Force the lottery to always result in a win.
+     *
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public static function alwaysWin($callback = null)
+    {
+        self::setResultFactory(fn () => true);
+
+        if ($callback === null) {
+            return;
+        }
+
+        $callback();
+
+        static::determineResultNormally();
+    }
+
+    /**
+     * Force the lottery to always result in a lose.
+     *
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public static function alwaysLose($callback = null)
+    {
+        self::setResultFactory(fn () => false);
+
+        if ($callback === null) {
+            return;
+        }
+
+        $callback();
+
+        static::determineResultNormally();
+    }
+
+    /**
+     * Set the sequence that will be used to determine lottery results.
+     *
+     * @param  array  $sequence
+     * @param  callable|null  $whenMissing
+     * @return void
+     */
+    public static function fix($sequence, $whenMissing = null)
+    {
+        return static::forceResultWithSequence($sequence, $whenMissing);
+    }
+
+    /**
+     * Set the sequence that will be used to determine lottery results.
+     *
+     * @param  array  $sequence
+     * @param  callable|null  $whenMissing
+     * @return void
+     */
+    public static function forceResultWithSequence($sequence, $whenMissing = null)
+    {
+        $next = 0;
+
+        $whenMissing ??= function ($chances, $outOf) use (&$next) {
+            $factoryCache = static::$resultFactory;
+
+            static::$resultFactory = null;
+
+            $result = static::resultFactory()($chances, $outOf);
+
+            static::$resultFactory = $factoryCache;
+
+            $next++;
+
+            return $result;
+        };
+
+        static::setResultFactory(function ($chances, $outOf) use (&$next, $sequence, $whenMissing) {
+            if (array_key_exists($next, $sequence)) {
+                return $sequence[$next++];
+            }
+
+            return $whenMissing($chances, $outOf);
+        });
+    }
+
+    /**
+     * Indicate that the lottery results should be determined normally.
+     *
+     * @return void
+     */
+    public static function determineResultNormally()
+    {
+        static::$resultFactory = null;
+    }
+
+    /**
+     * Set the factory that should be used to determine the lottery results.
+     *
+     * @param  callable  $factory
+     * @return void
+     */
+    public static function setResultFactory($factory)
+    {
+        self::$resultFactory = $factory;
+    }
+}