├── .gitignore
├── .npmignore
├── .vscode
    ├── launch.json
    └── tasks.json
├── LICENSE
├── editorconfig
├── package-lock.json
├── package.json
├── readme.md
├── src
    ├── app.d.ts
    ├── compiler.ts
    ├── config-reader.ts
    ├── config-store.ts
    ├── data-interfaces.ts
    ├── file-search.ts
    ├── index.ts
    ├── initializer
    │   ├── init-config.ts
    │   ├── init-prompt.ts
    │   ├── initializer.ts
    │   ├── model-builder.ts
    │   └── npm-installer.ts
    ├── input-watcher.ts
    ├── json-file-reader.ts
    ├── model-store.ts
    ├── path-utility.ts
    ├── reference-path-resolver.ts
    ├── template-process.ts
    ├── template-runner.ts
    └── yellicode-constants.ts
└── tsconfig.json


/.gitignore:
--------------------------------------------------------------------------------
1 | #Npm modules
2 | node_modules/
3 | npm-debug.log.*
4 | 
5 | #Custom generated output
6 | dist/
7 | *.tgz


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .vscode/*
2 | src
3 | !dist/*/src
4 | tsconfig.json
5 | *.npmignore
6 | *.ts
7 | !*.d.ts
8 | rollup.config.js


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Use IntelliSense to learn about possible attributes.
 3 |     // Hover to view descriptions of existing attributes.
 4 |     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "type": "node",
 9 |             "request": "launch",
10 |             "preLaunchTask": "build-es5",
11 |             "name": "Build and Launch",
12 |             "program": "${workspaceFolder}\\dist\\es5\\index",
13 |             "cwd": "", // <!-- set working dir here                        
14 |             "args": [                  
15 |                 "--log-level", "verbose"
16 |             ]
17 |         },
18 |         {
19 |             "type": "node",
20 |             "request": "launch",
21 |             "name": "Launch (no build)",
22 |             "program": "${workspaceFolder}\\dist\\es5\\index",
23 |             "cwd": "", // <!-- set working dir here                        
24 |             "args": [
25 |                 "--log-level", "verbose"
26 |             ]
27 |         }
28 |     ]
29 | }


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // See https://go.microsoft.com/fwlink/?LinkId=733558
 3 |     // for the documentation about the tasks.json format
 4 |     "version": "2.0.0",
 5 |     "tasks": [
 6 |         {
 7 |             "identifier": "build",
 8 |             "type": "npm",
 9 |             "script": "build",
10 |             "group": {
11 |                 "kind": "build",
12 |                 "isDefault": true
13 |             },
14 |             "problemMatcher": []
15 |         },
16 |         {
17 |             "identifier": "build-es5",
18 |             "type": "npm",
19 |             "script": "build:es5",
20 |             "group": {
21 |                 "kind": "build",
22 |                 "isDefault": true
23 |             },
24 |             "problemMatcher": []
25 |         }
26 |     ]
27 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Mozilla Public License Version 2.0
  2 | ==================================
  3 | 
  4 | 1. Definitions
  5 | --------------
  6 | 
  7 | 1.1. "Contributor"
  8 |     means each individual or legal entity that creates, contributes to
  9 |     the creation of, or owns Covered Software.
 10 | 
 11 | 1.2. "Contributor Version"
 12 |     means the combination of the Contributions of others (if any) used
 13 |     by a Contributor and that particular Contributor's Contribution.
 14 | 
 15 | 1.3. "Contribution"
 16 |     means Covered Software of a particular Contributor.
 17 | 
 18 | 1.4. "Covered Software"
 19 |     means Source Code Form to which the initial Contributor has attached
 20 |     the notice in Exhibit A, the Executable Form of such Source Code
 21 |     Form, and Modifications of such Source Code Form, in each case
 22 |     including portions thereof.
 23 | 
 24 | 1.5. "Incompatible With Secondary Licenses"
 25 |     means
 26 | 
 27 |     (a) that the initial Contributor has attached the notice described
 28 |         in Exhibit B to the Covered Software; or
 29 | 
 30 |     (b) that the Covered Software was made available under the terms of
 31 |         version 1.1 or earlier of the License, but not also under the
 32 |         terms of a Secondary License.
 33 | 
 34 | 1.6. "Executable Form"
 35 |     means any form of the work other than Source Code Form.
 36 | 
 37 | 1.7. "Larger Work"
 38 |     means a work that combines Covered Software with other material, in
 39 |     a separate file or files, that is not Covered Software.
 40 | 
 41 | 1.8. "License"
 42 |     means this document.
 43 | 
 44 | 1.9. "Licensable"
 45 |     means having the right to grant, to the maximum extent possible,
 46 |     whether at the time of the initial grant or subsequently, any and
 47 |     all of the rights conveyed by this License.
 48 | 
 49 | 1.10. "Modifications"
 50 |     means any of the following:
 51 | 
 52 |     (a) any file in Source Code Form that results from an addition to,
 53 |         deletion from, or modification of the contents of Covered
 54 |         Software; or
 55 | 
 56 |     (b) any new file in Source Code Form that contains any Covered
 57 |         Software.
 58 | 
 59 | 1.11. "Patent Claims" of a Contributor
 60 |     means any patent claim(s), including without limitation, method,
 61 |     process, and apparatus claims, in any patent Licensable by such
 62 |     Contributor that would be infringed, but for the grant of the
 63 |     License, by the making, using, selling, offering for sale, having
 64 |     made, import, or transfer of either its Contributions or its
 65 |     Contributor Version.
 66 | 
 67 | 1.12. "Secondary License"
 68 |     means either the GNU General Public License, Version 2.0, the GNU
 69 |     Lesser General Public License, Version 2.1, the GNU Affero General
 70 |     Public License, Version 3.0, or any later versions of those
 71 |     licenses.
 72 | 
 73 | 1.13. "Source Code Form"
 74 |     means the form of the work preferred for making modifications.
 75 | 
 76 | 1.14. "You" (or "Your")
 77 |     means an individual or a legal entity exercising rights under this
 78 |     License. For legal entities, "You" includes any entity that
 79 |     controls, is controlled by, or is under common control with You. For
 80 |     purposes of this definition, "control" means (a) the power, direct
 81 |     or indirect, to cause the direction or management of such entity,
 82 |     whether by contract or otherwise, or (b) ownership of more than
 83 |     fifty percent (50%) of the outstanding shares or beneficial
 84 |     ownership of such entity.
 85 | 
 86 | 2. License Grants and Conditions
 87 | --------------------------------
 88 | 
 89 | 2.1. Grants
 90 | 
 91 | Each Contributor hereby grants You a world-wide, royalty-free,
 92 | non-exclusive license:
 93 | 
 94 | (a) under intellectual property rights (other than patent or trademark)
 95 |     Licensable by such Contributor to use, reproduce, make available,
 96 |     modify, display, perform, distribute, and otherwise exploit its
 97 |     Contributions, either on an unmodified basis, with Modifications, or
 98 |     as part of a Larger Work; and
 99 | 
100 | (b) under Patent Claims of such Contributor to make, use, sell, offer
101 |     for sale, have made, import, and otherwise transfer either its
102 |     Contributions or its Contributor Version.
103 | 
104 | 2.2. Effective Date
105 | 
106 | The licenses granted in Section 2.1 with respect to any Contribution
107 | become effective for each Contribution on the date the Contributor first
108 | distributes such Contribution.
109 | 
110 | 2.3. Limitations on Grant Scope
111 | 
112 | The licenses granted in this Section 2 are the only rights granted under
113 | this License. No additional rights or licenses will be implied from the
114 | distribution or licensing of Covered Software under this License.
115 | Notwithstanding Section 2.1(b) above, no patent license is granted by a
116 | Contributor:
117 | 
118 | (a) for any code that a Contributor has removed from Covered Software;
119 |     or
120 | 
121 | (b) for infringements caused by: (i) Your and any other third party's
122 |     modifications of Covered Software, or (ii) the combination of its
123 |     Contributions with other software (except as part of its Contributor
124 |     Version); or
125 | 
126 | (c) under Patent Claims infringed by Covered Software in the absence of
127 |     its Contributions.
128 | 
129 | This License does not grant any rights in the trademarks, service marks,
130 | or logos of any Contributor (except as may be necessary to comply with
131 | the notice requirements in Section 3.4).
132 | 
133 | 2.4. Subsequent Licenses
134 | 
135 | No Contributor makes additional grants as a result of Your choice to
136 | distribute the Covered Software under a subsequent version of this
137 | License (see Section 10.2) or under the terms of a Secondary License (if
138 | permitted under the terms of Section 3.3).
139 | 
140 | 2.5. Representation
141 | 
142 | Each Contributor represents that the Contributor believes its
143 | Contributions are its original creation(s) or it has sufficient rights
144 | to grant the rights to its Contributions conveyed by this License.
145 | 
146 | 2.6. Fair Use
147 | 
148 | This License is not intended to limit any rights You have under
149 | applicable copyright doctrines of fair use, fair dealing, or other
150 | equivalents.
151 | 
152 | 2.7. Conditions
153 | 
154 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
155 | in Section 2.1.
156 | 
157 | 3. Responsibilities
158 | -------------------
159 | 
160 | 3.1. Distribution of Source Form
161 | 
162 | All distribution of Covered Software in Source Code Form, including any
163 | Modifications that You create or to which You contribute, must be under
164 | the terms of this License. You must inform recipients that the Source
165 | Code Form of the Covered Software is governed by the terms of this
166 | License, and how they can obtain a copy of this License. You may not
167 | attempt to alter or restrict the recipients' rights in the Source Code
168 | Form.
169 | 
170 | 3.2. Distribution of Executable Form
171 | 
172 | If You distribute Covered Software in Executable Form then:
173 | 
174 | (a) such Covered Software must also be made available in Source Code
175 |     Form, as described in Section 3.1, and You must inform recipients of
176 |     the Executable Form how they can obtain a copy of such Source Code
177 |     Form by reasonable means in a timely manner, at a charge no more
178 |     than the cost of distribution to the recipient; and
179 | 
180 | (b) You may distribute such Executable Form under the terms of this
181 |     License, or sublicense it under different terms, provided that the
182 |     license for the Executable Form does not attempt to limit or alter
183 |     the recipients' rights in the Source Code Form under this License.
184 | 
185 | 3.3. Distribution of a Larger Work
186 | 
187 | You may create and distribute a Larger Work under terms of Your choice,
188 | provided that You also comply with the requirements of this License for
189 | the Covered Software. If the Larger Work is a combination of Covered
190 | Software with a work governed by one or more Secondary Licenses, and the
191 | Covered Software is not Incompatible With Secondary Licenses, this
192 | License permits You to additionally distribute such Covered Software
193 | under the terms of such Secondary License(s), so that the recipient of
194 | the Larger Work may, at their option, further distribute the Covered
195 | Software under the terms of either this License or such Secondary
196 | License(s).
197 | 
198 | 3.4. Notices
199 | 
200 | You may not remove or alter the substance of any license notices
201 | (including copyright notices, patent notices, disclaimers of warranty,
202 | or limitations of liability) contained within the Source Code Form of
203 | the Covered Software, except that You may alter any license notices to
204 | the extent required to remedy known factual inaccuracies.
205 | 
206 | 3.5. Application of Additional Terms
207 | 
208 | You may choose to offer, and to charge a fee for, warranty, support,
209 | indemnity or liability obligations to one or more recipients of Covered
210 | Software. However, You may do so only on Your own behalf, and not on
211 | behalf of any Contributor. You must make it absolutely clear that any
212 | such warranty, support, indemnity, or liability obligation is offered by
213 | You alone, and You hereby agree to indemnify every Contributor for any
214 | liability incurred by such Contributor as a result of warranty, support,
215 | indemnity or liability terms You offer. You may include additional
216 | disclaimers of warranty and limitations of liability specific to any
217 | jurisdiction.
218 | 
219 | 4. Inability to Comply Due to Statute or Regulation
220 | ---------------------------------------------------
221 | 
222 | If it is impossible for You to comply with any of the terms of this
223 | License with respect to some or all of the Covered Software due to
224 | statute, judicial order, or regulation then You must: (a) comply with
225 | the terms of this License to the maximum extent possible; and (b)
226 | describe the limitations and the code they affect. Such description must
227 | be placed in a text file included with all distributions of the Covered
228 | Software under this License. Except to the extent prohibited by statute
229 | or regulation, such description must be sufficiently detailed for a
230 | recipient of ordinary skill to be able to understand it.
231 | 
232 | 5. Termination
233 | --------------
234 | 
235 | 5.1. The rights granted under this License will terminate automatically
236 | if You fail to comply with any of its terms. However, if You become
237 | compliant, then the rights granted under this License from a particular
238 | Contributor are reinstated (a) provisionally, unless and until such
239 | Contributor explicitly and finally terminates Your grants, and (b) on an
240 | ongoing basis, if such Contributor fails to notify You of the
241 | non-compliance by some reasonable means prior to 60 days after You have
242 | come back into compliance. Moreover, Your grants from a particular
243 | Contributor are reinstated on an ongoing basis if such Contributor
244 | notifies You of the non-compliance by some reasonable means, this is the
245 | first time You have received notice of non-compliance with this License
246 | from such Contributor, and You become compliant prior to 30 days after
247 | Your receipt of the notice.
248 | 
249 | 5.2. If You initiate litigation against any entity by asserting a patent
250 | infringement claim (excluding declaratory judgment actions,
251 | counter-claims, and cross-claims) alleging that a Contributor Version
252 | directly or indirectly infringes any patent, then the rights granted to
253 | You by any and all Contributors for the Covered Software under Section
254 | 2.1 of this License shall terminate.
255 | 
256 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
257 | end user license agreements (excluding distributors and resellers) which
258 | have been validly granted by You or Your distributors under this License
259 | prior to termination shall survive termination.
260 | 
261 | ************************************************************************
262 | *                                                                      *
263 | *  6. Disclaimer of Warranty                                           *
264 | *  -------------------------                                           *
265 | *                                                                      *
266 | *  Covered Software is provided under this License on an "as is"       *
267 | *  basis, without warranty of any kind, either expressed, implied, or  *
268 | *  statutory, including, without limitation, warranties that the       *
269 | *  Covered Software is free of defects, merchantable, fit for a        *
270 | *  particular purpose or non-infringing. The entire risk as to the     *
271 | *  quality and performance of the Covered Software is with You.        *
272 | *  Should any Covered Software prove defective in any respect, You     *
273 | *  (not any Contributor) assume the cost of any necessary servicing,   *
274 | *  repair, or correction. This disclaimer of warranty constitutes an   *
275 | *  essential part of this License. No use of any Covered Software is   *
276 | *  authorized under this License except under this disclaimer.         *
277 | *                                                                      *
278 | ************************************************************************
279 | 
280 | ************************************************************************
281 | *                                                                      *
282 | *  7. Limitation of Liability                                          *
283 | *  --------------------------                                          *
284 | *                                                                      *
285 | *  Under no circumstances and under no legal theory, whether tort      *
286 | *  (including negligence), contract, or otherwise, shall any           *
287 | *  Contributor, or anyone who distributes Covered Software as          *
288 | *  permitted above, be liable to You for any direct, indirect,         *
289 | *  special, incidental, or consequential damages of any character      *
290 | *  including, without limitation, damages for lost profits, loss of    *
291 | *  goodwill, work stoppage, computer failure or malfunction, or any    *
292 | *  and all other commercial damages or losses, even if such party      *
293 | *  shall have been informed of the possibility of such damages. This   *
294 | *  limitation of liability shall not apply to liability for death or   *
295 | *  personal injury resulting from such party's negligence to the       *
296 | *  extent applicable law prohibits such limitation. Some               *
297 | *  jurisdictions do not allow the exclusion or limitation of           *
298 | *  incidental or consequential damages, so this exclusion and          *
299 | *  limitation may not apply to You.                                    *
300 | *                                                                      *
301 | ************************************************************************
302 | 
303 | 8. Litigation
304 | -------------
305 | 
306 | Any litigation relating to this License may be brought only in the
307 | courts of a jurisdiction where the defendant maintains its principal
308 | place of business and such litigation shall be governed by laws of that
309 | jurisdiction, without reference to its conflict-of-law provisions.
310 | Nothing in this Section shall prevent a party's ability to bring
311 | cross-claims or counter-claims.
312 | 
313 | 9. Miscellaneous
314 | ----------------
315 | 
316 | This License represents the complete agreement concerning the subject
317 | matter hereof. If any provision of this License is held to be
318 | unenforceable, such provision shall be reformed only to the extent
319 | necessary to make it enforceable. Any law or regulation which provides
320 | that the language of a contract shall be construed against the drafter
321 | shall not be used to construe this License against a Contributor.
322 | 
323 | 10. Versions of the License
324 | ---------------------------
325 | 
326 | 10.1. New Versions
327 | 
328 | Mozilla Foundation is the license steward. Except as provided in Section
329 | 10.3, no one other than the license steward has the right to modify or
330 | publish new versions of this License. Each version will be given a
331 | distinguishing version number.
332 | 
333 | 10.2. Effect of New Versions
334 | 
335 | You may distribute the Covered Software under the terms of the version
336 | of the License under which You originally received the Covered Software,
337 | or under the terms of any subsequent version published by the license
338 | steward.
339 | 
340 | 10.3. Modified Versions
341 | 
342 | If you create software not governed by this License, and you want to
343 | create a new license for such software, you may create and use a
344 | modified version of this License if you rename the license and remove
345 | any references to the name of the license steward (except to note that
346 | such modified license differs from this License).
347 | 
348 | 10.4. Distributing Source Code Form that is Incompatible With Secondary
349 | Licenses
350 | 
351 | If You choose to distribute Source Code Form that is Incompatible With
352 | Secondary Licenses under the terms of this version of the License, the
353 | notice described in Exhibit B of this License must be attached.
354 | 
355 | Exhibit A - Source Code Form License Notice
356 | -------------------------------------------
357 | 
358 |   This Source Code Form is subject to the terms of the Mozilla Public
359 |   License, v. 2.0. If a copy of the MPL was not distributed with this
360 |   file, You can obtain one at http://mozilla.org/MPL/2.0/.
361 | 
362 | If it is not possible or desirable to put the notice in a particular
363 | file, then You may include the notice in a location (such as a LICENSE
364 | file in a relevant directory) where a recipient would be likely to look
365 | for such a notice.
366 | 
367 | You may add additional accurate notices of copyright ownership.
368 | 
369 | Exhibit B - "Incompatible With Secondary Licenses" Notice
370 | ---------------------------------------------------------
371 | 
372 |   This Source Code Form is "Incompatible With Secondary Licenses", as
373 |   defined by the Mozilla Public License, v. 2.0.


