net.sf.javagimmicks.io.folderdiff.FolderDiffBuilder Maven / Gradle / Ivy

Go to download
package net.sf.javagimmicks.io.folderdiff;

import java.io.File;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

import net.sf.javagimmicks.collections.CollectionDifference;
import net.sf.javagimmicks.collections.diff.Difference;
import net.sf.javagimmicks.collections.diff.DifferenceList;
import net.sf.javagimmicks.collections.diff.DifferenceUtils;
import net.sf.javagimmicks.collections.transformer.Transformer;
import net.sf.javagimmicks.collections.transformer.TransformerUtils;

public class FolderDiffBuilder
{
   private final Comparator PATH_COMPARATOR = FileInfoComparatorBuilder.PATH_INFO_COMPARATOR;
   
   private final File _sourceFolder;
   private final Collection _sourceIncludes = new TreeSet();
   private final Collection _sourceExcludes = new TreeSet();
   
   private final File _targetFolder;
   private final Collection _targetIncludes = new TreeSet();
   private final Collection _targetExcludes = new TreeSet();
   
   private final FileInfoComparatorBuilder _comparatorBuilder = new FileInfoComparatorBuilder();

   private boolean _recursive;
   private FolderDiffListener _listener;

   public FolderDiffBuilder(File sourceFolder, File targetFolder, boolean recursive)
   {
      _sourceFolder = sourceFolder;
      _targetFolder = targetFolder;
      
      _recursive = recursive;
   }

   public FolderDiffBuilder(File sourceFolder, File targetFolder)
   {
      this(sourceFolder, targetFolder, true);
   }
   
   public FolderDiff buildFolderDiff()
   {
      IncludeExcludeFilenameFilter sourceFilter = new IncludeExcludeFilenameFilter(_sourceIncludes, _sourceExcludes);
      FileScanner sourceScanner = new FileScanner(_sourceFolder, sourceFilter, _recursive);
      if(_listener != null)
      {
         sourceScanner.setFolderDiffListener(_listener);
      }
      List sourceFiles = sourceScanner.scan();

      IncludeExcludeFilenameFilter targetFilter = new IncludeExcludeFilenameFilter(_targetIncludes, _targetExcludes);
      FileScanner targetScanner = new FileScanner(_targetFolder, targetFilter, _recursive);
      if(_listener != null)
      {
         targetScanner.setFolderDiffListener(_listener);
      }
      List targetFiles = targetScanner.scan();
      
      SortedSet filesAll = new TreeSet(PATH_COMPARATOR);
      filesAll.addAll(getPathInfoCollection(sourceFiles));
      filesAll.addAll(getPathInfoCollection(targetFiles));

      DifferenceList differences = DifferenceUtils.findDifferences(sourceFiles, targetFiles, _comparatorBuilder.buildComparator());
      
      SortedSet filesDifferent = new TreeSet(PATH_COMPARATOR);
      SortedSet filesSourceOnly = new TreeSet(PATH_COMPARATOR);
      SortedSet filesTargetOnly = new TreeSet(PATH_COMPARATOR);

      for(Difference difference : differences)
      {
         List listDelete = difference.getDeleteList();
         List listAdd = difference.getAddList();
         
         CollectionDifference collectionDifference = new CollectionDifference(listDelete, listAdd);
         
         filesDifferent.addAll(getPathInfoCollection(collectionDifference.getBoth()));
         filesSourceOnly.addAll(getPathInfoCollection(collectionDifference.getOnlyA()));
         filesTargetOnly.addAll(getPathInfoCollection(collectionDifference.getOnlyB()));
      }
      
      
      SortedSet filesEqual = new TreeSet(filesAll);
      filesEqual.removeAll(filesDifferent);
      filesEqual.removeAll(filesSourceOnly);
      filesEqual.removeAll(filesTargetOnly);
      
      return new FolderDiff(
            _sourceFolder, _targetFolder,
            filesAll, filesEqual, filesDifferent, filesSourceOnly, filesTargetOnly);
   }

   public File getSourceFolder()
   {
      return _sourceFolder;
   }

   public Collection getSourceIncludes()
   {
      return _sourceIncludes;
   }

   public Collection getSourceExcludes()
   {
      return _sourceExcludes;
   }

   public File getTargetFolder()
   {
      return _targetFolder;
   }

   public Collection getTargetIncludes()
   {
      return _targetIncludes;
   }

   public Collection getTargetExcludes()
   {
      return _targetExcludes;
   }

   public boolean isRecursive()
   {
      return _recursive;
   }

   public boolean isCompareChecksum()
   {
      return _comparatorBuilder.isCompareChecksum();
   }

   public boolean isCompareLastModified()
   {
      return _comparatorBuilder.isCompareLastModified();
   }

   public boolean isCompareSize()
   {
      return _comparatorBuilder.isCompareSize();
   }
   
   public FolderDiffBuilder addSourceInclude(String pattern)
   {
      _sourceIncludes.add(pattern);
      return this;
   }
   
   public FolderDiffBuilder addSourceExclude(String pattern)
   {
      _sourceExcludes.add(pattern);
      return this;
   }
   
   public FolderDiffBuilder addTargetInclude(String pattern)
   {
      _targetIncludes.add(pattern);
      return this;
   }
   
   public FolderDiffBuilder addTargetExclude(String pattern)
   {
      _targetExcludes.add(pattern);
      return this;
   }
   
   public FolderDiffBuilder addSourceIncludes(Collection patterns)
   {
      _sourceIncludes.addAll(patterns);
      return this;
   }
   
   public FolderDiffBuilder addSourceExcludes(Collection patterns)
   {
      _sourceExcludes.addAll(patterns);
      return this;
   }
   
   public FolderDiffBuilder addTargetIncludes(Collection patterns)
   {
      _targetIncludes.addAll(patterns);
      return this;
   }
   
   public FolderDiffBuilder addTargetExcludes(Collection patterns)
   {
      _targetExcludes.addAll(patterns);
      return this;
   }
   
   public FolderDiffBuilder setRecursive(boolean recursive)
   {
      _recursive = recursive;
      return this;
   }

   public FolderDiffBuilder setCompareChecksum(boolean compareChecksum)
   {
      _comparatorBuilder.setCompareChecksum(compareChecksum);
      return this;
   }

   public FolderDiffBuilder setCompareLastModified(boolean compareLastModified)
   {
      _comparatorBuilder.setCompareLastModified(compareLastModified);
      return this;
   }

   public FolderDiffBuilder setCompareSize(boolean compareSize)
   {
      _comparatorBuilder.setCompareSize(compareSize);
      return this;
   }
   
   public FolderDiffBuilder reset()
   {
      _sourceIncludes.clear();
      _sourceExcludes.clear();
      _targetIncludes.clear();
      _targetExcludes.clear();
      
      setCompareChecksum(false);
      setCompareLastModified(false);
      setCompareSize(false);
      setRecursive(true);
      
      return this;
   }
   
   public FolderDiffBuilder setFolderDiffListener(FolderDiffListener listener)
   {
      _listener = listener;
      _comparatorBuilder.setFolderDiffListener(listener);
      
      return this;
   }
   
   private static Collection getPathInfoCollection(Collection collection)
   {
      return TransformerUtils.decorate(collection, FILE_TO_PATH_INFO);
   }
   
   private static final Transformer FILE_TO_PATH_INFO = new Transformer()
   {
      public PathInfo transform(FileInfo source)
      {
         return source.getPathInfo();
      }
   };
}