15.4 Providing Basic Artefacts 2.3.8

See the light - agile, industrial strength, rapid web application development made easy

(Quick Reference) # 15.4 Providing Basic Artefacts - Reference Documentation Authors: Graeme Rocher, Peter Ledbrook, Marc Palmer, Jeff Brown, Luke Daley, Burt Beckwith, Lari Hotari Version: 2.3.8 ## 15.4 Providing Basic Artefacts #### Adding a new Script A plugin can add a new script simply by providing the relevant Gant script in its scripts directory:
    + MyPlugin.groovy
       + scripts     <-- additional scripts here
       + grails-app
            + controllers
            + services
            + etc.
        + lib
#### Adding a new grails-app artifact (Controller, Tag Library, Service, etc.) A plugin can add new artifacts by creating the relevant file within the `grails-app` tree. Note that the plugin is loaded from where it is installed and not copied into the main application tree.
    + ExamplePlugin.groovy
       + scripts
       + grails-app
            + controllers  <-- additional controllers here
            + services <-- additional services here
            + etc.  <-- additional XXX here
        + lib
#### Providing Views, Templates and View resolution When a plugin provides a controller it may also provide default views to be rendered. This is an excellent way to modularize your application through plugins. Grails' view resolution mechanism will first look for the view in the application it is installed into and if that fails will attempt to look for the view within the plugin. This means that you can override views provided by a plugin by creating corresponding GSPs in the application's `grails-app/views` directory. For example, consider a controller called `BookController` that's provided by an 'amazon' plugin. If the action being executed is `list`, Grails will first look for a view called `grails-app/views/book/list.gsp` then if that fails it will look for the same view relative to the plugin. However if the view uses templates that are also provided by the plugin then the following syntax may be necessary:
    <g:render template="fooTemplate" plugin="amazon"/>
Note the usage of the `plugin` attribute, which contains the name of the plugin where the template resides. If this is not specified then Grails will look for the template relative to the application. #### Excluded Artefacts By default Grails excludes the following files during the packaging process: `grails-app/conf/BootStrap.groovy` `grails-app/conf/BuildConfig.groovy` (although it is used to generate `dependencies.groovy`) `grails-app/conf/Config.groovy` `grails-app/conf/DataSource.groovy` (and any other `*DataSource.groovy`) `grails-app/conf/UrlMappings.groovy` `grails-app/conf/spring/resources.groovy` Everything within `/web-app/WEB-INF` Everything within `/web-app/plugins/**` Everything within `/test/**` SCM management files within `**/.svn/**` and `**/CVS/**` If your plugin requires files under the `web-app/WEB-INF` directory it is recommended that you modify the plugin's `scripts/_Install.groovy` Gant script to install these artefacts into the target project's directory tree. In addition, the default `UrlMappings.groovy` file is excluded to avoid naming conflicts, however you are free to add a UrlMappings definition under a different name which will be included. For example a file called `grails-app/conf/BlogUrlMappings.groovy` is fine. The list of excludes is extensible with the `pluginExcludes` property:
    // resources that are excluded from plugin packaging
    def pluginExcludes = [
        "grails-app/views/error.gsp"
    ]
This is useful for example to include demo or test resources in the plugin repository, but not include them in the final distribution. | Quick Reference (hide)