Tool de construction: projet CoffeScript / Nœud avec plusieurs composants

Question

Je commence un projet au travail et je me demandais quel serait l'outil de construction de la meilleure construction.

Le tout est écrit dans CoffeScript, en utilisant Angularjs pour le côté client et Nodejs pour le serveur.

Il existe plusieurs composants à l'application:

• une application iPad
• une application iPhone (fonctionnalité différente de l'iPad)
• un CMS pour les applications
• Un serveur Nodejs

Il y a des tonnes de code partagé entre tous ceux-ci, à nouveau tous écrits dans Coffeescript.

Je voudrais un outil de construction où je peux énumérer quelle application utilise quel code (en grande partie partagée) et créerait les fichiers JavaScript de chaque application dans un dossier séparé.

Par exemple, je confectionnerais un dossier appelé '/ compilé / iPad /' qui a index.html et dossiers pour JS, CSS, IMG, etc. Je voudrais énumérer les fichiers de café compilés que je veux jeté dans / compilé / iPad / JS (une partie de /rsrc/shared/*.coffee, une partie de /rsrc/ipad/*.coffee, etc.) et quels fichiers je veux jeté dans / compilé / iPad / CSS. Je voudrais que cela soit capable de concaténer facilement des fichiers comment je veux aussi.

Il compilait également mes tests, de / src / test / iPad dans / compilé / test / iPad / *. JS.

Tous mes tests d'unité côté client sont écrits avec Testaculaire et je ne sais pas ce que je ' ll Écrivez encore les tests de l'unité côté serveur.

Quel outil de construction / configuration est la meilleure approche ici? Un makefile? Quelque chose comme grogneur? Je suis honnêtement nouveau à toute la scène de construction.

Modifier : a décidé d'aller avec la navigation de navigation. Vous pouvez trouver ma solution pour le faire fonctionner avec angular ici: HTTPS: // Groupes. google.com/forum/#!Topic/angular/ytovaikoccoccoccoccoccous

Answer 1

Je mettrais tout le code partagé dans les modules de nœud.js et créeriez un projet qui ressemble à quelque chose comme ce qui suit:

Project
|~apps/
| |~cms/
| | `-app.js
| |~ipad/
| | `-app.js
| |~iphone/
| | `-app.js
| `~node/
|   `-app.js
|~libs/
| |-module.js
| `-module2.js
|~specs/
| |~cms/
| | `-app.js
| |~ipad/
| | `-app.js
| |~iphone/
| | `-app.js
| `~node/
|   `-app.js
| `~libs/
|   |-module.js
|   `-module2.js
`-Makefile

Je voudrais ensuite utiliser quelque chose comme la navigation de navigation (il y en a d'autres) pour rendre les applications côté client si nécessaire.De cette façon, au lieu d'avoir un fichier de construction où vous dites ce dont vous avez besoin, vous avez réellement d'importants modules d'importation d'applications.

Answer 2

Personnellement, je pense que le lecteur d'écriture d'un code côté serveur dans JavaScript ou Coffeescript s'étend également à votre chaîne d'outils de construction également: alors soyez également à l'aide de JavaScript / Coffeescript aussi. Cela vous permettra d'automatiser facilement vos tâches de serveur / client à partir de votre outil de construction - je doute que ce soit de manière significative possible avec un autre outil tel que faire (vous n'auriez que d'écrire des emballages autour des appels de commandement Node.js). Suggestions, commandées par structure-ness:

• nœud.js : faites simplement rouler vos scripts de construction En JavaScript, et invocez-les avec noeud. Akin aux scripts shell, je suppose. Je ne recommande pas cet itinéraire.
• Jake ou Cake : Je viens du monde de Java, donc ce n'est pas surprenant que ces personnes me rappellent un peu de fourmi. Je préfère CoffeScript et préférez donc le gâteau.
• grogneur : Je n'avais pas entendu parler de cela avant donc je ne peux pas donner beaucoup de conseils. Cela me rappelle Maven, bien sûr ... et je peux simplement dire ... Plus la structure qu'un outil de construction a tendance à appliquer les moins flexibles que cela puisse être. C'est quelque chose d'un compromis. Tant que vous le faites, c'est «l'outil de construction», vous pouvez économiser des tonnes de temps. Mais si vous avez des problèmes spécifiques à l'application, il peut s'agir d'une douleur royale à résoudre.

Bien sûr, vous pouvez utiliser un autre outil de construction que vous connaissez déjà depuis une autre langue: râteau, maven, fourmi, gradle, etc.

Answer 3

J'ai fait presque cette chose exacte dans un fichier de gâteau à l'aide de modules de noeuds au besoin.

Définissez certaines variables globales réalisées avec le chemin de chaque fichier, concaténate ces fichiers dans un fichier dans le répertoire compilé que vous spécifiez, puis compilez qu'un fichier dans JS.

Pour les styles, même chose avec la concaténation sans la compilation, évidemment.

fs = require 'fs'
path = require 'path'
{spawn, exec} = require 'child_process'
parser = require('uglify-js').parser
uglify = require('uglify-js').uglify
cleanCss = require 'clean-css'

coffees = 
 [
  "/src/shared/file1.coffee"
  "/src/shared/file2.coffee"
  "/src/ipad/file1.coffee"
 ]

tests = 
  [
   "/src/ipad/tests.coffee"
  ]

styles = 
 [
  "/src/ipad/styles1.css"
  "/src/shared/styles2.css"
 ]

concatenate = (destinationFile, files, type) ->
  newContents = new Array
  remaining = files.length
  for file, index in files then do (file, index) ->
      fs.readFile file, 'utf8', (err, fileContents) ->
          throw err if err
          newContents[index] = fileContents
          if --remaining is 0
              fs.writeFile destinationFile, newContents.join '\n\n', 'utf8', (err) ->
                throw err if err
              if type is 'styles'
                 minifyCss fileName
              else
                 compileCoffee fileName


 compileCoffee = (file) ->
    exec "coffee -c #{file}", (err) ->
       throw err if err
       # delete coffee file leaving only js
       fs.unlink 'path/specifying/compiled_coffee', (err) -> 
          throw err if err
          minifyJs file

 minifyJs = (file) ->
  fs.readFile f, 'utf8', (err, contents) ->
      ast = parser.parse contents
      ast = uglify.ast_mangle ast 
      ast = uglify.ast_squeeze ast
      minified = uglify.gen_code ast

      writeMinified file, minified

writeMinified = (file, contents) ->
   fs.writeFile file, contents, 'utf8', (err) -> throw err if err  


minifyCss = (file) ->
    fs.readFile file, 'utf8', (err, contents) ->
    throw err if err
    minimized = cleanCss.process contents
    clean = minimized.replace 'app/assets', ''

    fs.writeFile file, clean, 'utf8', (err) ->
        throw err if err


task 'compile_coffees', 'concat, compile, and minify coffees', ->
  concatenate '/compiled/ipad/code.coffee', coffees, 'coffee'

task 'concat_styles', 'concat and minify styles', ->
  concatenate '/compiled/ipad/css/styles.css', styles, 'styles'

task 'compile_tests', 'concat, compile, and minify test', ->
  concatenate '/compiled/ipad/tests.coffee', tests, 'tests'

Maintenant, c'est à peu près ce que je pense que vous demandez.

pourrait certainement être plus joliment, notamment avoir une fonction distincte pour écrire le contenu minifié, mais cela fonctionne.

Pas parfait pour les styles non plus parce que j'avais l'aide de Sass et que j'avais d'autres fonctions avant de toucher la fonction minifiée, mais je pense que vous avez l'idée.