cakephp2-php8/libs/bake.php

<?php
/* SVN FILE: $Id$ */

/**
 * Creates ready-to-use file skeletons for applications.
 * 
 * Creates controller, model, view files, and the required directories on demand.
 * Used by /scripts/bake.php.
 *
 * PHP versions 4 and 5
 *
 * CakePHP :  Rapid Development Framework <http://www.cakephp.org/>
 * Copyright (c) 2005, CakePHP Authors/Developers
 *
 * Author(s): Michal Tatarynowicz aka Pies <tatarynowicz@gmail.com>
 *            Larry E. Masters aka PhpNut <nut@phpnut.com>
 *            Kamil Dzielinski aka Brego <brego.dk@gmail.com>
 *
 *  Licensed under The MIT License
 *  Redistributions of files must retain the above copyright notice.
 *
 * @filesource 
 * @author       CakePHP Authors/Developers
 * @copyright    Copyright (c) 2005, CakePHP Authors/Developers
 * @link         https://trac.cakephp.org/wiki/Authors Authors/Developers
 * @package      cake
 * @subpackage   cake.libs
 * @since        CakePHP v 0.2.9
 * @version      $Revision$
 * @modifiedby   $LastChangedBy$
 * @lastmodified $Date$
 * @license      http://www.opensource.org/licenses/mit-license.php The MIT License
 */

/**
 * Require needed libraries.
 */
uses('object', 'inflector');

/**
 * Creates ready-to-use file skeletons for applications.
 * 
 * Bake class creates files in configured application directories. This is a
 * base class for /scripts/add.php.
 *
 * @package    cake
 * @subpackage cake.libs
 * @since      CakePHP v 0.2.9
  */
class Bake extends Object
{
    /**
     * Standard input stream (php://stdin).
     *
     * @var    resource
     * @access private
     */
    var $stdin = null;

    /**
     * Standard output stream (php://stdout).
     *
     * @var    resource
     * @access private
     */
    var $stdout = null;

    /**
     * Standard error stream (php://stderr).
     *
     * @var    resource
     * @access private
     */
    var $stderr = null;

    /**
     * Counts actions taken.
     *
     * @var    integer
     * @access private
     */
    var $actions = null;

    /**
     * Decides whether to overwrite existing files without asking.
     *
     * @var    boolean
     * @access private
     */
    var $dontAsk = false;

    /**
     * Returns code template for PHP file generator.
     *
     * @param  string $type
     * @return string
     * @access private
     */
    function template($type)
    {
        switch ($type)
        {
            case 'view':   return "%s";
            case 'model':  return "<?php\n\nclass %s extends AppModel {\n}\n\n?>";
            case 'action': return "\n\tfunction %s () {\n\t}\n";
            case 'ctrl':   return "<?php\n\nclass %s extends %s {\n%s\n}\n\n?>";
            case 'helper': return "<?php\n\nclass %s extends AppController {\n}\n\n?>";
            case 'test':   return '<?php

class %sTest extends TestCase
{
    var $abc;

    // called before the tests
    function setUp() 
    {
        $this->abc = new %s ();
    }

    // called after the tests
    function tearDown() 
    {
        unset($this->abc);
    }
   
/*
    function testFoo () 
    {
        $result   = $this->abc->Foo();
        $expected = \'\';
        $this->assertEquals($result, $expected);
    }
*/
}

?>';
            default: return false;
        }
    }


    /**
     * Baker's constructor method. Initialises bakery, and starts production.
     *
     * @param  string $type
     * @param  array $names
     * @access public
     * @uses   Bake::stdin           Opens stream for reading.
     * @uses   Bake::stdout          Opens stream for writing.
     * @uses   Bake::stderr          Opens stream for writing.
     * @uses   Bake::newModel()      Depending on the case, can create a new model.
     * @uses   Bake::newView()       Depending on the case, can create a new view.
     * @uses   Bake::newController() Depending on the case, can create a new controller.
     */
    function __construct($type, $names)
    {
        $this->stdin  = fopen('php://stdin', 'r');
        $this->stdout = fopen('php://stdout', 'w');
        $this->stderr = fopen('php://stderr', 'w');

        // Output directory name
        fwrite($this->stderr, "\n".substr(ROOT,0,strlen(ROOT)-1).":\n".str_repeat('-',strlen(ROOT)+1)."\n");

        switch ($type)
        {
            case 'model':
            case 'models':
                foreach ($names as $model_name)
                {
                    $this->newModel($model_name);
                }
                break;

            case 'controller':
            case 'ctrl':
                $controller  = array_shift($names);
                $add_actions = array();
                foreach ($names as $action)
                {
                    $add_actions[] = $action;
                    $this->newView($controller, $action);
                }

                $this->newController($controller, $add_actions);
                break;

            case 'view':
            case 'views':
                $r = null;
                foreach ($names as $model_name)
                {
                    if (preg_match('/^([a-z0-9_]+(?:\/[a-z0-9_]+)*)\/([a-z0-9_]+)$/i', $model_name, $r))
                    {
                        $this->newView($r[1], $r[2]);
                    }
                }
                break;
        }

        if (!$this->actions)
        {
            fwrite($this->stderr, "Nothing to do, quitting.\n");
        }

    }

