cssgrid

#!/usr/bin/env php
<?php
/**
 * CLI script to generate a CSS grid
 *
 * @package CssGridGenerator
 */

namespace Grid;

// Prevents warnings when running in environments that don't have timezone set.
if (!ini_get('date.timezone')) {
    date_default_timezone_set('UTC');
}

$argRules = array(
    'h|help'    => 'help',
    'v|version' => 'version',
);

$args = new ArgV($argv, $argRules);

$grid = new Grid($args);
$grid->calculateColumns();
print $grid->renderCss();

/**
 * Grid class
 *
 * Takes input from CLI arguments and calculates the widths of the grid columns
 *
 * @package CssGridGenerator
 * @author Jansen Price <jansen.price@gmail.com>
 * @version $Id$
 */
class Grid
{
    /**
     * Version constant
     *
     * @var string
     */
    const VERSION = '0.8.2';

    /**
     * Constants for unit types
     *
     * @var string
     */
    const UNIT_PIXELS  = 'pixels';
    const UNIT_PERCENT = 'percent';

    /**
     * Array of possible options for output units
     *
     * @var array
     */
    protected $_outputUnitOptions = array(
        self::UNIT_PIXELS,
        self::UNIT_PERCENT,
    );

    /**
     * Settings
     *
     * @var array
     */
    protected $_settings = array(
        'cols'         => 12,
        'col-width'    => 64,
        'gutter'       => 10,
    );

    /**
     * Storage for the calculated column widths
     *
     * @var array
     */
    protected $_columns = array();

    /**
     * Output units
     *
     * @var string
     */
    protected $_outputUnit = '';

    /**
     * Constructor
     *
     * @param ArgV $args Argument object
     * @return void
     */
    public function __construct(ArgV $args)
    {
        if ($args->version | $args->v) {
            $this->displayVersion();
            exit(0);
        }

        if ($args->help | $args->h | $args->{'?'}) {
            $this->displayHelp();
            exit(0);
        }

        $this->set('cols', $args->cols);
        $this->set('col-width', $args->{'col-width'});
        $this->set('gutter', $args->gutter);

        $this->setOutputUnit($args->units);
    }

    /**
     * Get version of script
     *
     * @return string
     */
    public function getVersion()
    {
        return self::VERSION;
    }

    /**
     * Display version information
     *
     * @return self
     */
    public function displayVersion()
    {
        printf("cssgrid %s\n", $this->getVersion());
        return $this;
    }

    /**
     * Display help information
     *
     * @return self
     */
    public function displayHelp()
    {
        $this->displayVersion();

        print <<<EOS
Generate CSS for a grid based on specified columns, widths and gutter width

Usage: cssgrid [--cols=<number>] [--col-width=<number>] [--gutter=<number>]
       [--outer-margin=<number>] [--units=<pixels|percent>]

Options:
    --cols=<number>          Number of columns (default: 12)
    --col-width=<number>     Width in pixels of the columns (default: 64)
    --gutter=<number>        Width of the gutters between the columns (default: 10)
    --units=<pixels|percent> Output units (pixels or percent)

    -v, --version            Display version information and exit
    -h, --help               Display this help message and exit

Example:
    cssgrid --cols=8 --col-width=180 --gutter=18 --outer-margin=0 --units=percent

Output:
    The output is a CSS ruleset that can be added to a CSS file that defines
    the .grid and .grid-col classes with columns, pushes, pulls, prefixes and
    suffixes.

        The output will include a CSS comment header that provides the date of
    generation and parameters used to generate. It will also include a parameter of
    --max-width that will indicate the grid's total calculated width.


EOS;
    }

    /**
     * Calculate the column widths based on inputs
     *
     * @return self
     */
    public function calculateColumns()
    {
        $cols     = $this->get('cols');
        $colWidth = $this->get('col-width');
        $gutter   = $this->get('gutter');

        $maxWidth = ($colWidth * $cols + $gutter * ($cols - 1));
        $this->set('max-width', $maxWidth);

        $columnCalcs = array(
            'widths' => array(),
            'pushes' => array(),
            'pulls' => array(),
            'prefixes' => array(),
            'suffixes' => array(),
        );
        for ($index = 1; $index <= $cols; $index++) {
            $width = $colWidth * $index + $gutter * ($index - 1);

            $columnCalcs['widths'][$index] = $width;
            $columnCalcs['pushes'][$index] = ($width < $maxWidth) ? $width + $gutter : $width;
            $columnCalcs['pulls'][$index] = ($width < $maxWidth) ? ($width + $gutter) * -1 : $width * -1;
        }

        $this->_columns = $columnCalcs;
        return $this;
    }

