rbbt-rest 1.6.13 → 1.6.14

data/share/views/public/plugins/semantic-ui/tasks/docs/metadata.js

@@ -0,0 +1,137 @@
+
+/*******************************
+           Summarize Docs
+*******************************/
+
+var
+  // node dependencies
+  console      = require('better-console'),
+  fs           = require('fs'),
+  YAML         = require('yamljs')
+;
+
+var data = {};
+
+/**
+ * Test for prefix in string.
+ * @param {string} str
+ * @param {string} prefix
+ * @return {boolean}
+ */
+function startsWith(str, prefix) {
+  return str.indexOf(prefix) === 0;
+};
+
+function inArray(needle, haystack) {
+  var length = haystack.length;
+  for(var i = 0; i < length; i++) {
+      if(haystack[i] == needle) return true;
+  }
+  return false;
+}
+
+/**
+ * Parses a file for metadata and stores result in data object.
+ * @param {File} file - object provided by map-stream.
+ * @param {function(?,File)} - callback provided by map-stream to
+ * reply when done.
+ */
+function parser(file, callback) {
+  // file exit conditions
+  if(file.isNull()) {
+    return callback(null, file); // pass along
+  }
+
+  if(file.isStream()) {
+    return callback(new Error('Streaming not supported'));
+  }
+
+  try {
+
+    var
+      /** @type {string} */
+      text     = String(file.contents.toString('utf8')),
+      lines    = text.split('\n')
+      filename = file.path.substring(0, file.path.length - 4),
+      key      = 'server/documents',
+      position = filename.indexOf(key)
+    ;
+
+    // exit conditions
+    if(!lines) {
+      return;
+    }
+    if(position < 0) {
+      return callback(null, file);
+    }
+
+    filename = filename.substring(position + key.length + 1, filename.length);
+
+    var
+      lineCount = lines.length,
+      active    = false,
+      yaml      = [],
+      categories = [
+        'UI Element',
+        'UI Global',
+        'UI Collection',
+        'UI View',
+        'UI Module',
+        'UI Behavior'
+      ],
+      index,
+      meta,
+      line
+    ;
+
+    for(index = 0; index < lineCount; index++) {
+
+      line = lines[index];
+
+      // Wait for metadata block to begin
+      if(!active) {
+        if(startsWith(line, '---')) {
+          active = true;
+        }
+        continue;
+      }
+      // End of metadata block, stop parsing.
+      if(startsWith(line, '---')) {
+        break;
+      }
+      yaml.push(line);
+    }
+
+
+    // Parse yaml.
+    meta = YAML.parse(yaml.join('\n'));
+    if(meta && meta.type && meta.title && inArray(meta.type, categories) ) {
+      meta.category  = meta.type;
+      meta.filename  = filename;
+      meta.title     = meta.title;
+      // Primary key will by filepath
+      data[filename] = meta;
+    }
+    else {
+      // skip
+      // console.log(meta);
+    }
+
+
+  }
+
+  catch(error) {
+    console.log(error, filename);
+  }
+
+  callback(null, file);
+
+}
+
+/**
+ * Export function expected by map-stream.
+ */
+module.exports = {
+  result : data,
+  parser : parser
+};

data/share/views/public/plugins/semantic-ui/tasks/docs/serve.js