    /**
     * Creates new view in VIEWS/$controller/ directory.
     *
     * @param  string $controller
     * @param  string $name
     * @access private
     * @uses   Inflector::underscore() Underscores directory's name.
     * @uses   Bake::createDir()       Creates new directory in views dir, named after the controller.
     * @uses   VIEWS
     * @uses   Bake::createFile()      Creates view file.
     * @uses   Bake::template()        Collects view template.
     * @uses   Bake::actions           Adds one action for each run.
     */
    function newView($controller, $name)
    {
        //$controller = Inflector::pluralize($controller);
        $dir  = Inflector::underscore($controller);
        $path = $dir.DS.strtolower($name).".thtml";
        $this->createDir(VIEWS.$dir);
        $fn = VIEWS.$path;
        $this->createFile($fn, sprintf($this->template('view'), "<p>Edit <b>app".DS."views".DS."{$path}</b> to change this message.</p>"));
        $this->actions++;
    }

    /**
     * Creates new controller with defined actions, controller's test and helper
     * with helper's test.
     *
     * @param  string $name
     * @param  array $actions
     * @access private
     * @uses   Inflector::pluralize()
     * @uses   Bake::makeController()
     * @uses   Bake::makeControllerTest()
     * @uses   Bake::makeHelper()
     * @uses   Bake::makeHelperTest()
     * @uses   Bake::actions              Adds one action for each run.
     */
    function newController($name, $actions = array())
    {
        //$name = Inflector::pluralize($name);
        $this->makeController($name, $actions);
        $this->makeControllerTest($name);
        $this->makeHelper($name);
        $this->makeHelperTest($name);
        $this->actions++;
    }

    /**
     * Creates new controller file with defined actions.
     *
     * @param  string $name
     * @param  array $actions
     * @return boolean
     * @access private
     * @uses   Bake::makeControllerName() CamelCase for controller's name.
     * @uses   Bake::makeHelperName()     CamelCase for helper's name. 
     * @uses   Bake::template()           Controller's template.
     * @uses   Bake::getActions()         Actions' templates to be included in the controller.
     * @uses   Bake::createFile()         Creates controller's file.
     * @uses   Bake::makeControllerFn()   Underscored name for controller's filename.
     */
    function makeController($name, $actions)
    {
        $ctrl   = $this->makeControllerName($name);
        $helper = $this->makeHelperName($name);
        $body   = sprintf($this->template('ctrl'), $ctrl, $helper, join('', $this->getActions($actions)));
        return $this->createFile($this->makeControllerFn($name), $body);
    }

    /**
     * Returns controller's name in CamelCase.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   Inflector::camelize CamelCase for controller name.
     */
    function makeControllerName($name)
    {
        return Inflector::camelize($name).'Controller';
    }

    /**
     * Returns a name for controller's file, underscored.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   Inflector::underscore() Underscore for controller's file name.
     */
    function makeControllerFn($name)
    {
        return CONTROLLERS.Inflector::underscore($name).'_controller.php';
    }

    /**
     * Creates new test for a controller.
     *
     * @param  string $name
     * @return boolean
     * @access private
     * @uses   CONTROLLER_TESTS
     * @uses   Inflector::underscore()
     * @uses   Bake::getTestBody()
     * @uses   Bake::makeControllerName()
     * @uses   Bake::createFile()
     */
    function makeControllerTest($name)
    {
        $fn   = CONTROLLER_TESTS.Inflector::underscore($name).'_controller_test.php';
        $body = $this->getTestBody($this->makeControllerName($name));
        return $this->createFile($fn, $body);
    }

    /**
     * Creates new helper.
     *
     * @param  string $name
     * @return boolean
     * @access private
     * @uses   Bake::template()
     * @uses   Bake::makeHelperName()
     * @uses   Bake::createFile()
     * @uses   Bake::makeHelperFn()
     */
    function makeHelper($name)
    {
        $body = sprintf($this->template('helper'), $this->makeHelperName($name));
        return $this->createFile($this->makeHelperFn($name), $body);
    }

    /**
     * Returns CamelCase name for a helper.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   Inflector::camelize()
     */
    function makeHelperName($name)
    {
        return Inflector::camelize($name).'Helper';
    }

    /**
     * Underscores file name for a helper.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   HELPERS
     * @uses   Inflector::underscore()
     */
    function makeHelperFn($name)
    {
        return HELPERS.Inflector::underscore($name).'_helper.php';
    }

