How to use

SourceMerger

in

de.matrixweb.smaller.resource

/**
 * @param resolver
 *          The {@link ResourceResolver} to lookup sources
 * @param in
 *          The list of input files
 * @return Returns the merged result
 * @throws IOException
 * @deprecated
 */
@Deprecated
public String merge(final ResourceResolver resolver, final List<String> in)
  throws IOException {
 return merge(getResources(resolver, in));
}

/**
 * @param resolver
 *          The {@link ResourceResolver} to lookup sources
 * @param in
 *          The list of input files
 * @return Returns a {@link List} of resolved {@link Resource}s
 * @throws IOException
 * @deprecated
 */
@Deprecated
public List<Resource> getResources(final ResourceResolver resolver,
  final List<String> in) throws IOException {
 return getSourceFiles(resolver, in);
}

/**
 * @param resolver
 * @param task
 * @return Returns a list of input resources resolved from the given
 *         {@link Task}
 * @throws IOException
 */
@Deprecated
public static Resources createResourceGroup(final ResourceResolver resolver,
  final Task task) throws IOException {
 return createResourceGroupImpl1(resolver,
   new SourceMerger(GlobalOptions.isSourceOnce(task)),
   new ArrayList<String>(Arrays.asList(task.getIn())));
}

private Resource executeSimpleMerge(final VFS vfs, final Resource resource,
  final Map<String, Object> options) throws IOException {
 return resource.getResolver()
   .resolve(
     new SourceMerger("once".equals(options.get("source")) ? true
       : false).getMergedJsonFile(vfs, resource.getResolver(),
       resource.getPath()));
}

/**
 * @see de.matrixweb.smaller.resource.Resource#getContents()
 */
@Override
public String getContents() throws IOException {
 return this.merger.merge(this.resources);
}

 final ResourceResolver resolver, final String in) throws IOException {
final VFile file = vfs.find("/__temp__json__input");
final List<Resource> resources = getJsonSourceFiles(resolver.resolve(in));
VFSUtils.write(file, merge(resources));
return file.getPath();

@Deprecated
private List<Resource> getJsonSourceFiles(final ResourceResolver resolver,
  final Resource resource) throws IOException {
 final List<Resource> list = new ArrayList<Resource>();
 final Set<String> alreadyHandled = new HashSet<String>();
 for (final String s : new ObjectMapper().readValue(resource.getContents(),
   String[].class)) {
  if (!isUniqueFileResolved(alreadyHandled, s)) {
   list.add(resolver.resolve(s));
   alreadyHandled.add(s);
  }
 }
 return list;
}

private static Resources createResourceGroupImpl0(
  final ResourceResolver resolver, final SourceMerger merger,
  final List<String> files) throws IOException {
 return new Resources(merger.getResources(resolver, files));
}

@Deprecated
private List<Resource> getSourceFiles(final ResourceResolver resolver,
  final List<String> in) throws IOException {
 final List<Resource> inputs = new ArrayList<Resource>();
 for (final String s : in) {
  final Resource resource = resolver.resolve(s);
  if (resource.getPath().endsWith("json")) {
   inputs.addAll(getJsonSourceFiles(resource.getResolver(), resource));
  } else {
   inputs.add(resource);
  }
 }
 return inputs;
}

@Deprecated
private void execute1_0(final VFS vfs, final ResourceResolver resolver,
  final Resources resources, final List<ProcessorOptions> entries,
  final Task task) throws IOException {
 for (final ProcessorOptions entry : entries) {
  for (final Type type : Type.values()) {
   final List<Resource> res = resources.getByType(type);
   if (entry.processor.supportsType(type)) {
    LOGGER.info("Executing processor {} for type {}", entry.name, type);
    final List<Resource> results = new ArrayList<Resource>();
    // TODO: SourceMerger should not be required here
    final ResourceGroup group = new ResourceGroup(res, new SourceMerger(
      GlobalOptions.isSourceOnce(task)));
    group.apply(vfs, entry.processor, entry.options);
    results.addAll(group.getResources());
    resources.replace(res, results);
   }
  }
 }
}

/**
 * @param resources
 *          The {@link Resource}s to merge
 * @return Returns the merged resources
 * @throws IOException
 */
public String merge(final List<Resource> resources) throws IOException {
 return this.merge(resources, "\n");
}

private List<Resource> getJsonSourceFiles(final Resource resource)
  throws IOException {
 final List<Resource> list = new ArrayList<Resource>();
 final Set<String> alreadyHandled = new HashSet<String>();
 for (final String s : new ObjectMapper().readValue(resource.getContents(),
   String[].class)) {
  if (!isUniqueFileResolved(alreadyHandled, s)) {
   list.add(resource.getResolver().resolve(s));
   alreadyHandled.add(s);
  }
 }
 return list;
}

/**
 * @param version
 *          The spec version to execute
 * @param resolver
 *          The {@link ResourceResolver} to use for resource resolving
 * @param task
 *          The input {@link Task}
 * @return Returns the resolved input resources
 * @throws IOException
 */
public static Resources createResourceGroup(final Version version,
  final ResourceResolver resolver, final Task task) throws IOException {
 if (version.isAtLeast(Version._1_0_0)) {
  // Since version 1.1.0 no multi-resources
  return createResourceGroupImpl0(resolver,
    new SourceMerger(GlobalOptions.isSourceOnce(task)),
    new ArrayList<String>(Arrays.asList(task.getIn())));
 }
 return createResourceGroup(resolver, task);
}

private Resource executeComplexMerge(final VFS vfs, final Resource resource,
  final Map<String, Object> options) throws IOException {
 final Object typeOption = options.get("type");
 if (!(resource instanceof ResourceGroup) || typeOption != null
   && resource.getType() != Type.valueOf(typeOption.toString())) {
  return resource;
 }
 final ResourceGroup group = (ResourceGroup) resource;
 final Resource input = group.getResources().get(0);
 final VFile snapshot = vfs.stack();
 try {
  final VFile target = vfs.find(input.getPath());
  final Writer writer = VFSUtils.createWriter(target);
  try {
   writer.write(group.getMerger().merge(group.getResources()));
  } finally {
   IOUtils.closeQuietly(writer);
  }
  return input.getResolver().resolve(target.getPath());
 } catch (final IOException e) {
  vfs.rollback(snapshot);
  throw e;
 }
}