layla/cody

Installs: 7

Dependents: 1

Stars: 4

Watchers: 2

Language: PHP

0.2.1 2014-04-16 11:59 UTC

README

Cody is a code generator that generates objects and resources for different languages and frameworks. Cody utilises a very simple configuration format for defining your objects and resources.

The input format

The input format for the generator is as following (example is given in yaml, other formats are supported too)

The root

The root of the input contains the package name the resources that exist within in the package.

package: Vendor.Name
resources:
  __RESOURCES__
Property Description package Contains the vendor and name of the page, seperated with a . and capitalized.
The reason we capitalize the vendor and name is because this way, it will contain more information for our compilers.
Compilers will use the Package name in filenames and namespaces, this may differ per compiler. resources Determines the resources that are present in the package

Resources

The resources are defined with the names as the key, and the configurations as the value

Property Description name The name property indicates the name as the key, and the resource configuration as value

An example:

Models.User:
  __RESOURCE_CONFIGURATION__
Models.NewsItem
  __RESOURCE_CONFIGURATION__

Resource Configuration

The resource configuration may only contain 2 keys. The compilers key should always be present, it tells Cody what compiler(s) it should use to compile your resource. The second key can be one of the following:

Key Type Description compilers array Indicates what compilers should be used to compile the resource, available options are:
php-core
php-laravel
js-core
js-ember class class configuration Indicates the resource is of type Class, value of this key is the configuration for the class model model configuration Indicates the resource is of type Model, value of this key is the configuration for the model controller controller configuration Indicates the resource is of type Controller, value of this key is the configuration for the controller

The compiler expects the resource to ONLY contain the compilers property and on of the available types.

An example:

Models.User:
  class:
    __CLASS_CONFIGURATION__
  compilers:
    - php-laravel

Class configuration

The class configuration holds all the information we need to build a class. The available options are

Key Type Description base string Indicates the base class of this class properties property configuration Keys represent the name of the property, values contain the property configuration methods method configuration Keys represent the method name, values contain the method configuration
base: MyApp.Foundation.Models.Base
properties:
  rules:
    __PROPERTY_CONFIGURATION__
methods:
  get.rules:
    __METHOD_CONFIGURATION__
  set.rules
    __METHOD_CONFIGURATION__

Model configuration

A model is an extension of the class, it allows you to specify relations and columns, and will automatically add the necesarry methods / properties for you, depending on the compiler.

Key Type Description base string Indicates the base class of this class properties property configuration Indicates the properties that should be present on the class methods method configuration Indicates the methods that should be present on the class relations relation configuration Indicates the relations that should be present on the model columns column configuration Indicates the columns that should be present on the model
base: MyApp.Foundation.Models.Base
properties:
  rules:
    __property_configuration
methods:
  get.rules:
    __METHOD_CONFIGURATION__
  set.rules
    __METHOD_CONFIGURATION__
relations:
  __RELATION_CONFIGURATION__
columns:
  __COLUMN_CONFIGURATION__

Method configuration

A method can be added to class resources, or subclasses thereof (models, controllers, etc.)

Key Type Description body array Keys represent the compiler name, values contain the method body for the given compiler comment string The method's comment returnType * The return type, resource identifier or one of the following types:
array
integer

An example:

body:
  php-core: return $this->rules;
comment: Get the rules for this model
returnType: array

Property configuration

A property can be added to class resources, or subclasses thereof (models, controllers, etc.)

Key Type Description value * The value of the property comment string The property's comment

An example:

value:
  name: required
  email: required|email
comment: The rules for this model

Relation configuration

A relation can be added to a model resource, or subclasses thereof

Key Type Description type * The type of the relation other string The other resource

An example:

type: hasMany
other: Models.TrailCategory

Column configuration

A column can be added to a model resource, or subclasses thereof

Key Type Description type * The type of the column max string The max size nullable boolean Indicates if the columns is nullable

An example:

type: string
max: 255
nullable: true

Generate from CLI

The generator can take your input file and spit out JSON, or save the files to their calculated destinations. The input can even be a folder, if that's the case, Cody will use the top 2 folders as the package name, and all the folders below indicate the namespace. The files found in the deepest folders represent the resource name, and the contents of the file represent the resource configuration. An example of this setup can be found in vendor/cody/example

./generator generate [--format="yml"] [--save] [--path="."] [--json] [--sync] [path]

Arguments

Argument Description path path to file or directory containing config code

Options

Option Description --format Specify the input format (default: "yml")

Available options are:
yml
json
stdin --save Save code code to path --path Set the path for files (default: ".") --json Return files as JSON --sync Sync code with database

Generate from PHP

1) add this following line to the require section in your composer.json

"layla/cody": "dev-master"

2) run composer update

3) Register Cody's services by calling the following code

use Layla\Cody\CodyServiceProvider;
use Illuminate\Container\Container as Application;

$app = new Application;
$provider = new CodyServiceProvider($app);
$provider->register();

In case you already have a (compatible) container, you can pass that into the ServiceProvider.

4) Profit!

$input = array(
  'package' => 'Example.Package',
  'resources' => array(
    'Models.News' => array(
      'model' => array(
        'relations' => array(
          'categories' => array(
            'other' => 'Models.Category'
          )
        )
      ),
      'compilers' => array(
        'laravel-php'
      )
    )
  )
);

$files = $app->make('cody')->compileInput($input);

// Or, if you like your input to be parsed, specify the name of the parser as the second argument (gotta love YAML :)

$input = "
package: Example.Package
resources:
  Models.News:
    model:
      relations:
        categories:
          other: Models.Category
    compilers:
      laravel-php
";

$files = $app->make('cody')->compileInput($input, 'yml');

// Or json if you like

$input = '
{
  "package": "Example.Package",
  "resources": {
    Models."News": {
      "model": {
        "relations": {
          "categories": {
            "other": "Models.Category"
          }
        }
      }
      "compilers": [
        "laravel-php"
      ]
    }
  }
}';

$files = $app->make('cody')->compileInput($input, 'json');

foreach($files as $filename => $content)
{
  // save it, echo it, do whatever you want to do with it
}