Dissolve gerrit-prettify top-level directory

Change-Id: Ibc90240a7275a592a7667737aecabe0622a0233f

java/com/google/gerrit/prettify/BUILD

@@ -0,0 +1,31 @@
+load("//tools/bzl:gwt.bzl", "gwt_module")
+
+gwt_module(
+    name = "client",
+    srcs = glob(["common/**/*.java"]),
+    exported_deps = [
+        "//java/com/google/gerrit/extensions:client",
+        "//java/com/google/gerrit/reviewdb:client",
+        "//java/com/google/gwtexpui/safehtml",
+        "//java/org/eclipse/jgit:Edit",
+        "//java/org/eclipse/jgit:client",
+        "//lib:gwtjsonrpc",
+        "//lib:gwtjsonrpc_src",
+    ],
+    gwt_xml = "PrettyFormatter.gwt.xml",
+    visibility = ["//visibility:public"],
+    deps = ["//lib/gwt:user-neverlink"],
+)
+
+java_library(
+    name = "server",
+    srcs = glob(["common/**/*.java"]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//java/com/google/gerrit/reviewdb:server",
+        "//java/org/eclipse/jgit:server",
+        "//lib:guava",
+        "//lib:gwtjsonrpc",
+        "//lib/jgit/org.eclipse.jgit:jgit",
+    ],
+)

java/com/google/gerrit/prettify/PrettyFormatter.gwt.xml

@@ -0,0 +1,27 @@
+<!--
+ Copyright (C) 2008 The Android Open Source Project
+
+ 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.
+-->
+<module>
+  <replace-with class='com.google.gerrit.prettify.client.PrivateScopeImplIE8'>
+    <when-type-is class='com.google.gerrit.prettify.client.PrivateScopeImpl'/>
+    <any>
+      <when-property-is name="user.agent" value="ie8" />
+    </any>
+  </replace-with>
+
+  <inherits name='com.google.gwt.resources.Resources'/>
+  <inherits name='com.google.gwtexpui.safehtml.SafeHtml'/>
+  <source path='common' />
+</module>

java/com/google/gerrit/prettify/common/EditList.java

@@ -0,0 +1,178 @@
+// Copyright (C) 2009 The Android Open Source Project
+//
+// 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.google.gerrit.prettify.common;
+
+import java.util.Iterator;
+import java.util.List;
+import org.eclipse.jgit.diff.Edit;
+
+public class EditList {
+  private final List<Edit> edits;
+  private final int context;
+  private final int aSize;
+  private final int bSize;
+
+  public EditList(final List<Edit> edits, int contextLines, int aSize, int bSize) {
+    this.edits = edits;
+    this.context = contextLines;
+    this.aSize = aSize;
+    this.bSize = bSize;
+  }
+
+  public List<Edit> getEdits() {
+    return edits;
+  }
+
+  public Iterable<Hunk> getHunks() {
+    return new Iterable<Hunk>() {
+      @Override
+      public Iterator<Hunk> iterator() {
+        return new Iterator<Hunk>() {
+          private int curIdx;
+
+          @Override
+          public boolean hasNext() {
+            return curIdx < edits.size();
+          }
+
+          @Override
+          public Hunk next() {
+            final int c = curIdx;
+            final int e = findCombinedEnd(c);
+            curIdx = e + 1;
+            return new Hunk(c, e);
+          }
+
+          @Override
+          public void remove() {
+            throw new UnsupportedOperationException();
+          }
+        };
+      }
+    };
+  }
+
+  private int findCombinedEnd(int i) {
+    int end = i + 1;
+    while (end < edits.size() && (combineA(end) || combineB(end))) {
+      end++;
+    }
+    return end - 1;
+  }
+
+  private boolean combineA(int i) {
+    final Edit s = edits.get(i);
+    final Edit e = edits.get(i - 1);
+    // + 1 to prevent '... skipping 1 common line ...' messages.
+    return s.getBeginA() - e.getEndA() <= 2 * context + 1;
+  }
+
+  private boolean combineB(int i) {
+    final int s = edits.get(i).getBeginB();
+    final int e = edits.get(i - 1).getEndB();
+    // + 1 to prevent '... skipping 1 common line ...' messages.
+    return s - e <= 2 * context + 1;
+  }
+
+  public class Hunk {
+    private int curIdx;
+    private Edit curEdit;
+    private final int endIdx;
+    private final Edit endEdit;
+
+    private int aCur;
+    private int bCur;
+    private final int aEnd;
+    private final int bEnd;
+
+    private Hunk(int ci, int ei) {
+      curIdx = ci;
+      endIdx = ei;
+      curEdit = edits.get(curIdx);
+      endEdit = edits.get(endIdx);
+
+      aCur = Math.max(0, curEdit.getBeginA() - context);
+      bCur = Math.max(0, curEdit.getBeginB() - context);
+      aEnd = Math.min(aSize, endEdit.getEndA() + context);
+      bEnd = Math.min(bSize, endEdit.getEndB() + context);
+    }
+
+    public int getCurA() {
+      return aCur;
+    }
+
+    public int getCurB() {
+      return bCur;
+    }
+
+    public Edit getCurEdit() {
+      return curEdit;
+    }
+
+    public int getEndA() {
+      return aEnd;
+    }
+
+    public int getEndB() {
+      return bEnd;
+    }
+
+    public void incA() {
+      aCur++;
+    }
+
+    public void incB() {
+      bCur++;
+    }
+
+    public void incBoth() {
+      incA();
+      incB();
+    }
+
+    public boolean isStartOfFile() {
+      return aCur == 0 && bCur == 0;
+    }
+
+    public boolean isContextLine() {
+      return !isModifiedLine();
+    }
+
+    public boolean isDeletedA() {
+      return curEdit.getBeginA() <= aCur && aCur < curEdit.getEndA();
+    }
+
+    public boolean isInsertedB() {
+      return curEdit.getBeginB() <= bCur && bCur < curEdit.getEndB();
+    }
+
+    public boolean isModifiedLine() {
+      return isDeletedA() || isInsertedB();
+    }
+
+    public boolean next() {
+      if (!in(curEdit)) {
+        if (curIdx < endIdx) {
+          curEdit = edits.get(++curIdx);
+        }
+      }
+      return aCur < aEnd || bCur < bEnd;
+    }
+
+    private boolean in(Edit edit) {
+      return aCur < edit.getEndA() || bCur < edit.getEndB();
+    }
+  }
+}

