pomy/tasks/config.js

Based on the concept of a project object model (POM), POMY can manage a project's build, reporting and documentation from a central piece of information.

'use strict';

var
  gulp = require('gulp'),
  gutil = require('gulp-util'),
  rc = require('rc'),
  fs = require('fs'),
  util = require('util'),
  path = require('path'),
  config = require('config-file'),
  rename = require('gulp-rename'),
  jeditor = require("gulp-json-editor"),
  minimist = require('minimist'),
  git = require('gulp-git'),
  normalize = {
    "images": [
      "*.jpeg",
      "*.png",
      "*.jpg",
      "*.gif"
    ],
    "fonts": [
      "*.eot",
      "*.otf",
      "*.svg",
      "*.ttf",
      "*.woff",
      "*.woff2"
    ],
    "js": [
      "*.js"
    ],
    "css": [
      "*.css",
      "*.css.map"
    ],
    "less": [
      "*.less"
    ],
    "sass": [
      "*.sass"
    ],
    "scss": [
      "*.scss"
    ]
  },
  gitProperties = {};

global.getVersion = function(version) {
  version = version || "" + global.settings.version;
  var vs = version.split(".");
  if (vs.length > 3) {
    vs.splice(3, vs.length - 3);
  }
  return vs.join(".");
};

global.getConfigSettings = function() {
  var settings = util._extend({}, global.settings);

  settings.version = global.getVersion();

  delete settings._src;
  delete settings._dest;
  delete settings._testunit;
  delete settings._target;
  delete settings.env;
  delete settings.cwd;

  return settings;
};

global.getPackageSettings = function() {
  var settings = global.getConfigSettings();

  delete settings.resolutions;
  delete settings.overrides;
  delete settings.deploy;
  delete settings.site;
  delete settings.plugins;
  delete settings.params;
  delete settings.online;
  delete settings.manual;
  delete settings.owner;
  delete settings.proxy;
  delete settings.servletPath;
  delete settings.skin;
  delete settings.debug;
  delete settings.loglevel;
  delete settings.target;
  delete settings.snapshort;
  delete settings.organization;
  delete settings.contributors;
  delete settings.developers;
  delete settings.googleWebmasterMeta;
  delete settings.repositoryManager;
  delete settings.homepage;
  delete settings.bugs;
  delete settings.repository;
  delete settings.keywords;
  delete settings.define;
  delete settings.title;
  delete settings.artifact;
  delete settings.group;
  delete settings.main;

  if (settings.repositoryManager !== 'npm') {
    settings.dependencies = {};
  }

  return settings;
};

global.getRootPath = function() {
  var cwd = process.cwd();
  if (/\/node_modules\/pomy(\/?)$/g.test(cwd) ||
    /\\node_modules\\pomy(\\?)$/g.test(cwd) ||
    /\\\\node_modules\\\\pomy(\\\\?)$/g.test(cwd)) {
    return '../../';
  }
  return (minimist(process.argv.slice(2)).process === 'child') ? '../../' : './';
};

global.getPomyPath = function() {
  var cwd = process.cwd();
  if (/\/node_modules\/pomy(\/?)$/g.test(cwd) ||
    /\\node_modules\\pomy(\\?)$/g.test(cwd) ||
    /\\\\node_modules\\\\pomy(\\\\?)$/g.test(cwd)) {
    return './';
  }
  return (minimist(process.argv.slice(2)).process === 'child') ? './' : './node_modules/pomy/';
};

global.getCommandPath = function(cmd) {
  cmd = cmd || "";
  if (fs.existsSync(path.join(global.settings.cwd, "./node_modules/.bin/" + cmd))) {
    return path.resolve(global.settings.cwd, "./node_modules/.bin/" + cmd);
  } else if (fs.existsSync(path.join(global.settings.cwd, "../.bin/" + cmd))) {
    return path.resolve(global.settings.cwd, "../.bin/" + cmd);
  } else if (fs.existsSync(path.join(global.settings.cwd, "../node_modules/.bin/" + cmd))) {
    return path.resolve(global.settings.cwd, "../node_modules/.bin/" + cmd);
  } else {
    return cmd;
  }
};

