Set the filesets from those defined in the provided configuration file. If a given fileset isn't defined then a warning will be output. The `lintOnly` fileset is an optional fileset that will be excluded from the Plato fileset.
338972
function setFilesets(path, done) {
    var config = JSON.parse(fs.readFileSync(path, 'utf8'));

    /* jshint sub: true */
    var includeFiles = config['includeFiles'];
    var excludeFiles = config['excludeFiles'];
    var filterFiles = config['lintOnly'];
    /* jshint sub: false */

    if (filterFiles && !Array.isArray(filterFiles)) {
        filterFiles = [];
        console.log(chalk.yellow('invalid `lintOnly` set; ignoring'));
    }

    if (includeFiles && Array.isArray(includeFiles)) {
        filesets.include(includeFiles, filterFiles);
    } else {
        console.log(chalk.yellow('valid `includeFiles` not found in %s'), path);
    }

    if (excludeFiles && Array.isArray(includeFiles)) {
        filesets.exclude(excludeFiles);
    } else {
        console.log(chalk.yellow('valid `excludeFiles` not found in %s'), path);
    }

    done();
}
187775
public void setIncludes(final String includes) {
    if (this.localSet == null) {
      this.localSet = new ConditionalFileSet();
      this.owner.appendExceptFileSet(this.localSet);
    }
    this.localSet.setIncludes(includes);
  }
319151
def set(*args)
      val = args.pop
      keys = args.flatten
      StorageFile.set(path, [*@parents, *keys], val)
    end
718375
def put_fileset(self, fileset):
        
        target_path = self.fileset_path(fileset)
        if op.isfile(fileset.path):
            shutil.copyfile(fileset.path, target_path)
            # Copy side car files into repository
            for aux_name, aux_path in fileset.format.default_aux_file_paths(
                    target_path).items():
                shutil.copyfile(self.aux_file[aux_name], aux_path)
        elif op.isdir(fileset.path):
            if op.exists(target_path):
                shutil.rmtree(target_path)
            shutil.copytree(fileset.path, target_path)
        else:
            assert False
560713
public void setConfigurationSets(java.util.Collection<ConfigurationSet> configurationSets) {
        if (configurationSets == null) {
            this.configurationSets = null;
            return;
        }

        this.configurationSets = new com.amazonaws.internal.SdkInternalList<ConfigurationSet>(configurationSets);
    }
873906
def describe_file_set(modules):
    
    descriptor = FileSet()
    file_descriptors = []
    for module in modules:
        file_descriptors.append(describe_file(module))

    if file_descriptors:
        descriptor.files = file_descriptors

    return descriptor
1311606
def set(self, id_, lineno, value='', fname=None, args=None):
        
        if fname is None:
            if CURRENT_FILE:
                fname = CURRENT_FILE[-1]
            else:  # If no files opened yet, use owns program fname
                fname = sys.argv[0]
        self.table[id_] = ID(id_, args, value, lineno, fname)
615527
def read_set_from_file(filename: str) -> Set[str]:
    
    collection = set()
    with open(filename, 'r') as file_:
        for line in file_:
            collection.add(line.rstrip())
    return collection
1317132
@Override
	public void configure(Configuration parameters) {

		if (getFilePaths().length == 0) {
			// file path was not specified yet. Try to set it from the parameters.
			String filePath = parameters.getString(FILE_PARAMETER_KEY, null);
			if (filePath == null) {
				throw new IllegalArgumentException("File path was not specified in input format or configuration.");
			} else {
				setFilePath(filePath);
			}
		}

		if (!this.enumerateNestedFiles) {
			this.enumerateNestedFiles = parameters.getBoolean(ENUMERATE_NESTED_FILES_FLAG, false);
		}
	}
966738
public function lintFileList($file_list) {
    $this->say("Linting YAML files...");

    $files = explode("\n", $file_list);

    /** @var \Acquia\Blt\Robo\Filesets\FilesetManager $fileset_manager */
    $fileset_manager = $this->getContainer()->get('filesetManager');
    $fileset_ids = $this->getConfigValue('validate.yaml.filesets');
    $filesets = $fileset_manager->getFilesets($fileset_ids);

    $bin = $this->getConfigValue('composer.bin');
    $command = "'$bin/yaml-cli' lint '%s'";
    foreach ($filesets as $fileset_id => $fileset) {
      $filesets[$fileset_id] = $fileset_manager->filterFilesByFileset($files, $fileset);
    }

    $this->executeCommandAgainstFilesets($filesets, $command);
  }
146732
def setter(self, fset):
        
        self.fset = fset
        self.pipe_write = PipeWriteType.PIPE_READ_WRITE
        return self
535010
def setter(self, fset):
        
        self.fset = fset
        if self.attr_write == AttrWriteType.READ:
            if getattr(self, 'fget', None):
                self.attr_write = AttrWriteType.READ_WRITE
            else:
                self.attr_write = AttrWriteType.WRITE
        return self
1304574
def set_file(self, filename):
        
        filename = os.path.abspath(filename)
        self.set(ConfigSource(load_yaml(filename), filename))
56198
def _run_lint_on_file_stamped_args(file_path,  # suppress(too-many-arguments)
                                   stamp_file_path,
                                   log_technical_terms_to,
                                   linter_functions,
                                   tool_options,
                                   fix_what_you_can):
    """"""
    dictionary_path = os.path.abspath("DICTIONARY")
    dependencies = [file_path]

    if os.path.exists(dictionary_path):
        dependencies.append(dictionary_path)

    kwargs = OrderedDict()
    kwargs["jobstamps_dependencies"] = dependencies
    kwargs["jobstamps_cache_output_directory"] = stamp_file_path

    if log_technical_terms_to:
        kwargs["jobstamps_output_files"] = [log_technical_terms_to]

    return ((file_path,
             linter_functions,
             tool_options,
             fix_what_you_can),
            kwargs)
388559
def setnx(*args)
      val = args.pop
      keys = args.flatten
      StorageFile.setnx(path, [*@parents, *keys], val)
    end
772772
def check_set(set=None, family='ipv4'):
    '''
    

    '''
    if not set:
        return 'Error: Set needs to be specified'

    setinfo = _find_set_info(set)
    if not setinfo:
        return False
    return True
970095
def get_ruleset_file(ruleset=None):
    
    ruleset = ruleset or "default"

    ruleset_dirs = get_ruleset_dirs()
    for ruleset_directory in ruleset_dirs:
        possible_ruleset_files = [os.path.join(ruleset_directory, ruleset + ext) for ext in EXTS]

        for ruleset_file in possible_ruleset_files:
            if os.path.isfile(ruleset_file):
                logger.debug("Ruleset file '{}' found.".format(ruleset_file))
                return ruleset_file

    logger.warning("Ruleset with the name '{}' cannot be found at '{}'."
                   .format(ruleset, ruleset_dirs))
    raise ColinRulesetException("Ruleset with the name '{}' cannot be found.".format(ruleset))