Abbreviate.module

<?php

namespace ProcessWire;

/**
 * ProcessWire 'Abbreviate' module
 *
 * Hooks the save event to extract and mark all abbreviations
 *
 * Sven Schüring <ssch@zenmotion.de>
 * http://www.zenmotion.de
 *
 * ProcessWire 3.x
 * Copyright (C) 2010 by Ryan Cramer
 * Licensed under GNU/GPL v2, see LICENSE.TXT
 *
 * http://www.processwire.com
 * http://www.ryancramer.com
 */

class Abbreviate extends WireData implements Module, ConfigurableModule
{
    /**
     * database table name
     */
    const TABLE = 'abbreviations';

    /**
     * Version of the module database schema. Used for future schema updates
     */
    const SCHEMA_VERSION = 3;

    /**
     * getModuleInfo is a module required by all modules to tell ProcessWire about them
     *
     * @return array
     */
    public static function getModuleInfo()
    {
        return [
            'title'    => 'Abbreviate',
            'summary'  => 'Easily mark up and manage abbreviations',
            'version'  => 101,
            'href'     => 'http://www.zenmotion.de',
            'singular' => true,
            'autoload' => true,
            'icon'     => 'filter',
            'installs' => 'ProcessAbbreviate',
        ];
    }

    /**
     * Default data for module configuration
     *
     * @return array
     */
    public static function getDefaultData()
    {
        return [
            'autoMarkUp'    => 0,
            'schemaVersion' => 1,
        ];
    }

    /**
     * Populate the default config data
     * Default setting will be overwritten with user specific data
     */
    public function __construct()
    {
        foreach(self::getDefaultData() as $key => $value) {
            $this->$key = $value;
        }
    }

    public static function getModuleConfigInputfields(array $data)
    {
        $fields = new InputfieldWrapper();

        // since this is a static function, we can't use $this->modules, so get them from the global wire() function
        $modules = wire('modules');

        // merge default data (custom values overwrite defaults)
        $defaults = self::getDefaultData();
        $data = array_merge($defaults, $data);

        $field = $modules->get('InputfieldCheckbox');
        $field->attr('name', 'autoMarkUp');
        $field->attr('value', $data['autoMarkUp']);
        if ($data['autoMarkUp']) $field->attr('checked', 'checked');
        $field->label = __('automatic mark up abbreviations?');
        $field->description = __('You can choose this option if you want to automatic mark up abbreviations.');
        $fields->add($field);

        return $fields;
    }

    /**
     * Initialize the module
     *
     * @return void
     */
    public function init()
    {
        // update database schema if not latest
        if ($this->schemaVersion < self::SCHEMA_VERSION) {
            $this->updateDatabaseSchema();
        }

        if ($this->autoMarkUp) {
            $this->pages->addHookBefore('save', $this, 'handleBefore');
        }

        $this->pages->addHookAfter('save', $this, 'handleAfter');
    }

    /**
     * Module handling before page saving
     * Find not marked up abbreviations and mark them up
     *
     * @param  HookEvent $event
     *
     * @return void
     */
    public function handleBefore(HookEvent $event)
    {
        $page          = $event->arguments[0];
        $abbreviations = $this->findAll();

        foreach ($page->fields as $field) {
            if ($field->type instanceof FieldtypeTextarea) {
                $fieldName = $field->name;
                $text      = $page->$fieldName;

                foreach ($abbreviations as $abbreviation) {
                    $text = preg_replace(
                        '/(?!<abbr.*>)\b'. preg_quote($abbreviation->getText(), '/') .'(?!\w)(?!<\/abbr>)/',
                        $abbreviation,
                        $text
                    );
                }
                $page->$fieldName = $text;
            }
        }
    }