    /**
     * Creates new test for a helper.
     *
     * @param  string $name
     * @return boolean
     * @access private
     * @uses   HELPER_TESTS
     * @uses   Inflector::underscore()
     * @uses   Bake::getTestBody()
     * @uses   Bake::makeHelperName()
     * @uses   Bake::createFile()
     */
    function makeHelperTest($name)
    {
        $fn   = HELPER_TESTS.Inflector::underscore($name).'_helper_test.php';
        $body = $this->getTestBody($this->makeHelperName($name));
        return $this->createFile($fn, $body);
    }

    /**
     * Returns an array of actions' templates.
     *
     * @param  array $as
     * @return array
     * @access private
     * @uses   Bake::template()
     */
    function getActions($as)
    {
        $out = array();
        foreach ($as as $a)
        {
            $out[] = sprintf($this->template('action'), $a);
        }
        return $out;
    }

    /**
     * Returns a test template for given class.
     *
     * @param  string $class
     * @return string
     * @access private
     * @uses   Bake::template()
     */
    function getTestBody($class)
    {
        return sprintf($this->template('test'), $class, $class);
    }

    /**
     * Creates new model.
     *
     * @param  string $name
     * @access private
     * @uses   Bake::createFile()
     * @uses   Bake::getModelFn()
     * @uses   Bake::template()
     * @uses   Bake::getModelName()
     * @uses   Bake::makeModelTest()
     * @uses   Bake::actions
     */
    function newModel($name)
    {
        $this->createFile($this->getModelFn($name), sprintf($this->template('model'), $this->getModelName($name)));
        $this->makeModelTest ($name);
        $this->actions++;
    }

    /**
     * Returns an underscored filename for a model.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   MODELS
     * @uses   Inflector::underscore()
     */
    function getModelFn($name)
    {
        return MODELS.Inflector::underscore($name).'.php';
    }

    /**
     * Creates a test for given model.
     *
     * @param  string $name
     * @return boolean
     * @access private
     * @uses   MODEL_TESTS
     * @uses   Inflector::underscore()
     * @uses   Bake::getTestBody()
     * @uses   Bake::getModelName()
     * @uses   Bake::createFile()
     */
    function makeModelTest($name)
    {
        $fn   = MODEL_TESTS.Inflector::underscore($name).'_test.php';
        $body = $this->getTestBody($this->getModelName($name));
        return $this->createFile($fn, $body);
    }

    /**
     * Returns CamelCased name of a model.
     *
     * @param  string $name
     * @return string
     * @access private
     * @uses   Inflector::camelize()
     */
    function getModelName($name)
    {
        return Inflector::camelize($name);
    }

    /**
     * Creates a file with given path and contents.
     *
     * @param  string $path
     * @param  string $contents
     * @return boolean
     * @access private
     * @uses   Bake::dontAsk
     * @uses   Bake::stdin
     * @uses   Bake::stdout
     * @uses   Bake::stderr
     */
    function createFile($path, $contents)
    {
        $shortPath = str_replace(ROOT,null,$path);

        if (is_file($path) && !$this->dontAsk)
        {
            fwrite($this->stdout, "File {$shortPath} exists, overwrite? (yNaq) ");
            $key = trim(fgets($this->stdin));

            if ($key=='q')
            {
                fwrite($this->stdout, "Quitting.\n");
                exit;
            }
            elseif ($key=='a')
            {
                $this->dont_ask = true;
            }
            elseif ($key=='y')
            {
            }
            else
            {
                fwrite($this->stdout, "Skip   {$shortPath}\n");
                return false;
            }
        }

        if ($f = fopen($path, 'w'))
        {
            fwrite($f, $contents);
            fclose($f);
            fwrite($this->stdout, "Wrote   {$shortPath}\n");
            //         debug ("Wrote {$path}");
            return true;
        }
        else
        {
            fwrite($this->stderr, "Error! Couldn't open {$shortPath} for writing.\n");
            //         debug ("Error! Couldn't open {$path} for writing.");
            return false;
        }
    }

    /**
     * Creates a directory with given path.
     *
     * @param  string $path
     * @return boolean
     * @access private
     * @uses   Bake::stdin
     * @uses   Bake::stdout
     */
    function createDir($path)
    {
        if (is_dir($path))
        {
            return true;
        }

        $shortPath = str_replace(ROOT, null, $path);

        if (mkdir($path))
        {
            fwrite($this->stdout, "Created {$shortPath}\n");
            //         debug ("Created {$path}");
            return true;
        }
        else
        {
            fwrite($this->stderr, "Error! Couldn't create dir {$shortPath}\n");
            //         debug ("Error! Couldn't create dir {$path}");
            return false;
        }
    }

}

?>