@@ -0,0 +1,255 @@
+/*******************************
+           Serve Docs
+*******************************/
+var
+  gulp         = require('gulp'),
+
+  // node dependencies
+  console      = require('better-console'),
+  fs           = require('fs'),
+
+  // gulp dependencies
+  autoprefixer = require('gulp-autoprefixer'),
+  chmod        = require('gulp-chmod'),
+  clone        = require('gulp-clone'),
+  gulpif       = require('gulp-if'),
+  header       = require('gulp-header'),
+  less         = require('gulp-less'),
+  minifyCSS    = require('gulp-minify-css'),
+  plumber      = require('gulp-plumber'),
+  print        = require('gulp-print'),
+  rename       = require('gulp-rename'),
+  replace      = require('gulp-replace'),
+  uglify       = require('gulp-uglify'),
+  util         = require('gulp-util'),
+  watch        = require('gulp-watch'),
+
+  // user config
+  config       = require('../config/docs'),
+
+  // task config
+  tasks        = require('../config/tasks'),
+  configSetup  = require('../config/project/config'),
+  install      = require('../config/project/install'),
+
+  // shorthand
+  banner       = tasks.banner,
+  comments     = tasks.regExp.comments,
+  log          = tasks.log,
+  settings     = tasks.settings,
+
+  globs,
+  assets,
+  output,
+  source
+;
+
+require('../collections/internal')(gulp);
+
+module.exports = function () {
+
+  // use a different config
+  config = configSetup.addDerivedValues(config);
+
+  // shorthand
+  globs  = config.globs;
+  assets = config.paths.assets;
+  output = config.paths.output;
+  source = config.paths.source;
+
+
+  /*--------------
+     Copy Source
+  ---------------*/
+
+  gulp
+    .watch([
+      'src/**/*.*'
+    ], function(file) {
+      console.clear();
+      return gulp.src(file.path, {
+          base: 'src/'
+        })
+        .pipe(gulp.dest(output.less))
+        .pipe(print(log.created))
+      ;
+    })
+  ;
+
+  /*--------------
+    Copy Examples
+  ---------------*/
+
+  gulp
+    .watch([
+      'examples/**/*.*'
+    ], function(file) {
+      console.clear();
+      return gulp.src(file.path, {
+          base: 'examples/'
+        })
+        .pipe(gulp.dest(output.examples))
+        .pipe(print(log.created))
+      ;
+    })
+  ;
+
+  /*--------------
+      Watch CSS
+  ---------------*/
+
+  gulp
+    .watch([
+      source.config,
+      source.definitions   + '/**/*.less',
+      source.site          + '/**/*.{overrides,variables}',
+      source.themes        + '/**/*.{overrides,variables}'
+    ], function(file) {
+
+      var
+        lessPath,
+
+        stream,
+        compressedStream,
+        uncompressedStream,
+
+        isDefinition,
+        isPackagedTheme,
+        isSiteTheme,
+        isConfig
+      ;
+
+      // log modified file
+      gulp.src(file.path)
+        .pipe(print(log.modified))
+      ;
+
+      /*--------------
+         Find Source
+      ---------------*/
+
+      // recompile on *.override , *.variable change
+      isConfig        = (file.path.indexOf('theme.config') !== -1 || file.path.indexOf('site.variables') !== -1);
+      isPackagedTheme = (file.path.indexOf(source.themes) !== -1);
+      isSiteTheme     = (file.path.indexOf(source.site) !== -1);
+      isDefinition    = (file.path.indexOf(source.definitions) !== -1);
+
+      if(isConfig) {
+        // console.info('Rebuilding all files');
+        // cant rebuild paths are wrong
+        // gulp.start('build-docs');
+        return;
+      }
+      else if(isPackagedTheme) {
+        console.log('Change detected in packaged theme');
+        lessPath = util.replaceExtension(file.path, '.less');
+        lessPath = lessPath.replace(tasks.regExp.theme, source.definitions);
+      }
+      else if(isSiteTheme) {
+        console.log('Change detected in site theme');
+        lessPath = util.replaceExtension(file.path, '.less');
+        lessPath = lessPath.replace(source.site, source.definitions);
+      }
+      else {
+        console.log('Change detected in definition');
+        lessPath = file.path;
+      }
+
+      /*--------------
+        Create CSS
+      ---------------*/
+
+      if( fs.existsSync(lessPath) ) {
+
+        // unified css stream
+        stream = gulp.src(lessPath)
+          .pipe(plumber())
+          .pipe(less(settings.less))
+          .pipe(replace(comments.variables.in, comments.variables.out))
+          .pipe(replace(comments.large.in, comments.large.out))
+          .pipe(replace(comments.small.in, comments.small.out))
+          .pipe(replace(comments.tiny.in, comments.tiny.out))
+          .pipe(autoprefixer(settings.prefix))
+          .pipe(gulpif(config.hasPermission, chmod(config.permission)))
+        ;
+
+        // use 2 concurrent streams from same pipe
+        uncompressedStream = stream.pipe(clone());
+        compressedStream   = stream.pipe(clone());
+
+        uncompressedStream
+          .pipe(plumber())
+          .pipe(replace(assets.source, assets.uncompressed))
+          .pipe(header(banner, settings.header))
+          .pipe(gulp.dest(output.uncompressed))
+          .pipe(print(log.created))
+          .on('end', function() {
+            gulp.start('package uncompressed docs css');
+          })
+        ;
+
+        compressedStream = stream
+          .pipe(plumber())
+          .pipe(replace(assets.source, assets.compressed))
+          .pipe(minifyCSS(settings.minify))
+          .pipe(rename(settings.rename.minCSS))
+          .pipe(header(banner, settings.header))
+          .pipe(gulp.dest(output.compressed))
+          .pipe(print(log.created))
+          .on('end', function() {
+            gulp.start('package compressed docs css');
+          })
+        ;
+
+      }
+      else {
+        console.log('Cannot find UI definition at path', lessPath);
+      }
+    })
+  ;
+
+  /*--------------
+      Watch JS
+  ---------------*/
+
+  gulp
+    .watch([
+      source.definitions   + '/**/*.js'
+    ], function(file) {
+      gulp.src(file.path)
+        .pipe(plumber())
+        .pipe(gulpif(config.hasPermission, chmod(config.permission)))
+        .pipe(gulp.dest(output.uncompressed))
+        .pipe(print(log.created))
+        .pipe(uglify(settings.uglify))
+        .pipe(rename(settings.rename.minJS))
+        .pipe(gulp.dest(output.compressed))
+        .pipe(print(log.created))
+        .on('end', function() {
+          gulp.start('package compressed docs js');
+          gulp.start('package uncompressed docs js');
+        })
+      ;
+    })
+  ;
+
+  /*--------------
+    Watch Assets
+  ---------------*/
+
+  // only copy assets that match component names (or their plural)
+  gulp
+    .watch([
+      source.themes   + '/**/assets/**/' + globs.components + '?(s).*'
+    ], function(file) {
+      // copy assets
+      gulp.src(file.path, { base: source.themes })
+        .pipe(gulpif(config.hasPermission, chmod(config.permission)))
+        .pipe(gulp.dest(output.themes))
+        .pipe(print(log.created))
+      ;
+    })
+  ;
+
+
+};