    /**
     * Render the CSS
     *
     * @return string Generated CSS
     */
    public function renderCss()
    {
        $cssOutput = new GridOutputCss($this->_outputUnit);

        return $cssOutput->render($this);
    }

    /**
     * Get calculated column widths
     *
     * @return array
     */
    public function getColumnWidths()
    {
        return $this->_columns;
    }

    /**
     * Generate signature used to generate this CSS (input args)
     *
     * @return string
     */
    public function getGenerateSignature()
    {
        // recreate the input args so the defaults are apparent
        $args = array();

        $args[] = '--units=' . $this->_outputUnit;

        foreach ($this->_settings as $key => $value) {
            $args[] = '--' . $key . '=' . $value;
        }

        // create the comments that show the math behind the calculations
        $pixelConversionCommentBegin = $this->isOutputUnitsPercent() ? '(' : '';
        $pixelConversionCommentEnd = $this->isOutputUnitsPercent() ? ' / max-width) * 100' : '';

        $calculationComments  = ' ============================================' . "\n"
            . ' Formulas used for calculation of grid values' . "\n"
            . ' ============================================' . "\n"
            . ' gutter      = ' . $pixelConversionCommentBegin . 'gutter' . $pixelConversionCommentEnd . "\n"
            . ' col-width   = ' . $pixelConversionCommentBegin . '((col-width * col-index) + (gutter * (col-index - 1))' . $pixelConversionCommentEnd . "\n"
            . ' col-push    = ' . $pixelConversionCommentBegin . '((col-width * col-index) + (gutter * col-index))' . $pixelConversionCommentEnd . "\n"
            . ' col-pull    = ' . $pixelConversionCommentBegin . '((col-width * col-index) + (gutter * col-index))' . $pixelConversionCommentEnd . " * -1\n"
            . ' col-prefix  = ' . $pixelConversionCommentBegin . '((col-width * col-index) + (gutter * col-index))' . $pixelConversionCommentEnd . "\n"
            . ' col-suffix  = ' . $pixelConversionCommentBegin . '((col-width * col-index) + (gutter * col-index))' . $pixelConversionCommentEnd . " * -1";

        return 'Generated with cssgrid v' . $this->getVersion()
            . ' at ' . date('Y-m-d H:i:s T') . "\n"
            . ' https://github.com/sumpygump/css-grid-generator' . "\n"
            . ' cssgrid ' . implode(' ', $args) . "\n\n"
            . $calculationComments;
    }

    /**
     * Set output unit
     *
     * @param string $units Output type
     * @return self
     */
    public function setOutputUnit($units)
    {
        if (null === $units
            || !in_array($units, $this->_outputUnitOptions)
        ) {
            $units = self::UNIT_PIXELS;
        }

        $this->_outputUnit = $units;

        return $this;
    }

    /**
     * Set a value
     *
     * @param string $name Name of key
     * @param int|string $value Value
     * @return self
     */
    public function set($name, $value)
    {
        if (null === $value) {
            return $this;
        }

        $this->_settings[$name] = (int) $value;
        return $this;
    }

    /**
     * Return settings value by key name
     *
     * @param string $name Key name
     * @param mixed $default Default value if key doesn't exist
     * @return int
     */
    public function get($name, $default = 0)
    {
        if (isset($this->_settings[$name])) {
            return $this->_settings[$name];
        }

        return $default;
    }

    /**
     * Whether the output units is set to percentage
     *
     * @return bool
     */
    public function isOutputUnitsPercent()
    {
        return $this->_outputUnit == self::UNIT_PERCENT;
    }
}

/**
 * Output class for CSS grid generator
 *
 * @package CssGridGenerator
 * @author Jansen Price <jansen.price@gmail.com>
 * @version $Id$
 */
class GridOutputCss
{
    /**
     * Output type constants
     *
     * @var string
     */
    const OUTPUTUNIT_PIXELS  = 'pixels';
    const OUTPUTUNIT_PERCENT = 'percent';

