| /* |
| * Copyright 2000-2013 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.intellij.openapi.diff.impl.processing; |
| |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.diff.impl.string.DiffString; |
| import com.intellij.openapi.diff.ex.DiffFragment; |
| import com.intellij.openapi.diff.impl.ComparisonPolicy; |
| import com.intellij.openapi.diff.impl.highlighting.FragmentSide; |
| import com.intellij.openapi.diff.impl.highlighting.Util; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.util.diff.FilesTooBigForDiffException; |
| import org.jetbrains.annotations.NotNull; |
| |
| import java.util.ArrayList; |
| |
| public interface DiffCorrection { |
| DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException; |
| |
| class TrueLineBlocks implements DiffCorrection, FragmentProcessor<FragmentsCollector> { |
| private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.diff.impl.processing.DiffCorrection.TrueLineBlocks"); |
| private final DiffPolicy myDiffPolicy; |
| @NotNull private final ComparisonPolicy myComparisonPolicy; |
| |
| public TrueLineBlocks(@NotNull ComparisonPolicy comparisonPolicy) { |
| myDiffPolicy = new DiffPolicy.LineBlocks(comparisonPolicy); |
| myComparisonPolicy = comparisonPolicy; |
| } |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| FragmentsCollector collector = new FragmentsCollector(); |
| collector.processAll(fragments, this); |
| return collector.toArray(); |
| } |
| |
| @Override |
| public void process(@NotNull DiffFragment fragment, @NotNull FragmentsCollector collector) throws FilesTooBigForDiffException { |
| DiffString text1 = fragment.getText1(); |
| DiffString text2 = fragment.getText2(); |
| if (!fragment.isEqual()) { |
| if (myComparisonPolicy.isEqual(fragment)) |
| fragment = myComparisonPolicy.createFragment(text1, text2); |
| collector.add(fragment); |
| } else { |
| assert text1 != null; |
| assert text2 != null; |
| DiffString[] lines1 = text1.tokenize(); |
| DiffString[] lines2 = text2.tokenize(); |
| LOG.assertTrue(lines1.length == lines2.length); |
| for (int i = 0; i < lines1.length; i++) |
| collector.addAll(myDiffPolicy.buildFragments(lines1[i], lines2[i])); |
| } |
| } |
| |
| public DiffFragment[] correctAndNormalize(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| return Normalize.INSTANCE.correct(correct(fragments)); |
| } |
| } |
| |
| class ChangedSpace implements DiffCorrection, FragmentProcessor<FragmentsCollector> { |
| private final DiffPolicy myDiffPolicy; |
| private final ComparisonPolicy myComparisonPolicy; |
| |
| public ChangedSpace(ComparisonPolicy policy) { |
| myComparisonPolicy = policy; |
| myDiffPolicy = new DiffPolicy.ByChar(myComparisonPolicy); |
| } |
| |
| @Override |
| public void process(@NotNull DiffFragment fragment, @NotNull FragmentsCollector collector) throws FilesTooBigForDiffException { |
| if (!fragment.isChange()) { |
| collector.add(fragment); |
| return; |
| } |
| DiffString text1 = fragment.getText1(); |
| DiffString text2 = fragment.getText2(); |
| while (StringUtil.startsWithChar(text1, '\n') || StringUtil.startsWithChar(text2, '\n')) { |
| DiffString newLine1 = null; |
| DiffString newLine2 = null; |
| if (StringUtil.startsWithChar(text1, '\n')) { |
| newLine1 = DiffString.create("\n"); |
| text1 = text1.substring(1); |
| } |
| if (StringUtil.startsWithChar(text2, '\n')) { |
| newLine2 = DiffString.create("\n"); |
| text2 = text2.substring(1); |
| } |
| collector.add(new DiffFragment(newLine1, newLine2)); |
| } |
| DiffString spaces1 = text1.getLeadingSpaces(); |
| DiffString spaces2 = text2.getLeadingSpaces(); |
| if (spaces1.isEmpty() && spaces2.isEmpty()) { |
| DiffFragment trailing = myComparisonPolicy.createFragment(text1, text2); |
| collector.add(trailing); |
| return; |
| } |
| collector.addAll(myDiffPolicy.buildFragments(spaces1, spaces2)); |
| DiffFragment textFragment = myComparisonPolicy |
| .createFragment(text1.substring(spaces1.length(), text1.length()), text2.substring(spaces2.length(), text2.length())); |
| collector.add(textFragment); |
| } |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| FragmentsCollector collector = new FragmentsCollector(); |
| collector.processAll(fragments, this); |
| return collector.toArray(); |
| } |
| } |
| |
| interface FragmentProcessor<Collector> { |
| void process(@NotNull DiffFragment fragment, @NotNull Collector collector) throws FilesTooBigForDiffException; |
| } |
| |
| class BaseFragmentRunner<ActualRunner extends BaseFragmentRunner> { |
| private final ArrayList<DiffFragment> myItems = new ArrayList<DiffFragment>(); |
| private int myIndex = 0; |
| private DiffFragment[] myFragments; |
| |
| public void add(DiffFragment fragment) { |
| actualAdd(fragment); |
| } |
| |
| protected final void actualAdd(DiffFragment fragment) { |
| if (isEmpty(fragment)) return; |
| myItems.add(fragment); |
| } |
| |
| public DiffFragment[] toArray() { |
| return myItems.toArray(new DiffFragment[myItems.size()]); |
| } |
| |
| protected int getIndex() { return myIndex; } |
| |
| public DiffFragment[] getFragments() { return myFragments; } |
| |
| public void processAll(DiffFragment[] fragments, FragmentProcessor<ActualRunner> processor) throws FilesTooBigForDiffException { |
| myFragments = fragments; |
| for (;myIndex < myFragments.length; myIndex++) { |
| DiffFragment fragment = myFragments[myIndex]; |
| processor.process(fragment, (ActualRunner)this); |
| } |
| } |
| |
| public static int getTextLength(DiffString text) { |
| return text != null ? text.length() : 0; |
| } |
| |
| public static boolean isEmpty(DiffFragment fragment) { |
| return getTextLength(fragment.getText1()) == 0 && |
| getTextLength(fragment.getText2()) == 0; |
| } |
| |
| } |
| |
| class FragmentsCollector extends BaseFragmentRunner<FragmentsCollector> { |
| public void addAll(DiffFragment[] fragments) { |
| for (int i = 0; i < fragments.length; i++) { |
| add(fragments[i]); |
| } |
| } |
| } |
| |
| class FragmentBuffer extends BaseFragmentRunner<FragmentBuffer> { |
| private int myMark = -1; |
| private int myMarkMode = -1; |
| |
| public void markIfNone(int mode) { |
| if (mode == myMarkMode || myMark == -1) { |
| if (myMark == -1) myMark = getIndex(); |
| } else { |
| flushMarked(); |
| myMark = getIndex(); |
| } |
| myMarkMode = mode; |
| } |
| |
| @Override |
| public void add(DiffFragment fragment) { |
| flushMarked(); |
| super.add(fragment); |
| } |
| |
| protected void flushMarked() { |
| if (myMark != -1) { |
| actualAdd(Util.concatenate(getFragments(), myMark, getIndex())); |
| myMark = -1; |
| } |
| } |
| |
| @Override |
| public void processAll(DiffFragment[] fragments, FragmentProcessor<FragmentBuffer> processor) throws FilesTooBigForDiffException { |
| super.processAll(fragments, processor); |
| flushMarked(); |
| } |
| } |
| |
| class ConcatenateSingleSide implements DiffCorrection, FragmentProcessor<FragmentBuffer> { |
| public static final DiffCorrection INSTANCE = new ConcatenateSingleSide(); |
| private static final int DEFAULT_MODE = 1; |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| FragmentBuffer buffer = new FragmentBuffer(); |
| buffer.processAll(fragments, this); |
| return buffer.toArray(); |
| } |
| |
| @Override |
| public void process(@NotNull DiffFragment fragment, @NotNull FragmentBuffer buffer) { |
| if (fragment.isOneSide()) buffer.markIfNone(DEFAULT_MODE); |
| else buffer.add(fragment); |
| } |
| } |
| |
| class UnitEquals implements DiffCorrection, FragmentProcessor<FragmentBuffer> { |
| public static final DiffCorrection INSTANCE = new UnitEquals(); |
| private static final int EQUAL_MODE = 1; |
| private static final int FORMATTING_MODE = 2; |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| FragmentBuffer buffer = new FragmentBuffer(); |
| buffer.processAll(fragments, this); |
| return buffer.toArray(); |
| } |
| |
| @Override |
| public void process(@NotNull DiffFragment fragment, @NotNull FragmentBuffer buffer) { |
| if (fragment.isEqual()) buffer.markIfNone(EQUAL_MODE); |
| else if (ComparisonPolicy.TRIM_SPACE.isEqual(fragment)) buffer.markIfNone(FORMATTING_MODE); |
| else buffer.add(fragment); |
| } |
| } |
| |
| class Normalize implements DiffCorrection { |
| public static final DiffCorrection INSTANCE = new Normalize(); |
| |
| private Normalize() {} |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| return UnitEquals.INSTANCE.correct(ConcatenateSingleSide.INSTANCE.correct(fragments)); |
| } |
| } |
| |
| class ConnectSingleSideToChange implements DiffCorrection, FragmentProcessor<FragmentBuffer> { |
| public static final ConnectSingleSideToChange INSTANCE = new ConnectSingleSideToChange(); |
| private static final int CHANGE = 1; |
| |
| @Override |
| public DiffFragment[] correct(DiffFragment[] fragments) throws FilesTooBigForDiffException { |
| FragmentBuffer buffer = new FragmentBuffer(); |
| buffer.processAll(fragments, this); |
| return buffer.toArray(); |
| } |
| |
| @Override |
| public void process(@NotNull DiffFragment fragment, @NotNull FragmentBuffer buffer) { |
| if (fragment.isEqual()) buffer.add(fragment); |
| else if (fragment.isOneSide()) { |
| DiffString text = FragmentSide.chooseSide(fragment).getText(fragment); |
| if (StringUtil.endsWithChar(text, '\n')) |
| buffer.add(fragment); |
| else |
| buffer.markIfNone(CHANGE); |
| } else buffer.markIfNone(CHANGE); |
| } |
| } |
| } |
