<?php
/**
 * Abstract class to create shortcodes in WordPress.
 *
 * @author Mehdi Kabab <http://pioupioum.fr/>
 * @copyright Copyright (C) 2010 Mehdi Kabab
 * @license http://www.gnu.org/licenses/gpl.html  GNU GPL version 3 or later
 * @version 1.0.0
 * @link http://pioupioum.fr/snippets/wordpress-create-shortcode-class.html
 */
abstract class PPM_Shortcode
{
    /**
     * Default options.
     *
     * @var array
     **/
    protected $_default_options = array();
 
    /**
     * Options after initialization of shortcode.
     *
     * @var ArrayObject
     */
    private $_options;
 
    /**
     * Tag name of shortcode.
     *
     * @var string
     **/
    private $_name = null;
 
    /**
     * Constructor.
     *
     * @param string $tag Shortcode tag to be searched in post content.
     */
    public function __construct($tag)
    {
        $this->setTagName($tag);
        $this->_options = new ArrayObject(array(),
                                          ArrayObject::ARRAY_AS_PROPS);
    }
 
    /**
     * Excecute the shortcode.
     *
     * Called by the shortcode API.
     *
     * @param array $attributes Attributes used in the call of the shortcode.
     * @param string $content The content of the shortcode. Default to null.
     * @return string
     */
    public function run($attributes, $content = null)
    {
        $this->setOptions(shortcode_atts($this->_default_options, $attributes));
 
        return $this->_process($attributes, $content);
    }
 
    /**
     * Check if the current shortcode tag already registered.
     *
     * @global array $shortcode_tags
     * @return boolean
     */
    public function isRegistered()
    {
        global $shortcode_tags;
 
        return array_key_exists($this->getTagName(), $shortcode_tags);
    }
 
    /**
     * Register the shortcode.
     *
     * @return PPM_Shortcode
     * @throws Exception If the shortcode already exists.
     */
    public function register()
    {
        if ($this->isRegistered()) {
            throw new Exception(sprintf('The shortcode `%s` already exists!',
                                        $this->getTagName()));
        }
 
        add_shortcode($this->getTagName(), array($this, 'run'));
 
        return $this;
    }
 
    /**
     * Unregister the shortcode.
     *
     * @return PPM_Shortcode
     */
    public function unregister()
    {
        remove_shortcode($this->getTagName());
 
        return $this;
    }
 
    /**
     * Retrieve the name of shortcode.
     *
     * @return string
     */
    public function getTagName()
    {
        return $this->_name;
    }
 
    /**
     * Set the name of shortcode.
     *
     * @param string $name Shortcode tag to be searched in post content.
     * @return PPM_Shortcode
     */
    public function setTagName($name)
    {
        $this->_name = $name;
 
        return $this;
    }
 
    /**
     * Retrieve the requested option.
     *
     * @param string $name The option to search.
     * @return mixed
     */
    public function getOption($name)
    {
        return $this->_options->offsetGet($name);
    }
 
    /**
     * Test if an option exists for the shortcode.
     *
     * @param string $name
     * @return boolean
     */
    public function hasOption($name)
    {
        return $this->_options->offsetExists($name);
    }
 
    /**
     * Set an option.
     *
     * @param string $name
     * @param mixed $value
     * @return PPM_Shortcode
     */
    public function setOption($name, $value)
    {
        $this->_options->offsetSet($name, $value);
 
        return $this;
    }
 
    /**
     * Retrieve the options.
     *
     * @return ArrayObject
     */
    public function getOptions()
    {
        return $this->_options;
    }
 
    /**
     * Set the options.
     *
     * @param array $options
     * @return PPM_Shortcode
     */
    public function setOptions($options)
    {
        foreach ((array) $options as $name => $value) {
            $this->setOption($name, $value);
        }
 
        return $this;
    }
 
    /**
     * Concrete excecution of the shortcode.
     *
     * @param array $attributes Attributes used in the call of the shortcode.
     * @param string $content The content of the shortcode. Default to null.
     * @return string
     */
    abstract protected function _process($attributes, $content = null);
 
}
?>

#!/usr/bin/env php -n
<?php
/**
 * Export a wrapped representation of the words of a text.
 *
 * Optional parameters in a line that follows the text:
 *      l<size>. The column width. Default: 72.
 *      s<characters>. Characters to remove. Default: punctuation.
 *      o<asc|desc>. Sort order. Default: none.
 */