    /**
     * Template for printf format for grid column CSS rule
     *
     * @var string
     */
    protected $_template = ".grid-col_%dof%d { width: %s; }\n";

    /**
     * Template for printf format for grid push CSS rule
     *
     * @var string
     */
    protected $_pushTemplate = ".mix-grid-col_push%dof%d { left: %s; }\n";

    /**
     * Template for printf format for grid pull CSS rule
     *
     * @var string
     */
    protected $_pullTemplate = ".mix-grid-col_pull%dof%d { left: %s; }\n";

    /**
     * Template for printf format for grid prefix CSS rule
     *
     * @var string
     */
    protected $_prefixTemplate = ".mix-grid-col_prefix%dof%d { margin-left: %s; }\n";

    /**
     * Template for printf format for grid suffix CSS rule
     *
     * @var string
     */
    protected $_suffixTemplate = ".mix-grid-col_suffix%dof%d { margin-right: %s; }\n";

    /**
     * Output unit (pixels or percent)
     *
     * @var string
     */
    protected $_outputUnit = '';

    /**
     * Constructor
     *
     * @param string $outputUnit Output unit type
     * @return void
     */
    public function __construct($outputUnit = null)
    {
        if (null === $outputUnit) {
            $this->_outputUnit = self::OUTPUTUNIT_PIXELS;
        } else {
            $this->_outputUnit = $outputUnit;
        }
    }

    /**
     * Render the CSS
     *
     * @param Grid $grid Grid object
     * @return string
     */
    public function render($grid)
    {
        $css = <<<CSS
/* ---------------------------------------------------------------------
 Grid

 %s
------------------------------------------------------------------------ */
.grid:after {
    content: " ";
    display: block;
    height: 0;
    clear: both;
    visibility: hidden;
}

.grid-col {
    position: relative;
    float: left;
}

.grid-col + .grid-col {
    margin-left: %s;
}

CSS;

        // Format gutter css width (px or %)
        $gutterCssWidth = $this->getCssWidth(
            $grid->get('gutter'), $grid->get('max-width')
        );

        $css = sprintf($css, $grid->getGenerateSignature(), $gutterCssWidth);

        $css .= "\n";

        $columns = $grid->getColumnWidths();

        $totalColumns = count($columns['widths']);

        // Column widths CSS
        foreach ($columns['widths'] as $index => $width) {
            $cssWidth = $this->getCssWidth($width, $grid->get('max-width'));

            $css .= sprintf($this->_template, $index, $totalColumns, $cssWidth);
        }

        $css .= "\n";

        // Column pushes
        foreach ($columns['pushes'] as $index => $push) {
            $pushValue = $this->getCssWidth($push, $grid->get('max-width'));
            $css .= sprintf($this->_pushTemplate, $index, $totalColumns, $pushValue);
        }

        $css .= "\n";

        // Column pulls
        foreach ($columns['pulls'] as $index => $pull) {
            $pullValue = $this->getCssWidth($pull, $grid->get('max-width'));
            $css .= sprintf($this->_pullTemplate, $index, $totalColumns, $pullValue);
        }

        $css .= "\n";

        // Column prefixes
        foreach ($columns['pushes'] as $index => $prefix) {
            $prefixValue = $this->getCssWidth($prefix, $grid->get('max-width'));
            $css .= sprintf($this->_prefixTemplate, $index, $totalColumns, $prefixValue);
        }

        $css .= "\n";

        // Column suffixes
        foreach ($columns['pushes'] as $index => $suffix) {
            $suffixValue = $this->getCssWidth($suffix, $grid->get('max-width'));
            $css .= sprintf($this->_suffixTemplate, $index, $totalColumns, $suffixValue);
        }

        $css .= "\n";

        return $css;
    }

    /**
     * Get the css value for a given column based on current output unit
     *
     * e.g. '24px' or '6.7%'
     *
     * @param int $pixels Width in pixels
     * @param int $maxWidth Max width for entire grid
     * @return string
     */
    public function getCssWidth($pixels, $maxWidth = 1)
    {
        if ($this->isOutputUnitsPercent()) {
            $percent = $pixels / $maxWidth * 100;
            return $percent . '%';
        }

        return $pixels . 'px';
    }

