Resolves chunk dependency by concatenating them.
420896
def resolve_dependencies(self):
    
    self._concatenate_inner(True)
    self._concatenate_inner(False)
    self._insert_breaklines()
1138075
function parseDependenciesList (root, string) {
  return string.split(/\s+/).reduce(function (accumulator, dependency) {
    if (dependency.length > 0) {
      var absolutePath = path.resolve(root, defaultFileExtension(dependency))
      accumulator.push(absolutePath)
    }
    return accumulator
  }, [])
}
375098
def _chunks(l, ncols):
    """"""
    assert isinstance(ncols, int), "ncols must be an integer"
    for i in range(0, len(l), ncols):
        yield l[i: i+ncols]
382203
public void add(Chunks c) {
        assert c.chunkBits == chunkBits;
        assert c.defaultValue == defaultValue;

        int[][] oChunks = c.chunks;
        if (c.numChunks > numChunks) growTo(c.numChunks-1);
        for (int i = 0; i < oChunks.length; i++) {
            int[] oChunk = oChunks[i];
            if (oChunk!=null) {
                if (chunks[i]==null) {
                    chunks[i]=oChunk.clone();
                } else {
                    int[] chunk = chunks[i];
                    for (int j = 0; j < oChunk.length; j++) {
                        chunk[j] += oChunk[j];
                    }
                }
            }
        }
        this.maxIndex = Math.max(this.maxIndex,c.maxIndex);
    }
446790
def concatenate_slh(self, other):
        """"""
        selfS = self.S
        otherS = other.S
        new_S = block_matrix(
                selfS, zerosm((selfS.shape[0], otherS.shape[1]), dtype=int),
                zerosm((otherS.shape[0], selfS.shape[1]), dtype=int), otherS)
        new_L = vstackm((self.L, other.L))
        new_H = self.H + other.H

        return SLH(new_S, new_L, new_H)
958064
function resolveDependencyPaths(options) {
  function init(items) {
    // Invalid if not Array
    if (Array.isArray(items)) {
      items.forEach((item, idx, items) => {
        const isArray = Array.isArray(item);
        const id = isArray ? item[0] : item;

        // Ignore already resolved
        if ('string' == typeof id) {
          const filepath = dependencies.find(id);

          if (!filepath) return warn(`unable to load plugin ${strong(id)}`, 1);

          if (isArray) {
            item[0] = require(filepath);
          } else {
            items[idx] = require(filepath);
          }
        }
      });
    }
  }

  if (options.plugins) init(options.plugins);
  if (options.presets) init(options.presets);
}
437814
function concat(res, done) {
  const chunks = []
  res
    .on('data', chunk => {
      chunks.push(chunk)
    })
    .on('end', () => {
      done(Buffer.concat(chunks))
    })
}
1115689
def resolve_dependencies(nodes):
    
    done = set()
    while True:
        if len(done) == len(nodes):
            break
        for node in nodes:
            if node.name not in done:
                match = done.intersection(node.requires)
                if len(match) == len(node.requires):
                    done.add(node.name)
                    yield node
                    break
        else:
            raise ConfigException('Invalid requirements in pipeline!')
558526
private static void resolveDependencies(Collection<ArtifactSpec> collection, ShrinkwrapArtifactResolvingHelper helper) {
        // Identify the artifact specs that need resolution.
        // Ideally, there should be none at this point.
        collection.forEach(spec -> {
            if (spec.file == null) {
                // Resolve it.
                ArtifactSpec resolved = helper.resolve(spec);
                if (resolved != null) {
                    spec.file = resolved.file;
                } else {
                    throw new IllegalStateException("Unable to resolve artifact: " + spec.toString());
                }
            }
        });
    }
645111
function addDeps(a, b) {
  if (a && a.cache && b) {
    if (b.cache) {
      a.cache.mergeDeps(b.cache);
    }
    a.cache.addDeps(b.realpath || b);
  }
}
327700
public void addBin(List<Chunk> chunksToAdd, long lastLocus) {
    assert chunks != null;
    contig = new Contig(contig.referenceName, contig.start, lastLocus);
    chunks.addAll(chunksToAdd);
    updateSpan();
  }
359055
function concat(options, callback) {
  var files = options.files.map(function(file, i) {
    return {
      path: node_path.join(lib, file + '.js'),
      index: i
    }
  });

  var contents = [];
  async.each(files, function(task, done) {
    fs.readFile(task.path, function(err, content) {
      if (err) {
        return done(err);
      }

      contents[task.index] = content.toString();
      done(null);
    });

  }, function(err) {
    if (err) {
      return callback(err);
    }

    var intro = options.intro ? options.intro + '\n\n\n' : '';
    var outro = options.outro ? '\n\n\n' + options.outro : '';
    var content = intro + contents.join('\n\n') + outro;
    content = content.replace(/@VERSION/g, concat.version());
    callback(null, content);
  });
}
160782
def _combine(self, original, loc, tokens):
        """"""
        combined_tokens = super(CombineNode, self).postParse(original, loc, tokens)
        internal_assert(len(combined_tokens) == 1, "Combine produced multiple tokens", combined_tokens)
        return combined_tokens[0]
835165
function parseOne(chunk,callback){
	var chunk = parseChunk2String(chunk);
	var firstInclude = hasIncludes(chunk);
	if(firstInclude){
		parseFirstIncludes(chunk,function(newchunk){
			parseOne(newchunk,callback);
		});
	} else {
		callback(chunk);
	}
}
1251611
function logDuplicate(chunk) {
    log(logFlag,
      chalk.black.bgYellow('WARNING') + ' skipping ' +
      chalk.magenta(chunk.data.srcRelativePath) +
      ' as it would output to same path as ' +
      chalk.magenta(buffer[chunk.relative].data.srcRelativePath)
    );
  }
79697
def dependency_resolver(dependencies):
    

    items = dict((key, set(dependencies[key])) for key in dependencies)
    resolved_dependencies = []
    while items:
        batch = set(item for value in items.values() for item in value) - set(items.keys())
        batch.update(key for key, value in items.items() if not value)
        resolved_dependencies.append(batch)
        items = dict(((key, value - batch) for key, value in items.items() if value))
    return resolved_dependencies
1098328
function chunkNameResolver(chunk) {
    var name = null;

    if (chunk.name) {
        name = chunk.name;
    } else {
        var moduleFileName = getLazyModuleFileName(chunk);
        var hash = calcChunkHash(chunk);

        if (moduleFileName) {
            name = moduleFileName + '-' + hash;
        } else {
            name = hash;
        }
    }

    return name;
}