    /**
     * Module handling after page saving
     * Do the abbreviation extraction and persist to database
     *
     * @param  HookEvent $event
     *
     * @return void
     */
    public function handleAfter(HookEvent $event)
    {
        $page = $event->arguments[0];

        $abbreviations = [];
        foreach ($page->fields as $field) {
            if ($field->type instanceof FieldtypeTextarea) {
                $fieldName = $field->name;

                $abbreviations = array_merge($abbreviations, $this->extractAbbreviations($page->$fieldName));
            }
        }

        if (count($abbreviations) > 0) {
            $this->insert($abbreviations);

            $this->message(count($abbreviations) .' abbreviations found');
        }
    }

    /**
     * Extract all abbreviations and returns a array of Abbreviation
     *
     * @param  string $content
     *
     * @return array
     */
    public function extractAbbreviations($content)
    {
        preg_match_all('/<abbr.*title=".*".*>.*<\/abbr>/U', $content, $matches);

        foreach ($matches[0] as $value) {
            $abbreviation = new Abbreviation();

            // Attribute name at [1][x]
            // Attribute value at [2][x]
            // http://stackoverflow.com/questions/317053/regular-expression-for-extracting-tag-attributes#317081
            preg_match_all('/(\S+)=["]?((?:.(?!["]?\s+(?:\S+)=|[>"]))+.)["]?/', $value, $attributes);
            // Text of abbreviation is at [1][0]
            preg_match_all('/<abbr.*title=".*".*>(.*)<\/abbr>/U', $value, $text);

            $abbreviation->setText($text[1][0]);
            $abbreviation->setTitle($attributes[2][array_search('title', $attributes[1])]);
            if (in_array('lang', $attributes[1]))
                $abbreviation->setLanguage($attributes[2][array_search('lang', $attributes[1])]);

            $abbreviations[] = $abbreviation;
        }

        return isset($abbreviations) ? $abbreviations : [];
    }

    /**
     * Inserts all objects of Abbreviation
     *
     * @param  array  $abbreviations
     *
     * @return boolean
     */
    public function insert(array $abbreviations)
    {
        $abbreviations = array_unique($abbreviations);

        foreach ($abbreviations as $abbreviation) {
            $values[] = '('. implode(', ', [
                $this->database->quote($abbreviation->getText()),
                $this->database->quote($abbreviation->getTitle()),
                $this->database->quote($abbreviation->getLanguage()),
            ]) .')';
        }

        // slightly overwrite the duplicate abbreviation with the new/updated one
        $sql  = 'INSERT INTO '. self::TABLE;
        $sql .= ' (`text`, `title`, `language`) VALUES '. implode(',', $values);
        $sql .= ' ON DUPLICATE KEY UPDATE';
        $sql .= ' text=IF(VALUES(text) != "", VALUES(text), text),';
        $sql .= ' title=title,';
        $sql .= ' language=IF(VALUES(language) != "", VALUES(language), language)';

        try {
            if ($this->database->query($sql))
                return true;
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }

        return false;
    }

    /**
     * Delete the given abbreviation
     *
     * @param  Abbreviation $abbreviation
     *
     * @return boolean
     */
    public function delete(Abbreviation $abbreviation)
    {
        $sql = 'DELETE FROM '. self::TABLE .' WHERE `id`=:id';

        try {
            $query = $this->database->prepare($sql);
            $query->bindValue(':id', $abbreviation->getId());

            if ($query->execute()) {

                return true;
            }
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }

        return false;
    }

    /**
     * Find all saved abbreviations and return a array of Abbreviation
     *
     * @return array|false
     */
    public function findAll()
    {
        $sql = 'SELECT * FROM '. self::TABLE;

        try {
            $query = $this->database->prepare($sql);
            $query->execute();

            while ($row = $query->fetch(\PDO::FETCH_ASSOC)) {
                $abbreviation = new Abbreviation();
                $abbreviation->setId($row['id']);
                $abbreviation->setText($row['text']);
                $abbreviation->setTitle($row['title']);
                $abbreviation->setLanguage($row['language']);

                $abbreviations[] = $abbreviation;
            }
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }

        return isset($abbreviations) ? $abbreviations : false;
    }