/*
# ***** BEGIN LICENSE BLOCK *****
#
# Copyright (C) 2010 Mehdi Kabab <http://pioupioum.fr/>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without
# restriction, including without limitation the rights to use,
# copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following
# conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
# ***** END LICENSE BLOCK ***** */
 
if (version_compare(PHP_VERSION, '5.0.0', '<')) {
    throw new Exception('You must have PHP >= 5.0.0!');
}
 
$lenght = 72;      // the default column width.
$strip  = '\p{P}'; // removes the ponctuation
$sort   = false;   // no sorting
 
$raw = file('php://filter/read=string.tolower/resource=php://stdin',
            FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
if (isset($raw[1])) {
    $args = array_pop($raw);
    if (preg_match('#^(?:\s{0,}(?:l(?<lenght>\d+)|s(?<strip>.*)|o(?<sort>asc|desc))\s{0,})+$#u', trim($args), $matches)) {
        if (isset($matches['lenght']) && $matches['lenght'])
            $lenght = (int) $matches['lenght'];
        if (isset($matches['strip']) && $matches['strip'])
            $strip .= '|' . $matches['strip'];
        if (isset($matches['sort']) && $matches['sort'])
            $sort = $matches['sort'];
    } else {
        array_push($raw, $args);
    }
}
$raw = implode(' ', $raw);
 
// Removes punctuation and user characters
if ($strip) {
    $strip = str_replace('#', '\#', $strip);
    $raw   = preg_replace('#(' . $strip . ')#u', '', $raw);
}
 
// Estimating indent
$start_index = 0;
if (isset($_SERVER['TM_INPUT_START_LINE_INDEX'])) {
    $start_index = $_SERVER['TM_INPUT_START_LINE_INDEX'];
}
if ('YES' === $_SERVER['TM_SOFT_TABS']) {
    $tab = str_repeat(' ', $_SERVER['TM_TAB_SIZE']);
} else {
    $tab = "\t";
}
$tab_count    = floor($start_index / $_SERVER['TM_TAB_SIZE']);
$extra_spaces = $start_index % $_SERVER['TM_TAB_SIZE'];
$tabs         = str_repeat($tab, $tab_count) . str_repeat(' ', $extra_spaces);
$tabs_len     = $tab_count * $_SERVER['TM_TAB_SIZE'] + $extra_spaces;
 
// Extracting words now!
$words = preg_split('#\s+#', $raw);
$words = array_map('trim', $words);
$words = array_filter(array_unique($words)); // removes empty fields
if ($sort) {
    natsort($words);
    if ('desc' === $sort) {
        $words = array_reverse($words);
    }
}
$words = sprintf('%s\'%s\'',
                 $tabs,
                 wordwrap(implode("', '", $words), $lenght - $tabs_len, "\n$tabs"));
if (0 !== $start_index) {
    $words = ltrim($words);
}
 
if ("''" === $words) {
    return;
}
echo $words;

<?php
/**
 * Get UNIX timestamp for a date or date time.
 *
 * Example:
 * <code>
 * <?php
 * unix_timestamp('2010-03-09 22:43:46'); # 1268171026
 * unix_timestamp('10-03-09 22:43:46');   # 1268171026
 * unix_timestamp('2010-03-09');          # 1268089200
 * ?>
 * </code>
 *
 * @author    Mehdi Kabab <http://pioupioum.fr/>
 * @copyright 2010 Mehdi Kabab
 * @license   http://www.opensource.org/licenses/mit-license.html MIT License
 * @link      http://pioupioum.fr/snippets/php-convertir-datetime-unix-timestamp.html
 *
 * @param string The date or datetime to convert.
 * @return int The UNIX timestamp corresponding to the datetime.
 */
function unix_timestamp($date)
{
	$date = str_replace(array(' ', ':'), '-', $date);
	$c    = explode('-', $date);
	$c    = array_pad($c, 6, 0);
	array_walk($c, 'intval');
 
	return mktime($c[3], $c[4], $c[5], $c[1], $c[2], $c[0]);
}

<?php
/**
 * Reverse a CamelCase string.
 *
 * Examples:
 *     uncamel('lowerCamelCase') === 'lower_camel_case'
 *     uncamel('UpperCamelCase') === 'upper_camel_case'
 *     uncamel('ThisIsAString') === 'this_is_a_string'
 *     uncamel('notcamelcase') === 'notcamelcase'
 *     uncamel('lowerCamelCase', ' | ') === 'lower | camel | case'
 *
 * @author    Mehdi Kabab <http://pioupioum.fr/>
 * @copyright 2010 Mehdi Kabab
 * @license   http://www.opensource.org/licenses/mit-license.html MIT License
 * @link      http://pioupioum.fr/snippets/php-uncamel-fonction-convertir-camel-case.html
 *
 * @param  string $content The CamelCase string.
 * @param  string $separator The glue for the compound words. Defaults to '_'.
 * @return string
 */
function uncamel($content, $separator = '_')
{
	$content = preg_replace('#(?<=[a-zA-Z])([A-Z])(?=[a-zA-Z])#e', "'$separator' . strtolower('$1')", $content);
	$content{0} = strtolower($content{0});
 
	return $content;
}
?>

/**
 * Checks a URL belongs to a given domain.
 *
 * @param string $url The URL to test.
 * @param string $domain The target domain.
 * @return boolean
 */
function isDomainOf($url, $domain)
{
    if (false === filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_HOST_REQUIRED))
    {
        return false;
    }
 
    $host = parse_url($url, PHP_URL_HOST);
    if (false === $host)
    {
        return false;
    }
 
    return (boolean) preg_match('#^(?:[^\.]*\.){0,}' . $domain . '$#', $host);
}

