mantra.yaml

root: src
templates:
  # Module action template
  - name: actions
    text: |
      export default {
        $1({ Meteor }, param1) {

        }
      };

    placeholders:
      - Action name
    actions:
      - type: replace
        path: index.js
        what: /* IMPORTS */
        replace: import $name from "./$name";\n/* IMPORTS */
      - type: replace
        path: index.js
        what: /* CALLS */
        replace: $name,\n  /* CALLS */
      - type: create
        path: tests/$name.js
        text: |
          const { describe, it } = global;
          import { expect } from 'chai';
          import { spy, stub } from 'sinon';
          import actions from '../$name';

          describe('MODULE_NAME.actions.$name', () => {
            describe('ACTION_NAME', () => {
              it('should reject if title is not there', () => {
                const LocalState = {set: spy()};
                actions.create({LocalState}, null, 'content');
                const args = LocalState.set.args[0];
                expect(args[0]).to.be.equal('SAVING_ERROR');
                expect(args[1]).to.match(/required/);
              });
            });
          });

  - name: actionIndex
    create: true
    text: |
      /* IMPORTS */
      export default {
        /* CALLS */
      };

  # Module component template
  - name: storiesIndex
    create: true
    text: |
      // imports

  - name: components
    text: |
      import React, { Component } from "react";

      export default class $1 extends Component {
        render() {
          return null;
        }
      }

    placeholders:
      - Component Name
    actions:
      - type: create
        path: tests/$name.js
        text: |
          import React from 'react';
          const { describe, it } = global;
          import { expect } from 'chai';
          import { shallow } from 'enzyme';
          import Component from '../$name';

          describe('MODULE_NAME.components.$name', () => {
            it('should not be null', () => {
              const el = shallow(<Component />);
              expect(el).not.to.be.null;
            });
          });

      - type: create
        path: stories/$name_stories.js
        text: |
          import React from 'react';
          import { storiesOf, action } from '@kadira/storybook';
          import Component from '../$name';

          storiesOf('module.$name', module)
            .add('default view', () => {
              return (
                <Component />
              );
            })

      - type: replace
        path: stories/index.js
        what: // imports
        replace: |
          // imports
          import $name from "./$name_stories";
  # Module container template
  - name: containers
    text: |
      import { useDeps, composeAll, composeWithTracker } from 'mantra-core';

      import $1 from '../components/_____name_____.jsx';

      export const composer = ({context}, onData) => {
        const { Meteor } = context();

        onData(null, {});
      };

      export const depsMapper = (context, actions) => ({
        context: () => context
      });

      export default composeAll(
        composeWithTracker(composer),
        useDeps(depsMapper)
      )($1);

    placeholders:
      - Component Name
    actions:
      - type: replace
        path: $name.js
        what: _____name_____.jsx';
        replace: $name.jsx';
      - type: create
        path: tests/$name.js
        text: |
          const { describe, it } = global;
          import { expect } from 'chai';
          import { spy, stub } from 'sinon';
          import { composer, depsMapper } from '../$name';

          describe('MODULE_NAME.containers.$name', () => {
            describe('composer', () => {
              it('should ', () => {

              });
            });
          });

  # Module route template
  - name: route
    show: true
    create: true
    text: |
      import React from "react";
      import { mount } from "mantra-core";

      export default function (injectDeps) {
        // const MainLayoutCtx = injectDeps(MainLayout);
        // Move these as a module and call this from a main file
        // FlowRouter.route("/", {
        //   name: "ei.list",
        //   action() {
        //     mount(MainLayoutCtx, {
        //       content: () => (<EiList />)
        //     });
        //   }
        // });
      }

  # Module index template
  - name: module
    show: true
    create: true
    text: |
      import actions from "./actions";
      import routes from "./routes";

      export default {
        actions,
        routes
      };

  # Server publication template
  - name: server/publications
    text: |
      import { Meteor } from 'meteor/meteor';
      import { check } from 'meteor/check';

      import { $2 } from '../../lib/collections';

      export default function () {
        Meteor.publish("$1", function () {
          const selector = {};
          const options = {
            // fields: {_id: 1, title: 1},
            // sort: {createdAt: -1},
            // limit: 10
          };
          return $2.find(selector, options);
        });
      }

    placeholders:
      - Publication Name
      - Collection
    actions:
      - type: replace
        path: index.js
        what: /* IMPORTS */
        replace: import $name from "./$name";\n/* IMPORTS */

      - type: replace
        path: index.js
        what: /* CALLS */
        replace: $name();\n  /* CALLS */

  # Method template
  - name: server/methods
    text: |
      import { Meteor } from 'meteor/meteor';
      import { check } from 'meteor/check';

      export default function () {
        Meteor.methods({
          $1($2) {
            check($2, String);
          }
        });
      }

    placeholders:
      - Method Name
      - Parameters
    actions:
      - type: replace
        path: index.js
        what: /* IMPORTS */
        replace: import $name from "./$name";\n/* IMPORTS */

      - type: replace
        path: index.js
        what: /* CALLS */
        replace: $name();\n  /* CALLS */

  - name: server
    create: true
    show: true
    text: |
      import addInitialData from './configs/initial_adds.js';

      addInitialData();

      // import publications and methods

      import publications from './publications/index';
      import methods from './methods/index';

      publications();
      methods();

  - name: publicationIndex
    create: true
    text: |
      /* IMPORTS */
      export default function () {
        /* CALLS */
      }

  - name: methodIndex
    create: true
    text: |
      /* IMPORTS */
      export default function () {
        /* CALLS */
      }

  # context template
  - name: context
    create: true
    text: |
      import * as Collections from 'lib/collections';
      import { Meteor } from 'meteor/meteor';
      import { FlowRouter } from 'meteor/kadira:flow-router';
      import { ReactiveDict } from 'meteor/reactive-dict';
      import { Accounts } from 'meteor/accounts-base';

      export default function () {
        return {
          Meteor,
          FlowRouter,
          Collections,
          LocalState: new ReactiveDict(),
          Accounts
        };
      }

  # client index template
  - name: client
    create: true
    show: true
    text: |
      import "./configs/config";
      import {createApp} from 'mantra-core';
      import coreModule from "./modules/core/index";
      import initContext from "./configs/context";
      // init context
      const context = initContext();
      // create app
      const app = createApp(context);
      app.loadModule(coreModule);
      app.init();

    actions:
      - type: replace
        path: ../index.js
        what: import {createApp} from 'mantra-core';
        replace: |
          import {createApp} from 'mantra-core';
          import $nameModule from "./modules/$name";
      - type: replace
        path: ../index.js
        what: app.init();
        replace: |
          app.loadModule($nameModule);
          app.init()