The exported modules inside the ./handlers directory, or whatever the 'handlers path' setting is set to
should follow the standard set by the Swaggerize Express project (https://github.com/krakenjs/swaggerize-express).
@param verbExport
@returns {boolean}
175825
function validSwaggerize(handlerObj, verbExport) {
  var self = handlerObj;
  if (_.isFunction(verbExport)) {
    return true;
  }
  //If the verbExport is an array then each item in the array should be a function, if not then emit an error.
  else if (_.isArray(verbExport)) {
    verbExport.forEach(function(item) {
      if (!_.isFunction(item)) {
        //TODO: Do further testing of this error format line.
        self.server.emit('error', nodeUtil.format('Invalid swaggerize method %s', item));
        return false;
      }
    });
  }

  return true;
}
92061
function methodSupportsShorthand(version, method, shorthandType) {
    const mainAlias = getMainAlias(version, method)
    const methodShorthandData = _.get(getMethodData(version), [mainAlias, 'shorthand'])
    return _.isObject(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData)
}
808518
function initHandlebars (config) {
    // load any helpers in the helpers directory
    initHandlebarsHelpers(config)
    // hadlebars config - use reverse of dir list so that local app files
    // override modules and defaults
    var handlebarsConfig = {
        defaultLayout: config.handlebars.defaultLayout,
        ext: config.handlebars.ext,
        helpers: config.handlebars.helpers,
        layoutDirs: _.reverse(config.dir.layouts),
        partialDirs: _.reverse(config.dir.partials),
    }
    // debug handlebars config
    debug('init handlebars:', handlebarsConfig)
    // create new express handlebars engine
    var engine = expressHandlebarsMulti(handlebarsConfig)
    // configure express
    config.express.engine(config.handlebars.ext, engine)
    config.express.set('view engine', config.handlebars.ext)
    // views can be in specific views directories or in apps directories
    var viewsDir = config.dir.views
    var appDir = config.dir.app
    // app directory is also the primary views directory use the reverse
    // so that local app directories override modules and defaults
    config.express.set('views', _.reverse(appDir.concat(viewsDir)))
}
1156188
function looksLikeExport(astNode) {
    return astNode.type === "ExportDefaultDeclaration" || astNode.type === "ExportNamedDeclaration" ||
        astNode.type === "ExportAllDeclaration" || astNode.type === "ExportSpecifier";
}
1369144
function isExpoProject(projPath) {
	try {
		let module = resolveFrom(projPath, "expo");
		let appInfo = require(`${projPath}/app.json`);

		return !!(module && appInfo.expo);
	} catch (err) {
		return false;
	}
}
83042
function processHandler(fn) {
                if (_.isFunction(handler)) {
                    return fn(null, handler);
                }
                if (_.isString(handler)) {
                    return self.processStringHandler(mycro, handler, fn);
                }
                if (_.isObject(handler)) {
                    // make sure the object defines a `handler` attribute
                    if (!handler.handler) {
                        return fn('Unable to locate handler for ' + verb.toUpperCase() + ' ' + path.toString());
                    }
                    // extend options with any route specific options
                    if (handler.options && _.isObject(handler.options)) {
                        _.extend(options.defaultOptions, handler.options);
                    }
                    // allow route to override policy chain
                    if (handler.policies && _.isArray(handler.policies)) {
                        options.defaultPolicies = handler.policies;
                    }
                    // allow route to augment policy chain
                    if (handler.additionalPolicies && _.isArray(handler.additionalPolicies)) {
                        options.defaultPolicies = options.defaultPolicies.concat(handler.additionalPolicies);
                    }
                    if (_.isFunction(handler.handler)) {
                        return fn(null, handler.handler);
                    }
                    if (_.isString(handler.handler)) {
                        return self.processStringHandler(mycro, handler.handler, fn);
                    }
                }
                return fn('Unsupported handler type for '+ verb.toUpperCase() + ' ' + path.toString());
            }
706672
protected boolean routeToAll(RoutedMessage routedTrace, Set<String> logHandlerIds) {

        for (String logHandlerId : logHandlerIds) {
            routeTo(routedTrace, logHandlerId);
        }

        return true; //for now return true. Later we might have a config/flag to check whether to log normally or not.
    }
81465
function run(env) {
  console.log(); // empty line
  var verbfile = env.configPath;

  if (versionFlag && tasks.length === 0) {
    verbLog('CLI version', pkg.version);
    if (env.modulePackage && typeof env.modulePackage.version !== 'undefined') {
      verbLog('Local version', env.modulePackage.version);
    }
  }

  // `node_modules/verb`
  if (!env.modulePath || !fs.existsSync(env.modulePath)) {
    /* deps: verb */
    env.modulePath = resolve.sync('verb');
  }

  // chdir before requiring `verbfile.js` to allow users to chdir as needed
  if (process.cwd() !== env.cwd) {
    process.chdir(env.cwd);
    verbLog('working directory changed to', tildify(env.cwd));
  }

  // require verb
  var verbInst = require(env.modulePath);
  verbInst.extend('argv', argv);
  verbInst.emit('loaded');

  if (!argv._.length && argv.no) {
    exit(0);
  }

  // `verbfile.js`
  if ((hasVerbmd && !hasVerbfile) || !verbfile) {
    verbfile = resolve.sync('verb-default');
    env.configBase = path.dirname(env.configBase);
    require(verbfile)(verbInst);
  } else {
    // this is what actually loads up the verbfile
    require(verbfile);
  }

  verbLog('using verbfile', tildify(verbfile));
  logEvents(verbInst);

  process.nextTick(function () {
    if (simpleTasksFlag) {
      return logTasksSimple(env, verbInst);
    }
    if (tasksFlag) {
      return logTasks(env, verbInst);
    }

    verbInst.run(toRun, function (err) {
      if (err) console.error(err);
    });
  });
}
491348
def is_exported(self):
        
        self.open()
        exp = lvm_vg_is_exported(self.handle)
        self.close()
        return bool(exp)
23792
public boolean isSuffixExportable(String resourceName) {

        if (resourceName == null) {
            return false;
        }
        int pos = resourceName.lastIndexOf('.');
        if (pos >= 0) {
            String suffix = resourceName.substring(pos).toLowerCase();
            return m_exportSuffixes.contains(suffix);
        }
        return false;
    }
513865
function exported (options) {
  var exp = arrayify(options.data.root).find(where({ '!kind': 'module', id: this.id }))
  return exp || this
}
213313
protected boolean routeToAll(String msg, LogRecord logRecord, Set<String> logHandlerIds) {

        boolean logNormally = false;

        for (String id : logHandlerIds) {
            if (id.equals("DEFAULT")) {
                // DEFAULT is still in the list, so we should tell the caller to also log 
                // the message normally.
                logNormally = true;
            } else {
                routeTo(msg, logRecord, id);
            }
        }

        return logNormally;
    }
115124
private CmsModuleImportExportHandler getExportHandler() {

        String moduleName = getParamModule();

        // get the module
        CmsModule module = OpenCms.getModuleManager().getModule(moduleName);

        // create the handler description
        String handlerDescription = Messages.get().getBundle(getLocale()).key(
            Messages.GUI_MODULES_LIST_EXPORT_REPORT_HANDLER_NAME_1,
            moduleName);

        return CmsModuleImportExportHandler.getExportHandler(getCms(), module, handlerDescription);
    }
1359214
function isLocalModule(modulePath) {
  // TODO: handle alias module path like src
  const alias = getModuleResolverAlias();
  return /^\./.test(modulePath) || _.keys(alias).some(a => modulePath === a || _.startsWith(modulePath, a + '/'));
}
635272
function isExportsStatement(expression) {

    var type, object, property;

    type = expression.type;
    object = expression.object;
    property = expression.property;

    return type === 'MemberExpression' && object && object.name === 'exports' && property && property.type === 'Identifier';

}
996097
function MSPassportStrategy(options) {
  Strategy.call(this);
  this.name = "mspassport";
  
  var default_options = {
        protocol : "querystring",
        protocolHandler : function() { self.fail("protocolHandler must be implemented if protocol === 'custom'") }        
  };
    
  this.options = _defaults(default_options, options);
}
123869
function createExport(options) {
  options = Object.assign({}, options, { prepare: false })

  /** we need no styleguide preparation, like asset copying etc. */
  return resolveStyleguide(options)
  .then(function (styleguide) {
    return styleguide.exportStyleguide()
  })
  .catch(function (e) {
    error('Cli.createExport', 'failed to build Styleguide', e)
    throw (e)
  })
    /** create static styleguide structure */
}