File Format¶

[
  // Configuration object
  {
    "settings": [ "master" ],
    "specs": {
      ...
    }
  },
  ...
]

configuration Object¶

Configuring Applications to Have Multiple Mojits¶

Applications not only can specify multiple mojit instances in application.json, but mojits can have one or more child mojits as well.

[
  {
    "settings": [ "master" ],
    "specs": {
      "sign_in": {
        "type": "SignInMojit"
      },
      "sign_out": {
        "type": "SignOutMojit"
      }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "specs": {
      "parent": {
        "type": "ParentMojit",
        "config": {
          "child": {
            "type": "ChildMojit"
          }
        }
      }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "specs": {
      "father": {
        "type": "ParentMojit",
        "config": {
          "children": {
            "son": {
              "type": "ChildMojit"
            },
            "daughter": {
              "type": "ChildMojit"
            }
          }
        }
      }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "specs": {
      "grandfather": {
        "type": "GrandparentMojit",
        "config": {
          "child": {
            "son": {
              "type": "ChildMojit",
              "children": {
                "grandson": {
                  "type": "GrandchildMojit"
                },
                "grandaughter": {
                  "type": "GrandchildMojit"
                }
              }
            }
          }
        }
      }
    }
  }
]

Configuring Applications to Be Deployed to Client¶

To configure Mojito to deploy code to the client, you must be using the HTMLFrameMojit as the parent mojit and also set the deploy property of the configuration Object object to true in the config object of your mojit instance.

[
  {
    "settings": [ "master" ],
    "specs": {
      "frame": {
        "type": "HTMLFrameMojit",
        "config": {
          "deploy": true,
          "child": {
            "type": "PagerMojit"
          }
        }
      }
    }
  }
]

Example Application Configurations¶

This example application.json defines the two mojit instances foo and bar. The foo mojit instance is of type MessageViewer, and the bar mojit instance uses foo as the base mojit. Both have metadata configured in the config object.

[
  {
    "settings": [ "master" ],
    "yui": {
      "showConsoleInClient": false,
      "config": {
         "fetchCSS": false,
         "combine": true,
         "comboBase:" 'http://mydomain.com/combo?',
         "root": 'yui3/'
       }
    },
    "specs": {
      "foo": {
        "type": "MessageViewer",
        "config": {
          "message": "hi"
        }
      },
      "bar": {
        "base": "foo",
        "config": {
          "message": "hello"
        }
      }
    }
  }
]

Configuring Metadata¶

The definition.json file in the mojit directory is used to specify metadata about the mojit type. The contents of the file override the mojit type metadata that Mojito generates from the contents of the file system.

The information is available from the controller using the Config addon. For example, you would use ac.config.getDefinition('version') to get the version information.

The table below describes the configuration object in definition.json.

Configuring and Using an Application-Level Mojit¶

The definition.json file lets you configure a mojit to be available at the application level, so that other mojits can use its actions, addons, assets, binders, models, and views. Mojits available at the application level are not intended to be run alone, and some of its resources, such as the controller and configuration, are not available to other mojits.

To configure a mojit to be available at the application level, you set the appLevel property in definition.json to true as seen below:

[
  {
    "settings": [ "master" ],
    "appLevel": true
  }
]

To use an application-level mojit, other mojits must include the YUI module name in the requires array of the controller. For example, to use the FooMojitModel module of the application-level Foo mojit, the controller of the Bar mojit would include 'FooMojitModel' in the requires array as seen below:

YUI.add('BarMojit', function(Y, NAME) {
  Y.namespace('mojito.controllers')[NAME] = {
    init: function(config) {
      this.config = config;
    },
    index: function(actionContext) {
      actionContext.done({title: "Body"});
    }
  };
}, '0.0.1', {requires: ['FooMojitModel']});

Configuring Defaults for Mojit Instances¶

The defaults.json file in the mojit type directory can be used to specify defaults for each mojit instance of the type. The format is the same as the mojit instance as specified in the specs object of application.json. This means that you can specify a default action, as well as any defaults you might want to put in the config object.

Mojit Instances¶

A mojit instance is made entirely of configuration. This configuration specifies which mojit type to use and configures an instance of that type. The mojit instances are defined in the specs object of the application.json file.

See Application Configuration and Example Application Configurations for details of the specs object.

[
  {
    "settings": [ "master" ],
    "specs": {
      "foo": {
        "type": "Foo",
        "config": {
          "message": "hi"
        }
      }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "foo index": {
      "verbs": ["get"],
      "path": "/",
      "call": "foo.index"
    }
  }
]

Routing Configuration File¶

The routes.json file contains the routing configuration information in JSON. The JSON consists of an array of one or more configuration objects that include route objects specifying route paths, parameters, HTTP methods, and actions.

The table below describes the properties of the route object of routes.json.

Map Routes to Specific Mojit Instances and Actions¶

This type of route configuration is the most sophisticated and recommended for production applications. To map routes to a mojit instance and action, you create the file routes.json in your application directory. The routes.json file allows you to configure a single or multiple routes and specify the HTTP method and action to use for each route.

[
  {
    "settings": [ "master" ],
    "appPort": 8666,
    "specs": {
      "hello": {
        "type": "HelloMojit"
      }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "hello index": {
      "verbs": ["get"],
      "path": "/",
      "call": "hello.index"
    }
  }
]

[
  {
    "settings": [ "master" ],
    "hello index": {
      "verbs": ["get"],
      "path": "/",
      "call": "@HelloMojit.index",
      "params": { "first_visit": true }
    }
  }
]

[
  {
    "settings": [ "master" ],
    "root": {
      "verb": ["get"],
      "path": "/*",
      "call": "foo-1.index"
    },
    "foo_default": {
      "verb": ["get"],
      "path": "/foo",
      "call": "foo-1.index"
    },
    "bar_default": {
      "verb": ["get"],
      "path": "/bar",
      "call": "bar-1.index",
      "params": { "page": 1, "log_request": true }
    }
  }
]

Adding Routing Parameters¶

You can configure a routing path to have routing parameters with the params property. Routing parameters are accessible from the ActionContext object using the Params addon.

In the example routes.json below, routing parameters are added with an object. To get the value for the routing parameter page from a controller, you would use ac.params.getFromRoute("page").

[
  {
    "settings": [ "master" ],
    "root": {
      "verb": ["get"],
      "path": "/*",
      "call": "foo-1.index",
      "params": { "page": 1, "log_request": true }
    }
  }
]

Using Parameterized Paths to Call a Mojit Action¶

Your routing configuration can also use parameterized paths to call mojit actions. In the routes.json below, the path property uses parameters to capture a part of the matched URL and then uses that captured part to replace {{mojit-action}} in the value for the call``property.  Any value can be used for the parameter as long as it is prepended with a colon (e.g., ``:foo). After the parameter has been replaced by a value given in the path, the call to the action should have the following syntax: {mojit_instance}.(action}

[
  {
    "settings": [ "master" ],
    "_foo_action": {
      "verb": ["get", "post", "put"],
      "path": "/foo/:mojit-action",
      "call": "@foo-1.{mojit-action}"
    },
    "_bar_action": {
      "verb": ["get", "post", "put"],
      "path": "/bar/:mojit-action",
      "call": "@bar-1.{mojit-action}"
    }
  }
]

For example, based on the routes.json above, an HTTP GET call made on the path http://localhost:8666/foo/index would call the index function in the controller because the value of :mojit-action in the path (index in this case) would be then replace {mojit-action}} in the call property. The following URLs call the index and myAction functions in the controller.

• http://localhost:8666/foo/index
• http://localhost:8666/foo/myAction
• http://localhost:8666/bar/index

Using Regular Expressions to Match Routing Paths¶

You can use the regex property of the routing object to define a key-value pair that defines a path parameter and a regular expression. The key is prepended with a colon when represented as a path parameter. For example, the key name would be represented as :name as a path parameter: "path": "/:name". The associated value contains the regular expression that is matched against the request URL.

For example, in the routes.json below, if the path of the request matches the regular expression \d{1,2}_[Mm]ojitos?, the index action of the mojit instance is called.

[
  {
    "settings": [ "master" ],
    "regex_path": {
      "verbs": ["get"],
      "path": "/:matched_path",
      "regex": { "matched_path": "\d{1,2}_[Mm]ojitos?" },
      "call": "myMojit.index"
    }
  }
]

Based on the above routing configuration, the following URLs would call the index action:

• http://localhost:8666/1_mojito
• http://localhost:8666/99_Mojitos

Generate URLs from the Controller¶

The Mojito JavaScript library contains the Url addon that allows you to create a URL with the mojit instance, the action, and parameters from the controller.

In the code snippet below from routes.json, the mojit instance, the HTTP method, and the action are specified in the "foo_default" object.

"foo_default": {
  "verb": ["get"],
  "path": "/foo",
  "call": "foo-1.index"
}

In this code snippet from controller.js, the Url addon with the make method use the mojit instance and function specified in the routes.json above to create the URL /foo with the query string parameters ?foo=bar.

...
  index: function(ac) {
    ac.url.make('foo-1', 'index', null, 'GET',{'foo': 'bar'});
  }
...

The index function above returns the following URL: http://localhost:8666/foo?foo=bar

Application-Level Configurations¶

Only the mojit controller has access to application-level configurations through the actionContext object.

Application Context¶

The contexts for an application specify environment variables such as the runtime environment, the location, device, region, etc. Once again, only the controller that is passed the actionContext object can access the context. You can access the context using ac.context.

Below is an example of the context object:

{
  runtime: 'server',
  site: '',
  device: '',
  lang: 'en-US',
  langs: 'en-US,en',
  region: '',
  jurisdiction: '',
  bucket: '',
  flavor: '',
  tz: ''
}

Mojit-Level Configurations¶

Mojit-level configurations can be specified in two locations. You can specify mojit-level configurations in the config object of a mojit instance in application.json or default configurations for a mojit in mojits/{mojit_name}/defaults.json. The configurations of application.json override those in defaults.json.