1. Mojito CLI Basics¶

Introduction¶

There is a Mojito command-line utility that provide you with some essential functionality such as creating applications, mojits, and starting application. The utility also has commands for helping you develop and generate documentation.

In this module, we will be covering some of the more commonly used Mojito CLI commands to create an application, a mojit, and then run our application. In addition, we’ll learn how to use the utility to sanitize code, and run tests. Our lesson will give an overview of the utility, covering some features that you won’t use in this module, but will be using in future modules.

Final Product¶

Our first application isn’t very impressive as it just displays the default text, but the focus in this module is to learn how to use the Mojito CLI utility. In the process, we also create our first application and a mojit.

Lesson: Using the Mojito Command-Line Utility¶

We described the lesson section in the introduction, but we’ll mention it again here as it’s your first module. In the lesson of each module, you will be learning about a specific topic and not creating an application. Thus, the code snippets and explanations in the lesson will cover the topic that the application is focused on, but will not necessarily show application code. We just want to give you a heads up now so you’re not wondering why you’re not creating application code or why the code snippets are not the same as the code that you’re using to create your application in the Creating the Application section of each module.

info: (mojito-resource-store): Store initialized
info: (mojito-resource-store): Store initial preloaded
info: (mojito-resource-store): Store fully preloaded

Test Results:
artifacts/test/result.xml


✔  passed    github-model-tests :: github-model user tests :: test mojit model
✔  passed    github-tests :: Github user tests :: test mojit

Total tests: 2       ✔ Passed: 2     ⚑ Deferred: 0   ✖ Failed: 0     100% pass rate

Creating the Application¶

1. Let’s first create our application with the create command. We’re using the default for the reason that the simple application gives us too little to work with, and the full application includes a lot of features that we won’t need and may just be confusing. Once you’ve finished this tutorial, you very well may opt to start with the full application to quicken development.

   $ mojito create app 01_mojito_cli_basics

2. Change to your application directory, which you need to do to create mojits. Our dashboard application is going to get statistics from GitHub, so let’s create the mojit that will be doing a lot of work for us now.

   $ mojito create mojit Github

3. Let’s run some tests now. First, run the application unit tests, which, in reality, just runs all the unit tests of your mojits.

   $ mojito test app .

   You’ll see that a controller and a model test passed and that results were saved to artifacts/test/result.xml.

4. Since we only have one mojit, the application unit tests and the mojit unit tests should be the same, but go ahead and run the following command to confirm:

   $ mojito test mojit mojits/Github

5. You can also test a mojit module, which is basically the module name that you register with YUI.add. Mojit controllers and models are YUI modules.

   $ mojito test mojit mojits/Github github

   Notice that module names are lowercased (github).

6. Mojito’s test command comes with a very useful option for getting coverage results. Run the command for application unit tests, but add the option -c to get coverage results as well.

   $ mojito test app -c .

7. In a browser, open the file artifacts/test/coverage/lcov-report/index.html to see the code coverage report. The report gives line and function coverage.

8. Our application shouldn’t have any syntax errors–if it does, we should file a GitHub issue with Mojito <, but let’s run the ``jslint` command for both the application and our one mojit:

   $  mojito jslint app .
   $  mojito jslint mojit mojits/Github
   

9. Alright, we’ve tested and linted our application. Go ahead and start the application by running the following from your application directory.

   $ node app.js

   In future modules, we won’t include steps for running tests and linting your code, but highly recommend that you do this on your own to save yourself the headache of unraveling more complicated errors.

10. To view your application, open the URL http://localhost:8666/@Github/index in a browser. This is the page created and served by your application.

    It’s a strange URL, right? First, the port 8666 is the default port used by Mojito, which we’ll override in the next step. As for the path, well, we haven’t set up any routes yet, but the syntax for routes is as follows: /{mojit_instance}/{action}.

    We haven’t created a mojit instance, which is an in-memory instance created from the mojit code (mojit definition), but we’ll do that in the next module. If you open app.js in an editor, you’ll see we defined the following routing path:

    app.get(‘/:mojit/:action’, libmojito.dispatch(“{mojit}.{action}”));

    Mojito creates for us an anonymous instance of the mojit Github by prepending @ to the mojit name. As for 'index', it’s an action called from the mojit instance. Thus, the defined path uses parameterized arguments that allow you to explicitly state the anonymous instance and the action, which Mojito will then get from the path and execute.

11. Stop the application with Ctl-C, and the restart it with a different port by exporting PORT=8000:

    $ export PORT=8000; $ node app.js

    You can now view the application at http://localhost:8000/@Github/index.

12. As we discussed in our lesson, you can start an application in a given context, so that a specific set of configurations are applied for a runtime environment.

    To start the application in the development context, pass the context object to libmojito.extend in app.js. The context object in this case has the key-value pair environment:development as shown below:

    libmojito.extend(app, {
        context: {
            environment: "development"
        }
    });
    

13. Now when you restart your application, you’ll be starting it with the development context.

If you open the file application.json, you will see the property "settings" twice. The string value given in the array assigned to "settings" is the context. Although neither configuration object in application.json has many configurations, you can have many configuration objects with different configuration values that are mapped to a context.

Module Review¶

In this module, we covered the following features of the Mojito command-line utility:

• creating applications and mojits
• running application and mojit unit tests
• linting code
• starting applications
• specifying ports and contexts when starting applications.

Troubleshooting¶

err!  Mojito must be installed locally. Please try `npm i mojito

Error: listen EADDRINUSE

Q&A¶

• Why is there a mojito-cli and a mojito package?

  The mojito-cli package is the CLI utility for Mojito. the mojito package contains the framework that your applications needs to run. Thus, you want the mojito-cli package to be global and the mojito package to be local in your application. You don’t want an application to depend on a global installation of the framework.

• Is there a way to configure your application to run on a different default port?

  Yes, in app.js, you can define the port or use the value of the variable PORT.

  app.set('port', process.env.PORT || 8666);

  To set process.env.PORT, you can do the following from shell CLI: $ export PORT=8000

Test Yourself¶

Terms¶

archetypes

Different versions of template code for an artifact such as an application or a mojit. So, when you select the archetype simple for an application, you are asking Mojito to create an application using the boilerplate code from the simple version of an application.

mojits

The basic unit of composition and reuse in a Mojito application that uses MVC. Visually, you can think of a mojit as the rectangular area of a page that was constructed by a Mojito application.

YAML

anonymous mojit instance

A mojit instance auto-created by the Framework that you can reference in your application. The syntax is the mojit name prepended with @. For example: @Github

context

The runtime environment that your application runs in. For example, you can run your application in a development environment with the context environment:development.

Source Code for Example¶

01_mojito_cli_basics

Further Reading¶

• Mojito Introduction
• Mojito Command Line