global.analyzeDep = function(settings, result) {
  if (!result) {
    result = {};
  }

  if (!result.dependencies) {
    result.dependencies = {};
  }

  if (!result.overrides) {
    result.overrides = {};
  }

  var pomy = global.getPomyPath();
  var directory = pomy + 'bower_components';

  for (var name in settings.dependencies) {
    if (result.dependencies[name]) {
      continue;
    }
    result.dependencies[name] = settings.dependencies[name];
    result.overrides = util._extend(result.overrides, settings.overrides);
    global.analyzeDep(config(directory + "/" + name + "/pomy.json") || {}, result);
  }
};

global.loadSettings = function() {
  var localSettings = {},
    settings = {};

  if (fs.existsSync(path.join(global.getRootPath(), "local.json"))) {
    localSettings = config(global.getRootPath() + "local.json") || {};
  }

  settings = config(global.getRootPath() + "pomy.json") || {};

  return util._extend(settings, localSettings);
}

global.settings = global.loadSettings();

var cwd = process.cwd();
global.settings.cwd = /\/node_modules\/pomy(\/?)$/g.test(cwd) ||
  /\\node_modules\\pomy(\\?)$/g.test(cwd) ||
  /\\\\node_modules\\\\pomy(\\\\?)$/g.test(cwd) ? cwd : path.join(cwd, './node_modules/pomy');

global.settings._target = {
  root: 'target',
  classes: 'target/classes',
  site: 'target/site'
};

global.settings._testunit = {
  jsrt: 'jre/src/test',
  js: 'src/test'
};

global.settings._src = {
  root: 'src',
  main: 'src/main',
  fonts: 'src/main/fonts',
  images: 'src/main/images',
  css: 'src/main/css',
  less: 'src/main/less',
  scss: 'src/main/scss',
  sass: 'src/main/sass',
  skin: 'src/main/skin',
  skins: 'src/main/skins',
  js: 'src/main/js',
  template: 'src/main/template',
  jre: 'jre',
  jsrt: 'jre/src/main/js',
  rt: 'jre/src',
  core: 'jre/jsvm.js'
};

global.settings._dest = {
  root: 'classes',
  fonts: 'classes/fonts',
  images: 'classes/images',
  css: 'classes/css',
  skin: 'classes/skin',
  skins: 'classes/skins',
  js: 'classes/js',
  template: 'classes/template',
  jre: 'jre',
  jsrt: 'jre/classes/js',
  rt: 'jre/classes',
  lib: 'lib'
};

gulp.task('config:pom', function() {
  global.settings.env = gutil.env;

  var settings = {},
    _settings = global.settings;

  if (!_settings.deploy) {
    settings.deploy = {
      local: {},
      test: {},
      fat: {},
      uat: {},
      prod: {}
    };
  } else {
    settings.deploy = _settings.deploy;
  }

  if (!_settings.site) {
    settings.site = {};
  } else {
    settings.site = _settings.site;
  }

  if (!settings.deploy[_settings.target]) {
    settings.deploy[_settings.target] = {};
  }

  var ips = gutil.env.ips;
  if (ips) {
    if (typeof ips === 'string') {
      settings.deploy[_settings.target].ips = [ips];
    } else {
      settings.deploy[_settings.target].ips = ips;
    }
  }

  var port = gutil.env.port;
  if (port) {
    settings.deploy[_settings.target].port = port;
  }

  var sitePort = gutil.env.sitePort;
  if (sitePort) {
    settings.site.port = sitePort;
  }

  var syncPort = gutil.env.syncPort;
  if (syncPort) {
    settings.deploy[_settings.target].syncPort = syncPort;
  }

  settings.author = gutil.env.author || _settings.author || '';

  settings.keywords = gutil.env.keywords || _settings.keywords || '';

  settings.googleWebmasterMeta = gutil.env.googleWebmasterMeta || _settings.googleWebmasterMeta || '';

  settings.title = gutil.env.title || _settings.title || '';

  settings.description = gutil.env.description || _settings.description || '';

  util._extend(global.settings, settings);

  var target = (gutil.env.t || gutil.env.target || gutil.env.type || global.settings.target || 'local').toLowerCase();
  var loglevel = (gutil.env.loglevel || '').toLowerCase();
  var skin = (gutil.env.skin || '').toLowerCase();
  switch (target) {
    case "production":
    case "prod":
    case "release":
      global.settings.debug = false;
      global.settings.skin = skin || "default";
      global.settings.loglevel = loglevel || "error";
      global.settings.target = "prod";
      break;
    case "uat":
    case "production_uat":
    case "staging":
      global.settings.debug = false;
      global.settings.skin = skin || "uat";
      global.settings.loglevel = loglevel || "error";
      global.settings.target = "uat";
      break;
    case "fat":
    case "production_fat":
      global.settings.debug = false;
      global.settings.skin = skin || "fat";
      global.settings.loglevel = loglevel || "warn";
      global.settings.target = "fat";
      break;
    case "test":
    case "matrix":
      global.settings.debug = false;
      global.settings.skin = skin || "test";
      global.settings.loglevel = loglevel || "info";
      global.settings.target = "test";
      break;
    case "local":
    case "snapshort":
    default:
      global.settings.debug = true;
      global.settings.skin = skin || "default";
      global.settings.loglevel = loglevel || "debug";
      global.settings.target = "local";
      break;
  }

  var root = global.getRootPath();

  settings.version = global.getVersion();

  return gulp.src([root + "pomy.json"])
    .pipe(jeditor(settings))
    .pipe(gulp.dest(root));
});