    /**
     * Find one abbreviation by id and return a array of Abbreviation
     *
     * @param  string $id
     *
     * @return array|false
     */
    public function findOneById($id)
    {
        $sql = 'SELECT * FROM '. self::TABLE .' WHERE `id`=:id';

        try {
            $query = $this->database->prepare($sql);
            $query->bindValue(':id', $id);
            $query->execute();

            while ($row = $query->fetch(\PDO::FETCH_ASSOC)) {
                $abbreviation = new Abbreviation();
                $abbreviation->setId($row['id']);
                $abbreviation->setText($row['text']);
                $abbreviation->setTitle($row['title']);
                $abbreviation->setLanguage($row['language']);
            }
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }

        return isset($abbreviation) ? $abbreviation : false;
    }

    /**
     * Find all abbreviations by text and return a array of Abbreviation
     *
     * @param  string $text
     *
     * @return array|false
     */
    public function findAllByText($text)
    {
        $sql = 'SELECT * FROM '. self::TABLE .' WHERE `text`=:text';

        try {
            $query = $this->database->prepare($sql);
            $query->bindValue(':text', $text);
            $query->execute();

            while ($row = $query->fetch(\PDO::FETCH_ASSOC)) {
                $abbreviation = new Abbreviation();
                $abbreviation->setId($row['id']);
                $abbreviation->setText($row['text']);
                $abbreviation->setTitle($row['title']);
                $abbreviation->setLanguage($row['language']);

                $abbreviations[] = $abbreviation;
            }
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }

        return isset($abbreviations) ? $abbreviations : false;
    }

    /**
     * Update to the current database schema needed for latest module version
     *
     * @return boolean
     */
    protected function updateDatabaseSchema()
    {
        while ($this->schemaVersion < self::SCHEMA_VERSION) {
            ++$this->schemaVersion;

            switch ($this->schemaVersion) {
                case 2:
                    $sql = 'ALTER TABLE ' . self::TABLE . ' ADD `language` varchar(10) AFTER `title`';
                    $query = $this->database->prepare($sql);
                    break;
                case 3:
                    $maxIndexLength = $this->database->getMaxIndexLength();
                    $sql = 'ALTER TABLE ' . self::TABLE . ' MODIFY COLUMN `title` varchar(:maxIndexLength)';
                    $query = $this->database->prepare($sql);
                    $query->bindValue(':maxIndexLength', $maxIndexLength, \PDO::PARAM_INT);
                    break;
                default:
                    throw new WireException('Unrecognized database schema version: '. $this->schemaVersion);
            }

            if ($sql && $query->execute()) {
                $configData = $this->modules->getModuleConfigData($this);
                $configData['schemaVersion'] = $this->schemaVersion;
                $this->modules->saveModuleConfigData($this, $configData);
            } else {
                throw new WireException('Could not update database schema to version '. $this->schemaVersion);
            }
        }

        return true;
    }

    /**
     * Called when the module will installed
     *
     * @return void
     */
    public function ___install()
    {
        // initial schema state - updateDatabaseSchema() will do some updates if needed
        $sql = 'CREATE TABLE '. self::TABLE .'('.
               '`id` int unsigned NOT NULL AUTO_INCREMENT PRIMARY KEY, '.
               '`text` varchar(128) NOT NULL, '.
               '`title` varchar(:maxIndexLength) NOT NULL, '.
               'UNIQUE `title`(`title`)'.
               ');';

        try {
            $maxIndexLength = $this->database->getMaxIndexLength();

            $query = $this->database->prepare($sql);
            $query->bindValue(':maxIndexLength', $maxIndexLength, \PDO::PARAM_INT);
            $query->execute();
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }
    }

    /**
     * Called when the module will uninstalled
     *
     * @return void
     */
    public function ___uninstall()
    {
        $sql = 'DROP TABLE '. self::TABLE .';';

        try {
            $this->database->query($sql);
        } catch (\Exception $e) {
            $this->error($e->getMessage());
        }
    }
}