lincd-cli 0.1.7 → 0.1.8

package/defaults/module/src/data/example-ontology.json

@@ -4,15 +4,15 @@
     "owl": "http://www.w3.org/2002/07/owl#",
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
-    "test": "http://www.example.com/"
+    "${hyphen_name}": "${uri_base}"
   },
   "@graph": [
     {
-      "@id": "example:ExampleClass",
+      "@id": "${hyphen_name}:ExampleClass",
       "@type": "rdfs:Class",
       "rdfs:comment": "This is an example class. You can remove or rename it",
       "rdfs:isDefinedBy": {
-        "@id": "example:"
+        "@id": "${hyphen_name}:"
       },
       "rdfs:label": "Example Class"
     }

package/defaults/module/src/index.ts

@@ -1,4 +1,4 @@
-import './ontologies/example-ontology';
+import './ontologies/${hyphen_name}';
 
 //SHAPES FIRST
 import './shapes/ExampleShapeClass';

package/defaults/module/src/ontologies/example-ontology.ts

@@ -4,11 +4,10 @@ import {createNameSpace} from 'lincd/lib/utils/NameSpace';
 import {linkedOntology} from '../module';
 //finally, we pass on all the exports, plus the namespace, prefix and data loading function
 // as we register this ontology in the LINCD tree
-import * as _this from './example-ontology';
+import * as _this from './${hyphen_name}';
 
-let dataFile = '../data/example-ontology.json';
 export var loadData = () => {
-  return import(dataFile).then((data) => JSONLD.parse(data));
+  return import('../data/${hyphen_name}.json').then((data) => JSONLD.parse(data));
 };
 
 export var ns = createNameSpace('${uri_base}');
@@ -19,13 +18,13 @@ export var _self: NamedNode = ns('');
 //The main goal though of this file is to export a reference to NamedNode with the correct URI
 // for all the entities (Classes and properties) in the ontology
 export var ExampleClass: NamedNode = ns('ExampleClass');
-export var exampleName: NamedNode = ns('exampleName');
+export var exampleProperty: NamedNode = ns('exampleProperty');
 
-export const exampleOntology = {
+export const ${camel_module_name} = {
   ExampleClass,
-  exampleName,
+  exampleProperty,
 };
 
 //as third parameter, provide a prefix (string) that can be used to refer to the full ontology URL.
 //for example: 'schema' refers to https://www.schema.org/
-linkedOntology(_this, ns, 'exampl', loadData, dataFile);
+linkedOntology(_this, ns, '${hyphen_name}', loadData, '../data/${hyphen_name}.json');

package/defaults/module/src/shapes/ExampleShapeClass.ts

@@ -2,28 +2,28 @@ import {Shape} from 'lincd/lib/shapes/Shape';
 import {Literal, NamedNode} from 'lincd/lib/models';
 import {linkedShape} from '../module';
 import {literalProperty} from 'lincd/lib/utils/ShapeDecorators';
-import {exampleOntology} from '../ontologies/example-ontology';
+import {${camel_module_name}} from '../ontologies/${hyphen_name}';
 
 @linkedShape
 export class ExampleShapeClass extends Shape {
   /**
    * indicates that instances of this shape need to have this rdf.type
    */
-  static targetClass: NamedNode = exampleOntology.ExampleClass;
+  static targetClass: NamedNode = ${camel_module_name}.ExampleClass;
 
   /**
    * instances of this shape need to have exactly one value defined for the given property
    */
   @literalProperty({
-    path: exampleOntology.exampleName,
+    path: ${camel_module_name}.exampleProperty,
     required: true,
     maxCount: 1,
   })
   get name() {
-    return this.getValue(exampleOntology.exampleName);
+    return this.getValue(${camel_module_name}.exampleProperty);
   }
 
   set name(val: string) {
-    this.overwrite(exampleOntology.exampleName, new Literal(val));
+    this.overwrite(${camel_module_name}.exampleProperty, new Literal(val));
   }
 }

package/lib/cli.js

@@ -36,6 +36,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
 var utils_1 = require("./utils");
 require('require-extensions');
@@ -268,10 +277,90 @@ program.command('create-app [name] [uribase]').action(function (name, uriBase) {
 program.command('create-module [name] [uribase]').action(function (name, uriBase) {
     return createModule(name, uriBase);
 });
+program.command('create-ontology [suggested-prefix] [uribase]').action(function (prefix, uriBase) {
+    return createOntology(prefix, uriBase);
+});
+var createOntology = function (prefix, uriBase, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var targetFolder, codeName, hyphenName, cameCaseName, underscoreName, targetFile, targetDataFile, targetDataFile2, indexPath, indexContents, lines, newContents, key;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!prefix) {
+                        console.warn("Please provide a suggested prefix as the first argument");
+                        return [2 /*return*/];
+                    }
+                    targetFolder = path.join(basePath, 'src', 'ontologies');
+                    if (!fs.existsSync(targetFolder)) {
+                        if (fs.existsSync(path.join(basePath, 'src'))) {
+                            fs.mkdirSync(targetFolder);
+                        }
+                        else {
+                            warn("Please run this command from the root of your module. This command expects [modules]/src/ontologies to exists from that folder");
+                        }
+                    }
+                    if (!uriBase) {
+                        uriBase = 'http://lincd.org/ont/' + prefix;
+                    }
+                    codeName = prefix.replace(/\-/g, '_');
+                    hyphenName = prefix.replace(/[-_\s]+/g, '-');
+                    cameCaseName = camelCase(prefix);
+                    underscoreName = prefix.replace(/[-\s]+/g, '_');
+                    targetFile = path.join(targetFolder, hyphenName + '.ts');
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+                    targetDataFile = path.join(targetFolder, '..', 'data', hyphenName + '.json');
+                    targetDataFile2 = path.join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json'), targetDataFile);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
+                    setVariable('uri_base', uriBase);
+                    setVariable('camel_module_name', cameCaseName);
+                    setVariable('underscore_module_name', underscoreName);
+                    setVariable('hyphen_name', hyphenName);
+                    setVariable('module_name', prefix);
+                    log("Creating files for ontology '" + prefix + "'");
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, Promise.all([targetFile, targetDataFile, targetDataFile2]
+                            .map(function (file) {
+                            return replaceVariablesInFile(file);
+                        }))];
+                case 1:
+                    //replace variables in some of the copied files
+                    _a.sent();
+                    indexPath = ['index.ts', 'index.tsx'].map(function (f) {
+                        return path.join('src', f);
+                    }).find(function (indexFileName) {
+                        return fs.existsSync(indexFileName);
+                    });
+                    if (indexPath) {
+                        indexContents = fs.readFileSync(indexPath, 'utf-8');
+                        lines = indexContents.split(/\n/g);
+                        newContents = void 0;
+                        for (key in lines) {
+                            if (lines[key].indexOf('ontologies') !== -1) {
+                                //remove lines after this line and insert new line in its place
+                                lines[key] += "\nimport './ontologies/".concat(hyphenName, "';");
+                                newContents = lines.join("\n");
+                                // log("Found at "+key,lines,newContents);
+                                break;
+                            }
+                        }
+                        if (!newContents) {
+                            newContents = indexContents + "\nimport './ontologies/".concat(hyphenName, "';");
+                            // log("Added at end",newContents);
+                        }
+                        fs.writeFileSync(indexPath, newContents);
+                    }
+                    log("Prepared a new ontology data files in ".concat(chalk.magenta(targetDataFile.replace(basePath, ''))), "And an ontology accessor file in ".concat(chalk.magenta(targetFile.replace(basePath, ''))), "Added an import of this file from ".concat(chalk.magenta(indexPath)));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
 var createModule = function (name, uriBase, basePath) {
     if (basePath === void 0) { basePath = process.cwd(); }
     return __awaiter(void 0, void 0, void 0, function () {
-        var targetFolder, _a, packageName, scope, cleanPackageName, codeName, cameCaseName, underscoreName, version, installCommand;
+        var targetFolder, _a, packageName, scope, cleanPackageName, codeName, cameCaseName, underscoreName, hyphenName, version, installCommand;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -302,29 +391,43 @@ var createModule = function (name, uriBase, basePath) {
                     codeName = cleanPackageName.replace(/\-/g, '_');
                     cameCaseName = camelCase(name);
                     underscoreName = name.replace(/[-\s]+/g, '_');
+                    hyphenName = name.replace(/[-_\s]+/g, '-');
                     setVariable('uri_base', uriBase);
                     //longer similar variables names should come before the shorter ones
                     setVariable('camel_module_name', cameCaseName);
                     setVariable('underscore_module_name', underscoreName);
                     setVariable('module_name', name);
+                    setVariable('hyphen_name', hyphenName);
                     log("Creating new LINCD module '" + name + "'");
                     //replace variables in some of the copied files
-                    ['package.json', 'Gruntfile.js', 'src/module.ts']
-                        .map(function (f) { return path.join(targetFolder, f); })
-                        .forEach(function (file) {
-                        replaceVariablesInFile(file);
+                    return [4 /*yield*/, Promise.all(['src/index.ts', 'package.json', 'Gruntfile.js', 'src/module.ts', 'src/shapes/ExampleShapeClass.ts', 'src/ontologies/example-ontology.ts', 'src/data/example-ontology.json']
+                            .map(function (f) { return path.join(targetFolder, f); })
+                            .map(function (file) {
+                            return replaceVariablesInFile(file);
+                        }))];
+                case 1:
+                    //replace variables in some of the copied files
+                    _b.sent();
+                    //rename these to a file name similar to the module name
+                    ['src/ontologies/example-ontology.ts', 'src/data/example-ontology.json', 'src/data/example-ontology.json.d.ts'].forEach(function (f) {
+                        var parts = f.split('/');
+                        var newParts = __spreadArray([], parts, true);
+                        var _a = newParts.pop().split('.'), name = _a[0], extensions = _a.slice(1);
+                        var newName = hyphenName + '.' + extensions.join(".");
+                        console.log('rename ', path.join(targetFolder, f), path.join.apply(path, __spreadArray(__spreadArray([targetFolder], newParts, false), [newName], false)));
+                        fs.renameSync(path.join(targetFolder, f), path.join.apply(path, __spreadArray(__spreadArray([targetFolder], newParts, false), [newName], false)));
                     });
                     return [4 /*yield*/, execPromise('yarn --version')["catch"](function (err) {
                             console.log("yarn probably not working");
                             return '';
                         })];
-                case 1:
+                case 2:
                     version = _b.sent();
                     installCommand = version.toString().match(/[0-9]+/) ? 'yarn install' : 'npm install';
                     return [4 /*yield*/, execp("cd ".concat(targetFolder, " && ").concat(installCommand, " && npm exec lincd build"), true)["catch"](function (err) {
                             console.warn("Could not install dependencies");
                         })];
-                case 2:
+                case 3:
                     _b.sent();
                     log("Prepared a new LINCD module in ".concat(chalk.magenta(targetFolder)), "Run ".concat(chalk.blueBright('yarn build'), " from this directory to build once"), "Or ".concat(chalk.blueBright('yarn dev'), " to continuously rebuild on file changes"));
                     return [2 /*return*/];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lincd-cli",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Command line tools for the lincd.js library",
   "main": "lib/index.js",
   "scripts": {