gulp.task('config:npm', ['config:pom'], function() {
  var root = global.getRootPath();

  var settings = global.getPackageSettings();

  return gulp.src(root + "package.json")
    .pipe(jeditor(settings))
    .pipe(gulp.dest(root));
});

gulp.task('config:bower', ['config:npm'], function() {
  var root = global.getRootPath();
  var pomy = global.getPomyPath();

  var params = {},
    settings = global.settings;

  if (settings.repositoryManager !== 'npm') {
    if (settings.jre &&
      !settings.dependencies.jre &&
      !settings.devDependencies.jre) {
      settings.dependencies.jre = "^1.0.1";
    }
    // delete global.settings.dependencies.jre;
    // delete global.settings.devDependencies.jre;

    var dependencies = [];
    for (var name in settings.dependencies) {
      dependencies.push(name);
    }
    var overrides = util._extend({
      "normalizeMulti": [{
        "dependencies": dependencies,
        "normalize": normalize
      }]
    }, settings.overrides);

    params = {
      overrides: overrides,
      dependencies: settings.dependencies,
      resolutions: settings.resolutions
    };
  }

  return gulp.src(pomy + "bower.json")
    .pipe(jeditor(function(json) {
      if (params.overrides) {
        json.overrides = params.overrides;
      } else {
        json.overrides = {
          "normalizeMulti": [{
            "dependencies": params.dependencies || [],
            "normalize": normalize
          }]
        };
      }

      if (params.dependencies) {
        json.dependencies = params.dependencies;
      } else {
        json.dependencies = [];
      }

      if (params.resolutions) {
        json.resolutions = params.resolutions;
      } else {
        json.resolutions = {};
      }

      return json;
    }))
    .pipe(gulp.dest(pomy));
});

gulp.task('config:bower-after', function() {
  var root = global.getRootPath();
  var pomy = global.getPomyPath();

  var overrides = null,
    dependencies = null;

  if (global.settings.repositoryManager !== 'npm') {
    var result = {
      dependencies: {},
      overrides: {}
    };

    global.analyzeDep(global.settings, result);

    var deps = [];
    for (var nn in result.dependencies) {
      deps.push(nn);
    }

    overrides = util._extend({
        "normalizeMulti": [{
          "dependencies": deps,
          "normalize": normalize
        }]
      },
      result.overrides);
    dependencies = result.dependencies;
  }

  return gulp.src(pomy + "bower.json")
    .pipe(jeditor(function(json) {
      if (overrides) {
        json.overrides = overrides;
      } else {
        json.overrides = {
          "normalizeMulti": [{
            "dependencies": dependencies || [],
            "normalize": normalize
          }]
        };
      }
      if (dependencies) {
        json.dependencies = dependencies;
      } else {
        json.dependencies = [];
      }
      return json;
    }))
    .pipe(gulp.dest(pomy));
});

gulp.task('config:pm2site', ['config:pom'], function() {
  var settings = global.settings,
    site = settings.site || {},
    ip = site.domain ? site.domain : (site.ips && site.ips.length > 0 ? site.ips[0] : '127.0.0.1');
  var pomy = global.getPomyPath();
  return gulp.src(pomy + "site/startup.json")
    .pipe(jeditor({
      "apps": [{
        "args": [
          "--ip \"", ip,
          "\" --port \"", site.port,
          "\" --target \"", settings.target,
          "\" --debug \"", settings.debug, "\"",
        ].join(""),
        "name": settings.name + ".site"
      }]
    }))
    .pipe(gulp.dest(pomy + "site/"));
});