    /**
     * Whether the output units is set to percentage
     *
     * @return bool
     */
    public function isOutputUnitsPercent()
    {
        return $this->_outputUnit == self::OUTPUTUNIT_PERCENT;
    }
}

/**
 * ArgV class file
 *
 * @package Qi
 * @subpackage Console
 */

/**
 * ArgV provides a way to assign and gather command line arguments
 *
 * It will parse and assign option flags and arguments passed
 * in as command line arguments
 *
 * Examples of script arguments it can potentially parse:
 * - short option (-f) : can be grouped (-fvz)
 * - long option (--flag)
 * - short parameter (-p value)
 * - short parameter shunt (-pvalue)
 * - long parameter (--param value)
 * - long parameter shunt (--param=value)
 * - standalone argument (filename)
 *
 * @package Qi
 * @subpackage Console
 * @author Jansen Price <jansen.price@gmail.com>
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 * @version 1.3.4
 */
class ArgV
{
    /**#@+
     * Argument types
     *
     * @var string
     */
    const TYPE_OPTION    = 'option';
    const TYPE_PARAMETER = 'parameter';
    /**#@-*/

    /**
     * Store the argument data
     *
     * @var array
     */
    protected $_data = array();

    /**
     * Storage for the argument rules (params starting with '-' or '--')
     *
     * @var array
     */
    protected $_rules = array();

    /**
     * Map to link short and long argument names (e.g., "-p" and "--param")
     *
     * @var array
     */
    protected $_ruleMap = array();

    /**
     * Storage for the standalone arguments
     *
     * @var array
     */
    protected $_argumentStack = array();

    /**
     * Keep track of the current index of the argumentStack when setting them
     *
     * @var int
     */
    private $_argumentIndex = 1;

    /**
     * Help messages for each argument
     *
     * @var array
     */
    protected $_help = array();

    /**
     * Raw Arguments
     *
     * @var array
     */
    protected $_rawArguments = array();

    /**
     * Rules for parsing parameters
     *
     * @var array
     */
    protected $_rawRules = array();

    /**
     * Flag to indicate whether parsing has been done
     *
     * @var bool
     */
    protected $_hasParsed = false;

    /**
     * Create a new instance of an object of this class.
     *
     * $rules is an array that will specify the short or long names
     * of the option flags, parameters, help text
     * and the names of the arguments.
     *
     * e.g., array(
     *     'help|h'   => 'Show help',
     *     'delete|d' => 'Enter delete mode',
     *     'f'        => 'Flag with no long param name',
     *     'long'     => 'Flag with no short param name',
     *     'name|n:'  => 'Name to use', // colon means parameter required
     *     'arg:file' => 'Filename to use'
     * );
     *
     * So, after constructing the object,
     * the following will be available:
     *     $obj->help and $obj->h
     *     $obj->delete and $obj->d
     *     $obj->f
     *     $obj->long
     *     $obj->name
     *     $obj->file
     *
     * @param array $argv A key=>value array of arguments from the command line
     * @param array $rules A list of option flags and param names for arguments
     * @return void
     */
    public function __construct($argv, $rules = array())
    {
        $this->_rawRules = $rules;
        $this->_parseRules($rules);

        if (is_string($argv)) {
            $argv = self::parseArgumentString($argv);
        } else {
            // assume the script name was the first param if
            // a string was not given as input
            $scriptName = array_shift($argv);
        }

        if (count($argv) <= 0) {
            return;
        }

        $this->_rawArguments = $argv;

        $this->parse($argv);
    }

    /**
     * Get the raw arguments passed into this object
     *
     * @return array Raw arguments
     */
    public function getRawArguments()
    {
        return $this->_rawArguments;
    }