--------------------------------------------------------------------------------
/editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | 
 3 | root = true
 4 | 
 5 | [*]
 6 | indent_style = tab
 7 | end_of_line = lf
 8 | charset = utf-8
 9 | trim_trailing_whitespace = true
10 | insert_final_newline = true
11 | 
12 | [package.json]
13 | indent_style = space
14 | indent_size = 2
15 | 
16 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "@yellicode/cli",
  3 |   "version": "1.3.0",
  4 |   "lockfileVersion": 1,
  5 |   "requires": true,
  6 |   "dependencies": {
  7 |     "@types/lodash": {
  8 |       "version": "4.14.136",
  9 |       "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.136.tgz",
 10 |       "integrity": "sha512-0GJhzBdvsW2RUccNHOBkabI8HZVdOXmXbXhuKlDEd5Vv12P7oAVGfomGp3Ne21o5D/qu1WmthlNKFaoZJJeErA==",
 11 |       "dev": true
 12 |     },
 13 |     "@types/node": {
 14 |       "version": "8.0.53",
 15 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-8.0.53.tgz",
 16 |       "integrity": "sha1-OWs1r4JvpmqtRyyMt7jV4nf05tg=",
 17 |       "dev": true
 18 |     },
 19 |     "@types/semver": {
 20 |       "version": "5.5.0",
 21 |       "resolved": "https://registry.npmjs.org/@types/semver/-/semver-5.5.0.tgz",
 22 |       "integrity": "sha1-FGwqKe59O65L8vyydGNuJkyBPEU=",
 23 |       "dev": true
 24 |     },
 25 |     "@yellicode/core": {
 26 |       "version": "1.3.0",
 27 |       "resolved": "https://registry.npmjs.org/@yellicode/core/-/core-1.3.0.tgz",
 28 |       "integrity": "sha512-0YMxCD7iW9PyF6vYNrX9x5VJel9tqOi47ZC0hgXiOycBoy+5lLRlA0gUfDbvmXgVl+thebpkl3qOKS33m5SpHg==",
 29 |       "requires": {
 30 |         "nanoid": "^3.1.12"
 31 |       }
 32 |     },
 33 |     "anymatch": {
 34 |       "version": "3.1.3",
 35 |       "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
 36 |       "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
 37 |       "requires": {
 38 |         "normalize-path": "^3.0.0",
 39 |         "picomatch": "^2.0.4"
 40 |       }
 41 |     },
 42 |     "binary-extensions": {
 43 |       "version": "2.3.0",
 44 |       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
 45 |       "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw=="
 46 |     },
 47 |     "braces": {
 48 |       "version": "3.0.3",
 49 |       "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
 50 |       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
 51 |       "requires": {
 52 |         "fill-range": "^7.1.1"
 53 |       }
 54 |     },
 55 |     "chokidar": {
 56 |       "version": "3.6.0",
 57 |       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
 58 |       "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
 59 |       "requires": {
 60 |         "anymatch": "~3.1.2",
 61 |         "braces": "~3.0.2",
 62 |         "fsevents": "~2.3.2",
 63 |         "glob-parent": "~5.1.2",
 64 |         "is-binary-path": "~2.1.0",
 65 |         "is-glob": "~4.0.1",
 66 |         "normalize-path": "~3.0.0",
 67 |         "readdirp": "~3.6.0"
 68 |       }
 69 |     },
 70 |     "esprima": {
 71 |       "version": "2.7.3",
 72 |       "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
 73 |       "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE="
 74 |     },
 75 |     "fill-range": {
 76 |       "version": "7.1.1",
 77 |       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
 78 |       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
 79 |       "requires": {
 80 |         "to-regex-range": "^5.0.1"
 81 |       }
 82 |     },
 83 |     "fsevents": {
 84 |       "version": "2.3.3",
 85 |       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
 86 |       "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
 87 |       "optional": true
 88 |     },
 89 |     "glob-parent": {
 90 |       "version": "5.1.2",
 91 |       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
 92 |       "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
 93 |       "requires": {
 94 |         "is-glob": "^4.0.1"
 95 |       }
 96 |     },
 97 |     "is-binary-path": {
 98 |       "version": "2.1.0",
 99 |       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
100 |       "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
101 |       "requires": {
102 |         "binary-extensions": "^2.0.0"
103 |       }
104 |     },
105 |     "is-extglob": {
106 |       "version": "2.1.1",
107 |       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
108 |       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="
109 |     },
110 |     "is-glob": {
111 |       "version": "4.0.3",
112 |       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
113 |       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
114 |       "requires": {
115 |         "is-extglob": "^2.1.1"
116 |       }
117 |     },
118 |     "is-number": {
119 |       "version": "7.0.0",
120 |       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
121 |       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="
122 |     },
123 |     "json-parser": {
124 |       "version": "1.1.5",
125 |       "resolved": "https://registry.npmjs.org/json-parser/-/json-parser-1.1.5.tgz",
126 |       "integrity": "sha1-5i7FJh0aal/CDoEqMgdAxtkAVnc=",
127 |       "requires": {
128 |         "esprima": "^2.7.0"
129 |       }
130 |     },
131 |     "lock": {
132 |       "version": "0.1.3",
133 |       "resolved": "https://registry.npmjs.org/lock/-/lock-0.1.3.tgz",
134 |       "integrity": "sha1-9mwcqgxBlW4UJmCAOe1ZtxvfGFQ="
135 |     },
136 |     "lodash": {
137 |       "version": "4.17.21",
138 |       "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
139 |       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
140 |     },
141 |     "nanoid": {
142 |       "version": "3.2.0",
143 |       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.2.0.tgz",
144 |       "integrity": "sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA=="
145 |     },
146 |     "normalize-path": {
147 |       "version": "3.0.0",
148 |       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
149 |       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="
150 |     },
151 |     "picomatch": {
152 |       "version": "2.3.1",
153 |       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
154 |       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="
155 |     },
156 |     "readdirp": {
157 |       "version": "3.6.0",
158 |       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
159 |       "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
160 |       "requires": {
161 |         "picomatch": "^2.2.1"
162 |       }
163 |     },
164 |     "semver": {
165 |       "version": "5.7.2",
166 |       "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
167 |       "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="
168 |     },
169 |     "to-regex-range": {
170 |       "version": "5.0.1",
171 |       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
172 |       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
173 |       "requires": {
174 |         "is-number": "^7.0.0"
175 |       }
176 |     },
177 |     "typescript": {
178 |       "version": "3.1.3",
179 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.1.3.tgz",
180 |       "integrity": "sha512-+81MUSyX+BaSo+u2RbozuQk/UWx6hfG0a5gHu4ANEM4sU96XbuIyAB+rWBW1u70c6a5QuZfuYICn3s2UjuHUpA=="
181 |     }
182 |   }
183 | }
184 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@yellicode/cli",
 3 |   "version": "1.3.0",
 4 |   "description": "CLI for Yellicode - an extensible code generator.",
 5 |   "keywords": [
 6 |     "code generator",
 7 |     "code generation",
 8 |     "cli"
 9 |   ],