$test = array(
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://pioupioum.fr',
        'synopsis' => 'Le domaine testé lui même.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://example.com',
        'synopsis' => 'Un domaine différent.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://www.pioupioum.fr',
        'synopsis' => 'Un sous-domaine.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://foo.bar.pioupioum.fr',
        'synopsis' => 'Un double sous-domaine.'
    ),
    array(
        'domain'   => 'bar.pioupioum.fr',
        'url'      => 'http://foo.bar.pioupioum.fr',
        'synopsis' => 'Le dommaine cible contient un sous-domaine.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://assets1.pioupioum.fr/foo/bar.png',
        'synopsis' => 'Un contenu hébergé sur un sous-domaine.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://www.example.com/foo/bar.png',
        'synopsis' => 'Un contenu hébergé sur un domaine différent.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://fakepioupioum.fr',
        'synopsis' => 'Un domaine proche.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'http://www.fakepioupioum.fr',
        'synopsis' => 'Un domaine proche avec un sous-domaine.'
    ),
    array(
        'domain'   => 'pioupioum.fr',
        'url'      => 'pioupioum.fr',
        'synopsis' => 'Aucun protocol n\'étant spécifié, la fonction filter_var invalide le test.'
    )
);
 
for ($i = 0, $c = count($test); $c > $i; ++$i)
{
    $ok = isDomainOf($test[$i]['url'], $test[$i]['domain']);
    printf("%s\n[%s] L'URL \"%s\" %s sur le domaine \"%s\".\n\n",
        $test[$i]['synopsis'],
        ($ok) ? 'SUCCESS' : 'FAIL',
        $test[$i]['url'],
        ($ok) ? 'pointe bien' : 'ne pointe pas',
        $test[$i]['domain']
    );
}

<?php
/**
 * Attempts to remove recursively the directory named by dirname.
 *
 * @author Mehdi Kabab <http://pioupioum.fr>
 * @copyright Copyright (C) 2009 Mehdi Kabab
 * @license http://www.gnu.org/licenses/gpl.html  GNU GPL version 3 or later
 *
 * @param string $dirname Path to the directory.
 * @param boolean $followLinks Removes symbolic links if set to TRUE.
 * @return boolean Returns TRUE on success or FALSE on failure.
 * @throws Exception
 */
function recursive_rmdir($dirname, $followLinks = false)
{
    if (is_dir($dirname) && !is_link($dirname))
    {
        if (!is_writable($dirname))
            throw new Exception('You do not have renaming permissions!');
 
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($dirname),
            RecursiveIteratorIterator::CHILD_FIRST
        );
 
        while ($iterator->valid())
        {
            if (!$iterator->isDot())
            {
                if (!$iterator->isWritable())
                {
                    throw new Exception(sprintf(
                        'Permission Denied: %s.',
                        $iterator->getPathName()
                    ));
                }
                if ($iterator->isLink() && false === (boolean) $followLinks)
                {
                    $iterator->next();
                }
                if ($iterator->isFile())
                {
                    unlink($iterator->getPathName());
                }
                else if ($iterator->isDir())
                {
                    rmdir($iterator->getPathName());
                }
            }
 
            $iterator->next();
        }
        unset($iterator); // Fix for Windows.
 
        return rmdir($dirname);
    }
    else
    {
        throw new Exception(sprintf('Directory %s does not exist!', $dirname));
    }
}
?>