    /**
     * Parse arguments
     *
     * @param array $argv Arguments
     * @return void
     */
    public function parse($argv = null)
    {
        if (null === $argv) {
            $argv = $this->_rawArguments;
        }

        // If already parsed, then re-parse the rules
        // in order to reset the argument stack
        if ($this->_hasParsed === true) {
            $this->_argumentIndex = 1;

            $this->_data = array(); // reset data
            $this->_parseRules($this->_rawRules);
        }

        $this->_hasParsed = true;

        // enforce numeric array
        $argv = array_values($argv);

        for ($i = 0; $i < count($argv); $i++) {
            $val      = $argv[$i];
            $nextVal  = null;
            $shuntVal = '';

            if (substr($val, 0, 2) == "--") {
                $option = substr($val, 2);
                $pos    = false;
                if (strpos($option, '=') !== false) {
                    // Detect long parameter shunt
                    $pos      = strpos($option, '=');
                    $shuntVal = substr($option, $pos + 1);
                    $option   = substr($option, 0, $pos);
                }
                $rule = $this->getRule($option);

                if ($rule['type'] == self::TYPE_PARAMETER || $pos !== false) {
                    if ($shuntVal != '') {
                        $nextVal = $shuntVal;
                    } else {
                        $nextVal = $this->_getProperNextVal($argv, $i);
                    }
                    if (null === $nextVal) {
                        // If we didn't find anything, go back to the shuntval
                        if ($shuntVal != '') {
                            $nextVal = $shuntVal;
                        } else {
                            throw new ArgVException(
                                "Missing required parameter for arg $option"
                            );
                        }
                    }
                } else {
                    $nextVal = true;
                }

                $this->_setSingleOption($option, $nextVal);
            } elseif (substr($val, 0, 1) == "-") {
                $optionString = substr($val, 1);

                $optionStringLength = strlen($optionString);

                for ($s = 0; $s < $optionStringLength; $s++) {
                    $option = $optionString[$s];
                    $rule   = $this->getRule($option);

                    if ($rule['type'] == self::TYPE_PARAMETER) {
                        $nextVal = $this->_getProperNextVal($argv, $i);
                        if (null === $nextVal) {
                            // Detect short parameter shunt
                            if (substr($optionString, $s + 1) != '') {
                                $nextVal = substr($optionString, $s + 1);
                                $this->_setSingleOption($option, $nextVal);
                                break;
                            }
                            throw new ArgVException(
                                "Missing required parameter for arg $option"
                            );
                        }
                    } else {
                        $nextVal = true;
                    }

                    $this->_setSingleOption($option, $nextVal);
                }
            } else {
                $this->_setArgument(array_shift($this->_argumentStack), $val);
            }
        }
    }

    /**
     * Return whether this object has data
     *
     * @return bool
     */
    public function hasData()
    {
        return (!empty($this->_data));
    }

    /**
     * Retrieve the data as an array
     *
     * @return array
     */
    public function toArray()
    {
        return (array) ($this->_data);
    }

    /**
     * Parse rules for configuring this object
     *
     * @param array $rules The rules to parse
     * @return void
     */
    protected function _parseRules($rules)
    {
        $this->_argumentStack = array();

        foreach ($rules as $name => $value) {
            if (substr($name, 0, 4) == 'arg:') {
                // "arg:<something>" is a way to name standalone arguments
                $name = substr($name, 4);

                $this->_argumentStack[] = $name;
                $this->addHelp('<' . $name . '>', $value);
            } else {
                if (is_numeric($name)) {
                    $name  = $value;
                    $value = '';
                } else {
                    $this->addRule($name, $value);
                }
            }
        }
    }

    /**
     * Add a rule
     *
     * @param string $name Name of rule
     * @param string $helpText Help text for this rule
     * @return void
     */
    public function addRule($name, $helpText = null)
    {
        if (substr($name, -1) == ':') {
            // If the name ends in a colon, it requires a parameter
            $type = 'parameter';
            $name = substr($name, 0, -1);
        } else {
            $type = 'option';
        }

        if (strpos($name, '|') !== false) {
            // If the name has a pipe, the first value is the long option
            // name and the second is the short option name
            $parts = explode('|', $name);
            $name  = $parts[0];

            $shortName = substr($parts[1], 0, 1); // force to one char

            $this->_addRule($shortName, $type);
            $this->_addRule($name, $type);
            $this->_mapRules($shortName, $name);
            $helpName = $shortName . '|' . $name;
        } else {
            $this->_addRule($name, $type);
            $helpName = $name;
            if (strlen($name) == 1) {
                // provide backwards compatibility
                $longName = $helpText;
                $helpText = '';
                $this->_addRule($longName, $type);
                $this->_mapRules($name, $longName);
                $helpName = $name . '|' . $longName;
            }
        }

        $this->addHelp($helpName, $helpText);
    }