10 |   "license": "MPL-2.0",
11 |   "main": "./dist/es5/index.js",
12 |   "es2015": "./dist/es6/index.js",
13 |   "bin": {
14 |     "yellicode": "./dist/es6/index.js"
15 |   },
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "github:yellicode/cli.git"
19 |   },
20 |   "dependencies": {
21 |     "@yellicode/core": "^1.3.0",
22 |     "chokidar": "^3.6.0",
23 |     "json-parser": "^1.1.5",
24 |     "lock": "^0.1.3",
25 |     "lodash": "^4.17.15",
26 |     "semver": "^5.6.0",
27 |     "typescript": "^3.1.3"
28 |   },
29 |   "devDependencies": {
30 |     "@types/lodash": "^4.14.136",
31 |     "@types/node": "^8.0.53",
32 |     "@types/semver": "^5.5.0"
33 |   },
34 |   "scripts": {
35 |     "build:es5": "tsc",
36 |     "build:es6": "tsc -t es6 --moduleResolution node --outDir dist/es6",
37 |     "build:dist": "npm run build:es5 & npm run build:es6",
38 |     "build": "npm run build:dist",
39 |     "prepare": "npm run build:dist"
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | ## Yellicode CLI
2 | 
3 | ### CLI for Yellicode
4 | 
5 | Yellicode lets you build your own code generation templates with TypeScript. It consists of a Node.js CLI and extensible APIs, making it easy for developers to create, share and re-use code generators for their favorite programming languages and frameworks. 
6 | 
7 | Check out [our website](https://www.yellicode.com) for more.
8 | 
9 | License: MPL-2.0


--------------------------------------------------------------------------------
/src/app.d.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | interface CodeGenTemplateConfig {
  9 |     templateFile: string;
 10 |     modelFile?: string;
 11 |     debug?: boolean;
 12 |     templateArgs?: any;
 13 |     disable?: boolean;
 14 |     outputMode?: 'overwrite' | 'once' | 'append';
 15 |     connectionTimeout?: number;
 16 | }
 17 | 
 18 | interface CodeGenConfig {
 19 |     templates: CodeGenTemplateConfig[];
 20 |     compileTypeScript?: boolean;
 21 |     typeScriptConfigFile?: string;
 22 | }
 23 | 
 24 | // TODO: delete these interfaces or update their names
 25 | 
 26 | interface ITemplateInfo {
 27 |     /**
 28 |      * Gets an internally assigned unique id.
 29 |      */
 30 |     id: string;
 31 |     /**
 32 |      * Allows to override the default connection timeout.
 33 |      */
 34 |     connectionTimeout?: number;
 35 |     /**
 36 |      * Indicates from which config file the template info was read.
 37 |      */
 38 |     configFile: string;
 39 |     /**
 40 |      * The full path to the template file. This must be a path with a .js extension.
 41 |      * If compile is true, the corresponding .ts file is assumed to exist.
 42 |      */
 43 |     templateFile: string;
 44 |     /**
 45 |     * The full path to the original template file. This can be a path with a .js extension and a .ts extension.
 46 |     * the originalTemplateFile is the one that is watched for changes.
 47 |     */
 48 |     originalTemplateFile: string;
 49 |     /**
 50 |      * The full path to the model file.
 51 |      */
 52 |     modelFile?: string;
 53 |     /**
 54 |     * If true, template file is a TypeScript file that we should compile.
 55 |     */
 56 |     requiresCompilation: boolean;
 57 |     /**
 58 |      * True once the template is compiled and does not need any recompilation. This value must be rest to false
 59 |      * once the template has changed.
 60 |      */
 61 |     isCompiled: boolean;
 62 |     /**
 63 |      * When debugging and no debug target was specified, the first template info that has debug:true will be used
 64 |      * as debug target. Other templates will be ignored.
 65 |      */
 66 |     debug: boolean;
 67 | 
 68 |     /**
 69 |      * Contains any custom arguments that must be parsed to the template.
 70 |      */
 71 |     templateArgs?: any;
 72 | 
 73 |     /**
 74 |      * The output configured output mode. This value will be passed as-is to the template process.
 75 |      */
 76 |     outputMode?: string;
 77 | }
 78 | 
 79 | interface ITemplateCompilationConfig {
 80 |     /**
 81 |     * If true, TypeScript template files are compiled before they are run.
 82 |     */
 83 |     compile: boolean;
 84 |     /**
 85 |      * Contains the full path of a TypeScript config file, which will be used when compile is true.
 86 |      */
 87 |     typeScriptConfigFile: string | null;
 88 | }
 89 | 
 90 | interface IModelCache {
 91 |     invalidateCache(fileName: string): void;
 92 | }
 93 | 
 94 | interface IModelStore extends IModelCache {
 95 |     loadModel(fileName: string/*, callback: (err: string, model: any) => void*/): Promise<any>;
 96 | }
 97 | 
 98 | interface ICompileResult {
 99 |     success: boolean;
100 |     output?: string;
101 | }


--------------------------------------------------------------------------------
/src/compiler.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | 
 9 | import * as ts from "typescript";
10 | import * as fs from "fs";
11 | import * as path from "path";
12 | 
13 | import { Logger } from '@yellicode/core';
14 | 
15 | /** 
16 |  * Compiles TypeScript templates using the TypeScript comiler API.
17 |  * https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
18 |  */
19 | export class Compiler {
20 |     private _logger: Logger;
21 | 
22 |     constructor(logger: Logger) {
23 |         this._logger = logger;
24 |     }
25 | 
26 |     /**
27 |      * Compiles the template files using the specified tsconfig file.
28 |      */
29 |     public compileWithTsConfigFile(fileNames: string[], configFileName: string): Promise<ICompileResult> {
30 |         // Extract configuration from config file
31 |         const config = this.readConfigFile(configFileName);
32 |         return this.compileInternal(fileNames, config.options);
33 |     }
34 | 
35 |     /**
36 |      * Compiles the template files using a default configuration.    
37 |      */
38 |     public compile(fileNames: string[]): Promise<ICompileResult> {
39 |         // tsc options: https://www.typescriptlang.org/docs/handbook/compiler-options.html
40 |         const options: ts.CompilerOptions = {
41 |             noEmitOnError: true,
42 |             target: ts.ScriptTarget.ES2015, // We must use use ECMAScript 6 (ES6)/ ECMAScript 2015 (ES2015)
43 |             module: ts.ModuleKind.CommonJS, // NodeJS
44 |             inlineSourceMap: true
45 |         };
46 |         return this.compileInternal(fileNames, options);
47 |     }
48 | 
49 |     private reportDiagnostics(diagnostics: ts.Diagnostic[]): void {
50 |         diagnostics.forEach(diagnostic => {
51 |             if (diagnostic.category !== ts.DiagnosticCategory.Error)
52 |                 return;
53 | 
54 |             let message = '';
55 |             if (diagnostic.file) {
56 |                 let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start!);
57 |                 message += ` ${diagnostic.file.fileName} (${line + 1},${character + 1})`;
58 |             }
59 |             message += ": " + ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
60 |             this._logger.error(message);
61 |         });
62 |     }
63 | 
64 |     public compileInternal(fileNames: string[], options: ts.CompilerOptions): Promise<ICompileResult> {
65 |         const program = ts.createProgram(fileNames, options);
66 |         const emitResult = program.emit();
67 |         const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
68 | 
69 |         // If you get the error "Cannot find name 'require'.'", you need to install node types: https://stackoverflow.com/a/35961176
70 |         this.reportDiagnostics(allDiagnostics);
71 |         const exitCode = emitResult.emitSkipped ? 1 : 0;
72 |         return Promise.resolve<ICompileResult>({ success: exitCode === 0 });
73 |     }
74 | 
75 |     private readConfigFile(configFileName: string): ts.ParsedCommandLine {
76 |         // Read config file
77 |         const configFileText = fs.readFileSync(configFileName).toString();
78 |         // Parse JSON, after removing comments. Just fancier JSON.parse
79 |         const result = ts.parseConfigFileTextToJson(configFileName, configFileText);
80 |         const configObject = result.config;
81 |         if (!configObject) {
82 |             this.reportDiagnostics([result.error!]);
83 |             process.exit(1);;
84 |         }
85 | 
86 |         // Extract config infromation
87 |         const configParseResult = ts.parseJsonConfigFileContent(configObject, ts.sys, path.dirname(configFileName));
88 |         if (configParseResult.errors.length > 0) {
89 |             this.reportDiagnostics(configParseResult.errors);
90 |             process.exit(1);
91 |         }
92 | 
93 |         return configParseResult;
94 |     }
95 | }


--------------------------------------------------------------------------------
/src/config-reader.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | 
  9 | const fs = require('fs');
 10 | const path = require('path');
 11 | const jsonparser = require('json-parser');
 12 | const chokidar = require('chokidar');
 13 | 
 14 | import { Logger } from '@yellicode/core';
 15 | import { FileSearch } from './file-search';
 16 | import { TemplateRunner } from './template-runner';
 17 | import * as consts from './yellicode-constants';
 18 | import * as _ from 'lodash';
 19 | import { ConfigStore } from './config-store';
 20 | import { InputWatcher } from './input-watcher';
 21 | import { PathUtility } from './path-utility';
 22 | 
 23 | export class ConfigReader {
 24 | 
 25 |     constructor(private configStore: ConfigStore, private inputWatcher: InputWatcher, private templateRunner: TemplateRunner, private logger: Logger, private watchFiles: boolean) {
 26 | 
 27 |     }
 28 | 
 29 |     private readFile(fileName: string, isFirstTime: boolean, autoRun: boolean): Promise<void> {
 30 |         if (!fs.existsSync(fileName)) {
 31 |             return Promise.reject(`Configuration file '${fileName}' not found.`);
 32 |         }
 33 | 
 34 |         return new Promise((resolve, reject) => {
 35 |             fs.readFile(fileName, 'utf8', (err: any, fileContents: string) => {
 36 |                 if (err) {
 37 |                     return reject(`Error reading configuration file '${fileName}': ${err}`);
 38 |                 }
 39 |                 try {
 40 |                     this.onConfigFileRead(fileContents, fileName, isFirstTime, autoRun);
 41 |                     resolve();
 42 |                 } catch (e) {
 43 |                     reject(`Error parsing config file ${fileName}: ${e}.`);
 44 |                 }
 45 |             });
 46 |         });
 47 |     }
 48 | 
 49 |     public readDirectory(dirName: string, recursive: boolean, autoRun: boolean): Promise<void> {
 50 |         return this.readDirectoryInternal(dirName, recursive, autoRun)
 51 |             .then((configFiles: string[]) => {
 52 |                 if (this.watchFiles) {
 53 |                     // Watch all config files for changes
 54 |                     const configWatcher = chokidar.watch(configFiles, { persistent: true });
 55 |                     configWatcher.on('change', (filePath: string) => { this.onConfigFileChanged(filePath) });
 56 |                     configWatcher.on('unlink', (filePath: string) => { this.onConfigFileDeleted(filePath) });
 57 |                     // Also start watching the directory for new config files
 58 |                     // Create a glob-expression (https://en.wikipedia.org/wiki/Glob_(programming))
 59 |                     var globExpression = recursive ? `${dirName}/**/${consts.YELLICODE_CONFIG_FILE}` : path.join(dirName, consts.YELLICODE_CONFIG_FILE);
 60 |                     const newFileWatcher = chokidar.watch(globExpression, { persistent: true });
 61 |                     newFileWatcher.on('add', (path: string) => {
 62 |                         // We also get 'add' events for files that are already there, so check for duplicates.
 63 |                         if (configFiles!.indexOf(path) === -1) {
 64 |                             this.logger.info(`Config file '${path}' has been added`);
 65 |                             this.readFile(path, true, autoRun)
 66 |                                 .catch((err) => {
 67 |                                     // Even watch te file in case of errors, the user may fix it
 68 |                                     this.logger.error(err);
 69 |                                 })
 70 |                                 .then(() => {
 71 |                                     configWatcher.add(path);
 72 |                                 });
 73 |                         }
 74 |                     });
 75 |                 }
 76 |             });
 77 |     }
 78 | 
 79 |     private readDirectoryInternal(dirName: string, recursive: boolean, autoRun: boolean): Promise<string[]> {
 80 |         return new Promise<string[]>((resolve, reject) => {
 81 |             FileSearch.findFiles(dirName, recursive, consts.YELLICODE_CONFIG_FILE, (err: any, configFiles: string[] | null) => {
 82 |                 if (err) {
 83 |                     return reject(err);
 84 |                 }
 85 |                 if (!configFiles || configFiles.length === 0) {
 86 |                     this.logger.warn(`No config files found in directory '${dirName}'.`);
 87 |                     return resolve(configFiles || []);
 88 |                 }
 89 | 
 90 |                 this.logger.verbose(`Found ${configFiles.length} config files in directory '${dirName}'.`);
 91 |                 this.logger.verbose(`Config files: ${configFiles.join(', ')}`);
 92 |                 var numberOfFilesToRead: number = configFiles.length;
 93 |                 configFiles.forEach(filePath => {
 94 |                     this.readFile(filePath, true, autoRun)
 95 |                         .catch((err) => {
 96 |                             // Log the error and continue
 97 |                             this.logger.error(err);
 98 |                         })
 99 |                         .then(() => {
100 |                             numberOfFilesToRead--;
101 |                             if (numberOfFilesToRead <= 0) {
102 |                                 resolve(configFiles);
103 |                             }
104 |                         });
105 |                 });
106 |             });
107 |         })
108 |     }
109 | 
110 |     private onConfigFileRead(fileContents: string, configFileName: string, isFirstTime: boolean, autoRun: boolean) {
111 |         const config: CodeGenConfig = jsonparser.parse(fileContents, null, true); // parse... true to remove comments
112 |         if (!config || !config.templates)
113 |             return;
114 | 
115 |         const dirName = path.dirname(configFileName); // for resolving configured file names
116 |         const shouldCompileTypeScript: boolean = config.compileTypeScript || false;
117 |         const typeScriptConfigFile = (shouldCompileTypeScript && config.typeScriptConfigFile) ? path.join(dirName, config.typeScriptConfigFile) : null;
118 |         this.configStore.setTemplateCompilationConfig(configFileName, { compile: shouldCompileTypeScript, typeScriptConfigFile: typeScriptConfigFile });
119 | 
120 |         // Clean up the store for this config file so that it is refreshed
121 |         this.configStore.removeTemplates(configFileName);
122 |         config.templates.forEach((templateEntry: CodeGenTemplateConfig, index: number) => {
123 |             let configuredTemplatePath: string = templateEntry.templateFile;
124 |             if (!configuredTemplatePath || configuredTemplatePath.length === 0){
125 |                 this.logger.warn(`Template ${index} has no configured template file and will be ignored.`)
126 |                 return;
127 |             }
128 | 
129 |             if (templateEntry.disable === true){
130 |                 // The template is temporarily disabled. Skip it entirely.
131 |                 this.logger.info(`Template '${configuredTemplatePath}' is disabled and will be ignored.`);
132 |                 return;
133 |             }
134 | 
135 |             // Compile TypeScript?
136 |             let isTypeScriptTemplate: boolean = false;
137 | 
138 |             // Ensure a '.js' extension
139 |             const templateExtension = path.extname(configuredTemplatePath);
140 |             switch (templateExtension.toLowerCase()) {
141 |                 case '':
142 |                     // No extension
143 |                     configuredTemplatePath = configuredTemplatePath + '.js';
144 |                     break;
145 |                 case '.ts':
146 |                     isTypeScriptTemplate = true;
147 |                     break;
148 |                 case '.js':
149 |                 default:
150 |                     break;
151 |             }
152 | 
153 |             // The configured file name is always relative to the config file. Make this a full path.
154 |             //let originalTemplateFileName: string = path.join(dirName, configuredTemplatePath).toLowerCase(); // can be .ts or .js
155 |             // UPDATE: try not to change the case of the originalTemplateFileName, so that the the compiler creates files with the same casing
156 |             let originalTemplateFileName: string = path.join(dirName, configuredTemplatePath); // can be .ts or .js
157 |             // The templateFileName should always have a .js extension
158 |             const templateFileName: string = isTypeScriptTemplate ? PathUtility.ensureJsExtension(originalTemplateFileName) : originalTemplateFileName;
159 |             // If TS compilation is not enabled, don't deal with .ts files and always use the .js file (compilation is assumed to be done externally)
160 |             if (isTypeScriptTemplate && !shouldCompileTypeScript) originalTemplateFileName = templateFileName;
161 | 
162 |             // Now we have all template info
163 |             const templateInfo: ITemplateInfo = {
164 |                 id: `template_${index + 1}`, // make id useable as property
165 |                 configFile: configFileName,
166 |                 templateFile: templateFileName,
167 |                 originalTemplateFile: originalTemplateFileName,
168 |                 requiresCompilation: isTypeScriptTemplate && shouldCompileTypeScript,
169 |                 isCompiled: false,
170 |                 debug: templateEntry.debug || false,
171 |                 templateArgs: templateEntry.templateArgs,
172 |                 outputMode: templateEntry.outputMode,
173 |                 connectionTimeout: templateEntry.connectionTimeout
174 |             };
175 | 
176 |             // Get the model file (optional)
177 |             if (templateEntry.modelFile) {
178 |                 // Ensure a '.ymn' extension
179 |                 let configuredModelPath: string = templateEntry.modelFile;
180 |                 const modelExtension = path.extname(configuredModelPath);
181 |                 if (!modelExtension || (modelExtension !== consts.YELLICODE_DOCUMENT_EXTENSION && modelExtension !== '.json')) {
182 |                     configuredModelPath = configuredModelPath + consts.YELLICODE_DOCUMENT_EXTENSION;
183 |                 }
184 |                 // Make an absolute path
185 |                 templateInfo.modelFile = path.join(dirName, configuredModelPath).toLowerCase();
186 |             }
187 | 
188 |             this.configStore.addTemplate(templateInfo);
189 |         });
190 | 
191 |         // Warn if TS files must be compiled but there are templates with no ts extension
192 |         if (shouldCompileTypeScript) {
193 |             var templatesRequiringCompilation = this.configStore.listAllTemplatesRequiringCompilation()
194 |             if (templatesRequiringCompilation.length === 0) {
195 |                 this.logger.warn(`Config file' ${configFileName}' has compileTypeScript enabled but has no configured template with a .ts extension.`);
196 |             }
197 |         }
198 | 
199 |         // Watch (or unwatch) changes to template- and model files.
200 |         // First watch/unwatch files, then run them. If we do this in the reverse order and running templates causes compilation of TS files,
201 |         // the resulting .js files will be detected by the running watch task, which will result in an error that no ITemplateInfo could be
202 |         // found for that .js file (this happens in the rare cases that the config switches from JS to TS).
203 |         this.watchOrUnwatchInputFiles(configFileName);
204 | 
205 |         if (autoRun) {
206 |             // Run all templates (we do this after any config file change, but also initially)
207 |             this.templateRunner.runTemplatesUsingConfigFile(configFileName); // TODO: we get a Promise here but don't use it's result yet
208 |         }
209 |     }
210 | 
211 |     private watchOrUnwatchInputFiles(configFileName: string) {
212 |         if (!this.watchFiles)
213 |             return;
214 | 
215 |         // Check if all templates that are being watched are still in the config store
216 |         const configuredTemplates = this.configStore.listAllTemplates();
217 |         const templateFilesBeingWatched = this.inputWatcher.getWatchedTemplateFiles();
218 |         const modelFilesBeingWatched = this.inputWatcher.getWatchedModelFiles();
219 | 
220 |         const templateFilesToWatch: string[] = [];
221 |         const modelFilesToWatch: string[] = [];
222 | 
223 |         configuredTemplates.forEach((templateInfo: ITemplateInfo) => {
224 |             // If the template is not being watched, add it
225 |             if (templateFilesBeingWatched.indexOf(templateInfo.originalTemplateFile) === -1 && templateFilesToWatch.indexOf(templateInfo.originalTemplateFile) == -1) {
226 |                 templateFilesToWatch.push(templateInfo.originalTemplateFile);
227 |             }
228 |             // If the model is not being watched, add it
229 |             if (templateInfo.modelFile != null && modelFilesBeingWatched.indexOf(templateInfo.modelFile) === -1 && modelFilesToWatch.indexOf(templateInfo.modelFile) === -1) {
230 |                 modelFilesToWatch.push(templateInfo.modelFile);
231 |             }
232 |         });
233 | 
234 |         // Now check which currently watched templates need to be unwatched
235 |         const templateFilesToUnwatch: string[] = _.remove(templateFilesBeingWatched, (fileName: string) => {
236 |             // Unwatch if the file is not configured anymore
237 |             return !(_.some(configuredTemplates, (t: ITemplateInfo) => fileName === t.originalTemplateFile));
238 |         })
239 | 
240 |         if (templateFilesToUnwatch.length > 0) {
241 |             this.logger.verbose(`The following templates will be unwatched: ${templateFilesToUnwatch.join(', ')}`);
242 |             this.inputWatcher.unwatchTemplateFiles(templateFilesToUnwatch);
243 |         }
244 | 
245 |         if (templateFilesToWatch.length > 0) {
246 |             this.logger.verbose(`The following templates will be watched: ${templateFilesToWatch.join(', ')}`);
247 |             this.inputWatcher.watchTemplateFiles(templateFilesToWatch);
248 |         }
249 | 
250 |         // Do the same for model files
251 |         const modelFilesToUnwatch: string[] = _.remove(modelFilesBeingWatched, (fileName: string) => {
252 |             // Unwatch if the file is not configured anymore
253 |             return !(_.some(configuredTemplates, (t: ITemplateInfo) => fileName === t.modelFile));
254 |         })
255 | 
256 |         if (modelFilesToUnwatch.length > 0) {
257 |             this.logger.verbose(`The following models will be unwatched: ${modelFilesToUnwatch.join(', ')}`);
258 |             this.inputWatcher.unwatchModelFiles(modelFilesToUnwatch);
259 |         }
260 | 
261 |         if (modelFilesToWatch.length > 0) {
262 |             this.logger.verbose(`The following models will be watched: ${modelFilesToUnwatch.join(', ')}`);
263 |             this.inputWatcher.watchModelFiles(modelFilesToWatch);
264 |         }
265 |     }
266 | 
267 |     private onConfigFileChanged(filePath: string) {
268 |         this.logger.info(`Config file ${filePath} has changed. Reloading...`);
269 |         this.readFile(filePath, false, true)
270 |             .catch((err) => {
271 |                 this.logger.error(err);
272 |             });
273 |     }
274 | 
275 |     private onConfigFileDeleted(filePath: string) {
276 |         var deleted = this.configStore.removeTemplates(filePath);
277 |         this.logger.info(`Config file ${filePath} was deleted. Removed ${(deleted != null) ? deleted.length : 0} templates.`);
278 |     }
279 | }
280 | 
281 | 


--------------------------------------------------------------------------------
/src/config-store.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | const fs = require('fs');
 9 | const path = require('path');
10 | 
11 | import * as _ from 'lodash';
12 | 
13 | export class ConfigStore {
14 | 
15 |     /**
16 |      * List of templates being detected in any of the config files found in the root directory. 
17 |      */
18 |     private templates: ITemplateInfo[] = [];
19 |     private templateTypeScriptConfigs: { [configFile: string]: ITemplateCompilationConfig } = {};
20 | 
21 |     constructor() {
22 | 
23 |     }
24 | 
25 |     public addTemplate(template: ITemplateInfo): boolean {
26 |         this.templates.push(template);
27 |         return true;
28 |     }
29 | 
30 |     public listAllTemplateUsingTemplateFile(fileName: string): ITemplateInfo[] {
31 |         if (!fileName) return [];
32 |         const safeFileName = fileName.toLowerCase();
33 |         return this.templates.filter((item: ITemplateInfo) => {
34 |             return safeFileName === item.templateFile.toLowerCase();
35 |         })
36 |     }
37 | 
38 |     public listAllTemplates(): ITemplateInfo[] {
39 |         return this.templates;
40 |     }
41 | 
42 |     public listAllTemplatesRequiringCompilation(): ITemplateInfo[] {
43 |         return this.templates.filter((item: ITemplateInfo) => item.requiresCompilation);
44 |     }
45 | 
46 |     public listAllTemplatesUsingModel(modelFile: string): ITemplateInfo[] {
47 |         return this.templates.filter((item: ITemplateInfo) => modelFile === item.modelFile);
48 |     }
49 | 
50 |     public listAllTemplatesFromConfigFile(configFile: string): ITemplateInfo[] {
51 |         return this.templates.filter((item: ITemplateInfo) => configFile === item.configFile);
52 |     }
53 | 
54 |     public removeTemplates(configFileName: string): ITemplateInfo[] {
55 |         return _.remove(this.templates, (item: ITemplateInfo) => configFileName === item.configFile);
56 |     }
57 | 
58 |     public setTemplateCompilationConfig(configFileName: string, config: ITemplateCompilationConfig): void {
59 |         this.templateTypeScriptConfigs[configFileName] = config;
60 |     }
61 | 
62 |     public getTemplateCompilationConfig(configFileName: string): ITemplateCompilationConfig {
63 |         if (this.templateTypeScriptConfigs.hasOwnProperty(configFileName)) {
64 |             return this.templateTypeScriptConfigs[configFileName];
65 |         }
66 |         return { compile: false, typeScriptConfigFile: null };
67 |     }
68 | 
69 |     private hasTemplate(fileName: string): boolean {
70 |         return this.listAllTemplateUsingTemplateFile(fileName) != null;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/data-interfaces.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 | * Copyright (c) 2020 Yellicode
  3 | *
  4 | * This Source Code Form is subject to the terms of the Mozilla Public
  5 | * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 | * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 | */
  8 | 
  9 | /**
 10 | * This code was generated by a tool.
 11 | * 
 12 | * Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
 13 | */
 14 | /**
 15 | * Contains the current version of this meta model. Note that the meta model version is independent
 16 | * from versions of packages that depend on the meta model.
 17 | */
 18 | export const MetaVersion = '0.1.1';
 19 | 
 20 | export type ElementType = "taggedValueSpecification"|"stereotypeExtension"|"class"|"stereotype"|"property"|"package"|"profile"|"dataType"|"primitiveType"|"parameter"|"operation"|"model"|"literalUnlimitedNatural"|"literalString"|"literalReal"|"literalNull"|"literalInteger"|"literalBoolean"|"interfaceRealization"|"interface"|"generalization"|"enumerationLiteral"|"enumeration"|"documentReference"|"document"|"comment"|"association";
 21 | 
 22 | /**
 23 | * VisibilityKind is an enumeration type that defines literals to determine the visibility of Elements
 24 | * in a model.
 25 | */
 26 | export type VisibilityKind = 'public' | 'private' | 'protected' | 'package';
 27 | 
 28 | /**
 29 | * An Element is a constituent of a model. As such, it has the capability of owning other Elements.
 30 | */
 31 | export interface ElementData {
 32 | 	/**
 33 | 	* Gets the element type.
 34 | 	*/
 35 | 	elementType: ElementType;
 36 | 	/**
 37 | 	* Indicates which stereotypes from the selected profile (or profiles) are applied to the element. The
 38 | 	* selected profiles are the profiles that are applied to the containing package.
 39 | 	*/
 40 | 	appliedStereotypes?: string[];
 41 | 	/**
 42 | 	* Gets the unique ID of the element.
 43 | 	*/
 44 | 	id: string;
 45 | 	/**
 46 | 	* The Comments owned by this Element.
 47 | 	*/
 48 | 	ownedComments?: CommentData[];
 49 | 	/**
 50 | 	* Contains 0 or more tagged values for the element.
 51 | 	*/
 52 | 	taggedValues?: TaggedValueSpecificationData[];
 53 | }
 54 | 
 55 | /**
 56 | * A NamedElement is an Element in a model that may have a name. The name may be given directly and/or
 57 | * via the use of a StringExpression.
 58 | */
 59 | export interface NamedElementData extends ElementData {
 60 | 	/**
 61 | 	* If true, using this element should be avoided, typically because it has been superseded.
 62 | 	*/
 63 | 	isDeprecated: boolean;
 64 | 	/**
 65 | 	* The name of the NamedElement.
 66 | 	*/
 67 | 	name: string;
 68 | 	/**
 69 | 	* Determines whether and how the NamedElement is visible outside its owning Namespace.
 70 | 	*/
 71 | 	visibility?: VisibilityKind;
 72 | }
 73 | 
 74 | /**
 75 | * A TypedElement is a NamedElement that may have a Type specified for it.
 76 | */
 77 | export interface TypedElementData extends NamedElementData {
 78 | 	/**
 79 | 	* The type of the TypedElement.
 80 | 	*/
 81 | 	type?: string;
 82 | }
 83 | 
 84 | /**
 85 | * A ValueSpecification is the specification of a (possibly empty) set of values.
 86 | */
 87 | export interface ValueSpecificationData extends TypedElementData {
 88 | }
 89 | 
 90 | /**
 91 | * A PackageableElement is a NamedElement that may be owned directly by a Package.
 92 | */
 93 | export interface PackageableElementData extends NamedElementData {
 94 | }
 95 | 
 96 | /**
 97 | * A Type constrains the values represented by a TypedElement.
 98 | */
 99 | export interface TypeData extends PackageableElementData {
100 | 	/**
101 | 	* If true, the type was inferred by a tool, for example during data import. An inferred type is never
102 | 	* owned by any Package.
103 | 	*/
104 | 	isInferred: boolean;
105 | }
106 | 
107 | /**
108 | * Specifies the value of a meta attribute (tagged value) for a particular element.
109 | */
110 | export interface TaggedValueSpecificationData {
111 | 	/**
112 | 	* Refers to the tagged value definition (metaattribute) of the tagged value's stereotype.
113 | 	*/
114 | 	definition: string;
115 | 	/**
116 | 	* Specifies the actual tagged value.
117 | 	*/
118 | 	specification: ValueSpecificationData;
119 | }
120 | 
121 | /**
122 | * A RedefinableElement is an element that, when defined in the context of a Classifier, can be
123 | * redefined more specifically or differently in the context of another Classifier that specializes
124 | * (directly or indirectly) the context Classifier.
125 | */
126 | export interface RedefinableElementData extends NamedElementData {
127 | 	/**
128 | 	* Indicates whether it is possible to further redefine a RedefinableElement. If the value is true,
129 | 	* then it is not possible to further redefine the RedefinableElement.
130 | 	*/
131 | 	isLeaf: boolean;
132 | }
133 | 
134 | /**
135 | * A Classifier represents a classification of instances according to their Features.
136 | */
137 | export interface ClassifierData extends TypeData, RedefinableElementData {
138 | 	/**
139 | 	* The Generalization relationships for this Classifier. These Generalizations navigate to more general
140 | 	* Classifiers in the generalization hierarchy.
141 | 	*/
142 | 	generalizations?: GeneralizationData[];
143 | 	/**
144 | 	* If true, the Classifier can only be instantiated by instantiating one of its specializations. An
145 | 	* abstract Classifier is intended to be used by other Classifiers e.g., as the target of Associations
146 | 	* or Generalizations.
147 | 	*/
148 | 	isAbstract: boolean;
149 | 	/**
150 | 	* If true, the Classifier cannot be specialized.
151 | 	*/
152 | 	isFinalSpecialization: boolean;
153 | }
154 | 
155 | /**
156 | * StructuredClassifiers may contain an internal structure of connected elements each of which plays a
157 | * role in the overall Behavior modeled by the StructuredClassifier.
158 | */
159 | export interface StructuredClassifierData extends ClassifierData {
160 | }
161 | 
162 | /**
163 | * A multiplicity is a definition of an inclusive interval of non-negative integers beginning with a
164 | * lower bound and ending with a (possibly infinite) upper bound. A MultiplicityElement embeds this
165 | * information to specify the allowable cardinalities for an instantiation of the Element.
166 | */
167 | export interface MultiplicityElementData extends ElementData {
168 | 	/**
169 | 	* For a multivalued multiplicity, this attribute specifies whether the values in an instantiation of
170 | 	* this MultiplicityElement are sequentially ordered.
171 | 	*/
172 | 	isOrdered: boolean;
173 | 	/**
174 | 	* For a multivalued multiplicity, this attributes specifies whether the values in an instantiation of
175 | 	* this MultiplicityElement are unique.
176 | 	*/
177 | 	isUnique: boolean;
178 | 	/**
179 | 	* The specification of the lower bound for this multiplicity.
180 | 	*/
181 | 	lowerValue?: ValueSpecificationData;
182 | 	/**
183 | 	* The specification of the upper bound for this multiplicity.
184 | 	*/
185 | 	upperValue?: ValueSpecificationData;
186 | }
187 | 
188 | /**
189 | * Defines a common interface for named elements that are part of an ordered collection.
190 | */
191 | export interface OrderedElementData extends ElementData {
192 | 	/**
193 | 	* Gets or set the sort order of the element if it is part of a collection. The value is 0 for elements
194 | 	* to which no particular ordering applies. Elements with a lower order come before elements with a
195 | 	* higher order.
196 | 	*/
197 | 	order: number;
198 | }
199 | 
200 | /**
201 | * A Feature declares a behavioral or structural characteristic of Classifiers.
202 | */
203 | export interface FeatureData extends RedefinableElementData, OrderedElementData {
204 | 	/**
205 | 	* Specifies whether this Feature characterizes individual instances classified by the Classifier
206 | 	* (false) or the Classifier itself (true).
207 | 	*/
208 | 	isStatic: boolean;
209 | }
210 | 
211 | /**
212 | * A StructuralFeature is a typed feature of a Classifier that specifies the structure of instances of
213 | * the Classifier.
214 | */
215 | export interface StructuralFeatureData extends FeatureData, MultiplicityElementData, TypedElementData {
216 | 	/**
217 | 	* If isReadOnly is true, the StructuralFeature may not be written to after initialization.
218 | 	*/
219 | 	isReadOnly: boolean;
220 | }
221 | 
222 | /**
223 | * Each stereotype may extend one or more metaclasses through a StereoTypeExtension.
224 | */
225 | export interface StereotypeExtensionData {
226 | 	/**
227 | 	* A required extension means that an instance of a stereotype must always be linked to an instance of
228 | 	* the extended metaclass. The instance of the stereotype is typically deleted only when either the
229 | 	* instance of the extended metaclass is deleted, or when the profile defining the stereotype is
230 | 	* removed from the applied profiles of the package.  
231 | 	*/
232 | 	isRequired: boolean;
233 | 	metaClass: ElementType;
234 | }
235 | 
236 | /**
237 | * Defines a common interface for Classifiers (Class, DataType and Interface) that have attributes and
238 | * operations.
239 | */
240 | export interface MemberedClassifierData extends ClassifierData {
241 | 	/**
242 | 	* The attributes owned by the Element. Note that in UML, OwnedAttributes is a property of derived
243 | 	* classes of Classifier (Class, DataType and Interface).
244 | 	*/
245 | 	ownedAttributes?: PropertyData[];
246 | 	/**
247 | 	* The Operations owned by the Element. Note that in UML, OwnedOperations is a property of derived
248 | 	* classes of Classifier (Class, DataType and Interface).
249 | 	*/
250 | 	ownedOperations?: OperationData[];
251 | }
252 | 
253 | /**
254 | * A BehavioredClassifier may have InterfaceRealizations, and owns a set of Behaviors one of which may
255 | * specify the behavior of the BehavioredClassifier itself.
256 | */
257 | export interface BehavioredClassifierData extends ClassifierData {
258 | 	/**
259 | 	* The set of InterfaceRealizations owned by the BehavioredClassifier. Interface realizations reference
260 | 	* the Interfaces of which the BehavioredClassifier is an implementation.
261 | 	*/
262 | 	interfaceRealizations?: InterfaceRealizationData[];
263 | }
264 | 
265 | /**
266 | * A Class classifies a set of objects and specifies the features that characterize the structure and
267 | * behavior of those objects. A Class may have an internal structure and Ports.
268 | */
269 | export interface ClassData extends BehavioredClassifierData, StructuredClassifierData, MemberedClassifierData {
270 | 	/**
271 | 	* Determines whether an object specified by this Class is active or not. If true, then the owning
272 | 	* Class is referred to as an active Class. If false, then such a Class is referred to as a passive
273 | 	* Class.
274 | 	*/
275 | 	isActive: boolean;
276 | }
277 | 
278 | /**
279 | * Stereotype is a profile class which defines how an existing metaclass may be extended as part of a
280 | * profile. It enables the use of a platform or domain specific terminology or notation in place of, or
281 | * in addition to, the ones used for the extended metaclass.
282 | */
283 | export interface StereotypeData extends ClassData {
284 | 	extends?: StereotypeExtensionData[];
285 | 	/**
286 | 	* Gets a name for the stereotype that is safe to use in Javascript.
287 | 	*/
288 | 	safeName: string;
289 | }
290 | 
291 | /**
292 | * Relationship is an abstract concept that specifies some kind of relationship between Elements.
293 | */
294 | export interface RelationshipData extends ElementData {
295 | }
296 | 
297 | /**
298 | * A Property is a StructuralFeature. A Property related by ownedAttribute to a Classifier (other than
299 | * an association) represents an attribute and might also represent an association end. It relates an
300 | * instance of the Classifier to a value or set of values of the type of the attribute. A Property
301 | * related by memberEnd to an Association represents an end of the Association. The type of the
302 | * Property is the type of the end of the Association.
303 | */
304 | export interface PropertyData extends StructuralFeatureData {
305 | 	aggregation: AggregationKind;
306 | 	/**
307 | 	* A ValueSpecification that is evaluated to give a default value for the Property when an instance of
308 | 	* the owning Classifier is instantiated.
309 | 	*/
310 | 	defaultValue?: ValueSpecificationData;
311 | 	/**
312 | 	* Specifies whether the property is derived as the union of all of the Properties that are constrained
313 | 	* to subset it.
314 | 	*/
315 | 	isDerived: boolean;
316 | 	/**
317 | 	* Specifies whether the property is derived as the union of all of the Properties that are constrained
318 | 	* to subset it.
319 | 	*/
320 | 	isDerivedUnion: boolean;
321 | 	/**
322 | 	* True indicates this property can be used to uniquely identify an instance of the containing Class.
323 | 	*/
324 | 	isID: boolean;
325 | 	/**
326 | 	* Returns true if the Property is owned by a classifier or is included in the NavigableOwnedEnds of an
327 | 	* association.
328 | 	*/
329 | 	isNavigable: boolean;
330 | }
331 | 
332 | /**
333 | * A package is used to group elements, and provides a namespace for the grouped elements.
334 | * A package can have one or more profile applications to indicate which profiles have been applied.
335 | * Because a profile is a package, it is possible to apply a profile not only to packages, but also to
336 | * profiles.
337 | */
338 | export interface PackageData extends PackageableElementData {
339 | 	appliedProfiles?: string[];
340 | 	/**
341 | 	* Denotes where the namespace structure for your class model starts; all nested packages below a
342 | 	* namespace root will form the namespace hierarchy for contained types.
343 | 	*/
344 | 	isNamespaceRoot: boolean;
345 | 	/**
346 | 	* Specifies the packageable elements that are owned by this Package.
347 | 	*/
348 | 	packagedElements?: PackageableElementData[];
349 | }
350 | 
351 | /**
352 | * Metamodel customizations are defined in a profile, which is then applied to a package. A profile can
353 | * define classes, stereotypes, data types, primitive types, enumerations. Stereotypes are specific
354 | * metaclasses, tagged values are standard metaattributes, and profiles are specific kinds of packages.
355 | */
356 | export interface ProfileData extends PackageData {
357 | 	/**
358 | 	* Gets a name for the profile that is safe to use in Javascript.
359 | 	*/
360 | 	safeName: string;
361 | }
362 | 
363 | /**
364 | * A DataType is similar to a Class; however, instances of data type are identified only by their
365 | * value. If two data types have the same value, the instances are considered identical.
366 | */
367 | export interface DataTypeData extends MemberedClassifierData {
368 | }
369 | 
370 | /**
371 | * A PrimitiveType defines a predefined DataType, without any substructure. A PrimitiveType may have an
372 | * algebra and operations defined outside of UML, for example, mathematically.
373 | */
374 | export interface PrimitiveTypeData extends DataTypeData {
375 | }
376 | 
377 | /**
378 | * ParameterDirectionKind is an Enumeration that defines literals used to specify direction of
379 | * parameters.
380 | */
381 | export type ParameterDirectionKind = 'in' | 'inout' | 'out' | 'return';
382 | 
383 | /**
384 | * A Parameter is a specification of an argument used to pass information into or out of an invocation
385 | * of a BehavioralFeature. Parameters can be treated as ConnectableElements within Collaborations.
386 | */
387 | export interface ParameterData extends TypedElementData, MultiplicityElementData, OrderedElementData {
388 | 	/**
389 | 	* Specifies a ValueSpecification that represents a value to be used when no argument is supplied for
390 | 	* the Parameter.
391 | 	*/
392 | 	defaultValue?: ValueSpecificationData;
393 | 	direction: ParameterDirectionKind;
394 | 	/**
395 | 	* Tells whether an output parameter may emit a value to the exclusion of the other outputs.
396 | 	*/
397 | 	isException: boolean;
398 | 	/**
399 | 	* Tells whether an input parameter may accept values while its behavior is executing, or whether an
400 | 	* output parameter may post values while the behavior is executing.
401 | 	*/
402 | 	isStream: boolean;
403 | }
404 | 
405 | /**
406 | * A BehavioralFeature is a feature of a Classifier that specifies an aspect of the behavior of its
407 | * instances. A BehavioralFeature is implemented (realized) by a Behavior. A BehavioralFeature
408 | * specifies that a Classifier will respond to a designated request by invoking its implementing
409 | * method.
410 | */
411 | export interface BehavioralFeatureData extends FeatureData {
412 | 	/**
413 | 	* If true, then the BehavioralFeature does not have an implementation, and one must be supplied by a
414 | 	* more specific Classifier. If false, the BehavioralFeature must have an implementation in the
415 | 	* Classifier or one must be inherited.
416 | 	*/
417 | 	isAbstract: boolean;
418 | 	/**
419 | 	* The parameters owned by this Operation.
420 | 	*/
421 | 	ownedParameters?: ParameterData[];
422 | }
423 | 
424 | /**
425 | * An Operation is a BehavioralFeature of a Classifier that specifies the name, type, parameters, and
426 | * constraints for invoking an associated Behavior. An Operation may invoke both the execution of
427 | * method behaviors as well as other behavioral responses.
428 | */
429 | export interface OperationData extends BehavioralFeatureData {
430 | 	/**
431 | 	* Specifies if the operation is a class constructor.
432 | 	*/
433 | 	isConstructor: boolean;
434 | 	/**
435 | 	* Specifies whether an execution of the BehavioralFeature leaves the state of the system unchanged
436 | 	* (isQuery=true) or whether side effects may occur (isQuery=false).
437 | 	*/
438 | 	isQuery: boolean;
439 | }
440 | 
441 | /**
442 | * Represents the top-level package.
443 | */
444 | export interface ModelData extends PackageData {
445 | }
446 | 
447 | /**
448 | * A LiteralSpecification identifies a literal constant being modeled.
449 | */
450 | export interface LiteralSpecificationData extends ValueSpecificationData {
451 | }
452 | 
453 | /**
454 | * A LiteralUnlimitedNatural is a specification of an UnlimitedNatural number.
455 | */
456 | export interface LiteralUnlimitedNaturalData extends LiteralSpecificationData {
457 | 	/**
458 | 	* The specified UnlimitedNatural value.
459 | 	*/
460 | 	value: string;
461 | }
462 | 
463 | /**
464 | * A LiteralString is a specification of a String value.
465 | */
466 | export interface LiteralStringData extends LiteralSpecificationData {
467 | 	/**
468 | 	* The specified String value.
469 | 	*/
470 | 	value: string;
471 | }
472 | 
473 | /**
474 | * A LiteralReal is a specification of a Real value.
475 | */
476 | export interface LiteralRealData extends LiteralSpecificationData {
477 | 	/**
478 | 	* The specified Real value.
479 | 	*/
480 | 	value: number;
481 | }
482 | 
483 | /**
484 | * A LiteralNull specifies the lack of a value.
485 | */
486 | export interface LiteralNullData extends LiteralSpecificationData {
487 | }
488 | 
489 | /**
490 | * A LiteralInteger is a specification of an Integer value.
491 | */
492 | export interface LiteralIntegerData extends LiteralSpecificationData {
493 | 	/**
494 | 	* The specified Integer value.
495 | 	*/
496 | 	value: number;
497 | }
498 | 
499 | /**
500 | * A LiteralBoolean is a specification of a Boolean value.
501 | */
502 | export interface LiteralBooleanData extends LiteralSpecificationData {
503 | 	/**
504 | 	* The specified Boolean value.
505 | 	*/
506 | 	value: boolean;
507 | }
508 | 
509 | /**
510 | * A DirectedRelationship represents a relationship between a collection of source model Elements and a
511 | * collection of target model Elements.
512 | */
513 | export interface DirectedRelationshipData extends RelationshipData {
514 | }
515 | 
516 | /**
517 | * An InterfaceRealization is a specialized realization relationship between a BehavioredClassifier and
518 | * an Interface. This relationship signifies that the realizing BehavioredClassifier conforms to the
519 | * contract specified by the Interface.
520 | */
521 | export interface InterfaceRealizationData extends DirectedRelationshipData {
522 | 	/**
523 | 	* References the Interface specifying the conformance contract.
524 | 	*/
525 | 	contract: string;
526 | }
527 | 
528 | /**
529 | * Interfaces declare coherent services that are implemented by BehavioredClassifiers that implement
530 | * the Interfaces via InterfaceRealizations.
531 | */
532 | export interface InterfaceData extends MemberedClassifierData {
533 | }
534 | 
535 | /**
536 | * A Generalization is a taxonomic relationship between a more general Classifier and a more specific
537 | * Classifier. Each instance of the specific Classifier is also an instance of the general
538 | * Classifier.The specific Classifier inherits the features of the more general Classifier. A
539 | * Generalization is owned by the specific Classifier.
540 | */
541 | export interface GeneralizationData extends DirectedRelationshipData {
542 | 	/**
543 | 	* The general classifier in the Generalization relationship.
544 | 	*/
545 | 	general: string;
546 | 	/**
547 | 	* Indicates whether the specific Classifier can be used wherever the general Classifier can be used.
548 | 	* If true, the execution traces of the specific Classifier shall be a superset of the execution traces
549 | 	* of the general Classifier. If false, there is no such constraint on execution traces. If unset, the
550 | 	* modeler has not stated whether there is such a constraint or not.
551 | 	*/
552 | 	isSubstitutable: boolean;
553 | }
554 | 
555 | /**
556 | * An EnumerationLiteral is a user-defined data value for an Enumeration.
557 | */
558 | export interface EnumerationLiteralData extends NamedElementData, OrderedElementData {
559 | 	specification: ValueSpecificationData;
560 | }
561 | 
562 | /**
563 | * An Enumeration is a DataType whose values are enumerated in the model as EnumerationLiterals.
564 | */
565 | export interface EnumerationData extends DataTypeData {
566 | 	/**
567 | 	* Gets the base type of the enumeration. For most programming language, this is an integral type if
568 | 	* not specified.
569 | 	*/
570 | 	baseType?: string;
571 | 	/**
572 | 	* The ordered set of literals owned by this Enumeration.
573 | 	*/
574 | 	ownedLiterals?: EnumerationLiteralData[];
575 | }
576 | 
577 | export interface DocumentReferenceData {
578 | 	location: DocumentLocationKind;
579 | 	/**
580 | 	* Gets the name of the reference. If the reference is a NPM reference, this field contains the package
581 | 	* name (including any @scope). If the reference is a local one, this field contains the file name
582 | 	* without extension.
583 | 	*/
584 | 	name: string;
585 | 	path: string;
586 | }
587 | 
588 | export type DocumentLocationKind = 'local' | 'npm';
589 | 
590 | export interface DocumentData {
591 | 	creator: string;
592 | 	/**
593 | 	* Gets the unique ID of the document.
594 | 	*/
595 | 	id: string;
596 | 	/**
597 | 	* Contains the main model structure.
598 | 	*/
599 | 	model?: ModelData;
600 | 	modelTypeName: string;
601 | 	modelTypeVersion: string;
602 | 	/**
603 | 	* Contains a model with 0 or more profiles (packages) in it.
604 | 	*/
605 | 	profiles?: ModelData;
606 | 	references?: DocumentReferenceData[];
607 | }
608 | 
609 | /**
610 | * A Comment is a textual annotation that can be attached to a set of Elements.
611 | */
612 | export interface CommentData extends ElementData {
613 | 	body: string;
614 | }
615 | 
616 | /**
617 | * Associations represent relationships between classes.
618 | */
619 | export interface AssociationData extends RelationshipData, ClassifierData {
620 | 	/**
621 | 	* Gets all ends of the association, that is, ends that are either owned by the association or by a
622 | 	* classifier (as attributes).
623 | 	*/
624 | 	memberEnds?: string[];
625 | 	/**
626 | 	* The ends that are owned by the Association itself.
627 | 	*/
628 | 	ownedEnds?: PropertyData[];
629 | }
630 | 
631 | /**
632 | * AggregationKind is an Enumeration for specifying the kind of aggregation of a Property.
633 | */
634 | export type AggregationKind = 'none' | 'shared' | 'composite';
635 | 
636 | /**
637 | * Contents from partial file ./data-interfaces.partial.ts.
638 | */
639 | 
640 | /**
641 |  * Augments the generated DocumentReferenceData with a document property that is used
642 |  * internally.
643 |  */
644 | export interface DocumentReferenceData {
645 |     /**
646 |      * Contains the document data for the reference document. This field only has a value
647 |      * after the referenced document is loaded. This is done by the host process.
648 |      */
649 |     document: DocumentData;
650 | }
651 | 
652 | 


--------------------------------------------------------------------------------
/src/file-search.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | import { Stats } from "fs";
 9 | const fs = require('fs');
10 | const path = require('path');
11 | 
12 | export class FileSearch {
13 |     private static _directoryIgnoreList: string[] = ['node_modules'];
14 | 
15 |     public static findFiles(dirName: string, recursive: boolean, fileName: string, callback: (err: any, list: string[] | null) => void): void {
16 |         // Recursively search the working dir for files matching fileName.
17 |         //console.log('CodeGen: findFilesRecursive on directory \'%s\'', dirName);
18 | 
19 |         fs.readdir(dirName, (err: any, files: string[]) => {
20 |             if (err) {
21 |                 return callback(err, null);
22 |             }
23 | 
24 |             let list: string[] = [];
25 |             let pending = files.length;
26 |             if (pending === 0) {
27 |                 // we are done
28 |                 callback(null, list);
29 |                 return;
30 |             }
31 | 
32 |             var onFileHandled = () => {
33 |                 pending -= 1;
34 |                 if (pending === 0) {
35 |                     // We are done reading through the file list
36 |                     callback(null, list);
37 |                     return;
38 |                 }
39 |             };
40 | 
41 |             files.forEach(file => {
42 |                 const filePath = path.join(dirName, file);
43 |                 fs.stat(filePath, (errStat: NodeJS.ErrnoException, stats: Stats) => {
44 |                     if (errStat) {
45 |                         return callback(errStat, null);
46 |                     }
47 |                     var baseName = path.basename(file);
48 |                     if (recursive && stats.isDirectory()) {
49 |                         if (FileSearch._directoryIgnoreList.indexOf(baseName) <= -1) {
50 |                             // Recursively read on
51 |                             FileSearch.findFiles(filePath, true, fileName, (errSubDir, subDirList: string[] | null) => {
52 |                                 if (subDirList && subDirList.length > 0) {
53 |                                     list = list.concat(subDirList);
54 |                                 }
55 |                                 onFileHandled();
56 |                             });
57 |                         } else {
58 |                             onFileHandled();
59 |                         }
60 |                     } else {
61 |                         if (baseName.toLowerCase() === fileName) {
62 |                             list.push(filePath);
63 |                         }
64 |                         onFileHandled();
65 |                     }
66 |                     //   console.log('CodeGen: pending in directory \'%s\': %s', dirName, pending);
67 |                 });
68 |             });
69 |         });
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | /*
  3 |  * Copyright (c) 2019 Yellicode
  4 |  *
  5 |  * This Source Code Form is subject to the terms of the Mozilla Public
  6 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  7 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  8 |  */
  9 | 
 10 | const path = require('path');
 11 | import { ConsoleLogger, LogLevel } from '@yellicode/core';
 12 | import { ConfigStore } from './config-store';
 13 | import { ModelStore } from './model-store';
 14 | import { TemplateRunner } from './template-runner';
 15 | import { InputWatcher } from './input-watcher';
 16 | import { ConfigReader } from './config-reader';
 17 | import { Compiler } from './compiler';
 18 | import { Initializer } from './initializer/initializer';
 19 | 
 20 | const WATCH_PROCESS_ARG = '--watch';
 21 | const WATCH_PROCESS_ARG_ALIAS = '-w';
 22 | const INIT_PROCESS_ARG = 'init';
 23 | 
 24 | const TEMPLATE_FILE_PROCESS_ARG = '--template';
 25 | const TEMPLATE_FILE_PROCESS_ARG_ALIAS = '-t';
 26 | 
 27 | const DEBUG_TEMPLATE_PROCESS_ARG = '--debug-template';
 28 | const LOG_LEVEL_ARG = '--log-level';
 29 | 
 30 | /**
 31 |  * True to let the user/IDE attach a debugger to the template child process.
 32 |  */
 33 | let debugTemplate = false;
 34 | 
 35 | /**
 36 |  * True to run once and not watch for changes in input files.
 37 |  */
 38 | let watch = false;
 39 | 
 40 | /**
 41 |  * If defined, runs a single template (although it must still be configured).
 42 |  */
 43 | let templateFileName: string;
 44 | 
 45 | /**
 46 |  * If true, don't run anything but the initializer.
 47 |  */
 48 | let initOnly: boolean = false;
 49 | 
 50 | let logLevel = LogLevel.Info;
 51 | const args = process.argv;
 52 | 
 53 | args.forEach((val, index, array) => {
 54 |     switch (val.toLowerCase()) {
 55 |         case DEBUG_TEMPLATE_PROCESS_ARG:
 56 |             debugTemplate = true;
 57 |             break;
 58 |         case WATCH_PROCESS_ARG:
 59 |         case WATCH_PROCESS_ARG_ALIAS:
 60 |             watch = true;
 61 |             break;
 62 |         case TEMPLATE_FILE_PROCESS_ARG:
 63 |         case TEMPLATE_FILE_PROCESS_ARG_ALIAS:
 64 |             templateFileName = array[index + 1];
 65 |             break;
 66 |         case LOG_LEVEL_ARG:
 67 |             const logLevelString = array[index + 1].toLowerCase();
 68 |             logLevel = LogLevel.parse(logLevelString) || logLevel;
 69 |             break;        
 70 |         case INIT_PROCESS_ARG:
 71 |             initOnly = true;
 72 |             break;
 73 |         default:
 74 |             break;
 75 |     }
 76 | });
 77 | 
 78 | /**
 79 |  * Well, a logger.... one that logs to the console...
 80 |  */
 81 |  const logger = new ConsoleLogger(console, logLevel);
 82 | // const logger = new ConsoleLogger(console, logLevel, true); // include timestamps
 83 | 
 84 | /**
 85 |  * Stores the template- and model info, and their relations.
 86 |  */
 87 | const configStore = new ConfigStore();
 88 | /**
 89 |  * Stores the model data.
 90 |  */
 91 | const modelStore: IModelStore = new ModelStore(logger);
 92 | 
 93 | /**
 94 |  * Compiles TS to JS.
 95 |  */
 96 | const compiler = new Compiler(logger);
 97 | 
 98 | /**
 99 |  * Runs code templates based on the template file name or 
100 |  */
101 | const templateRunner: TemplateRunner = new TemplateRunner(configStore, modelStore, logger, compiler, debugTemplate, watch);
102 | /**
103 |  * Watches changes to input files (template- and model files) and invokes the template runner when something changed.
104 |  */
105 | const inputWatcher = new InputWatcher(templateRunner, modelStore, logger); // modelStore also implements IModelCache
106 | /**
107 |  * Reads (and watch changes to) config files and pass the results to the config store.
108 |  */
109 | const configReader: ConfigReader = new ConfigReader(configStore, inputWatcher, templateRunner, logger, watch);
110 | 
111 | function errorHandler(err: any) {
112 |     logger.error(`An unhandler error has occured: ${err}.`);
113 |     process.exit(); 
114 | }
115 | 
116 | const workingDirectory = path.resolve(".");
117 | 
118 | function start() {
119 |     const recursive = false; // recursively searches the working dir for codegenconfig.json files. Enable if needed and when fully tested.    
120 |     logger.info(`Yellicode is starting in working directory ${workingDirectory}.`);
121 |     logger.verbose(`Template debugging: ${debugTemplate}. Watching: ${watch}.`);
122 | 
123 |     configReader.readDirectory(workingDirectory, recursive, false)
124 |         .then(() => {
125 |             if (templateFileName) {
126 |                 templateRunner.runTemplatesUsingTemplateFile(templateFileName, true).then(() => {
127 |                     process.exit(); // not watching, so exit
128 |                 }, errorHandler);
129 |             }
130 |             else if (watch && !debugTemplate) {
131 |                 templateRunner.runAll().catch(errorHandler);
132 |             }
133 |             else templateRunner.runAll().then(() => {
134 |                 process.exit(); // not watching, so exit            
135 |             }, errorHandler);
136 |         })
137 |         .catch((err) => {
138 |             logger.error(err);
139 |         });
140 | }
141 | 
142 | if (initOnly) {
143 |     const initializer = new Initializer(logger);
144 |     initializer.run(workingDirectory).then(() => {
145 |         logger.info('Yellicode initialization finished. Run \'yellicode\' or \'yellicode --watch\' to start code generation.');
146 |         process.exit();
147 |     });
148 | }
149 | else start();


--------------------------------------------------------------------------------
/src/initializer/init-config.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | export interface InitConfig {
 9 |     modelName: string;    
10 |     templateFileName: string;
11 |     outputFileName: string;
12 | }


--------------------------------------------------------------------------------
/src/initializer/init-prompt.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | import { InitConfig } from "./init-config";
 9 | import * as path from 'path';
10 | import * as rl from 'readline';
11 | import { PathUtility } from "../path-utility";
12 | 
13 | export class InitPrompt {
14 |     public static PromptForConfig(config: InitConfig): Promise<InitConfig> {        
15 |         console.log('This utility will walk you through creating a codegenconfig.json file, a basic code generation template and an initial model file.');
16 |         console.log('If the directory does not have a NPM package.json file, one will be created with sensible defaults (similar to the "npm init -y" command).');
17 |         console.log();
18 |    //     console.log(`Press ^C at any time to quit.`); // to be handled
19 | 
20 |         return InitPrompt.promptForString(`Model name: (${config.modelName})`)
21 |             .then((modelName) => {                
22 |                 if (modelName) config.modelName = modelName;
23 |                 // console.log(`Using model ${config.modelName}`);
24 |                 return InitPrompt.promptForString(`Template file: (${config.templateFileName})`);
25 |             })
26 |             .then((templateFileName: string) => {       
27 |                 if (templateFileName) config.templateFileName = templateFileName;
28 |                 // console.log(`Using template ${config.templateFileName}`);                
29 |                 // Ask for the output file name, but first set the default based on the previous answer        
30 |                 config.outputFileName = PathUtility.removeTsExtension(config.templateFileName) + '-output.txt';
31 |                 return InitPrompt.promptForString(`Output file: (${config.outputFileName})`);
32 |             }).then((outputFileName: string) => {
33 |                 if (outputFileName) config.outputFileName = outputFileName;
34 |                 // console.log(`Using output file ${config.outputFileName}`);                
35 |                 return config;                
36 |             });
37 |     }
38 | 
39 |     private static promptForString(question: string): Promise<string> {        
40 |         return new Promise((resolve, reject) => {
41 |             const { stdin, stdout } = process;
42 |         
43 |             stdin.resume();
44 |             stdout.write(question);
45 |         
46 |             stdin.on('data', data => {
47 |                 let answer = data ? data.toString().trim() : null;
48 |                 if (answer && (answer.length === 0)) {answer = null};
49 |                 resolve(answer);
50 |             });
51 |             stdin.on('error', err => reject(err));
52 |           });
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/initializer/initializer.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | import * as path from 'path';
  9 | import * as fs from "fs";
 10 | 
 11 | import { Logger } from '@yellicode/core';
 12 | import * as consts from '../yellicode-constants';
 13 | import { NpmInstaller } from './npm-installer';
 14 | import { ModelBuilder } from './model-builder';
 15 | import { InitConfig } from './init-config';
 16 | import { InitPrompt } from './init-prompt';
 17 | 
 18 | export class Initializer {
 19 |     private npmInstaller: NpmInstaller;
 20 | 
 21 |     constructor(private logger: Logger) {
 22 |         this.npmInstaller = new NpmInstaller(logger);
 23 |     }
 24 | 
 25 |     public run(workingDir: string): Promise<void> {
 26 |         const baseName = path.basename(workingDir);
 27 | 
 28 |         const defaultConfig: InitConfig = {
 29 |             modelName: baseName,
 30 |             templateFileName: `${baseName}.template.ts`,
 31 |             outputFileName: `${baseName}.template-output.txt`
 32 |         };
 33 | 
 34 |         return InitPrompt.PromptForConfig(defaultConfig).then(config => {
 35 |             Initializer.sanitizeConfig(config);
 36 |             return this.runInternal(workingDir, config);
 37 |         })
 38 |     }
 39 | 
 40 |     private static sanitizeConfig(initConfig: InitConfig) {
 41 |         // Ensure *no* extension on the model name        
 42 |         if (initConfig.modelName.endsWith(consts.YELLICODE_DOCUMENT_EXTENSION)) {
 43 |             initConfig.modelName = initConfig.modelName.substring(0, initConfig.modelName.length - 4);
 44 |         }
 45 | 
 46 |         // Ensure a ts extension on the template name
 47 |         if (!initConfig.templateFileName.endsWith('.ts')) {
 48 |             initConfig.templateFileName += '.ts';
 49 |         }
 50 |     }
 51 | 
 52 |     private runInternal(workingDir: string, initConfig: InitConfig): Promise<void> {
 53 |         // A modelName without a .json extension becomes a Yellicode model.
 54 |         // Otherwise it becomes a plain JSON document.
 55 |         const isJsonModel = initConfig.modelName.endsWith('.json');
 56 |         const modelFileName = isJsonModel ?
 57 |             initConfig.modelName :
 58 |             initConfig.modelName + consts.YELLICODE_DOCUMENT_EXTENSION;
 59 | 
 60 |         // Create a model file
 61 |         this.logger.info(`Creating model ${modelFileName}...`);
 62 |         return Initializer.createModelFile(workingDir, modelFileName, isJsonModel)
 63 |             .then(() => {
 64 |                 // Create a template file
 65 |                 this.logger.info(`Creating template ${initConfig.templateFileName}...`);
 66 | 
 67 |                 return isJsonModel ? 
 68 |                     Initializer.createTemplateFileForJsonModel(workingDir, initConfig.templateFileName, initConfig.outputFileName, modelFileName) :
 69 |                     Initializer.createTemplateFile(workingDir, initConfig.templateFileName, initConfig.outputFileName);
 70 |             })
 71 |             .then(() => {
 72 |                 // Create a codegenconfig.json file
 73 |                 this.logger.info(`Creating codegenconfig.json...`);
 74 |                 return Initializer.createCodeGenConfigFile(workingDir, initConfig.templateFileName, modelFileName);
 75 |             })
 76 |             .then(() => {
 77 |                 const dependencies: string[] = ['@yellicode/core', '@yellicode/templating'];
 78 |                 if (!isJsonModel){
 79 |                     dependencies.push('@yellicode/elements');
 80 |                 }
 81 |                 this.logger.info(`Installing NPM packages (${dependencies.join(', ')})...`);
 82 |                 return this.npmInstaller.installDevPackages(workingDir, dependencies);
 83 |             })
 84 |             .catch((err) => {
 85 |                 this.logger.error(err);
 86 |             });
 87 | 
 88 |     }
 89 | 
 90 |     private static createModelFile(workingDir: string, modelFileName: string, isJsonModel: boolean): Promise<void> {
 91 |         let document: any;
 92 | 
 93 |         if (isJsonModel) {
 94 |             document = {};
 95 |         }
 96 |         else {
 97 |             const modelName = path.basename(modelFileName, consts.YELLICODE_DOCUMENT_EXTENSION);
 98 |             document = ModelBuilder.buildSampleModel(modelName);
 99 |         }
100 | 
101 |         const fullFileName = path.join(workingDir, modelFileName);
102 |         return new Promise<void>((resolve, reject) => {
103 |             fs.writeFile(fullFileName, JSON.stringify(document, undefined, 4), (err) => {
104 |                 if (err) {
105 |                     reject(err);
106 |                 }
107 |                 else resolve();
108 |             });
109 |         });
110 |     }
111 | 
112 |     private static createTemplateFileForJsonModel(workingDir: string, templateFileName: string, outputFileName: string, modelFileName: string): Promise<void> {
113 |   // Note: escape a `, { and } as \`, \{ and \} respectively
114 |   const template = `import { TextWriter } from '@yellicode/core';
115 | import { Generator } from '@yellicode/templating';
116 |           
117 | Generator.generateFromModel({ outputFile: './${outputFileName}' }, (writer: TextWriter, model: any) => {
118 |     writer.writeLine(\`Output from template '${templateFileName}' with JSON model '${modelFileName}', generated at $\{new Date().toISOString()\}.\`);      
119 | });`;
120 |   
121 |           const fullFileName = path.join(workingDir, `${templateFileName}`);
122 |           return new Promise<void>((resolve, reject) => {
123 |               fs.writeFile(fullFileName, template, (err) => {
124 |                   if (err) {
125 |                       reject(err);
126 |                   }
127 |                   else resolve();
128 |               });
129 |           });
130 |     }
131 | 
132 |     private static createTemplateFile(workingDir: string, templateFileName: string, outputFileName: string): Promise<void> {
133 | 
134 |         // Note: escape a `, { and } as \`, \{ and \} respectively
135 |         const template = `import { TextWriter } from '@yellicode/core';
136 | import { Generator } from '@yellicode/templating';        
137 | import * as elements from '@yellicode/elements';
138 |         
139 | Generator.generateFromModel({ outputFile: './${outputFileName}' }, (writer: TextWriter, model: elements.Model) => {
140 |     writer.writeLine(\`Output from template '${templateFileName}' with model '$\{model.name\}', generated at $\{new Date().toISOString()\}.\`);
141 |     writer.writeLine();
142 |     model.getAllTypes().forEach((t) => {
143 |         writer.writeLine(\`Type $\{t.name\}: $\{t.getFirstCommentBody()\}\`);
144 |         if (elements.isClass(t)) {
145 |             writer.increaseIndent();
146 |             writer.writeLine(\`Class $\{t.name\} has the following attributes:\`);
147 |             t.ownedAttributes.forEach(att => {
148 |                 writer.writeLine(\`- $\{att.name\} ($\{att.getTypeName()\}): $\{att.getFirstCommentBody()\}\`);
149 |             });
150 |             writer.decreaseIndent();
151 |         }
152 |     })
153 | });`;
154 | 
155 |         const fullFileName = path.join(workingDir, `${templateFileName}`);
156 |         return new Promise<void>((resolve, reject) => {
157 |             fs.writeFile(fullFileName, template, (err) => {
158 |                 if (err) {
159 |                     reject(err);
160 |                 }
161 |                 else resolve();
162 |             });
163 |         });
164 |     }
165 | 
166 |     private static createCodeGenConfigFile(workingDir: string, templateFileName: string, modelFileName: string) {
167 |         const modelName = path.basename(modelFileName, consts.YELLICODE_DOCUMENT_EXTENSION);
168 | 
169 |         const config: CodeGenConfig = {
170 |             compileTypeScript: true, templates: [
171 |                 { modelFile: modelName, templateFile: templateFileName }
172 |             ]
173 |         };
174 | 
175 |         const fullFileName = path.join(workingDir, consts.YELLICODE_CONFIG_FILE);
176 |         return new Promise<void>((resolve, reject) => {
177 |             fs.writeFile(fullFileName, JSON.stringify(config, undefined, 4), (err) => {
178 |                 if (err) {
179 |                     reject(err);
180 |                 }
181 |                 else resolve();
182 |             });
183 |         });
184 |     }
185 | }


--------------------------------------------------------------------------------
/src/initializer/model-builder.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | import * as elements from '../data-interfaces';
 9 | import { UniqueId } from '@yellicode/core';
10 | 
11 | export class ModelBuilder {
12 |     public static buildSampleModel(modelName: string): elements.DocumentData {
13 |         const modelData: elements.ModelData = {
14 |             elementType: "model",
15 |             id: UniqueId.create(6),
16 |             name: modelName
17 |         } as elements.ModelData;
18 | 
19 |         modelData.packagedElements = [ModelBuilder.createSampleClass()];
20 | 
21 |         return {
22 |             id: UniqueId.create(6),
23 |             creator: "Yellicode CLI",
24 |             modelTypeName: "Yellicode YML",
25 |             modelTypeVersion: elements.MetaVersion,
26 |             model: modelData
27 |         }
28 |     }
29 | 
30 |      private static createSampleClass(): elements.PackageableElementData {
31 |         const sampleClass: elements.ClassData = {
32 |             elementType: "class",
33 |             id: UniqueId.create(6),
34 |             visibility: "public",
35 |             name: 'Class1',
36 |             ownedComments: ModelBuilder.createComment('This is a sample class.')
37 |         } as elements.ClassData;
38 | 
39 |         // Add an attribute
40 |         const sampleAttribute1: elements.PropertyData = {
41 |             elementType: "property",
42 |             id: UniqueId.create(),
43 |             visibility: "public",
44 |             name: 'StringProperty',
45 |             type: 'string_id', // the built-in string type
46 |             ownedComments: ModelBuilder.createComment('This is a sample string property.')
47 |         } as elements.PropertyData;
48 | 
49 |         const sampleAttribute2: elements.PropertyData = {
50 |             elementType: "property",
51 |             id: UniqueId.create(),
52 |             visibility: "public",
53 |             name: 'IntCollectionProperty',
54 |             type: 'integer_id', // the built-in int type,
55 |             upperValue: this.createInfiniteUnlimitedNaturalData(),
56 |             ownedComments: ModelBuilder.createComment('This is a sample int collection property.')
57 |         } as elements.PropertyData;
58 | 
59 |         sampleClass.ownedAttributes = [sampleAttribute1, sampleAttribute2];
60 |         return sampleClass;
61 |     }
62 | 
63 |     private static createComment(body: string): elements.CommentData[] | null {
64 |         if (!body || body.length === 0) return null;
65 |         return [{ elementType: "comment", body: body } as elements.CommentData];
66 |     }
67 | 
68 |     private static createInfiniteUnlimitedNaturalData(): elements.ValueSpecificationData {
69 |         return { elementType: "literalUnlimitedNatural", value: "*" } as elements.LiteralUnlimitedNaturalData;
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/initializer/npm-installer.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | import * as childProcess from 'child_process';
 9 | import * as path from 'path';
10 | import * as fs from 'fs';
11 | import { Logger } from '@yellicode/core';
12 | 
13 | export class NpmInstaller {    
14 |     constructor(private logger: Logger) {       
15 |         
16 |     }
17 | 
18 | 	public installDevPackages(workingDir: string, packagePaths: string[]): Promise<void> {
19 | 		// The following will call installDevPackage sequentially so that we can report the
20 | 		// progress each event in order (and I don't know if installing in parallel is even recommended)	
21 | 
22 | 		// A package.json is required in order to install anything
23 | 		let chain: Promise<void> = this.ensurePackageJson(workingDir); // or Promise.resolve();
24 | 		packagePaths.forEach(packagePath => {
25 | 			chain = chain.then(() => {
26 | 				const installCommandArgs = `install ${packagePath} --save-dev`;				
27 | 				return this.execNpmCommand(workingDir, installCommandArgs);
28 | 			});
29 | 		});
30 | 		return chain;
31 | 	}
32 | 
33 | 	public installDevPackage(documentPath: string, packagePath: string): Promise<void> {
34 | 		const workingDir = path.dirname(documentPath);
35 | 
36 | 		// A package.json is required in order to install anything
37 | 		return this.ensurePackageJson(workingDir)
38 | 			.then(() => {
39 | 				const installCommandArgs = `install ${packagePath} --save-dev`;
40 | 				return this.execNpmCommand(workingDir, installCommandArgs);
41 | 			});
42 | 	}
43 | 
44 | 	private ensurePackageJson(workingDir: string): Promise<void> {
45 | 		const packageJsonPath = path.join(workingDir, 'package.json');
46 | 		if (fs.existsSync(packageJsonPath)) {
47 | 			return Promise.resolve();
48 | 		}
49 | 		// The following command creates a package.json without asking any further questions
50 | 		const npmInitCommand = 'init --yes'; // https://docs.npmjs.com/getting-started/using-a-package.json#the---yes-init-flag
51 | 		return this.execNpmCommand(workingDir, npmInitCommand);
52 | 	}
53 | 
54 | 	private execNpmCommand(workingDir: string, commandArgs: string): Promise<void> {
55 | 		const command = `npm ${commandArgs}`;
56 | 
57 | 		const options = { silent: false, cwd: workingDir };
58 | 		this.logger.verbose(`Executing npm command '${command}' in working directory ${workingDir}...`);
59 | 		return new Promise<void>((resolve, reject) => {			
60 | 			const child = childProcess.exec(command, options, (error, stdout, stderr) => {                
61 |                 if (stdout) this.logger.info(stdout);
62 | 				if (stderr) this.logger.info(stderr); // we can get WARN and ERROR from stderr
63 | 				if (error !== null) {
64 | 					reject(`Npm command '${command}' has failed. ${error}.`);
65 | 				}
66 | 			});
67 | 
68 | 			child.on('exit', (code) => {
69 | 				if (code === 0) {
70 | 					resolve();
71 | 				} else {
72 | 					reject(`Npm command '${command}' has failed. The process has exited with code ${code}.`);
73 | 				}
74 | 			});
75 | 		});
76 | 
77 | 	}
78 | }
79 | 


--------------------------------------------------------------------------------
/src/input-watcher.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | const chokidar = require('chokidar');
  9 | const path = require('path');
 10 | 
 11 | import { Logger } from '@yellicode/core';
 12 | import { TemplateRunner } from "./template-runner";
 13 | 
 14 | export class InputWatcher {
 15 | 
 16 |     /**
 17 |     * Watches for changes to template files.
 18 |     */
 19 |     private templatesWatcher: any = null;
 20 |     private modelsWatcher: any = null;
 21 | 
 22 |     constructor(private templateRunner: TemplateRunner, private modelCache: IModelCache, private logger: Logger) {
 23 | 
 24 |     }
 25 | 
 26 |     watchTemplateFiles(files: string[]): void {
 27 |         if (this.templatesWatcher == null) {
 28 |             this.templatesWatcher = chokidar.watch(files, { persistent: true });
 29 |             this.templatesWatcher.on('change', (templateFile: string) => {
 30 |                 this.logger.info(`Template '${templateFile}' has changed. Running template...`);
 31 |                 // Wait a little to make sure that the file write process has finished (had this issue with a 200KB file on Windows)
 32 |                 setTimeout(() => {
 33 |                     debugger;
 34 |                     this.templateRunner.runTemplatesUsingTemplateFile(templateFile, true)
 35 |                         .catch(e => {
 36 |                             this.logger.error(e);
 37 |                         });
 38 |                 }, 1000)
 39 | 
 40 |             });
 41 |         } else this.templatesWatcher.add(files);
 42 |     };
 43 | 
 44 |     watchModelFiles(files: string[]): void {
 45 |         if (this.modelsWatcher == null) {
 46 |             this.modelsWatcher = chokidar.watch(files, { persistent: true });
 47 |             this.modelsWatcher.on('change', (modelFile: string) => {
 48 |                 this.logger.info(`Model '${modelFile}' has changed. Running template(s)...`);
 49 |                 this.modelCache.invalidateCache(modelFile);
 50 |                 // Wait a little to make sure that the file write process has finished (had this issue with a 200KB file on Windows)
 51 |                 setTimeout(() => {
 52 |                     this.templateRunner.runTemplatesUsingModel(modelFile)
 53 |                         .catch(e => {
 54 |                             this.logger.error(e);
 55 |                         });
 56 |                 }, 1000)
 57 |             });
 58 |         } else this.modelsWatcher.add(files);
 59 |     };
 60 | 
 61 |     getWatchedTemplateFiles(): string[] {
 62 |         if (this.templatesWatcher == null)
 63 |             return [];
 64 | 
 65 |         return InputWatcher.getWatched(this.templatesWatcher);
 66 | 
 67 |     };
 68 | 
 69 |     getWatchedModelFiles(): string[] {
 70 |         if (this.modelsWatcher == null)
 71 |             return [];
 72 | 
 73 |         return InputWatcher.getWatched(this.modelsWatcher);
 74 |     }
 75 | 
 76 | 
 77 |     unwatchTemplateFiles(files: string[]) {
 78 |         if (this.templatesWatcher == null)
 79 |             return;
 80 | 
 81 |         this.templatesWatcher.unwatch(files);
 82 |     }
 83 | 
 84 |     unwatchModelFiles(files: string[]) {
 85 |         if (this.modelsWatcher == null)
 86 |             return;
 87 | 
 88 |         this.modelsWatcher.unwatch(files);
 89 |     }
 90 | 
 91 | 
 92 |     private static getWatched(watcher: any): string[] {
 93 |         const result: string[] = [];
 94 |         // getWatched() returns an object with dir paths as keys and arrays of contained paths as values.
 95 |         const watched = watcher.getWatched();
 96 |         for (let dirName in watched) {
 97 |             if (watched.hasOwnProperty(dirName)) {
 98 |                 const filesInDir = watched[dirName];
 99 |                 filesInDir.forEach((f: string) => {
100 |                     result.push(path.join(dirName, f))
101 |                 });
102 |             };
103 |         };
104 |         return result;
105 |     }
106 | }


--------------------------------------------------------------------------------
/src/json-file-reader.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | const fs = require('fs');
 9 | const jsonparser = require('json-parser');
10 | 
11 | export class JsonFileReader {
12 | 
13 |     public static readFile(fileName: string): Promise<any> {
14 |         if (!fs.existsSync(fileName)) {
15 |             return Promise.reject(`File '${fileName}' not found.`);
16 |         }
17 | 
18 |         return new Promise<void>((resolve, reject) => {
19 |             fs.readFile(fileName, 'utf8', (err: NodeJS.ErrnoException, text: Buffer) => {
20 |                 try {
21 |                     const model = jsonparser.parse(text, null, true); // parse... true to remove comments
22 |                     resolve(model);
23 |                 } catch (e) {
24 |                     reject(`Error parsing file '${fileName}': ${e}`);
25 |                 }
26 |             });
27 |         })
28 |     }
29 | }


--------------------------------------------------------------------------------
/src/model-store.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | const lock = require('lock'); // https://www.npmjs.com/package/lock
  9 | import { ReferencePathResolver, PathResolverResult } from './reference-path-resolver';
 10 | import { JsonFileReader } from './json-file-reader';
 11 | import { Logger } from '@yellicode/core';
 12 | import * as ModelData from "./data-interfaces";
 13 | 
 14 | export class ModelStore implements IModelStore, IModelCache {
 15 |     private _lock = lock();
 16 |     private _cache: any = {};
 17 |     private _logger: Logger;
 18 | 
 19 |     constructor(logger: Logger) {
 20 |         this._logger = logger;
 21 |     }
 22 | 
 23 |     public loadModel(fileName: string): Promise<any> {
 24 |         // First check the cache
 25 |         if (this._cache.hasOwnProperty(fileName)) {
 26 |             this._logger.verbose(`Returning model '${fileName}' from the cache.`);
 27 |             return Promise.resolve(this._cache[fileName]);
 28 |         }
 29 | 
 30 |         return new Promise<void>((resolve, reject) => {
 31 |             this.loadModelInternal(fileName, (err: any, model: any) => {
 32 |                 if (err) {
 33 |                     reject(err);
 34 |                 }
 35 |                 else resolve(model);
 36 |             });
 37 |         });
 38 |     }
 39 | 
 40 |     private loadModelInternal(fileName: string, callback: (err: any, model: any) => void) {
 41 |         const cache = this._cache;
 42 | 
 43 |         // First obtain a lock on the filename, multiple templates might want to use the same model.
 44 |         this._lock(fileName, (release: Function) => {
 45 |             // We obtained a lock on filename. 
 46 |             const invokeReleaseLockFunc = release((err: any, model: any) => {
 47 |                 callback(err, model);
 48 |             })
 49 | 
 50 |             // Check if another call already filled the cache in the meantime
 51 |             if (cache.hasOwnProperty(fileName)) {                
 52 |                 this._logger.verbose(`Returning model '${fileName}' from the cache.`);
 53 |                 invokeReleaseLockFunc(null, cache[fileName])
 54 |                 return;
 55 |             }
 56 | 
 57 |             const referencePathResolver = new ReferencePathResolver(this._logger, fileName);
 58 |             this.readModelFile(fileName, referencePathResolver).then((model: any) => {
 59 |                 // Add to the cache
 60 |                 this._logger.verbose(`Adding model '${fileName}' to the cache.`);
 61 |                 cache[fileName] = model;
 62 |                 invokeReleaseLockFunc(null, model);
 63 | 
 64 |             }).catch((err) => {
 65 |                 invokeReleaseLockFunc(err, null);
 66 |             });
 67 |         })
 68 |     }
 69 | 
 70 |     public invalidateCache(fileName: string) {
 71 |         if (!this._cache.hasOwnProperty(fileName))
 72 |             return;
 73 | 
 74 |         delete this._cache[fileName];
 75 |     }
 76 | 
 77 |     private readModelFile(fileName: string, referencePathResolver: ReferencePathResolver): Promise<any> {
 78 |         //  console.log(`Modelstore: reading file `+fileName);
 79 |         var promise = JsonFileReader.readFile(fileName).then(model => {
 80 |             // Is the model a plain JSON file or is it a document?
 81 |             const asDocument = model as ModelData.DocumentData;
 82 |             if (!(asDocument.modelTypeName && asDocument.modelTypeVersion)) {
 83 |                 // Not a document: return as-is
 84 |                 return Promise.resolve(model);
 85 |             }
 86 |             else {
 87 |                 return this.readDocumentReferences(asDocument, fileName, referencePathResolver).then(() => { return asDocument; });
 88 |             }
 89 |         });
 90 | 
 91 |         return promise;
 92 |     }
 93 | 
 94 |     private readDocumentReferences(document: ModelData.DocumentData, fileName: string, referencePathResolver: ReferencePathResolver): Promise<void> {
 95 | 
 96 |         if (!document.references) return Promise.resolve();
 97 | 
 98 |         const promises: Promise<void>[] = [];
 99 |         document.references.forEach(r => {
100 |             const promise = referencePathResolver.resolve(r)
101 |                 .then((result: PathResolverResult) => {
102 |                     this._logger.verbose(`File name of ${r.location} reference ${r.name || r.path} : '${result.path}'.`);
103 |                     // Load the referenced document. This will also read any referenced documents.
104 |                     if (result.isDuplicate)
105 |                         return Promise.resolve(); // avoid recursion
106 | 
107 |                     return this.readModelFile(result.path, referencePathResolver).then((model: ModelData.DocumentData) => {
108 |                         r.document = model; //  store the model in the reference                        
109 |                     });
110 |                 });
111 |             promises.push(promise);
112 |         });
113 | 
114 |         // Convert Promise<void[]> (Promise.all) to Promise<void>
115 |         return new Promise<void>((resolve, reject) => {
116 |             Promise.all(promises).then(() => {
117 |                 resolve();
118 |             }, (reason) => {
119 |                 reject(reason);
120 |             })
121 |         });
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/path-utility.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | export class PathUtility {
 9 |     public static ensureJsExtension(path: string): string {
10 |         if (!path)
11 |             return path;
12 | 
13 |         if (path.endsWith('.js')) {
14 |             return path;
15 |         }
16 | 
17 |         if (path.endsWith('.ts')) {
18 |             // Remove the .ts extension
19 |             path = path.substring(0, path.length - 3);
20 |         }
21 |         return path + '.js';
22 |     }
23 | 
24 |     public static removeTsExtension(path: string): string {
25 |         if (!path || !path.endsWith('.ts'))
26 |             return path;
27 | 
28 |         return path.substring(0, path.length - 3);
29 |     }
30 | }


--------------------------------------------------------------------------------
/src/reference-path-resolver.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | const path = require('path');
 9 | const fs = require('fs');
10 | 
11 | import * as ModelData from "./data-interfaces";
12 | import { Logger } from '@yellicode/core';
13 | import { JsonFileReader } from './json-file-reader';
14 | import * as Consts from './yellicode-constants'
15 | 
16 | export interface PathResolverResult {
17 |     path: string;
18 |     isDuplicate: boolean;
19 | }
20 | 
21 | export class ReferencePathResolver {
22 |     private _baseDirectory: string;
23 |     private _nodeModulesDirectory: string;
24 |     private _logger: Logger;
25 |     private _resolvedPaths: string[] = [];
26 | 
27 |     constructor(logger: Logger, fileName: string) {
28 |         this._logger = logger;
29 |         this._baseDirectory = path.dirname(fileName);
30 |         this._nodeModulesDirectory = path.join(this._baseDirectory, "node_modules");
31 |     }
32 | 
33 |     public resolve(reference: ModelData.DocumentReferenceData): Promise<PathResolverResult> {
34 |         let innerResult: Promise<string>;
35 | 
36 |         switch (reference.location) {
37 |             case 'local':
38 |                 innerResult = Promise.resolve(path.join(this._baseDirectory, reference.path));
39 |                 break;
40 |             case 'npm':
41 |                 const packageName = reference.name || reference.path; // there is no name if the name and path are the same                              
42 |                 const packagePathSegments: string[] = [path.join(this._baseDirectory, "node_modules")];
43 |                 packagePathSegments.push(...packageName.split('/')) // deal with @scope/packageName, e.g. @mycompany/mypackage    
44 |                 const packageRootDirectory = path.join(...packagePathSegments);
45 |                 innerResult = this.readDocumentFileNameFromPackageJson(packageRootDirectory, packageName);
46 |                 break;
47 |             default:
48 |                 return Promise.reject(`Cannot resolve document reference '${reference.path}.' Location '${reference.location}' is not supported.`);
49 |         }
50 |         return innerResult.then(fileName => {
51 |             const normalizedFileName = fileName.toLowerCase();
52 |             const result: PathResolverResult = { path: normalizedFileName, isDuplicate: false };
53 |             if (this._resolvedPaths.indexOf(normalizedFileName) > -1) {
54 |                 result.isDuplicate = true;
55 |             }
56 |             else this._resolvedPaths.push(normalizedFileName);
57 |             return result;
58 |         })
59 |     }
60 | 
61 |     private readDocumentFileNameFromPackageJson(packageRootDirectory: string, packageName: string): Promise<string> {
62 |         if (!fs.existsSync(packageRootDirectory)) {
63 |             return Promise.reject(`Referenced NPM package '${packageName}' was not found in '${this._nodeModulesDirectory}'.`);
64 |         }
65 |         // Find a package.json
66 |         const packageJsonFileName = path.join(packageRootDirectory, 'package.json');
67 |         if (!fs.existsSync(packageJsonFileName)) {
68 |             return Promise.reject(`Cannot determine filename for NPM reference '${packageName}'. File '${packageJsonFileName}' not found.`);
69 |         }
70 |         return JsonFileReader.readFile(packageJsonFileName).then((packageJsonFile) => {
71 |             if (!(Consts.YELLICODE_SECTION_NAME in packageJsonFile)) {
72 |                 return Promise.reject(`Package '${packageName}' is missing package.json entry '${Consts.YELLICODE_SECTION_NAME}'.`);
73 |             }
74 |             const yellicodeSection = packageJsonFile[Consts.YELLICODE_SECTION_NAME];
75 |             if (!(Consts.YELLICODE_MODEL_NAME in yellicodeSection)) {
76 |                 return Promise.reject(`Package '${packageName}' is missing package.json entry '${Consts.YELLICODE_SECTION_NAME}.${Consts.YELLICODE_MODEL_NAME}'.`);
77 |             }
78 |             // Now we have path relative to the package.json. Ensure an extension and resolve it.
79 |             let relativePath = yellicodeSection[Consts.YELLICODE_MODEL_NAME];
80 |             const modelExtension = path.extname(relativePath);
81 |             if (!modelExtension) {
82 |                 relativePath = relativePath + Consts.YELLICODE_DOCUMENT_EXTENSION;
83 |             }
84 |             return path.join(packageRootDirectory, relativePath);
85 |         });
86 |     }
87 | }


--------------------------------------------------------------------------------
/src/template-process.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | import * as childProcess from 'child_process';
  9 | import * as path from 'path';
 10 | import * as semver from 'semver';
 11 | 
 12 | import { Logger } from '@yellicode/core';
 13 | import { IProcessMessage, ISetModelMessage } from '@yellicode/core';
 14 | 
 15 | const DEFAULT_CONNECTION_TIMEOUT = 5000;
 16 | const ACTIVE_PROCESS_POLL_INTERVAL = 500;
 17 | const DEFAULT_DEBUG_PORT_LEGACY = 5858;
 18 | const DEFAULT_DEBUG_PORT_INSPECTOR = 9229;
 19 | 
 20 | export class TemplateProcess {
 21 |     private static useLegacyDebugProtocol: boolean;
 22 |     private static debugPort: number = 5858; // the default debug port
 23 |     private hasSeenProcessMessages: boolean = false;
 24 |     private hasGeneratorActivity: boolean = false;
 25 | 
 26 |     /**
 27 |      * Reference counter for the number of active "generate(..)" or "generateFromModel(..)" calls in the template.
 28 |      */
 29 |     private generateCount: number = 0;
 30 | 
 31 |     constructor(private fileName: string, private modelData: any, private logger: Logger, private enableDebugging: boolean, private templateArgs: any, private outputMode?: string) {
 32 | 
 33 |     }
 34 | 
 35 |     static initialise() {
 36 |         // The legacy debugger has been deprecated as of Node 7.7.0 (https://nodejs.org/en/docs/guides/debugging-getting-started/).
 37 |         // The inspector protocol is supported as of Node >= 6.3, but only v6.14.2 understands the --inspect-brk flag.
 38 |         if (semver.lt(process.version, '6.14.2')) {
 39 |             TemplateProcess.debugPort = DEFAULT_DEBUG_PORT_LEGACY;
 40 |             TemplateProcess.useLegacyDebugProtocol = true;
 41 |         }
 42 |         else {
 43 |             TemplateProcess.debugPort = DEFAULT_DEBUG_PORT_INSPECTOR;
 44 |             TemplateProcess.useLegacyDebugProtocol = false;
 45 |         }
 46 |     }
 47 | 
 48 |     public run(connectionTimeout?: number): Promise<void> {
 49 |         const templateProcess = this.createTemplateProcess();
 50 |         const timeOut = connectionTimeout || DEFAULT_CONNECTION_TIMEOUT;
 51 | 
 52 |         // Give the process some time to get started. For example, the timeout will expire if the user never imports the Generator at all.
 53 |         if (!this.enableDebugging) { // when debugging, the user needs time to attach to the child process
 54 |             setTimeout(() => {
 55 |                 if ((this.hasSeenProcessMessages && this.hasGeneratorActivity) || !templateProcess.connected)
 56 |                     return;
 57 | 
 58 |                 this.logger.error(`Child process for template '${this.fileName}' did not start any activity within the ${timeOut}ms. Disconnecting.`);
 59 |                 templateProcess.disconnect();
 60 |             }, timeOut);
 61 |         }
 62 | 
 63 |         return new Promise((resolve, reject) => {
 64 |             templateProcess.on('error', (err: Error) => {
 65 |                 this.logger.verbose(`Error on template process for '${this.fileName}': ${err}.`);
 66 |                 return reject(err);
 67 |             });
 68 | 
 69 |             templateProcess.on('exit', (code: number) => {
 70 |                 if (code === 0) {
 71 |                     this.logger.verbose(`Template process for '${this.fileName}' has exited with success code ${code}.`);
 72 |                     resolve();
 73 |                 } else {
 74 |                     reject(`Template process for '${this.fileName}' has exited with code ${code}.`);
 75 |                 }
 76 |             });
 77 | 
 78 |             templateProcess.on('disconnect', () => {
 79 |                 // The process has disconnected. Most likely because we disconnected in monitorActiveTemplateProcess().
 80 |                 this.logger.verbose(`Template process for '${this.fileName}' has disconnected.`);
 81 |                 resolve();
 82 |             });
 83 | 
 84 |             templateProcess.on('message', (m: IProcessMessage) => {
 85 |                 // The first process message is (most likely) a 'processStarted' message. This message is sent when the single-instance Generator is created by the template process.
 86 |                 // It is exported as a single instance by the templating package so we should receive it only once.
 87 |                 this.hasSeenProcessMessages = true;
 88 | 
 89 |                 if (m.log) {
 90 |                     this.logger.log(m.log.message, m.log.level);
 91 |                 }
 92 |                 if (!m.cmd)
 93 |                     return; // this was a log-only message
 94 | 
 95 |                 let isGeneratorActivity = false;
 96 |                 this.logger.verbose(`Received event '${m.cmd}' from template '${this.fileName}'. GenerateCount: ${this.generateCount}. Template activity: ${this.hasSeenProcessMessages}.`);
 97 |                 switch (m.cmd) {
 98 |                     case 'generateStarted':
 99 |                         isGeneratorActivity = true;
100 |                         this.generateCount++;
101 |                         break;
102 |                     case 'generateFinished':
103 |                         isGeneratorActivity = true;
104 |                         this.generateCount--;
105 |                         break;
106 |                     case 'getModel':
107 |                         isGeneratorActivity = true;
108 |                         // The template requested the configured model. If there is one, it is already loaded (and cached) at this point.
109 |                         if (this.modelData == null) {
110 |                             this.logger.warn(`Template '${this.fileName}' has no configured model. Please check the code generation config.`);
111 |                         }
112 |                         let setModelMessage: ISetModelMessage = { cmd: 'setModel', modelData: this.modelData };
113 |                         templateProcess.send(setModelMessage);
114 |                         break;
115 |                     default:
116 |                         break;
117 |                 }
118 | 
119 |                 if (isGeneratorActivity && !this.hasGeneratorActivity) {
120 |                     // This is the first generator activity: start monitoring.
121 | 
122 |                     this.logger.verbose(`Start monitoring template process for '${this.fileName}'.`);
123 |                     this.hasGeneratorActivity = true;
124 |                     this.monitorActiveTemplateProcess(templateProcess);
125 |                     // setTimeout(() => {
126 |                     // }, ACTIVE_PROCESS_POLL_INTERVAL); // gives a double interval the first time (between 'processStarted' and the first 'generateStarted')
127 |                 }
128 |             });
129 |         });
130 |     }
131 | 
132 |     private monitorActiveTemplateProcess(templateProcess: any): void {
133 |         // Monitor the child process.
134 |         var intervalId = setInterval(() => {
135 |             this.logger.verbose(`Checking child process for template '${this.fileName}'. Connected ${templateProcess.connected}, generateCount: ${this.generateCount}`);
136 |             if (!templateProcess.connected) {
137 |                 this.logger.verbose(`Lost connection with template process for '${this.fileName}'.`);
138 |                 clearInterval(intervalId); // the process has already stopped
139 |                 return;
140 |             }
141 |             // The child process is active and connected.
142 |             let shouldDisconnect = this.generateCount === 0;
143 |             if (shouldDisconnect) {
144 |                 if (templateProcess.connected) {
145 |                     this.logger.verbose(`Disconnecting template process for '${this.fileName}'.`);
146 |                     templateProcess.disconnect(); // this will trigger a 'disconnect' event that we handle in run()
147 |                 }
148 |                 clearInterval(intervalId);
149 |             }
150 |         }, ACTIVE_PROCESS_POLL_INTERVAL);
151 |     }
152 | 
153 |     private createTemplateProcess(): any {
154 |         var execArgv = [];
155 | 
156 |         if (this.enableDebugging) {
157 |             // If this process is in debug mode, the forked process will also use process.execArgv - and the same debug port 5858 -. This would result
158 |             // in a "childprocess.fork EADDRINUSE :::5858." So, for debug mode we need to assign a port for each child process.
159 |             const debugArg = this.getDebugProcessArg();
160 |             execArgv.push(debugArg);
161 |         }
162 |         // Determine the working directory of the template process. This must be the directory in which the template resides, so that
163 |         // paths relative to the template are resolved correctly.
164 |         const workingDir = path.dirname(this.fileName);
165 |         // const inheritIO = [0, 1, 2, 'ipc']; // equivalent to [process.stdin, process.stdout, process.stderr] or 'inherit'
166 |         // const pipeIO = ['pipe', 'pipe', 'pipe']; // default
167 |         const options = { env: process.env, silent: false, execArgv: execArgv, cwd: workingDir};
168 |         const processArgs: string[] = [];
169 |         if (this.templateArgs) {
170 |             processArgs.push('--templateArgs');
171 |             processArgs.push(JSON.stringify(this.templateArgs));
172 |         }
173 |         if (this.outputMode){
174 |             processArgs.push('--outputMode');
175 |             processArgs.push(this.outputMode);
176 |         }
177 |         return childProcess.fork(this.fileName, processArgs, options);
178 |     }
179 | 
180 |     private getDebugProcessArg(): string {
181 |         const debugPort = ++TemplateProcess.debugPort;
182 |         let arg: string;
183 | 
184 |         // The inspector protocol is supported as of Node >= 6.3.
185 |         // The legacy debugger has been deprecated as of Node 7.7.0 (https://nodejs.org/en/docs/guides/debugging-getting-started/).
186 |         // 'debug-brk' and 'inspect-brk' stops the process at the first line until a debugger is attached
187 |         if (TemplateProcess.useLegacyDebugProtocol) {
188 |             // legacy: the original V8 Debugger Protocol
189 |             this.logger.warn(`Using the legacy V8 debugger protocol because the current node.js version is ${process.version}.`);
190 |             arg = `--debug-brk=${debugPort}`;
191 |         }
192 |         else {
193 |             // inspector: the new V8 Inspector Protocol
194 |             arg = `--inspect-brk=${debugPort}`;
195 |         }
196 | 
197 |         this.logger.info(`Waiting for debugger to attach on port ${debugPort}...`);
198 |         // console.log(`In Visual Studio 2015 or later, press CTRL+ALT+P, select Node.js remote debugging and use qualifier tcp://localhost:${debugPort}#ping=0`);
199 |         // console.log(`In Visual Studio Code, start debugging (type: 'node') using request type 'attach' and set the port to ${debugPort}.`);
200 |         return arg;
201 |     }
202 | }
203 | 
204 | // Start static initialization
205 | TemplateProcess.initialise();


--------------------------------------------------------------------------------
/src/template-runner.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2019 Yellicode
  3 |  *
  4 |  * This Source Code Form is subject to the terms of the Mozilla Public
  5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
  6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  7 |  */
  8 | const fs = require('fs');
  9 | const path = require('path');
 10 | const childProcess = require('child_process'); // or import { ChildProcess } from 'child_process'; ??;
 11 | const process = require('process');
 12 | import * as ts from "typescript";
 13 | import * as _ from 'lodash';
 14 | import { Logger } from '@yellicode/core';
 15 | import { Compiler } from "./compiler";
 16 | import { TemplateProcess } from "./template-process";
 17 | import { ConfigStore } from "./config-store";
 18 | import { PathUtility } from "./path-utility";
 19 | 
 20 | export class TemplateRunner {
 21 |     private runningTemplates: { [templateId: string]: ITemplateInfo } = {};
 22 | 
 23 |     constructor(
 24 |         private configStore: ConfigStore,
 25 |         private modelStore: IModelStore,
 26 |         private logger: Logger,
 27 |         private compiler: Compiler,
 28 |         private enableDebugging: boolean,
 29 |         private isWatching: boolean) {
 30 | 
 31 |     }
 32 | 
 33 |     public runAll(): Promise<void> {
 34 |         this.logger.verbose('Running all templates...')
 35 |         return this.runTemplatesGroupedByConfigFile(this.configStore.listAllTemplates());
 36 |     }
 37 | 
 38 |     public runTemplatesUsingModel(fileName: string): Promise<void> {
 39 |         this.logger.verbose(`Running all templates with model '${fileName}'...`)
 40 |         return this.runTemplatesGroupedByConfigFile(this.configStore.listAllTemplatesUsingModel(fileName));
 41 |     }
 42 | 
 43 |     public runTemplatesUsingConfigFile(configFileName: string): Promise<void> {
 44 |         this.logger.verbose(`Running all templates in config file '${configFileName}'...`)
 45 |         const compilationConfig = this.configStore.getTemplateCompilationConfig(configFileName);
 46 |         return this.runTemplatesFromTemplateInfo(this.configStore.listAllTemplatesFromConfigFile(configFileName), compilationConfig);
 47 |     }
 48 | 
 49 |     private runTemplatesGroupedByConfigFile(templates: ITemplateInfo[]): Promise<void> {
 50 |         var grouped = _.groupBy(templates, 'configFile');
 51 |         const promises: Promise<void>[] = [];
 52 |         for (var configFile in grouped) {
 53 |             const compilationConfig = this.configStore.getTemplateCompilationConfig(configFile);
 54 |             const templates = grouped[configFile];
 55 |             promises.push(this.runTemplatesFromTemplateInfo(templates, compilationConfig));
 56 |         }
 57 | 
 58 |         // Convert Promise<void[]> (Promise.all) to Promise<void>
 59 |         return new Promise<void>((resolve, reject) => {
 60 |             Promise.all(promises).then(() => {
 61 |                 resolve();
 62 |             }, (reason) => {
 63 |                 reject(reason);
 64 |             })
 65 |         });
 66 |     }
 67 | 
 68 |     /**
 69 |      *
 70 |      * @param fileName The full path to the template file. The path can have a .js or .ts extension.
 71 |      */
 72 |     public runTemplatesUsingTemplateFile(fileName: string, requireRecompilation: boolean): Promise<void> {
 73 |         if (!fileName)
 74 |             return Promise.reject('FileName is undefined.')
 75 | 
 76 |         fileName = fileName.toLowerCase();
 77 | 
 78 |         // Ensure a .js extension, not .ts or anything else. This may be the case where fileName is passed as a command line argument.
 79 |         fileName = PathUtility.ensureJsExtension(fileName);
 80 | 
 81 |         // Lookup the template info
 82 |         var templateInfos = this.configStore.listAllTemplateUsingTemplateFile(fileName);
 83 |         if (templateInfos.length == 0) {
 84 |             this.logger.error(`Could not find configuration for template '${fileName}'. Please make sure that you provide a configured template path.`);
 85 |             return Promise.resolve(); // fail silently
 86 |         }
 87 | 
 88 |         // Force recompilation (because this function is called when a template file changes)
 89 |         if (requireRecompilation) {
 90 |             templateInfos.forEach(ti => {
 91 |                 if (ti.requiresCompilation) {
 92 |                     ti.isCompiled = false
 93 |                 };
 94 |             })
 95 |         }
 96 | 
 97 |         return this.runTemplatesGroupedByConfigFile(templateInfos);
 98 |     }
 99 | 
100 |     public runTemplateFromTemplateInfo(templateInfo: ITemplateInfo): Promise<void> {
101 |         const compilationConfig = this.configStore.getTemplateCompilationConfig(templateInfo.configFile);
102 |         return this.runTemplatesFromTemplateInfo([templateInfo], compilationConfig);
103 |     }
104 | 
105 |     private runTemplatesFromTemplateInfo(templateInfos: ITemplateInfo[], compilationConfig: ITemplateCompilationConfig): Promise<void> {
106 |         if (templateInfos.length === 0) return Promise.resolve();
107 | 
108 |         const templatesToRun: ITemplateInfo[] = [];
109 | 
110 |         // If debugging: we can only debug one template at a time, so: the first file with debug:true, or otherwise just the first file. .
111 |         if (this.enableDebugging) {
112 |             let debugTarget = templateInfos.find(ti => ti.debug === true);
113 |             if (!debugTarget) debugTarget = templateInfos[0]; // also needed when running using --debug-template --template 'myfileName'
114 |             templateInfos = [debugTarget];
115 |         }
116 | 
117 |         // Manage which templates are running
118 |         templateInfos.forEach((ti) => {
119 |             if (this.runningTemplates.hasOwnProperty(ti.id)) {
120 |                 this.logger.verbose(`Template '${ti.id}' is already running.`);
121 |             } else {
122 |                 if (fs.existsSync(ti.originalTemplateFile)) {
123 |                     this.runningTemplates[ti.id] = ti;
124 |                     templatesToRun.push(ti);
125 |                 }
126 |                 // If a template doesn't exist, yield an error and don't include it
127 |                 else this.logger.error(`Template file '${ti.originalTemplateFile}' not found.`);
128 |             }
129 |         });
130 | 
131 |         if (templatesToRun.length === 0) {
132 |             // All templates are already running. This might happen if multiple file changes
133 |             // are triggered within a very short timespan.
134 |             return Promise.resolve();
135 |         }
136 | 
137 |         return this.compileTemplates(templatesToRun, compilationConfig)
138 |             .then((result: ICompileResult) => {
139 |                 return this.runCompiledTemplates(templatesToRun);
140 |             })
141 |             .then(() => {
142 |                 // this.logger.verbose('All templates done, updating run status.')
143 |                 templatesToRun.forEach(ti => { delete this.runningTemplates[ti.id]; });
144 |             });
145 |     }
146 | 
147 |     private compileTemplates(templates: ITemplateInfo[], typeScriptConfig: ITemplateCompilationConfig): Promise<ICompileResult> {
148 |         if (!typeScriptConfig.compile)
149 |             return Promise.resolve<ICompileResult>({ success: true });
150 | 
151 |         const templatesToCompile = _.filter(templates, t => t.requiresCompilation && !t.isCompiled);
152 | 
153 |         if (templatesToCompile.length === 0) {
154 |             this.logger.verbose(`Not compiling templates because all templates are up to date.`);
155 |             return Promise.resolve<ICompileResult>({ success: true });
156 |         }
157 | 
158 |         let templateFiles = templatesToCompile.map(ti => { return ti.originalTemplateFile; });
159 |         // If multiple instances of a template file are configured (which is ok), templatesToCompile contains multiple TemplateInfos pointing
160 |         // to the same file. Note: do not filter templatesToCompile, because we update isCompiled for each instance.
161 |         templateFiles = _.uniqBy(templateFiles, f => {return f.toLowerCase();});
162 | 
163 |         let compilerPromise: Promise<ICompileResult>;
164 |         const templateLoggingInfo = templateFiles.length === 1 ? `template file '${templateFiles[0]}'` : `${templateFiles.length} template files`;
165 |         const tsConfigPath = typeScriptConfig.typeScriptConfigFile;
166 |         if (tsConfigPath != null && fs.existsSync(tsConfigPath)) {
167 |             this.logger.info(`Compiling ${templateLoggingInfo} using TypeScript configuration ${tsConfigPath}...`);
168 |             compilerPromise = this.compiler.compileWithTsConfigFile(templateFiles, tsConfigPath);
169 |         } else {
170 |             this.logger.info(`Compiling ${templateLoggingInfo} using default TypeScript configuration...`);
171 |             compilerPromise = this.compiler.compile(templateFiles);
172 |         }
173 |         return compilerPromise.then((result) => {
174 |             // Mark each template as compiled, even if not succesful, the log will report any compilation errors and
175 |             // isCompiled will be reset once the user updates the template.
176 |             templatesToCompile.forEach(ti => ti.isCompiled = true);
177 |             if (!result.success) {
178 |                 this.logger.warn(`Compilation of one or more templates has failed. See the console for details.`);
179 |             }
180 |             return result;
181 |         });
182 |     }
183 | 
184 |     private runCompiledTemplates(templates: ITemplateInfo[]): Promise<void> {
185 |         this.logger.info(`Running ${templates.length} templates...`);
186 |         const promises: Promise<void>[] = [];
187 |         // Create a promise for each template to run. If one fails, the others should continue,
188 |         // so just catch and log.
189 |         templates.forEach((t) => {
190 |             promises.push(this.runCompiledTemplate(t).catch((reason) => {
191 |                 this.logger.error(`Failed running template '${t.templateFile}': ${reason}`);
192 |             }));
193 |         });
194 | 
195 |         return new Promise<void>((resolve, reject) => {
196 |             Promise.all(promises).then(() => {
197 |                 this.logger.info(this.isWatching ? 'Code generation done. Watching for changes.' : 'Code generation done.');
198 |                 resolve();
199 |             });
200 |         });
201 |     }
202 | 
203 |     private runCompiledTemplate(templateInfo: ITemplateInfo): Promise<void> {
204 |         let promise: Promise<void>;
205 |         if (templateInfo.modelFile == null) {
206 |             promise = this.runTemplateProcess(templateInfo, null);
207 |         } else {
208 |             promise = this.modelStore.loadModel(templateInfo.modelFile)
209 |                 .then((model: any) => {
210 |                     //console.info("Promise (runCompiledTemplate): loadModel suceeded. Calling runTemplateProcess...");
211 |                     return this.runTemplateProcess(templateInfo, model);
212 |                 });
213 |         }
214 |         return promise;
215 |     }
216 | 
217 |     private runTemplateProcess(templateInfo: ITemplateInfo, model: any): Promise<void> {
218 |         const fileName: string = templateInfo.templateFile;
219 | 
220 |         if (!fs.existsSync(fileName)) {
221 |             return Promise.reject(`Template file '${fileName}' not found.`);
222 |         }
223 | 
224 |         const templateProcess = new TemplateProcess(fileName, model, this.logger, this.enableDebugging, templateInfo.templateArgs, templateInfo.outputMode);
225 |         this.logger.verbose(`Running template '${fileName}'...`);
226 |         return templateProcess.run(templateInfo.connectionTimeout);
227 |     }
228 | }


--------------------------------------------------------------------------------
/src/yellicode-constants.ts:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2019 Yellicode
 3 |  *
 4 |  * This Source Code Form is subject to the terms of the Mozilla Public
 5 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 6 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 7 |  */
 8 | export const YELLICODE_SECTION_NAME = 'com_yellicode';
 9 | export const YELLICODE_MODEL_NAME = 'model';
10 | export const YELLICODE_DOCUMENT_EXTENSION = '.ymn';
11 | export const YELLICODE_CONFIG_FILE = 'codegenconfig.json';


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "target": "es5",
 4 |         "module": "commonjs",
 5 |         "outDir": "dist/es5",
 6 |         "inlineSourceMap": true,
 7 |         "removeComments": true,
 8 |         "strict": true,
 9 |         "lib": [
10 |             "es2015",
11 |             "dom"
12 |         ]
13 |     }
14 | }


--------------------------------------------------------------------------------