├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── composer.json
├── phpunit.xml.dist
├── src
    ├── TwigGenerator
    │   └── Builder
    │   │   ├── BaseBuilder.php
    │   │   ├── BuilderInterface.php
    │   │   └── Generator.php
    └── autoload.php
└── tests
    ├── TwigGenerator
        └── Tests
        │   └── Builder
        │       ├── BaseBuilderTest.php
        │       ├── Fixtures
        │           ├── Builder
        │           │   └── DemoBuilder.php
        │           └── Templates
        │           │   └── DemoBuilder.php.twig
        │       └── GeneratorTest.php
    └── bootstrap.php


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Eclipse ide
 2 | .settings
 3 | .project
 4 | .buildpath
 5 | 
 6 | # Composer
 7 | composer.lock
 8 | composer.phar
 9 | 
10 | vendor


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | php: 5.3
 3 | before_script:
 4 |   - wget http://getcomposer.org/composer.phar
 5 |   - php composer.phar install
 6 | script: phpunit
 7 | notifications:
 8 |   email:
 9 |     - cedric.lombardot@gmail.com
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2011 Francois Zaninotto, Cedric Lombardot
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # TwigGenerator ![project status](http://stillmaintained.com/cedriclombardot/TwigGenerator.png) ![build status](https://secure.travis-ci.org/cedriclombardot/TwigGenerator.png)#
  2 | 
  3 | TwigGenerator is a PHP code generator based on the [Twig](https://github.com/fabpot/Twig) template engine. It leverages the power of Twig templates to simplify the generation of PHP code, to make it more extensible, and more readable.
  4 | 
  5 | ## Installation
  6 | 
  7 | Checkout this GitHub repository and setup the composer dependencies (Twig and Symfony ClassLoader):
  8 | 
  9 | ```
 10 | git clone https://github.com/cedriclombardot/TwigGenerator.git
 11 | cd TwigGenerator
 12 | wget -nc http://getcomposer.org/composer.phar
 13 | php composer.phar install
 14 | ```
 15 | 
 16 | ## Usage
 17 | 
 18 | To generate PHP classes, you need to create a "Builder", and one or more Twig templates. Then, add the new Builder to a "Generator", and generate the result.
 19 | 
 20 | ### Creating a Builder class
 21 | 
 22 | First, create a class extending `TwigGenerator\Builder\BaseBuilder` - no need for methods at start.
 23 | 
 24 | ```php
 25 | <?php
 26 | 
 27 | namespace MyProject\Builder;
 28 | 
 29 | use TwigGenerator\Builder\BaseBuilder;
 30 | 
 31 | class MyBuilder extends BaseBuilder
 32 | {
 33 | }
 34 | ```
 35 | 
 36 | **Tip**: Alternatively, a builder can implement the `TwigGenerator\Builder\BuilderInterface` if it has to extend a custom class.
 37 | 
 38 | ### Creating Twig Templates
 39 | 
 40 | Next, create a couple twig templates under the `templates/` directory. Usually, you need at least one template for the main structure, plus one template per feature added to the class.
 41 | 
 42 | Here is an example main template (or layout) for creating a custom PHP class (to be stored in `templates/_base/common.php.twig`):
 43 | 
 44 | ```php
 45 | <?php
 46 | {{ namespace is defined ? "namespace " ~ namespace ~ ";" : "" }}
 47 | 
 48 | class {{ className }} {{ extends is defined ? "extends " ~ extends : "" }}
 49 | {
 50 | {% block functions %}
 51 | {% endblock %}
 52 | }
 53 | ```
 54 | 
 55 | And now, an example for adding a custom method (to be stored in `templates/MyBuilder.php.twig`):
 56 | 
 57 | ```
 58 | {% extends "_base/common.php.twig" %}
 59 | 
 60 | {% block functions %}
 61 | 	public function tellMeHello()
 62 | 	{
 63 | 		echo "Hello world";
 64 | 	}
 65 | {% endblock %}
 66 | ```
 67 | 
 68 | ### Generating the code
 69 | 
 70 | Use a `TwigGenerator\Builder\Generator` instance to generate the result. For instance:
 71 | 
 72 | ```php
 73 | <?php
 74 | // initialize the autoload
 75 | require_once '/path/to/TwigGenerator/src/autoload.php';
 76 | // alternatively, use your favorite PSR-0 autoloader configured with TwigGenerator, Symfony and Twig
 77 | 
 78 | // initialize a builder
 79 | $builder = new MyProject\Builder\MyBuilder();
 80 | $builder->setOutputName('MyBuilder.php');
 81 | 
 82 | // add specific configuration for my builder
 83 | $builder->setVariable('className', 'MyBuilder');
 84 | 
 85 | // create a generator
 86 | $generator = new TwigGenerator\Builder\Generator();
 87 | $generator->setTemplateDirs(array(
 88 | 	__DIR__.'/templates',
 89 | ));
 90 | 
 91 | // allways regenerate classes even if they exist -> no cache
 92 | $generator->setMustOverwriteIfExists(true);
 93 | 
 94 | // set common variables
 95 | $generator->setVariables(array(
 96 | 	'namespace' => 'MyProject\Generated',
 97 | ));
 98 | 
 99 | // add the builder to the generator
100 | $generator->addBuilder($builder);
101 | 
102 | // You can add other builders here
103 | 
104 | // Run generation for all builders
105 | $generator->writeOnDisk(__DIR__.'/Generated');
106 | ```
107 | 
108 | The file will be generated in `MyProject\Generated\MyBuilder.php`, as follows:
109 | 
110 | ```php
111 | <?php
112 | namespace MyProject\Generated;
113 | 
114 | class MyBuilder
115 | {
116 | 	public function tellMeHello()
117 | 	{
118 | 		echo "Hello world";
119 | 	}
120 | }
121 | ```
122 | 
123 | ## Other Examples
124 | 
125 | You can see some basic code generation samples in the tests, and on some GitHub repositories like [fzaninotto/Doctrine2ActiveRecord](https://github.com/fzaninotto/Doctrine2ActiveRecord), or [cedriclombardot/AdmingeneratorGeneratorBundle](https://github.com/cedriclombardot/AdmingeneratorGeneratorBundle).
126 | 
127 | 
128 | ## Unit Tests
129 | 
130 | Then, just run:
131 | 
132 |     phpunit
133 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "cedriclombardot/twig-generator",
 3 |     "type": "library",
 4 |     "description": "A generator for PHP code based on Twig template engine",
 5 |     "keywords": ["twig", "generator", "code generation"],
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Cédric Lombardot",
10 |             "email": "cedric.lombardot@gmail.com"
11 |         },
12 |         {
13 |             "name": "François Zaninotto"
14 |         }
15 |     ],
16 |     "require": {
17 |         "php": ">=5.3.0",
18 |         "twig/twig": ">=1.1, <2.0-dev"
19 |     },
20 |     "autoload": {
21 |         "psr-0": { "TwigGenerator": "src/" }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          bootstrap="tests/bootstrap.php"
 6 |          colors="false"
 7 |          convertErrorsToExceptions="true"
 8 |          convertNoticesToExceptions="true"
 9 |          convertWarningsToExceptions="true"
10 |          processIsolation="false"
11 |          stopOnFailure="false"
12 |          syntaxCheck="false"
13 | >
14 |     <testsuites>
15 |         <testsuite name="TwigGenerator Test Suite">
16 |             <directory>./tests/</directory>
17 |         </testsuite>
18 |     </testsuites>
19 | 
20 |     <filter>
21 |         <whitelist>
22 |             <directory>./src/TwigGenerator/</directory>
23 |         </whitelist>
24 |     </filter>
25 | </phpunit>
26 | 
27 | 


--------------------------------------------------------------------------------
/src/TwigGenerator/Builder/BaseBuilder.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the TwigGenerator package.
  5 |  * For the full copyright and license information, please view the LICENSE
  6 |  * file that was distributed with this source code.
  7 |  *
  8 |  * @license    MIT License
  9 |  */
 10 | 
 11 | namespace TwigGenerator\Builder;
 12 | 
 13 | /**
 14 |  * @author Cédric Lombardot
 15 |  */
 16 | abstract class BaseBuilder implements BuilderInterface
 17 | {
 18 |     /**
 19 |      * Default Twig file extension.
 20 |      */
 21 |     const TWIG_EXTENSION = '.php.twig';
 22 | 
 23 |     /**
 24 |      * @var \TwigGenerator\Builder\Generator    The generator.
 25 |      */
 26 |     protected $generator;
 27 | 
 28 |     /**
 29 |      * @var array   A list of template directories.
 30 |      */
 31 |     protected $templateDirectories = array();
 32 | 
 33 |     /**
 34 |      * @var string
 35 |      */
 36 |     protected $templateName;
 37 | 
 38 |     /**
 39 |      * @var string
 40 |      */
 41 |     protected $outputName;
 42 | 
 43 |     /**
 44 |      * @var Boolean
 45 |      */
 46 |     protected $mustOverwriteIfExists = false;
 47 | 
 48 |     /**
 49 |      * @var array
 50 |      */
 51 |     protected $twigFilters = array(
 52 |         'addslashes',
 53 |         'var_export',
 54 |         'is_numeric',
 55 |         'ucfirst',
 56 |         'substr',
 57 |     );
 58 | 
 59 |     /**
 60 |      * @var array
 61 |      */
 62 |     protected $variables = array();
 63 | 
 64 |     /**
 65 |      * @var array
 66 |      */
 67 |     protected $twigExtensions = array(
 68 |     );
 69 | 
 70 |     /**
 71 |      * Constructor
 72 |      */
 73 |     public function __construct()
 74 |     {
 75 |         $this->templateDirectories = $this->getDefaultTemplateDirs();
 76 |         $this->templateName = $this->getDefaultTemplateName();
 77 |     }
 78 | 
 79 |     /**
 80 |      * {@inheritDoc}
 81 |      */
 82 |     public function setGenerator(Generator $generator)
 83 |     {
 84 |         $this->generator = $generator;
 85 |     }
 86 | 
 87 |     /**
 88 |      * {@inheritDoc}
 89 |      */
 90 |     public function getGenerator()
 91 |     {
 92 |         return $this->generator;
 93 |     }
 94 | 
 95 |     /**
 96 |      * {@inheritDoc}
 97 |      */
 98 |     public function addTemplateDir($templateDir)
 99 |     {
100 |         $this->templateDirectories[$templateDir] = $templateDir;
101 |     }
102 | 
103 |     /**
104 |      * {@inheritDoc}
105 |      */
106 |     public function setTemplateDirs(array $templateDirs)
107 |     {
108 |         $this->templateDirectories = $templateDirs;
109 |     }
110 | 
111 |     /**
112 |      * {@inheritDoc}
113 |      */
114 |     public function getTemplateDirs()
115 |     {
116 |         return $this->templateDirectories;
117 |     }
118 | 
119 |     /**
120 |      * {@inheritDoc}
121 |      */
122 |     public function getDefaultTemplateDirs()
123 |     {
124 |         return array();
125 |     }
126 | 
127 |     /**
128 |      * {@inheritDoc}
129 |      */
130 |     public function setTemplateName($templateName)
131 |     {
132 |         $this->templateName = $templateName;
133 |     }
134 | 
135 |     /**
136 |      * {@inheritDoc}
137 |      */
138 |     public function getTemplateName()
139 |     {
140 |         return $this->templateName;
141 |     }
142 | 
143 |     /**
144 |      * {@inheritDoc}
145 |      */
146 |     public function getDefaultTemplateName()
147 |     {
148 |         return $this->getSimpleClassName() . self::TWIG_EXTENSION;
149 |     }
150 | 
151 |     /**
152 |      * {@inheritDoc}
153 |      */
154 |     public function getSimpleClassName($class = null)
155 |     {
156 |         if (null === $class) {
157 |             $class = get_class($this);
158 |         }
159 | 
160 |         $classParts = explode('\\', $class);
161 |         $simpleClassName = array_pop($classParts);
162 | 
163 |         return $simpleClassName;
164 |     }
165 | 
166 |     /**
167 |      * {@inheritDoc}
168 |      */
169 |     public function setOutputName($outputName)
170 |     {
171 |         $this->outputName = $outputName;
172 |     }
173 | 
174 |     /**
175 |      * {@inheritDoc}
176 |      */
177 |     public function getOutputName()
178 |     {
179 |         return $this->outputName;
180 |     }
181 | 
182 |     /**
183 |      * {@inheritDoc}
184 |      */
185 |     public function mustOverwriteIfExists()
186 |     {
187 |         return $this->mustOverwriteIfExists;
188 |     }
189 | 
190 |     /**
191 |      * {@inheritDoc}
192 |      */
193 |     public function setMustOverwriteIfExists($status = true)
194 |     {
195 |         $this->mustOverwriteIfExists = $status;
196 |     }
197 | 
198 |     /**
199 |      * {@inheritDoc}
200 |      */
201 |     public function setVariables(array $variables)
202 |     {
203 |         $this->variables = $variables;
204 |     }
205 | 
206 |     /**
207 |      * {@inheritDoc}
208 |      */
209 |     public function setVariable($key, $value)
210 |     {
211 |         $this->variables[$key] = $value;
212 |     }
213 | 
214 |     /**
215 |      * {@inheritDoc}
216 |      */
217 |     public function getVariables()
218 |     {
219 |         return $this->variables;
220 |     }
221 | 
222 |     /**
223 |      * {@inheritDoc}
224 |      */
225 |     public function hasVariable($key)
226 |     {
227 |         return isset($this->variables[$key]);
228 |     }
229 | 
230 |     /**
231 |      * {@inheritDoc}
232 |      */
233 |     public function getVariable($key, $default = null)
234 |     {
235 |         return $this->hasVariable($key) ? $this->variables[$key] : $default;
236 |     }
237 | 
238 |     /**
239 |      * {@inheritDoc}
240 |      */
241 |     public function writeOnDisk($outputDirectory)
242 |     {
243 |         $path = $outputDirectory . DIRECTORY_SEPARATOR . $this->getOutputName();
244 |         $dir  = dirname($path);
245 | 
246 |         if (!is_dir($dir)) {
247 |             mkdir($dir, 0777, true);
248 |         }
249 | 
250 |         if (!file_exists($path) || (file_exists($path) && $this->mustOverwriteIfExists)) {
251 |             file_put_contents($path, $this->getCode());
252 |         }
253 |     }
254 | 
255 |     /**
256 |      * {@inheritDoc}
257 |      */
258 |     public function getCode()
259 |     {
260 |         $loader = new \Twig_Loader_Filesystem($this->getTemplateDirs());
261 |         $twig = new \Twig_Environment($loader, array(
262 |             'autoescape' => false,
263 |             'strict_variables' => true,
264 |             'debug' => true,
265 |             'cache' => $this->getGenerator()->getTempDir(),
266 |         ));
267 | 
268 |         $this->addTwigExtensions($twig, $loader);
269 |         $this->addTwigFilters($twig);
270 |         $template = $twig->loadTemplate($this->getTemplateName());
271 | 
272 |         $variables = $this->getVariables();
273 |         $variables['builder'] = $this;
274 | 
275 |         return $template->render($variables);
276 |     }
277 | 
278 |     /**
279 |      * {@inheritDoc}
280 |      */
281 |     public function addTwigFilters(\Twig_Environment $twig)
282 |     {
283 |         foreach ($this->twigFilters as $twigFilter) {
284 |             if (($pos = strpos($twigFilter, ':')) !== false) {
285 |                 $twigFilterName = substr($twigFilter, $pos + 2);
286 |             } else {
287 |                 $twigFilterName = $twigFilter;
288 |             }
289 |             $twig->addFilter($twigFilterName, new \Twig_Filter_Function($twigFilter));
290 |         }
291 |     }
292 | 
293 |     /**
294 |      * {@inheritDoc}
295 |      */
296 |     public function addTwigExtensions(\Twig_Environment $twig, \Twig_LoaderInterface $loader)
297 |     {
298 |         foreach ($this->twigExtensions as $twigExtensionName) {
299 |             $twigExtension = new $twigExtensionName($loader);
300 |             $twig->addExtension($twigExtension);
301 |         }
302 |     }
303 | }
304 | 


--------------------------------------------------------------------------------
/src/TwigGenerator/Builder/BuilderInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the TwigGenerator package.
  5 |  * For the full copyright and license information, please view the LICENSE
  6 |  * file that was distributed with this source code.
  7 |  *
  8 |  * @license    MIT License
  9 |  */
 10 | 
 11 | namespace TwigGenerator\Builder;
 12 | 
 13 | /**
 14 |  * This interface defines the structure of builders.
 15 |  *
 16 |  * @author Cédric Lombardot
 17 |  */
 18 | interface BuilderInterface
 19 | {
 20 |     /**
 21 |      * Set the generator.
 22 |      *
 23 |      * @param \TwigGenerator\Builder\Generator $generator A generator.
 24 |      */
 25 |     public function setGenerator(Generator $generator);
 26 | 
 27 |     /**
 28 |      * Return the generator.
 29 |      *
 30 |      * @return \TwigGenerator\Builder\Generator The generator.
 31 |      */
 32 |     public function getGenerator();
 33 | 
 34 |     /**
 35 |      * Add a template directory.
 36 |      *
 37 |      * @param string $templateDir A template directory.
 38 |      */
 39 |     public function addTemplateDir($templateDir);
 40 | 
 41 |     /**
 42 |      * Set a list of template directories.
 43 |      *
 44 |      * @param array $templateDirs
 45 |      */
 46 |     public function setTemplateDirs(array $templateDirs);
 47 | 
 48 |     /**
 49 |      * Return an array of template directories.
 50 |      *
 51 |      * @return array An array of template directories.
 52 |      */
 53 |     public function getTemplateDirs();
 54 | 
 55 |     /**
 56 |      * Return all default template directories.
 57 |      *
 58 |      * @return array An array of default directories.
 59 |      */
 60 |     public function getDefaultTemplateDirs();
 61 | 
 62 |     /**
 63 |      * Set the template name.
 64 |      *
 65 |      * @param string $templateName A template name.
 66 |      */
 67 |     public function setTemplateName($templateName);
 68 | 
 69 |     /**
 70 |      * Return the template name.
 71 |      *
 72 |      * @return string The template name.
 73 |      */
 74 |     public function getTemplateName();
 75 | 
 76 |     /**
 77 |      * Return the default template name.
 78 |      *
 79 |      * @return string The default template name.
 80 |      */
 81 |     public function getDefaultTemplateName();
 82 | 
 83 |     /**
 84 |      * Return the simple classname.
 85 |      *
 86 |      * @param string    A classname.
 87 |      *
 88 |      * @return string The short classname.
 89 |      */
 90 |     public function getSimpleClassName($class = null);
 91 | 
 92 |     /**
 93 |      * Set the output filename.
 94 |      *
 95 |      * @param string $outputName The output filename.
 96 |      */
 97 |     public function setOutputName($outputName);
 98 | 
 99 |     /**
100 |      * Return the output name.
101 |      *
102 |      * @return string The output name.
103 |      */
104 |     public function getOutputName();
105 | 
106 |     /**
107 |      * Return whether the builder must overwrite the file or not.
108 |      *
109 |      * @return Boolean true if the builder must overwrite the file, false otherwise.
110 |      */
111 |     public function mustOverwriteIfExists();
112 | 
113 |     /**
114 |      * Change the overwrite status.
115 |      *
116 |      * @param Boolean $status The status.
117 |      */
118 |     public function setMustOverwriteIfExists($status = true);
119 | 
120 |     /**
121 |      * Set an array of variables.
122 |      *
123 |      * @param array $variables An array of variables.
124 |      */
125 |     public function setVariables(array $variables);
126 | 
127 |     /**
128 |      * Return an array of variables.
129 |      *
130 |      * @return array An array of variables.
131 |      */
132 |     public function getVariables();
133 | 
134 |     /**
135 |      * Return whether the builder contains a variable or not.
136 |      *
137 |      * @return Boolean true if the builder contains the variable, false otherwise.
138 |      */
139 |     public function hasVariable($key);
140 | 
141 |     /**
142 |      * Get a variable identified by its key.
143 |      *
144 |      * @param string $path    The key.
145 |      * @param mixed  $default The default value.
146 |      *
147 |      * @return mixed The variable.
148 |      */
149 |     public function getVariable($path, $default = null);
150 | 
151 |     /**
152 |      * Set a new key/value.
153 |      *
154 |      * @param string $key   The key.
155 |      * @param mixed  $value The value.
156 |      */
157 |     public function setVariable($key, $value);
158 | 
159 |     /**
160 |      * Write files to disk.
161 |      *
162 |      * @param string $outputDirectory The output directory.
163 |      */
164 |     public function writeOnDisk($outputDirectory);
165 | 
166 |     /**
167 |      * Return the parsed code to insert into the file.
168 |      *
169 |      * @return string The parsed code to insert into the file.
170 |      */
171 |     public function getCode();
172 | 
173 |     /**
174 |      * Add Twig filters from a given Twig environment.
175 |      *
176 |      * @param \Twig_Environment $twig A Twig environment.
177 |      */
178 |     public function addTwigFilters(\Twig_Environment $twig);
179 | 
180 |     /**
181 |      * Add Twig extensions.
182 |      *
183 |      * @param \Twig_Environment     $twig   A Twig environment.
184 |      * @param \Twig_LoaderInterface $loader A Twig loader.
185 |      */
186 |     public function addTwigExtensions(\Twig_Environment $twig, \Twig_LoaderInterface $loader);
187 | }
188 | 


--------------------------------------------------------------------------------
/src/TwigGenerator/Builder/Generator.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the TwigGenerator package.
  5 |  * For the full copyright and license information, please view the LICENSE
  6 |  * file that was distributed with this source code.
  7 |  *
  8 |  * @license    MIT License
  9 |  */
 10 | 
 11 | namespace TwigGenerator\Builder;
 12 | 
 13 | /**
 14 |  * @author Cédric Lombardot
 15 |  */
 16 | class Generator
 17 | {
 18 |     /**
 19 |      */
 20 |     const TEMP_DIR_PREFIX = 'TwigGenerator';
 21 | 
 22 |     /**
 23 |      * @var string  The temporary dir.
 24 |      */
 25 |     protected $tempDir;
 26 | 
 27 |     /**
 28 |      * @var array   List of builders.
 29 |      */
 30 |     protected $builders = array();
 31 | 
 32 |     /**
 33 |      * @var Boolean
 34 |      */
 35 |     protected $mustOverwriteIfExists = false;
 36 | 
 37 |     /**
 38 |      * @var array
 39 |      */
 40 |     protected $templateDirectories = array();
 41 | 
 42 |     /**
 43 |      * @var array   Variables to pass to the builder.
 44 |      */
 45 |     protected $variables = array();
 46 | 
 47 |     /**
 48 |      * @var boolean Activate remove temp dir after generation
 49 |      */
 50 |     protected $autoRemoveTempDir = true;
 51 | 
 52 |     /**
 53 |      * Init a new generator and automatically define the base of temp directory.
 54 |      *
 55 |      * @param string $baseTempDir Existing base directory for temporary template files
 56 |      */
 57 |     public function __construct($baseTempDir = null)
 58 |     {
 59 |         if (null === $baseTempDir) {
 60 |             $baseTempDir = sys_get_temp_dir();
 61 |         }
 62 | 
 63 |         $this->tempDir = realpath($baseTempDir).DIRECTORY_SEPARATOR.self::TEMP_DIR_PREFIX;
 64 | 
 65 |         if (!is_dir($this->tempDir)) {
 66 |             mkdir($this->tempDir, 0777, true);
 67 |         }
 68 |     }
 69 | 
 70 |     public function setAutoRemoveTempDir($autoRemoveTempDir = true)
 71 |     {
 72 |         $this->autoRemoveTempDir = $autoRemoveTempDir;
 73 |     }
 74 | 
 75 |     public function setMustOverwriteIfExists($status = true)
 76 |     {
 77 |         $this->mustOverwriteIfExists = $status;
 78 |     }
 79 | 
 80 |     public function setTemplateDirs(array $templateDirs)
 81 |     {
 82 |         $this->templateDirectories = $templateDirs;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Ensure to remove the temp directory.
 87 |      */
 88 |     public function __destruct()
 89 |     {
 90 |         if ($this->tempDir && is_dir($this->tempDir) && $this->autoRemoveTempDir) {
 91 |             $this->removeDir($this->tempDir);
 92 |         }
 93 |     }
 94 | 
 95 |     /**
 96 |      * @param string The temporary directory path
 97 |      */
 98 |     public function setTempDir($tempDir)
 99 |     {
100 |         $this->tempDir = $tempDir;
101 |     }
102 | 
103 |     /**
104 |      * @return string The temporary directory.
105 |      */
106 |     public function getTempDir()
107 |     {
108 |         return $this->tempDir;
109 |     }
110 | 
111 |     /**
112 |      * @return array The list of builders.
113 |      */
114 |     public function getBuilders()
115 |     {
116 |         return $this->builders;
117 |     }
118 | 
119 |     /**
120 |      * Add a builder.
121 |      *
122 |      * @param \TwigGenerator\Builder\BuilderInterface $builder A builder.
123 |      *
124 |      * @return \TwigGenerator\Builder\BuilderInterface The builder
125 |      */
126 |     public function addBuilder(BuilderInterface $builder)
127 |     {
128 |         $builder->setGenerator($this);
129 |         $builder->setTemplateDirs($this->templateDirectories);
130 |         $builder->setMustOverwriteIfExists($this->mustOverwriteIfExists);
131 |         $builder->setVariables(array_merge($this->variables, $builder->getVariables()));
132 | 
133 |         $this->builders[] = $builder;
134 | 
135 |         return $builder;
136 |     }
137 | 
138 |     /**
139 |      * Add an array of variables to pass to builders.
140 |      *
141 |      * @param array $variables A set of variables.
142 |      */
143 |     public function setVariables(array $variables = array())
144 |     {
145 |         $this->variables = $variables;
146 |     }
147 | 
148 |     /**
149 |      * Generate and write classes to disk.
150 |      *
151 |      * @param string $outputDirectory An output directory.
152 |      */
153 |     public function writeOnDisk($outputDirectory)
154 |     {
155 |         foreach ($this->getBuilders() as $builder) {
156 |             $builder->writeOnDisk($outputDirectory);
157 |         }
158 |     }
159 | 
160 |     /**
161 |      * Remove a directory.
162 |      *
163 |      * @param string $target A directory.
164 |      */
165 |     private function removeDir($target)
166 |     {
167 |         $fp = opendir($target);
168 |         while (false !== $file = readdir($fp)) {
169 |             if (in_array($file, array('.', '..'))) {
170 |                 continue;
171 |             }
172 | 
173 |             if (is_dir($target.'/'.$file)) {
174 |                 self::removeDir($target.'/'.$file);
175 |             } else {
176 |                 unlink($target.'/'.$file);
177 |             }
178 |         }
179 |         closedir($fp);
180 |         rmdir($target);
181 |     }
182 | }
183 | 


--------------------------------------------------------------------------------
/src/autoload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Simple autoloader that follow the PHP Standards Recommendation #0 (PSR-0)
 5 |  * @see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md for more informations.
 6 |  *
 7 |  * Code inspired from the SplClassLoader RFC
 8 |  * @see https://wiki.php.net/rfc/splclassloader#example_implementation
 9 |  */
10 | spl_autoload_register(function ($className) {
11 |     $className = ltrim($className, '\\');
12 |     $fileName = '';
13 |     $namespace = '';
14 |     if ($lastNsPos = strripos($className, '\\')) {
15 |         $namespace = substr($className, 0, $lastNsPos);
16 |         $className = substr($className, $lastNsPos + 1);
17 |         $fileName = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
18 |     }
19 |     $fileName = __DIR__ . DIRECTORY_SEPARATOR . $fileName . $className . '.php';
20 |     if (file_exists($fileName)) {
21 |         require $fileName;
22 | 
23 |         return true;
24 |     }
25 | 
26 |     return false;
27 | });
28 | 


--------------------------------------------------------------------------------
/tests/TwigGenerator/Tests/Builder/BaseBuilderTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace TwigGenerator\Tests\Builder;
  4 | 
  5 | use TwigGenerator\Tests\Builder\Fixtures\Builder\DemoBuilder;
  6 | 
  7 | class BaseBuilderTest extends \PHPUnit_Framework_TestCase
  8 | {
  9 |     public function testGetSimpleClassName()
 10 |     {
 11 |         $builder = new DemoBuilder();
 12 |         $this->assertEquals('DemoBuilder', $builder->getSimpleClassName(), 'getSimpleClassName remove the namespaced part of get_class');
 13 | 
 14 |         $this->assertEquals('Bar', $builder->getSimpleClassName('\\Foo\\Bar'), 'getSimpleClassName remove the namespaced part of get_class');
 15 |     }
 16 | 
 17 |     public function testGetDefaultTemplateName()
 18 |     {
 19 |         $builder = new DemoBuilder();
 20 |         $this->assertEquals('DemoBuilder.php.twig', $builder->getDefaultTemplateName(), 'getDefaultTemplateName return the twig file path');
 21 |     }
 22 | 
 23 |     public function testSetVariables()
 24 |     {
 25 |         $builder = new DemoBuilder();
 26 |         $builder->setVariables(array('foo' => 'bar'));
 27 |         $this->assertEquals(array('foo' => 'bar'), $builder->getVariables(), 'setVariables accept an array');
 28 |     }
 29 | 
 30 |     public function testGetVariable()
 31 |     {
 32 |         $builder = new DemoBuilder();
 33 |         $builder->setVariables(array('foo' => 'bar'));
 34 |         $this->assertEquals('bar', $builder->getVariable('foo','default'));
 35 |         $this->assertEquals('default', $builder->getVariable('nonexistant','default'));
 36 |     }
 37 | 
 38 |     public function testSetVariable()
 39 |     {
 40 |         $builder = new DemoBuilder();
 41 |         $builder->setVariables(array('foo' => 'bar'));
 42 | 
 43 |         $builder->setVariable('foo', 'demo');
 44 |         $this->assertEquals('demo', $builder->getVariable('foo'), 'setVariable overwrite the default variables setted');
 45 | 
 46 |         $builder->setVariable('add', 'bar');
 47 |         $this->assertEquals('bar', $builder->getVariable('add'), 'setVariable can also add a variable');
 48 |     }
 49 | 
 50 |     public function testHasVariable()
 51 |     {
 52 |         $builder = new DemoBuilder();
 53 |         $builder->setVariables(array('foo' => 'bar'));
 54 |         $this->assertTrue($builder->hasVariable('foo'), 'hasVariable return true on a valid key');
 55 |         $this->assertFalse($builder->hasVariable('var'), 'hasVariable return false on a invalid key');
 56 |     }
 57 | 
 58 |     public function testGetCode()
 59 |     {
 60 |         $builder = $this->initBuilder();
 61 | 
 62 |         $this->assertEquals('Hello cedric !', $builder->getCode());
 63 | 
 64 |         $builder->setVariables(array('name' => 'Tux'));
 65 |         $this->assertEquals('Hello Tux !', $builder->getCode(), 'If i change variables code is changed');
 66 |     }
 67 | 
 68 |     public function testWriteOnDisk()
 69 |     {
 70 |         $builder = $this->initBuilder();
 71 | 
 72 |         $builder->writeOnDisk(sys_get_temp_dir());
 73 |         $this->assertTrue(file_exists(sys_get_temp_dir() . '/test.php'));
 74 |         $this->assertEquals('Hello cedric !', file_get_contents(sys_get_temp_dir() . '/test.php'));
 75 | 
 76 |         $builder->setVariables(array('name' => 'Tux'));
 77 |         $builder->writeOnDisk(sys_get_temp_dir());
 78 |         $this->assertTrue($builder->mustOverwriteIfExists());
 79 |         $this->assertTrue(file_exists(sys_get_temp_dir() . '/test.php'));
 80 |         $this->assertEquals('Hello Tux !', file_get_contents(sys_get_temp_dir() . '/test.php'), 'If i change variables code is changed');
 81 | 
 82 |         $builder->setVariables(array('name' => 'cedric'));
 83 |         $builder->setMustOverwriteIfExists(false);
 84 |         $builder->writeOnDisk(sys_get_temp_dir());
 85 |         $this->assertFalse($builder->mustOverwriteIfExists());
 86 |         $this->assertTrue(file_exists(sys_get_temp_dir() . '/test.php'));
 87 |         $this->assertEquals('Hello Tux !', file_get_contents(sys_get_temp_dir() . '/test.php'), 'If i change variables on an existant files code is not generated');
 88 | 
 89 |         unlink(sys_get_temp_dir() . '/test.php');
 90 |         $this->assertFalse(file_exists(sys_get_temp_dir() . '/test.php'));
 91 |         $builder->writeOnDisk(sys_get_temp_dir());
 92 |         $this->assertEquals('Hello cedric !', file_get_contents(sys_get_temp_dir() . '/test.php'), 'If i change variables on a non existant files code is generated');
 93 |     }
 94 | 
 95 |     protected function initBuilder()
 96 |     {
 97 |         $builder = new DemoBuilder();
 98 |         $generator = $this->getMockBuilder('TwigGenerator\Builder\Generator')
 99 |                           ->disableOriginalConstructor()
100 |                           ->getMock();
101 | 
102 |         $builder->setGenerator($generator);
103 |         $builder->setMustOverwriteIfExists(true);
104 |         $builder->setOutputName('test.php');
105 |         $builder->setTemplateDirs(array(__DIR__.'/Fixtures/Templates'));
106 |         $builder->setVariables(array('name' => 'cedric'));
107 |         $builder->setTemplateName($builder->getDefaultTemplateName());
108 | 
109 |         return $builder;
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/tests/TwigGenerator/Tests/Builder/Fixtures/Builder/DemoBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TwigGenerator\Tests\Builder\Fixtures\Builder;
 4 | 
 5 | use TwigGenerator\Builder\BaseBuilder;
 6 | 
 7 | class DemoBuilder extends BaseBuilder
 8 | {
 9 | 
10 |     public function getDefaultTemplateDirs()
11 |     {
12 |         return array(__DIR__.'/../Templates');
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/TwigGenerator/Tests/Builder/Fixtures/Templates/DemoBuilder.php.twig:
--------------------------------------------------------------------------------
1 | Hello {{ name }} !


--------------------------------------------------------------------------------
/tests/TwigGenerator/Tests/Builder/GeneratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace TwigGenerator\Tests\Builder;
 4 | 
 5 | use TwigGenerator\Tests\Builder\Fixtures\Builder\DemoBuilder;
 6 | use TwigGenerator\Builder\Generator;
 7 | 
 8 | class GeneratorTest extends \PHPUnit_Framework_TestCase
 9 | {
10 |     public function testAddBuilder()
11 |     {
12 |         $builder = new DemoBuilder();
13 |         $builder->setVariables(array('foo' => 'bar'));
14 | 
15 |         $generator = new Generator();
16 |         $generator->setVariables(array('foo' => 'common bar', 'baz' => 'common baz' ));
17 |         $generator->addBuilder($builder);
18 | 
19 |         $this->assertEquals('bar', $builder->getVariable('foo'), 'Builder variable is more important than common builder variable');
20 |         $this->assertEquals('common baz', $builder->getVariable('baz'), 'Expected common builder variable');
21 |     }
22 | 
23 |     public function testAddBuilderOnlyBuilderVariables()
24 |     {
25 |         $builder = new DemoBuilder();
26 |         $builder->setVariables(array('foo' => 'bar'));
27 | 
28 |         $generator = new Generator();
29 |         $generator->addBuilder($builder);
30 | 
31 |         $this->assertEquals('bar', $builder->getVariable('foo'), 'Expected builder variable');
32 |     }
33 | 
34 |     public function testAddBuilderOnlyGeneratorCommonVariables()
35 |     {
36 |         $builder1 = new DemoBuilder();
37 |         $builder2 = new DemoBuilder();
38 | 
39 |         $generator = new Generator();
40 |         $generator->setVariables(array('foo' => 'common foo'));
41 |         $generator->addBuilder($builder1);
42 |         $generator->addBuilder($builder2);
43 | 
44 |         $this->assertEquals('common foo', $builder1->getVariable('foo'), 'Expected common builder variable');
45 |         $this->assertEquals('common foo', $builder2->getVariable('foo'), 'Expected common builder variable');
46 |     }
47 | 
48 |     public function testCallAddBuilderBeforeSetVariables()
49 |     {
50 |         $builder = new DemoBuilder();
51 | 
52 |         $generator = new Generator();
53 |         $generator->addBuilder($builder);
54 |         $generator->setVariables(array('foo' => 'bar'));
55 | 
56 |         $this->assertNull($builder->getVariable('foo'), ' If addBuilder is called before setVariables then common builder variables will be skipped');
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | if ((!$loader = @include __DIR__.'/../vendor/autoload.php')) {
4 |     die('You must set up the project dependencies, run the following command:'.PHP_EOL.PHP_EOL.
5 |         '    php composer.phar install'.PHP_EOL);
6 | }
7 | 
8 | $loader->add('TwigGenerator\\Tests', 'tests');
9 | 


--------------------------------------------------------------------------------