1 files changed, 287 insertions, 0 deletions
diff --git a/platform/www/inc/Input/Input.php b/platform/www/inc/Input/Input.php
new file mode 100644
index 0000000..3d2426b
--- /dev/null
+++ b/platform/www/inc/Input/Input.php
@@ -0,0 +1,287 @@
+<?php
+
+namespace dokuwiki\Input;
+
+/**
+ * Encapsulates access to the $_REQUEST array, making sure used parameters are initialized and
+ * have the correct type.
+ *
+ * All function access the $_REQUEST array by default, if you want to access $_POST or $_GET
+ * explicitly use the $post and $get members.
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ */
+class Input
+{
+
+    /** @var Post Access $_POST parameters */
+    public $post;
+    /** @var Get Access $_GET parameters */
+    public $get;
+    /** @var Server Access $_SERVER parameters */
+    public $server;
+
+    protected $access;
+
+    /**
+     * @var Callable
+     */
+    protected $filter;
+
+    /**
+     * Intilizes the dokuwiki\Input\Input class and it subcomponents
+     */
+    public function __construct()
+    {
+        $this->access = &$_REQUEST;
+        $this->post = new Post();
+        $this->get = new Get();
+        $this->server = new Server();
+    }
+
+    /**
+     * Apply the set filter to the given value
+     *
+     * @param string $data
+     * @return string
+     */
+    protected function applyfilter($data)
+    {
+        if (!$this->filter) return $data;
+        return call_user_func($this->filter, $data);
+    }
+
+    /**
+     * Return a filtered copy of the input object
+     *
+     * Expects a callable that accepts one string parameter and returns a filtered string
+     *
+     * @param Callable|string $filter
+     * @return Input
+     */
+    public function filter($filter = 'stripctl')
+    {
+        $this->filter = $filter;
+        $clone = clone $this;
+        $this->filter = '';
+        return $clone;
+    }
+
+    /**
+     * Check if a parameter was set
+     *
+     * Basically a wrapper around isset. When called on the $post and $get subclasses,
+     * the parameter is set to $_POST or $_GET and to $_REQUEST
+     *
+     * @see isset
+     * @param string $name Parameter name
+     * @return bool
+     */
+    public function has($name)
+    {
+        return isset($this->access[$name]);
+    }
+
+    /**
+     * Remove a parameter from the superglobals
+     *
+     * Basically a wrapper around unset. When NOT called on the $post and $get subclasses,
+     * the parameter will also be removed from $_POST or $_GET
+     *
+     * @see isset
+     * @param string $name Parameter name
+     */
+    public function remove($name)
+    {
+        if (isset($this->access[$name])) {
+            unset($this->access[$name]);
+        }
+        // also remove from sub classes
+        if (isset($this->post) && isset($_POST[$name])) {
+            unset($_POST[$name]);
+        }
+        if (isset($this->get) && isset($_GET[$name])) {
+            unset($_GET[$name]);
+        }
+    }
+
+    /**
+     * Access a request parameter without any type conversion
+     *
+     * @param string $name Parameter name
+     * @param mixed $default Default to return if parameter isn't set
+     * @param bool $nonempty Return $default if parameter is set but empty()
+     * @return mixed
+     */
+    public function param($name, $default = null, $nonempty = false)
+    {
+        if (!isset($this->access[$name])) return $default;
+        $value = $this->applyfilter($this->access[$name]);
+        if ($nonempty && empty($value)) return $default;
+        return $value;
+    }
+
+    /**
+     * Sets a parameter
+     *
+     * @param string $name Parameter name
+     * @param mixed $value Value to set
+     */
+    public function set($name, $value)
+    {
+        $this->access[$name] = $value;
+    }
+
+    /**
+     * Get a reference to a request parameter
+     *
+     * This avoids copying data in memory, when the parameter is not set it will be created
+     * and intialized with the given $default value before a reference is returned
+     *
+     * @param string $name Parameter name
+     * @param mixed $default If parameter is not set, initialize with this value
+     * @param bool $nonempty Init with $default if parameter is set but empty()
+     * @return mixed (reference)
+     */
+    public function &ref($name, $default = '', $nonempty = false)
+    {
+        if (!isset($this->access[$name]) || ($nonempty && empty($this->access[$name]))) {
+            $this->set($name, $default);
+        }
+
+        return $this->access[$name];
+    }
+
+    /**
+     * Access a request parameter as int
+     *
+     * @param string $name Parameter name
+     * @param int $default Default to return if parameter isn't set or is an array
+     * @param bool $nonempty Return $default if parameter is set but empty()
+     * @return int
+     */
+    public function int($name, $default = 0, $nonempty = false)
+    {
+        if (!isset($this->access[$name])) return $default;
+        if (is_array($this->access[$name])) return $default;
+        $value = $this->applyfilter($this->access[$name]);
+        if ($value === '') return $default;
+        if ($nonempty && empty($value)) return $default;
+
+        return (int)$value;
+    }
+
+    /**
+     * Access a request parameter as string
+     *
+     * @param string $name Parameter name
+     * @param string $default Default to return if parameter isn't set or is an array
+     * @param bool $nonempty Return $default if parameter is set but empty()
+     * @return string
+     */
+    public function str($name, $default = '', $nonempty = false)
+    {
+        if (!isset($this->access[$name])) return $default;
+        if (is_array($this->access[$name])) return $default;
+        $value = $this->applyfilter($this->access[$name]);
+        if ($nonempty && empty($value)) return $default;
+
+        return (string)$value;
+    }
+
+    /**
+     * Access a request parameter and make sure it is has a valid value
+     *
+     * Please note that comparisons to the valid values are not done typesafe (request vars
+     * are always strings) however the function will return the correct type from the $valids
+     * array when an match was found.
+     *
+     * @param string $name Parameter name
+     * @param array $valids Array of valid values
+     * @param mixed $default Default to return if parameter isn't set or not valid
+     * @return null|mixed
+     */
+    public function valid($name, $valids, $default = null)
+    {
+        if (!isset($this->access[$name])) return $default;
+        if (is_array($this->access[$name])) return $default; // we don't allow arrays
+        $value = $this->applyfilter($this->access[$name]);
+        $found = array_search($value, $valids);
+        if ($found !== false) return $valids[$found]; // return the valid value for type safety
+        return $default;
+    }
+
+    /**
+     * Access a request parameter as bool
+     *
+     * Note: $nonempty is here for interface consistency and makes not much sense for booleans
+     *
+     * @param string $name Parameter name
+     * @param mixed $default Default to return if parameter isn't set
+     * @param bool $nonempty Return $default if parameter is set but empty()
+     * @return bool
+     */
+    public function bool($name, $default = false, $nonempty = false)
+    {
+        if (!isset($this->access[$name])) return $default;
+        if (is_array($this->access[$name])) return $default;
+        $value = $this->applyfilter($this->access[$name]);
+        if ($value === '') return $default;
+        if ($nonempty && empty($value)) return $default;
+
+        return (bool)$value;
+    }
+
+    /**
+     * Access a request parameter as array
+     *
+     * @param string $name Parameter name
+     * @param mixed $default Default to return if parameter isn't set
+     * @param bool $nonempty Return $default if parameter is set but empty()
+     * @return array
+     */
+    public function arr($name, $default = array(), $nonempty = false)
+    {
+        if (!isset($this->access[$name])) return $default;
+        if (!is_array($this->access[$name])) return $default;
+        if ($nonempty && empty($this->access[$name])) return $default;
+
+        return (array)$this->access[$name];
+    }
+
+    /**
+     * Create a simple key from an array key
+     *
+     * This is useful to access keys where the information is given as an array key or as a single array value.
+     * For example when the information was submitted as the name of a submit button.
+     *
+     * This function directly changes the access array.
+     *
+     * Eg. $_REQUEST['do']['save']='Speichern' becomes $_REQUEST['do'] = 'save'
+     *
+     * This function returns the $INPUT object itself for easy chaining
+     *
+     * @param string $name
+     * @return Input
+     */
+    public function extract($name)
+    {
+        if (!isset($this->access[$name])) return $this;
+        if (!is_array($this->access[$name])) return $this;
+        $keys = array_keys($this->access[$name]);
+        if (!$keys) {
+            // this was an empty array
+            $this->remove($name);
+            return $this;
+        }
+        // get the first key
+        $value = array_shift($keys);
+        if ($value === 0) {
+            // we had a numeric array, assume the value is not in the key
+            $value = array_shift($this->access[$name]);
+        }
+
+        $this->set($name, $value);
+        return $this;
+    }
+}