Load all inline css files from the file system
@param rootDir
@param apps
197707
function loadInlineCss(rootDir, apps) {
    _.each(apps, function (app, appName) {
        _.each(app.routes, function (route) {
            var filePath = rootDir + '/app/' + appName + '/inline/' + route.name + '.css';
            if (route.inline && fs.existsSync(filePath)) {
                inlineCssCache[appName + '||' + route.name] = fs.readFileSync(filePath, { encoding: 'utf8' });
            }
        });
    });
}
828277
public static void loadApplicationBindings( Application app ) {

		File descDir = new File( app.getDirectory(), Constants.PROJECT_DIR_DESC );
		File appBindingsFile = new File( descDir, APP_BINDINGS_FILE );

		Logger logger = Logger.getLogger( ConfigurationUtils.class.getName());
		Properties props = Utils.readPropertiesFileQuietly( appBindingsFile, logger );
		for( Map.Entry<?,?> entry : props.entrySet()) {
			for( String part : Utils.splitNicely((String) entry.getValue(), "," )) {
				if( ! Utils.isEmptyOrWhitespaces( part ))
					app.bindWithApplication((String) entry.getKey(), part );
			}
		}
	}
481992
function loadTemplates (dirs, options) {
    // require dirs to be array
    if (!Array.isArray(dirs)) {
        dirs = [dirs]
    }
    // templates indexed by absolute file name
    var templates = {}
    // load all templates in all directories
    return Promise.each(dirs, dir => {
        // load all files under dir
        return globby('**/*'+GLOBAL.ext, {
            cwd: dir,
            follow: true,
        })
        // compile templates for files
        .then(files => {
            return loadTemplatesFiles(dir, files, options, templates)
        })
    })
    // resolve with templates
    .then(() => templates)
}
787748
private void addGeneratedCSSResource(FacesContext context, String resourceName, UIViewRoot view) {
        addGeneratedResource(context, resourceName, "javax.faces.resource.Stylesheet", "butterfaces-dist-css", view);
    }
1162202
function loadResources() {
        var resources = {};
        var resourcesDir = path.join(this.injector.rootDir, this.injector.servicesDir + '/resources');


        if (!fs.existsSync(resourcesDir)) {
            return resources;
        }

        var me = this;
        var resourceNames = fs.readdirSync(resourcesDir);

        _.each(resourceNames, function (resourceName) {
            if (resourceName.substring(resourceName.length - 3) !== '.js') {  // only dirs, not js files
                resources[resourceName] = me.injector.loadModule(utils.getCamelCase(resourceName + '.resource'));
            }
        });

        return resources;
    }
986124
function loadResources( state, filePath ) {
	var resourcePath = path.resolve( process.cwd(), filePath );
	return getResources( resourcePath )
		.then( function( list ) {
			return when.all( _.map( _.filter( list ), loadModule.bind( undefined, state ) ) )
				.then( function( lists ) {
					return _.flatten( lists );
				} );
		} );
}
228201
def setup_directories(options)
      @directories = options[:directories] || []
      [
        'app/assets/javascripts',
        'app/assets/stylesheets',
        'app/views/components'
      ].each { |known_dir|
        if !@directories.include?(known_dir) && File.exists?(known_dir)
          @directories << known_dir
        end
      }
    end
1085792
function _loadCmds(dirpath) {
    if (fs.existsSync(dirpath) && fs.statSync(dirpath).isDirectory()) {
      var commandFiles = util.walkSync(dirpath);
      _.each(commandFiles, function(cf) {
        _require(cf);
      });
    } else {
      logger.debug('Directory not found '+dirpath);
      throw new Error('Command directory not found');
    }
  }
584360
private void loadGalleries() {

        CmsRpcAction<List<CmsGalleryFolderBean>> action = new CmsRpcAction<List<CmsGalleryFolderBean>>() {

            @Override
            public void execute() {

                start(200, true);
                List<String> types = new ArrayList<String>();
                for (CmsResourceTypeBean type : m_dialogBean.getTypes()) {
                    types.add(type.getType());
                }

                getGalleryService().getGalleries(types, this);
            }

            @Override
            protected void onResponse(List<CmsGalleryFolderBean> result) {

                m_dialogBean.setGalleries(result);
                m_handler.setGalleriesTabContent(result, m_searchObject.getGalleries());
                m_handler.onGalleriesTabSelection();
                stop(false);
            }
        };
        action.execute();
    }
1050608
public void setRoots(java.util.Collection<Root> roots) {
        if (roots == null) {
            this.roots = null;
            return;
        }

        this.roots = new java.util.ArrayList<Root>(roots);
    }
751895
def setup(self):
        """"""
        super(CleanCSSFilter, self).setup()
        self.root = current_app.config.get('COLLECT_STATIC_ROOT')
253539
function (args) {
            var subModules = args.subModules;
            this._rootModule.loadModules(args.pageId, subModules, args.cb);
        }
840641
public static List<File> createRecipeDirectories( File applicationDirectory ) throws IOException {

		List<File> result = new ArrayList<> ();
		ApplicationLoadResult alr = RuntimeModelIo.loadApplicationFlexibly( applicationDirectory );
		if( alr.getApplicationTemplate() != null ) {
			for( Component c : ComponentHelpers.findAllComponents( alr.getApplicationTemplate())) {
				File directory = ResourceUtils.findInstanceResourcesDirectory( applicationDirectory, c );
				if( ! directory.exists())
					result.add( directory );

				Utils.createDirectory( directory );
			}
		}

		return result;
	}
1191006
protected void addDefaultApps(ContextHandlerCollection parent,
      final String appDir) throws IOException {
    // set up the context for "/logs/" if "hadoop.log.dir" property is defined. 
    String logDir = System.getProperty("hadoop.log.dir");
    if (logDir != null) {
      Context logContext = new Context(parent, "/logs");
      logContext.setResourceBase(logDir);
      logContext.addServlet(StaticServlet.class, "/");
      defaultContexts.put(logContext, true);
    }
    // set up the context for "/static/*"
    Context staticContext = new Context(parent, "/static");
    staticContext.setResourceBase(appDir + "/static");
    staticContext.addServlet(StaticServlet.class, "/*");
    defaultContexts.put(staticContext, true);
  }
1155013
private void processDirectories(final File[] networks) {
        phaseOutput(format("=== %s ===", getApplicationName()));

        ProtoNetwork network = stage1(networks);
        Set<EquivalenceDataIndex> eqs = stage2();

        if (!eqs.isEmpty()) {
            network = stage3(network, eqs);
        }
        stage4(network);
    }
867975
public void setApplications(java.util.Collection<Application> applications) {
        if (applications == null) {
            this.applications = null;
            return;
        }

        this.applications = new java.util.ArrayList<Application>(applications);
    }
38853
function loadAll( state, resourcePath ) {
	var loadActions = [ loadResources( state, resourcePath ) ] || [];
	if ( state.config.modules ) {
		_.each( state.config.modules, function( mod ) {
			var modPath;
			if ( /[\/]/.test( mod ) ) {
				modPath = require.resolve( path.resolve( process.cwd(), mod ) );
			} else {
				modPath = require.resolve( mod );
			}
			loadActions.push( loadModule( state, modPath ) );
		} );
	}
	loadActions.push( loadModule( state, './ahResource' ) );
	return when.all( loadActions );
}