java/com/google/gerrit/prettify/common/SparseFileContent.java

@@ -0,0 +1,208 @@
+// Copyright (C) 2009 The Android Open Source Project
+//
+// 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.google.gerrit.prettify.common;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SparseFileContent {
+  protected List<Range> ranges;
+  protected int size;
+
+  private transient int currentRangeIdx;
+
+  public SparseFileContent() {
+    ranges = new ArrayList<>();
+  }
+
+  public int size() {
+    return size;
+  }
+
+  public void setSize(int s) {
+    size = s;
+  }
+
+  public String get(int idx) {
+    final String line = getLine(idx);
+    if (line == null) {
+      throw new ArrayIndexOutOfBoundsException(idx);
+    }
+    return line;
+  }
+
+  public boolean contains(int idx) {
+    return getLine(idx) != null;
+  }
+
+  public int first() {
+    return ranges.isEmpty() ? size() : ranges.get(0).base;
+  }
+
+  public int next(int idx) {
+    // Most requests are sequential in nature, fetching the next
+    // line from the current range, or the immediate next range.
+    //
+    int high = ranges.size();
+    if (currentRangeIdx < high) {
+      Range cur = ranges.get(currentRangeIdx);
+      if (cur.contains(idx + 1)) {
+        return idx + 1;
+      }
+
+      if (++currentRangeIdx < high) {
+        // Its not plus one, its the base of the next range.
+        //
+        return ranges.get(currentRangeIdx).base;
+      }
+    }
+
+    // Binary search for the current value, since we know its a sorted list.
+    //
+    int low = 0;
+    do {
+      final int mid = (low + high) / 2;
+      final Range cur = ranges.get(mid);
+
+      if (cur.contains(idx)) {
+        if (cur.contains(idx + 1)) {
+          // Trivial plus one case above failed due to wrong currentRangeIdx.
+          // Reset the cache so we don't miss in the future.
+          //
+          currentRangeIdx = mid;
+          return idx + 1;
+        }
+
+        if (mid + 1 < ranges.size()) {
+          // Its the base of the next range.
+          currentRangeIdx = mid + 1;
+          return ranges.get(currentRangeIdx).base;
+        }
+
+        // No more lines in the file.
+        //
+        return size();
+      }
+
+      if (idx < cur.base) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    } while (low < high);
+
+    return size();
+  }
+
+  private String getLine(int idx) {
+    // Most requests are sequential in nature, fetching the next
+    // line from the current range, or the next range.
+    //
+    int high = ranges.size();
+    if (currentRangeIdx < high) {
+      Range cur = ranges.get(currentRangeIdx);
+      if (cur.contains(idx)) {
+        return cur.get(idx);
+      }
+
+      if (++currentRangeIdx < high) {
+        final Range next = ranges.get(currentRangeIdx);
+        if (next.contains(idx)) {
+          return next.get(idx);
+        }
+      }
+    }
+
+    // Binary search for the range, since we know its a sorted list.
+    //
+    if (ranges.isEmpty()) {
+      return null;
+    }
+
+    int low = 0;
+    do {
+      final int mid = (low + high) / 2;
+      final Range cur = ranges.get(mid);
+      if (cur.contains(idx)) {
+        currentRangeIdx = mid;
+        return cur.get(idx);
+      }
+      if (idx < cur.base) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    } while (low < high);
+    return null;
+  }
+
+  public void addLine(int i, String content) {
+    final Range r;
+    if (!ranges.isEmpty() && i == last().end()) {
+      r = last();
+    } else {
+      r = new Range(i);
+      ranges.add(r);
+    }
+    r.lines.add(content);
+  }
+
+  private Range last() {
+    return ranges.get(ranges.size() - 1);
+  }
+
+  @Override
+  public String toString() {
+    final StringBuilder b = new StringBuilder();
+    b.append("SparseFileContent[\n");
+    for (Range r : ranges) {
+      b.append("  ");
+      b.append(r.toString());
+      b.append('\n');
+    }
+    b.append("]");
+    return b.toString();
+  }
+
+  static class Range {
+    protected int base;
+    protected List<String> lines;
+
+    private Range(int b) {
+      base = b;
+      lines = new ArrayList<>();
+    }
+
+    protected Range() {}
+
+    private String get(int i) {
+      return lines.get(i - base);
+    }
+
+    private int end() {
+      return base + lines.size();
+    }
+
+    private boolean contains(int i) {
+      return base <= i && i < end();
+    }
+
+    @Override
+    public String toString() {
+      // Usage of [ and ) is intentional to denote inclusive/exclusive range
+      return "Range[" + base + "," + end() + ")";
+    }
+  }
+}