ninjs-lodash/lib/config/settings.old.js

lodash wrapper + utils

/**
 * Settings -> merge(os, env, globals, .folders, .files, config)
 */
'use strict'

const _ = require('lodash')
const path = require('path')
const fs = require('fs-extra')
const deepExtend = require('../libs/deep-extend')
const core = require('../core')

// all setting defaults
let _SETTINGS = {
  "env": require('./env')
}

exports = module.exports = ctor

// load all settings from .folders/.files
let ninjs_settings = loadName('ninjs')
let snapp_settings = loadName('snapp')
let vscode_settings = loadName('vscode')

// merge all settings together into root _.$('') cash <-- see what I did there ;)
_SETTINGS = deepExtend(_SETTINGS, ninjs_settings || {}, snapp_settings || {})

// assign exports and global lodash (_) object
_.assign(exports, _SETTINGS)
_.assign(_, { "$": ctor, "$load": load, "$loadKey": load, "$loadName": loadName })

function _getFile(src) {
  if(!src || !_.isString(src)) return
  let ext = path.parse(src).ext
  let isJson = ext && _.toLower(ext) === '.json' ? true : false
  let isJs = ext && _.toLower(ext) === '.js' ? true : false
  if(!isJson && !isJs) return
  let file = isJson ? _.attempt(fs.readFileSync, src, 'utf8') : _.attempt(require, src)
  if(!file || _.isError(file)) return
  file = isJson ? _.strip(file) : file
  let parsed = isJson ? _.attempt(JSON.parse, file) : file
  return _.isError(parsed) ? file : parsed
}


//getter/setter
function ctor(k, v) {
  let isPaths = k && _.isString(k) && k.indexOf('paths.') === 0 ? true : false
  if(!isPaths) {
    return v ? set(k, v) : get(k)
  } else {
    return getPath.apply(null, _.toArray(arguments))
  }
}

function getPath() {
  let args = _.args(arguments)
  args = _.compact(_.map(args, (str) => {
    if(!str || !_.isString(str) || str === ' ') return
    return str
  }))
  if(!args.length > 0) return ''
  let head = args.shift()
  let src = get(head)
  if(args.length > 0 && src && _.isString(src)) {
    args.unshift(src)
    return path.join.apply(null, args)
  }
  return src
}

//get setting key
function get(k) {
  if(!k || !_.isString(k)) return _SETTINGS
  return _.get(_SETTINGS, k)
}

//set setting key with val (merged if already exists and is plain object {})
function set(k, v) {
  let curr = get(k)
  if(curr && _.isPlainObject(curr) && _.isPlainObject(v)) v = deepExtend(curr, v)
  if(k) _.set(_SETTINGS, k, v)
  if(!k) _SETTINGS = v
  return get(k)
}

// require src and merge with SETTINGS if exists
function load(src, key) {
  if(key) return loadKey(src, key)
  if(!src || !_.isString(src)) return
  let file = _getFile(src)
  if(!file || _.isError(file) || !_.isPlainObject(file)) return
  _SETTINGS = deepExtend(_SETTINGS, file)
  return _SETTINGS
}

function loadKey(src, key) {
  if(!src || !_.isString(src)) return
  if(!key || !_.isString(key)) return
  let file = _getFile(src)
  if(!file || _.isError(file) || !_.isPlainObject(file)) return
  let prop = _.get(_SETTINGS, key) || {}
  let merged = deepExtend(prop, file)
  _SETTINGS[key] = merged
  return _.get(_SETTINGS, key)
}

function loadName(name) {
  if(!name || !_.isString(name)) return
  name = name.indexOf('.') === 0 ? name.substr(1) : name
  let dotname = '.' + name
  let stings = loadKey(path.resolve(__dirname, '..', '..', dotname, 'settings.js'), name)
  stings = loadKey(path.resolve(__dirname, '..', '..', dotname, 'settings.json'), name) || stings
  stings = loadKey(path.join(process.cwd(), dotname, 'settings.js'), name) || stings
  stings = loadKey(path.join(process.cwd(), dotname, 'settings.json'), name) || stings
  return stings
}