data/share/views/public/plugins/semantic-ui/tasks/install.js

@@ -0,0 +1,397 @@
+/*******************************
+         Install Task
+*******************************/
+
+/*
+   Install tasks
+
+   For more notes
+
+   * Runs automatically after npm update (hooks)
+   * (NPM) Install - Will ask for where to put semantic (outside pm folder)
+   * (NPM) Upgrade - Will look for semantic install, copy over files and update if new version
+   * Standard installer runs asking for paths to site files etc
+
+*/
+
+var
+  gulp           = require('gulp'),
+
+  // node dependencies
+  console        = require('better-console'),
+  extend         = require('extend'),
+  fs             = require('fs'),
+  mkdirp         = require('mkdirp'),
+  path           = require('path'),
+
+  // gulp dependencies
+  chmod          = require('gulp-chmod'),
+  del            = require('del'),
+  jsonEditor     = require('gulp-json-editor'),
+  plumber        = require('gulp-plumber'),
+  prompt         = require('gulp-prompt'),
+  rename         = require('gulp-rename'),
+  replace        = require('gulp-replace'),
+  requireDotFile = require('require-dot-file'),
+  wrench         = require('wrench'),
+
+  // install config
+  install        = require('./config/project/install'),
+
+  // user config
+  config         = require('./config/user'),
+
+  // release config (name/title/etc)
+  release        = require('./config/project/release'),
+
+  // shorthand
+  questions      = install.questions,
+  files          = install.files,
+  folders        = install.folders,
+  regExp         = install.regExp,
+  settings       = install.settings,
+  source         = install.source
+;
+
+// Export install task
+module.exports = function () {
+
+  var
+    currentConfig = requireDotFile('semantic.json'),
+    manager       = install.getPackageManager(),
+    rootQuestions = questions.root
+  ;
+
+  console.clear();
+
+  /* Test NPM install
+  manager = {
+    name : 'NPM',
+    root : path.normalize(__dirname + '/../')
+  };
+  */
+
+  /*--------------
+      PM Config
+  ---------------*/
+
+  /* Don't do end user config if SUI is a sub-module */
+  if( install.isSubModule() ) {
+    console.info('SUI is a sub-module, skipping end-user install');
+    return;
+  }
+
+  // run update scripts if semantic.json exists
+  if(currentConfig && manager.name === 'NPM') {
+
+    var
+      updateFolder = path.join(manager.root, currentConfig.base),
+      updatePaths  = {
+        config       : path.join(manager.root, files.config),
+        tasks        : path.join(updateFolder, folders.tasks),
+        themeImport  : path.join(updateFolder, folders.themeImport),
+        definition   : path.join(currentConfig.paths.source.definitions),
+        site         : path.join(currentConfig.paths.source.site),
+        theme        : path.join(currentConfig.paths.source.themes),
+        defaultTheme : path.join(currentConfig.paths.source.themes, folders.defaultTheme)
+      }
+    ;
+
+    // duck-type if there is a project installed
+    if( fs.existsSync(updatePaths.definition) ) {
+
+      // perform update if new version
+      if(currentConfig.version !== release.version) {
+        console.log('Updating Semantic UI from ' + currentConfig.version + ' to ' + release.version);
+
+        console.info('Updating ui definitions...');
+        wrench.copyDirSyncRecursive(source.definitions, updatePaths.definition, settings.wrench.overwrite);
+
+        console.info('Updating default theme...');
+        wrench.copyDirSyncRecursive(source.themes, updatePaths.theme, settings.wrench.merge);
+        wrench.copyDirSyncRecursive(source.defaultTheme, updatePaths.defaultTheme, settings.wrench.overwrite);
+
+        console.info('Updating tasks...');
+        wrench.copyDirSyncRecursive(source.tasks, updatePaths.tasks, settings.wrench.overwrite);
+
+        console.info('Updating gulpfile.js');
+        gulp.src(source.userGulpFile)
+          .pipe(plumber())
+          .pipe(gulp.dest(updateFolder))
+        ;
+
+        // copy theme import
+        console.info('Updating theme import file');
+        gulp.src(source.themeImport)
+          .pipe(plumber())
+          .pipe(gulp.dest(updatePaths.themeImport))
+        ;
+
+        console.info('Adding new site theme files...');
+        wrench.copyDirSyncRecursive(source.site, updatePaths.site, settings.wrench.merge);
+
+        console.info('Updating version...');
+
+        // update version number in semantic.json
+        gulp.src(updatePaths.config)
+          .pipe(plumber())
+          .pipe(rename(settings.rename.json)) // preserve file extension
+          .pipe(jsonEditor({
+            version: release.version
+          }))
+          .pipe(gulp.dest(manager.root))
+        ;
+
+        console.info('Update complete! Run "\033[92mgulp build\033[0m" to rebuild dist/ files.');
+
+        return;
+      }
+      else {
+        console.log('Current version of Semantic UI already installed');
+        return;
+      }
+
+    }
+    else {
+      console.error('Cannot locate files to update at path: ', updatePaths.definition);
+      console.log('Running installer');
+    }
+
+  }
+
+  /*--------------
+   Determine Root
+  ---------------*/
+
+  // PM that supports Build Tools (NPM Only Now)
+  if(manager.name == 'NPM') {
+    rootQuestions[0].message = rootQuestions[0].message
+      .replace('{packageMessage}', 'We detected you are using \033[92m' + manager.name + '\033[0m. Nice! ')
+      .replace('{root}', manager.root)
+    ;
+    // set default path to detected PM root
+    rootQuestions[0].default = manager.root;
+    rootQuestions[1].default = manager.root;
+
+    // insert PM questions after "Install Type" question
+    Array.prototype.splice.apply(questions.setup, [2, 0].concat(rootQuestions));
+
+    // omit cleanup questions for managed install
+    questions.cleanup = [];
+  }
+
+  /*--------------
+       Set-up
+  ---------------*/
+
+  return gulp
+    .src('gulpfile.js')
+    .pipe(prompt.prompt(questions.setup, function(answers) {
+
+      /*--------------
+       Exit Conditions
+      ---------------*/
+
+      // if config exists and user specifies not to proceed
+      if(answers.overwrite !== undefined && answers.overwrite == 'no') {
+        return;
+      }
+
+      console.clear();
+      console.log('Installing');
+      console.log('------------------------------');
+
+
+      /*--------------
+            Paths
+      ---------------*/
+
+      var
+        installPaths = {
+          config            : files.config,
+          configFolder      : folders.config,
+          site              : answers.site || folders.site,
+          themeConfig       : files.themeConfig,
+          themeConfigFolder : folders.themeConfig
+        },
+        installFolder = false
+      ;
+
+      /*--------------
+         PM Install
+      ---------------*/
+
+      // Check if PM install
+      if(answers.useRoot || answers.customRoot) {
+
+        // Set root to custom root path if set
+        if(answers.customRoot) {
+          if(answers.customRoot === '') {
+            console.log('Unable to proceed, invalid project root');
+            return;
+          }
+          manager.root = answers.customRoot;
+        }
+
+        // special install paths only for PM install
+        installPaths = extend(false, {}, installPaths, {
+          definition   : folders.definitions,
+          lessImport   : folders.lessImport,
+          tasks        : folders.tasks,
+          theme        : folders.themes,
+          defaultTheme : path.join(folders.themes, folders.defaultTheme),
+          themeImport  : folders.themeImport
+        });
+
+        // add project root to semantic root
+        installFolder = path.join(manager.root, answers.semanticRoot);
+
+        // add install folder to all output paths
+        for(var destination in installPaths) {
+          if( installPaths.hasOwnProperty(destination) ) {
+            // config goes in project root, rest in install folder
+            installPaths[destination] = (destination == 'config' || destination == 'configFolder')
+              ? path.normalize( path.join(manager.root, installPaths[destination]) )
+              : path.normalize( path.join(installFolder, installPaths[destination]) )
+            ;
+          }
+        }
+
+        // create project folders
+        try {
+          mkdirp.sync(installFolder);
+          mkdirp.sync(installPaths.definition);
+          mkdirp.sync(installPaths.theme);
+          mkdirp.sync(installPaths.tasks);
+        }
+        catch(error) {
+          console.error('NPM does not have permissions to create folders at your specified path. Adjust your folders permissions and run "npm install" again');
+        }
+
+        console.log('Installing to \033[92m' + answers.semanticRoot + '\033[0m');
+
+        console.info('Copying UI definitions');
+        wrench.copyDirSyncRecursive(source.definitions, installPaths.definition, settings.wrench.overwrite);
+
+        console.info('Copying UI themes');
+        wrench.copyDirSyncRecursive(source.themes, installPaths.theme, settings.wrench.merge);
+        wrench.copyDirSyncRecursive(source.defaultTheme, installPaths.defaultTheme, settings.wrench.overwrite);
+
+        console.info('Copying gulp tasks');
+        wrench.copyDirSyncRecursive(source.tasks, installPaths.tasks, settings.wrench.overwrite);
+
+        // copy theme import
+        console.info('Adding theme files');
+        gulp.src(source.themeImport)
+          .pipe(plumber())
+          .pipe(gulp.dest(installPaths.themeImport))
+        ;
+        gulp.src(source.lessImport)
+          .pipe(plumber())
+          .pipe(gulp.dest(installPaths.lessImport))
+        ;
+
+        // create gulp file
+        console.info('Creating gulpfile.js');
+        gulp.src(source.userGulpFile)
+          .pipe(plumber())
+          .pipe(gulp.dest(installFolder))
+        ;
+
+      }
+
+      /*--------------
+         Site Theme
+      ---------------*/
+
+      // Copy _site templates folder to destination
+      if( fs.existsSync(installPaths.site) ) {
+        console.info('Site folder exists, merging files (no overwrite)', installPaths.site);
+      }
+      else {
+        console.info('Creating site theme folder', installPaths.site);
+      }
+      wrench.copyDirSyncRecursive(source.site, installPaths.site, settings.wrench.merge);
+
+      /*--------------
+        Theme Config
+      ---------------*/
+
+      var
+        // determine path to site theme folder from theme config
+        // force CSS path variable to use forward slashes for paths
+        pathToSite   = path.relative(path.resolve(installPaths.themeConfigFolder), path.resolve(installPaths.site)).replace(/\\/g,'/'),
+        siteVariable = "@siteFolder   : '" + pathToSite + "/';"
+      ;
+
+      // rewrite site variable in theme.less
+      console.info('Adjusting @siteFolder to: ', pathToSite + '/');
+
+      if(fs.existsSync(installPaths.themeConfig)) {
+        console.info('Modifying src/theme.config (LESS config)', installPaths.themeConfig);
+        gulp.src(installPaths.themeConfig)
+          .pipe(plumber())
+          .pipe(replace(regExp.siteVariable, siteVariable))
+          .pipe(gulp.dest(installPaths.themeConfigFolder))
+        ;
+      }
+      else {
+        console.info('Creating src/theme.config (LESS config)', installPaths.themeConfig);
+        gulp.src(source.themeConfig)
+          .pipe(plumber())
+          .pipe(rename({ extname : '' }))
+          .pipe(replace(regExp.siteVariable, siteVariable))
+          .pipe(gulp.dest(installPaths.themeConfigFolder))
+        ;
+      }
+
+      /*--------------
+        Semantic.json
+      ---------------*/
+
+      var
+        jsonConfig = install.createJSON(answers)
+      ;
+
+      // adjust variables in theme.less
+      if( fs.existsSync(files.config) ) {
+        console.info('Extending config file (semantic.json)', installPaths.config);
+        gulp.src(installPaths.config)
+          .pipe(plumber())
+          .pipe(rename(settings.rename.json)) // preserve file extension
+          .pipe(jsonEditor(jsonConfig))
+          .pipe(gulp.dest(installPaths.configFolder))
+        ;
+      }
+      else {
+        console.info('Creating config file (semantic.json)', installPaths.config);
+        gulp.src(source.config)
+          .pipe(plumber())
+          .pipe(rename({ extname : '' })) // remove .template from ext
+          .pipe(jsonEditor(jsonConfig))
+          .pipe(gulp.dest(installPaths.configFolder))
+        ;
+      }
+
+      // Completion Message
+      if(installFolder) {
+        console.log('Install complete! Navigate to \033[92m' + answers.semanticRoot + '\033[0m and run "\033[92mgulp build\033[0m" to build');
+      }
+      else {
+        console.log('');
+        console.log('');
+      }
+
+    }))
+    .pipe(prompt.prompt(questions.cleanup, function(answers) {
+      if(answers.cleanup == 'yes') {
+        del(install.setupFiles);
+      }
+      if(answers.build == 'yes') {
+        gulp.start('build');
+      }
+    }))
+  ;
+
+
+};