Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * ====================================================================
   * Copyright (c) 2004-2006 TMate Software Ltd.  All rights reserved.
   *
   * This software is licensed as described in the file COPYING, which
   * you should have received as part of this distribution.  The terms
   * are also available at http://svnkit.com/license.html
   * If newer versions of this license are posted there, you may use a
   * newer version instead, at your option.
  * ====================================================================
  */
 package org.tmatesoft.svn.core.internal.wc;
 
 import java.io.File;
 import java.util.Map;
 import java.util.Set;
 

Author(s):
TMate Software Ltd.
Version:
1.1.0
 
 public class SVNDiffEditor implements ISVNEditor {
 
     private SVNWCAccess myWCAccess;
     private boolean myUseAncestry;
     private boolean myIsReverseDiff;
     private boolean myIsCompareToBase;
     private boolean myIsRootOpen;
     private long myTargetRevision;
     private SVNFileInfo myCurrentFile;
     private SVNAdminAreaInfo myAdminInfo;
     private boolean myIsRecursive;
     private File myTempDirectory;
 
     public SVNDiffEditor(SVNWCAccess wcAccessSVNAdminAreaInfo infoAbstractDiffCallback callback,
             boolean useAncestryboolean reverseDiffboolean compareToBaseboolean recursive) {
          = wcAccess;
          = info;
          = useAncestry;
          = reverseDiff;
          = recursive;
          = compareToBase;
          = callback;
          = new SVNDeltaProcessor();
     }
 
     public void targetRevision(long revisionthrows SVNException {
          = revision;
     }
 
     public void openRoot(long revisionthrows SVNException {
          = true;
          = createDirInfo(null""false);
     }
 
     public void deleteEntry(String pathlong revisionthrows SVNException {
         File fullPath = new File(.getAnchor().getRoot(), path);
         SVNAdminArea dir = .probeRetrieve(fullPath);
         SVNEntry entry = .getEntry(fullPathfalse);
         if (entry == null) {
             return;
         }
         String name = SVNPathUtil.tail(path);
         ..add(name);
         if (! && entry.isScheduledForDeletion()) {
             return;
         }
         if (entry.isFile()) {
             if () {
                 File baseFile = dir.getBaseFile(namefalse);
                 Map baseProps = dir.getBaseProperties(name).asMap();
                 getDiffCallback().fileDeleted(pathbaseFilenullnullnullbaseProps);
             } else {
                reportAddedFile(pathentry);
            }
        } else if (entry.isDirectory()) {
            SVNDirectoryInfo info = createDirInfo(pathfalse);
            reportAddedDir(info);
        }
    }
    
    private void reportAddedDir(SVNDirectoryInfo infothrows SVNException {
        SVNAdminArea dir = retrieve(info.myPath);
        Map wcProps;
        if () {
            wcProps = dir.getBaseProperties(dir.getThisDirName()).asMap();
        } else {
            wcProps = dir.getProperties(dir.getThisDirName()).asMap();
        }
        Map propDiff = computePropsDiff(new HashMap(), wcProps);
        if (!propDiff.isEmpty()) {
            getDiffCallback().propertiesChanged(info.myPathnullpropDiff);
        }
        for(Iterator entries = dir.entries(false); entries.hasNext();) {
            SVNEntry entry = (SVNEntryentries.next();
            if (dir.getThisDirName().equals(entry.getName())) {
                continue;
            }
            if (! && entry.isScheduledForDeletion()) {
                continue;
            }
            if (entry.isFile()) {
                reportAddedFile(info, SVNPathUtil.append(info.myPathentry.getName()), entry);
            } else if (entry.isDirectory() && ) {
                SVNDirectoryInfo childInfo = createDirInfo(info, SVNPathUtil.append(info.myPathentry.getName()), false);
                reportAddedDir(childInfo);
            }
        }
    }
    private void reportAddedFile(SVNDirectoryInfo infoString pathSVNEntry entrythrows SVNException {
        if (entry.isCopied()) {
            if () {
                return;
            }
            reportModifiedFile(infoentry);
            return;
        }
        SVNAdminArea dir = retrieve(info.myPath);
        String name = SVNPathUtil.tail(path);
        Map wcProps = null;
        if () {
            wcProps = dir.getBaseProperties(name).asMap();
        } else {
            wcProps = dir.getProperties(name).asMap();
        }
        String mimeType = (StringwcProps.get(.);
        Map propDiff = computePropsDiff(new HashMap(), wcProps);
        
        File sourceFile;
        if () {
            sourceFile = dir.getBaseFile(namefalse);
        } else {
            sourceFile = detranslateFile(dirname);
        }
        getDiffCallback().fileAdded(pathnullsourceFile, 0, entry.getRevision(), nullmimeTypenullpropDiff);
    }
    
    private void reportModifiedFile(SVNDirectoryInfo dirInfoSVNEntry entrythrows SVNException {
        SVNAdminArea dir = retrieve(dirInfo.myPath);
        String schedule = entry.getSchedule();
        String fileName = entry.getName();
        if (entry.isCopied()) {
            schedule = null;
        }
        if (! && entry.isScheduledForReplacement()) {
            schedule = null;
        }
        Map propDiff = null;
        Map baseProps = null;
        File baseFile = dir.getBaseFile(fileNamefalse);
        if (!entry.isScheduledForDeletion()) {
            boolean modified = dir.hasPropModifications(fileName);
            if (modified) {
                baseProps = dir.getBaseProperties(fileName).asMap();
                propDiff = computePropsDiff(basePropsdir.getProperties(fileName).asMap());
            } else {
                propDiff = new HashMap();
            }
        } else {
            baseProps = dir.getBaseProperties(fileName).asMap();
        }
        boolean isAdded = schedule != null && entry.isScheduledForAddition();
        String filePath = SVNPathUtil.append(dirInfo.myPathfileName);
        if (schedule != null && (entry.isScheduledForDeletion() || entry.isScheduledForReplacement())) {
            String mimeType = dir.getBaseProperties(fileName).getPropertyValue(.);
            getDiffCallback().fileDeleted(filePathbaseFilenullmimeTypenulldir.getBaseProperties(fileName).asMap());
            isAdded = entry.isScheduledForReplacement();
        }
        if (isAdded) {
            String mimeType = dir.getProperties(fileName).getPropertyValue(.);
            
            File tmpFile = detranslateFile(dirfileName);
//            SVNDebugLog.getDefaultLog().info("added");
            getDiffCallback().fileAdded(filePathnulltmpFile, 0, entry.getRevision(), mimeTypenulldir.getBaseProperties(fileName).asMap(), propDiff);
        } else if (schedule == null) {
            boolean modified = dir.hasTextModifications(fileNamefalse);
            File tmpFile = null;
            if (modified) {
                tmpFile = detranslateFile(dirfileName);
            }
//            SVNDebugLog.getDefaultLog().info("modified: " + modified);
            if (modified || (propDiff != null && !propDiff.isEmpty())) {
                String baseMimeType = dir.getBaseProperties(fileName).getPropertyValue(.); 
                String mimeType = dir.getProperties(fileName).getPropertyValue(.);
                getDiffCallback().fileChanged(filePathmodified ? baseFile : nulltmpFileentry.getRevision(), -1, 
                        baseMimeTypemimeTypebasePropspropDiff);
            }
        }
        
    }
    public void addDir(String pathString copyFromPathlong copyFromRevisionthrows SVNException {
         = createDirInfo(pathtrue);
    }
    public void openDir(String pathlong revisionthrows SVNException {
         = createDirInfo(pathfalse);
    }
    public void changeDirProperty(String nameString valuethrows SVNException {
        if (. == null) {
            . = new HashMap();
        }
        ..put(namevalue);
    }
    public void closeDir() throws SVNException {
        // display dir prop changes.
        Map diff = .;
        if (diff != null && !diff.isEmpty()) {
            // reverse changes
            Map originalProps = null;
            if (.) {
                originalProps = new HashMap();
            } else {
                SVNAdminArea dir = retrieve(.);
                if (dir != null && ) {
                    originalProps = dir.getBaseProperties(dir.getThisDirName()).asMap();
                } else {
                    originalProps = dir.getProperties(dir.getThisDirName()).asMap();
                    Map baseProps = dir.getBaseProperties(dir.getThisDirName()).asMap();
                    Map reposProps = new HashMap(baseProps);
                    for(Iterator diffNames = diff.keySet().iterator(); diffNames.hasNext();) {
                        String diffName = (StringdiffNames.next();
                        reposProps.put(diffNamediff.get(diffName));
                    }
                    diff = computePropsDiff(originalPropsreposProps);
                    
                }
            }
            if (!) {
                reversePropChanges(originalPropsdiff);
            }
            getDiffCallback().propertiesChanged(.originalPropsdiff);
            ..add("");
        }
        if (!.) {
            localDirectoryDiff();
        }
        String name = SVNPathUtil.tail(.);
        if ( != null) {
            ..add(name);
        }
    }
    public void addFile(String pathString copyFromPathlong copyFromRevision)
            throws SVNException {
        String name = SVNPathUtil.tail(path);
         = createFileInfo(pathtrue);
    }
    public void openFile(String pathlong revisionthrows SVNException {
        String name = SVNPathUtil.tail(path);
         = createFileInfo(pathfalse);
    }
    public void changeFileProperty(String pathString nameString valuethrows SVNException {
        if (. == null) {
            . = new HashMap();
        }
        ..put(namevalue);
    }
    public void applyTextDelta(String pathString baseChecksumthrows SVNException {
        SVNEntry entry = .getEntry(.getAnchor().getFile(path), false);
        if (entry != null && entry.isCopied()) {
            . = false;
        }
        if (!.) {
            SVNAdminArea dir = retrieve(.);
            String fileName = SVNPathUtil.tail(.);
            . = dir.getBaseFile(fileNamefalse);
        } 
        . = createTempFile();
    }
    public OutputStream textDeltaChunk(String pathSVNDiffWindow diffWindowthrows SVNException {
        return .textDeltaChunk(diffWindow);
    }
    public void textDeltaEnd(String paththrows SVNException {
    }
    public void closeFile(String commitPathString textChecksumthrows SVNException {
        String fileName = SVNPathUtil.tail(.);
        
        File filePath = .getAnchor().getFile(.);
        SVNAdminArea dir = .probeRetrieve(filePath);
        SVNEntry entry = .getEntry(filePathfalse);
        Map baseProperties = null;
        if (.) {
            baseProperties = new HashMap();
        } else {
            baseProperties = dir != null ? dir.getBaseProperties(fileName).asMap() : new HashMap();
        }
        Map reposProperties = new HashMap(baseProperties);
        if (. != null) {
            for(Iterator propNames = ..keySet().iterator(); propNames.hasNext();) {
                String propName = (StringpropNames.next();
                reposProperties.put(propName..get(propName));
            }
        }
        String reposMimeType = (StringreposProperties.get(.);
        File reposFile = .;
        File localFile = null;
        if (reposFile == null) {
            reposFile = dir.getBaseFile(fileNamefalse);
        }
        if (. || (! && entry.isScheduledForDeletion())) {
            if () {
                getDiffCallback().fileAdded(commitPathnullreposFile, 0, nullreposMimeTypenull.);
            } else {
                getDiffCallback().fileDeleted(commitPathreposFilenullreposMimeTypenullreposProperties);
            }
            return;
        }
        boolean modified = . != null;
        if (!modified && !) {
            modified = dir.hasTextModifications(fileNamefalse);
        }
        if (modified) {
            if () {
                localFile = dir.getBaseFile(fileNamefalse);
            } else {
                localFile = detranslateFile(dirfileName);
            }
        } else {
            localFile = null;
            reposFile = null;
        }
        
        Map originalProps = null;
        if () {
            originalProps = baseProperties;
        } else {
            originalProps = dir.getProperties(fileName).asMap();
            . = computePropsDiff(originalPropsreposProperties);
        }
        
        if (localFile != null || (. != null && !..isEmpty())) {
            String originalMimeType = (StringoriginalProps.get(.);
            if (. != null && !..isEmpty() && !) {
                reversePropChanges(originalProps.);
            }
            if (localFile != null || reposFile != null || (. != null && !..isEmpty())) {
                getDiffCallback().fileChanged(commitPath
                         ? localFile : reposFile
                         ? reposFile : localFile
                         ? -1 : ,
                         ?  : -1,
                         ? originalMimeType : reposMimeType
                         ? reposMimeType : originalMimeType,
                        originalProps.);
            }
        }
    }
    public SVNCommitInfo closeEdit() throws SVNException {
        if (!) {
            localDirectoryDiff(createDirInfo(null""false));
        }
        return null;
    }
    
    public void abortEdit() throws SVNException {
    }
    public void absentDir(String paththrows SVNException {
    }
    public void absentFile(String paththrows SVNException {
    }
    public void cleanup() {
        if ( != null) {
            SVNFileUtil.deleteAll(true);
        }
    }
    private void localDirectoryDiff(SVNDirectoryInfo infothrows SVNException {
        if () {
            return;
        }
        SVNAdminArea dir = retrieve(info.myPath);
        boolean anchor = !"".equals(.getTargetName()) && dir == .getAnchor();
        if (!anchor && !info.myComparedEntries.contains("")) {
            // generate prop diff for dir.
            if (dir.hasPropModifications(dir.getThisDirName())) {
                SVNVersionedProperties baseProps = dir.getBaseProperties(dir.getThisDirName());
                Map propDiff = baseProps.compareTo(dir.getProperties(dir.getThisDirName())).asMap();
                getDiffCallback().propertiesChanged(info.myPathbaseProps.asMap(), propDiff);
            }
        }
        Set processedFiles = null;
        if (getDiffCallback().isDiffUnversioned()) {
            processedFiles = new HashSet();
        }
        for (Iterator entries = dir.entries(false); entries.hasNext();) {
            SVNEntry entry = (SVNEntryentries.next();
            
            if (processedFiles != null && !dir.getThisDirName().equals(entry.getName())) {
                processedFiles.add(entry.getName());
            }
            if (anchor && !.getTargetName().equals(entry.getName())) {
                continue;
            }
            if (dir.getThisDirName().equals(entry.getName())) {
                continue;
            }
            if (info.myComparedEntries.contains(entry.getName())) {
                continue;
            }
            info.myComparedEntries.add(entry.getName());
            if (entry.isFile()) {
                reportModifiedFile(infoentry);
            } else if (entry.isDirectory()) {
                if (anchor || ) {
                    SVNDirectoryInfo childInfo = createDirInfo(info, SVNPathUtil.append(info.myPathentry.getName()), false);
                    localDirectoryDiff(childInfo);
                }
            }
        }
        if (getDiffCallback().isDiffUnversioned()) {
            diffUnversioned(dir.getRoot(), diranchorprocessedFiles);
        }
    }
    private void diffUnversioned(File rootSVNAdminArea dirboolean anchorSet processedFilesthrows SVNException {
        File[] allFiles = root.listFiles();
        for (int i = 0; allFiles != null && i < allFiles.lengthi++) {
            File file = allFiles[i];
            if (SVNFileUtil.getAdminDirectoryName().equals(file.getName())) {
                continue;
            }
            if (processedFiles != null && processedFiles.contains(file.getName())) {
                continue;
            }
            if (anchor && !.getTargetName().equals(file.getName())) {
                continue;
            } else if (dir != null) {// && SVNStatusEditor.isIgnored(, name)dir.isIgnored(file.getName())) {
                Collection globalIgnores = SVNStatusEditor.getGlobalIgnores(.getOptions());
                Collection ignores = SVNStatusEditor.getIgnorePatterns(dirglobalIgnores);
                if (SVNStatusEditor.isIgnored(ignoresfile.getName())) {
                    continue;
                }
            }
            // generate patch as for added file.
            SVNFileType fileType = SVNFileType.getType(file);
            if (fileType == .) {
                diffUnversioned(filenullfalsenull);
            } else if (fileType == .) {
                String mimeType1 = null;
                String mimeType2 = SVNFileUtil.detectMimeType(file);
                String filePath = SVNPathUtil.append(dir.getRelativePath(.getAnchor()), file.getName());
                getDiffCallback().fileAdded(filePathnullfile, 0, 0, mimeType1mimeType2nullnull);
            }
        }
    }
    private SVNDirectoryInfo createDirInfo(SVNDirectoryInfo parentString pathboolean added) {
        SVNDirectoryInfo info = new SVNDirectoryInfo();
        info.myParent = parent;
        info.myPath = path;
        info.myIsAdded = added;
        return info;
    }
    private SVNFileInfo createFileInfo(SVNDirectoryInfo parentString pathboolean added) {
        SVNFileInfo info = new SVNFileInfo();
        info.myPath = path;
        info.myIsAdded = added;
        if (parent.myIsAdded) {
            while(parent.myIsAdded) {
                parent = parent.myParent;
            }
            info.myPath = SVNPathUtil.append(parent.myPath"fake");
        }
        return info;
    }
    
    private File detranslateFile(SVNAdminArea dirString namethrows SVNException {
        SVNVersionedProperties properties = dir.getProperties(name);
        String keywords = properties.getPropertyValue(.);
        String eolStyle = properties.getPropertyValue(.);
        boolean special = properties.getPropertyValue(.) != null;
        if (keywords == null && eolStyle == null && (!special || .)) {
            return dir.getFile(name);
        }
        byte[] eol = SVNTranslator.getEOL(eolStyle);
        File tmpFile = createTempFile();
        Map keywordsMap = SVNTranslator.computeKeywords(keywordsnullnullnullnull);
        SVNTranslator.translate(dir.getFile(name), tmpFileeolkeywordsMapspecialfalse);
        return tmpFile;
    }
    
    private File createTempFile() throws SVNException {
        File tmpFile = null;
        try {
            return File.createTempFile("diff."".tmp"getTempDirectory());
        } catch (IOException e) {
            SVNFileUtil.deleteFile(tmpFile);
            SVNErrorMessage err = SVNErrorMessage.create(.e.getMessage());
            SVNErrorManager.error(err);
        }
        return null;
    }
    
    private File getTempDirectory() throws SVNException {
        if ( == null) {
             = getDiffCallback().createTempDirectory();
        }
        return ;
    }
    
    private SVNAdminArea retrieve(String paththrows SVNException {
        File dir = .getAnchor().getFile(path);
        return .retrieve(dir);
    }
    
        return ;
    }
    private static class SVNDirectoryInfo {
        private boolean myIsAdded;
        private String myPath;
        private Map myPropertyDiff;
        private SVNDirectoryInfo myParent;
        private Set myComparedEntries = new HashSet();
    }
    private static class SVNFileInfo {
        private boolean myIsAdded;
        private String myPath;
        private File myFile;
        private File myBaseFile;
        private Map myPropertyDiff;
    }
    private static void reversePropChanges(Map baseMap diff) {
        Collection namesList = new ArrayList(diff.keySet());
        for (Iterator names = namesList.iterator(); names.hasNext();) {
            String name = (Stringnames.next();
            String newValue = (Stringdiff.get(name);
            String oldValue = (Stringbase.get(name);
            if (oldValue == null && newValue != null) {
                base.put(namenewValue);
                diff.put(namenull);
            } else if (oldValue != null && newValue == null) {
                base.put(namenull);
                diff.put(nameoldValue);
            } else if (oldValue != null && newValue != null) {
                base.put(namenewValue);
                diff.put(nameoldValue);
            }
        }
    }
    private static Map computePropsDiff(Map props1Map props2) {
        Map propsDiff = new HashMap();
        for (Iterator names = props2.keySet().iterator(); names.hasNext();) {
            String newPropName = (Stringnames.next();
            if (props1.containsKey(newPropName)) {
                // changed.
                Object oldValue = props2.get(newPropName);
                if (oldValue != null && !oldValue.equals(props1.get(newPropName))) {
                    propsDiff.put(newPropNameprops2.get(newPropName));
                } else if (oldValue == null && props1.get(newPropName) != null) {
                    propsDiff.put(newPropNameprops2.get(newPropName));
                }
            } else {
                // added.
                propsDiff.put(newPropNameprops2.get(newPropName));
            }
        }
        for (Iterator names = props1.keySet().iterator(); names.hasNext();) {
            String oldPropName = (Stringnames.next();
            if (!props2.containsKey(oldPropName)) {
                // deleted
                propsDiff.put(oldPropNamenull);
            }
        }
        return propsDiff;
    }
New to GrepCode? Check out our FAQ X