    /**
     * Add a rule (low level)
     *
     * @param string $name Name of argument
     * @param string $type Argument type
     * @return void
     */
    protected function _addRule($name, $type)
    {
        $this->_rules[$name] = array(
            'type' => $type,
        );
    }

    /**
     * Add a rule map between two argument names
     *
     * @param string $name Name
     * @param string $alias Alias
     * @return void
     */
    protected function _mapRules($name, $alias)
    {
        $this->_ruleMap[$name]  = $alias;
        $this->_ruleMap[$alias] = $name;
    }

    /**
     * Get a rule by it's name
     *
     * @param string $name Rule name
     * @return mixed
     */
    public function getRule($name)
    {
        if (!isset($this->_rules[$name])) {
            return false;
        }

        return $this->_rules[$name];
    }

    /**
     * Add a help message for an argument
     *
     * @param string $name Argument name
     * @param string $helpText Help message
     * @return mixed
     */
    public function addHelp($name, $helpText)
    {
        if (!is_string($name)) {
            return false;
        }

        $this->_help[$name] = $helpText;
    }

    /**
     * Get help messages
     *
     * @return array
     */
    public function getHelp()
    {
        return $this->_help;
    }

    /**
     * Set a single option (one that starts with --)
     *
     * @param string $name Option name
     * @param string $value Option value
     * @return void
     */
    protected function _setSingleOption($name, $value = true)
    {
        $this->_data[$name] = $value;

        if (isset($this->_ruleMap[$name])) {
            $this->_data[$this->_ruleMap[$name]] = $value;
        }
    }

    /**
     * Set an argument
     *
     * @param mixed $argument An argument name
     * @param mixed $value A value
     * @return void
     */
    protected function _setArgument($argument, $value)
    {
        // This is in case the name of the argument
        // was not set during construction
        $this->_data['__arg' . $this->_argumentIndex++] = $value;

        if ($argument) {
            $this->_data[$argument] = $value;
        }
    }

    /**
     * Get a proper next val from the arg list
     *
     * Used to fetch a parameter for arguments that require one
     *
     * @param array $args List of arguments
     * @param int &$i Current index
     * @return mixed
     */
    protected function _getProperNextVal($args, &$i)
    {
        if (!isset($args[$i + 1])) {
            return null;
        }

        $value = $args[$i + 1];

        if (substr($value, 0, 1) == '-') {
            return null;
        }

        $i++; // increment counter so next argument doesn't count as standalone
        return $value;
    }

    /**
     * Getter
     *
     * @param mixed $option The name of the option to get
     * @return mixed The data for the request option or null
     */
    public function __get($option)
    {
        return $this->get($option);
    }

    /**
     * Get an argument by name
     *
     * @param mixed $option The name of the option to get
     * @return mixed The value
     */
    public function get($option)
    {
        if (isset($this->_data[$option])) {
            return $this->_data[$option];
        }
        return null;
    }

    /**
     * Set a variable
     *
     * @param string $var Variable name
     * @param string $value Value
     * @return void
     */
    public function set($var, $value)
    {
        $this->_data[$var] = $value;
    }

    /**
     * Get all (just) the arguments as an array
     *
     * @return array
     */
    public function getArgs()
    {
        $out = array();
        foreach ($this->_data as $arg => $value) {
            if (substr($arg, 0, 5) == '__arg') {
                $out[] = $value;
            }
        }
        return $out;
    }

    /**
     * Parse a string and return an argument array
     *
     * This mimics the way the argv array is created from the
     * parameters given when a program is invoked from the command line
     *
     * @param mixed $input Input as argument string
     * @return void
     */
    public static function parseArgumentString($input)
    {
        $args = preg_split(
            "/[\s,]*\\\"([^\\\"]+)\\\"[\s,]*|"
            . "[\s,]*'([^']+)'[\s,]*|" . "[\s,]+/",
            trim($input), 0,
            PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE
        );
        return $args;
    }
}

/**
 * ArgVException
 *
 * @uses Exception
 * @package Qi
 * @subpackage Console
 * @author Jansen Price <jansen.price@gmail.com>
 * @license http://www.opensource.org/licenses/mit-license.php MIT
 * @version 1.3.4
 */
class ArgVException extends \Exception
{
}