gulp.task('config:startup-config', ['config:bower'], function() {
  var root = global.getRootPath();
  var pomy = global.getPomyPath();

  var configPath = null;
  if (!fs.existsSync(path.join(root, "startup.json"))) {
    configPath = pomy + "startup.json";
  } else {
    configPath = root + "startup.json";
  }

  var settings = global.settings,
    site = settings.deploy[settings.target] || {},
    ip = site.domain || 'localhost';

  return gulp.src(configPath)
    .pipe(jeditor({
      "apps": [{
        "args": [
          "--ip \"", ip,
          "\" --port \"", site.port,
          "\" --target \"", settings.target,
          "\" --debug \"", settings.debug, "\"",
        ].join(""),
        "name": settings.name
      }]
    }))
    .pipe(gulp.dest(root));
});

gulp.task('config:startup', ['config:startup-config'], function() {
  var root = global.getRootPath();
  var pomy = global.getPomyPath();

  var configPath = [];

  if (fs.existsSync(path.join(root, "startup.js"))) {
    configPath.push(root + "startup.js");
  } else {
    configPath.push(pomy + "startup.js");
  }

  if (!fs.existsSync(path.join(root, "logo.ico"))) {
    configPath.push(pomy + "logo.ico");
  }

  return gulp.src(configPath)
    .pipe(gulp.dest(root));
});

gulp.task('config:pm2', ['config:startup'], function(cb) {
  cb();
});

gulp.task('config:short-commit-id', function(cb) {
  git.revParse({
    args: '--short HEAD'
  }, function(err, branch) {
    gitProperties.shortCommitId = branch;
    cb();
  });
});

gulp.task('config:commit-id', function(cb) {
  git.revParse({
    args: 'HEAD'
  }, function(err, id) {
    gitProperties.commitId = id;
    cb();
  });
});

gulp.task('config:branch', function(cb) {
  git.revParse({
    args: '--abbrev-ref HEAD'
  }, function(err, id) {
    gitProperties.branch = id;
    cb();
  });
});

gulp.task('config:git', ['config:short-commit-id', 'config:commit-id', 'config:branch'], function(cb) {
  cb();
});

gulp.task('config:configure', ['config:pm2', 'config:git'], function() {
  var root = global.getRootPath();

  var settings = {};
  var configPath = null;
  if (fs.existsSync(path.join(global.getRootPath(), "local.json"))) {
    settings = config(global.getRootPath() + "local.json") || {};
    configPath = root + "local.json";
  } else {
    settings = global.getConfigSettings();
    configPath = root + "pomy.json";
  }

  settings.debug = global.settings.debug;
  settings.skin = global.settings.skin;
  settings.loglevel = global.settings.loglevel;
  settings.target = global.settings.target;

  var params = settings.params || global.settings.params;

  if (params && params[settings.target]) {
    util._extend(settings, params[settings.target]);
  }

  var version = gutil.env.update || gutil.env.targetversion || gutil.env.tv || gutil.env.v || gutil.env.version || global.getVersion();
  if (version) {
    settings.version = version;
  }

  var skin = gutil.env.s || gutil.env.skin;
  if (skin) {
    settings.skin = skin;
  }

  if (!settings.repository) {
    settings.repository = {};
  }

  if (settings.snapshort) {
    var sv = gitProperties.shortCommitId || gitProperties.commitId || new Date().getTime().toString(16);
    settings.version = global.getVersion() + "." + sv;
  }

  if (gitProperties.commitId) {
    settings.repository.commitId = gitProperties.commitId;
  }

  if (gitProperties.branch) {
    settings.repository.branch = gitProperties.branch;
  }

  util._extend(global.settings, settings);

  if (global.settings.name) {
    rc(global.settings.name, global.getConfigSettings());
  }

  return gulp.src([configPath])
    .pipe(jeditor(settings))
    .pipe(gulp.dest(root));
});

gulp.task('config', ['config:configure'], function() {
  var root = global.getRootPath(),
    settings = global.settings,
    target = settings.target,
    base = root + settings._src.root;

  return gulp.src([base + "/**/*." + target])
    .pipe(rename(function(path) {
      // path.dirname path.basename path.extname
      path.extname = ".js";
    }))
    .pipe(gulp.dest(base));
});