html export added

META-INF/plugin.xml

@@ -5,7 +5,6 @@
     <version>1.0</version>
     <vendor>JetBrains</vendor>
     <idea-version since-build="8000"/>
-
   <application-components>
   </application-components>
 

src/patch/ReviewCommitHandlerFactory.java

@@ -27,7 +27,7 @@ public CheckinHandler createHandler(CheckinProjectPanel panel) {
     }
 
     private class ReviewCommitHandler extends CheckinHandler {
-        private CheckinProjectPanel checkinProjectPanel;
+        private final CheckinProjectPanel checkinProjectPanel;
         private JCheckBox checkbox;
 
         public ReviewCommitHandler(CheckinProjectPanel panel) {

src/patch/ReviewPatchExtensionPoint.java

@@ -5,17 +5,9 @@
 import com.intellij.openapi.project.ProjectManager;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.xmlb.XmlSerializer;
-import org.jdom.Element;
-import org.jdom.JDOMException;
-import org.jdom.input.SAXBuilder;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import reviewresult.ReviewManager;
-import reviewresult.persistent.ReviewsState;
-
-import java.io.IOException;
-import java.io.StringReader;
 
 /**
  * User: Alisa.Afonina
@@ -47,7 +39,7 @@ public CharSequence provideContent(@NotNull String path) {
     @Override
     public void consumeContent(@NotNull String path, @NotNull CharSequence content) {
         for(Project project : ProjectManager.getInstance().getOpenProjects()) {
-            ReviewManager.getInstance(project).importReviewsToFile(path, content.toString());
+            ReviewManager.getInstance(project).importReviewsFromFile(path, content.toString());
         }
     }
 

src/reviewresult/Review.java

@@ -1,18 +1,18 @@
 package reviewresult;
 
 import com.intellij.openapi.actionSystem.DataKey;
+import com.intellij.openapi.diff.DocumentContent;
 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.fileEditor.OpenFileDescriptor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import reviewresult.persistent.Context;
 import reviewresult.persistent.ReviewBean;
 import reviewresult.persistent.ReviewItem;
+import utils.Util;
 
 import java.util.List;
 
@@ -29,23 +29,27 @@ public class Review {
     private boolean activated = false;
 
     public static final DataKey<Review> REVIEW_DATA_KEY = DataKey.create("Review");
-    public Review(@NotNull ReviewBean reviewBean, @NotNull Project project){
+    private String filePath;
+    private String fileName;
+
+    public Review(@NotNull ReviewBean reviewBean, @NotNull Project project, @NotNull String filePath){
         this.reviewBean = reviewBean;
         this.project = project;
-        final VirtualFile baseDir = project.getBaseDir();
-        if(baseDir == null)  {reviewBean.setValid(false); return;}
-        VirtualFile virtualFile = baseDir.findFileByRelativePath(reviewBean.getFilePath());
+        this.filePath = filePath;
+        VirtualFile virtualFile = Util.getInstance(project).getVirtualFile(filePath);
         if(virtualFile == null)  {reviewBean.setValid(false); return;}
-
+        fileName = virtualFile.getName();
         this.reviewBean.checkValid(virtualFile.getLength(), virtualFile.isValid());
     }
 
-    public Review(Project project, String reviewName, int start, int end, VirtualFile virtualFile) {
+    public Review(Project project, int start, int end, VirtualFile virtualFile) {
         this.project = project;
         VirtualFile baseDir = project.getBaseDir();
         if(baseDir == null)  {return;}
         String relativePath = VfsUtil.getRelativePath(virtualFile, baseDir, '/');
-        this.reviewBean = new ReviewBean(reviewName, start, end, relativePath);
+        this.reviewBean = new ReviewBean(null, start, end);
+        this.filePath = relativePath;
+        fileName = virtualFile.getName();
         this.reviewBean.checkValid(virtualFile.getLength(), virtualFile.isValid());
     }
 
@@ -67,41 +71,29 @@ public void setName(String name) {
     }
 
     public int getStart() {
-        return reviewBean.getStart();
-    }
-
-    @Nullable
-    public OpenFileDescriptor getElement() {
-        if(reviewBean.isValid())
-            return new OpenFileDescriptor(project, getVirtualFile() , reviewBean.getStart());
-        else
-            return null;
+        return reviewBean.getContext().getStart();
     }
 
     public boolean isValid() {
+        final VirtualFile virtualFile = Util.getInstance(project).getVirtualFile(filePath);
+        if(virtualFile == null) return false;
         return reviewBean.isValid()
-          && ProjectRootManager.getInstance(project).getFileIndex().isInContent(getVirtualFile());
+          && ProjectRootManager.getInstance(project).getFileIndex().isInContent(virtualFile);
     }
 
-    public int getLine() {
+    public int getLineNumber() {
         if(!reviewBean.isValid()) return -1;
-        Document document = FileDocumentManager.getInstance().getDocument(getVirtualFile());
+        Document document = Util.getInstance(project).getDocument(filePath);
         if(document == null) return -1;
-        if(reviewBean.getStart()  > document.getText().length()) return -1;
-        return document.getLineNumber(reviewBean.getStart());
+        if(reviewBean.getContext().getStart()  > document.getText().length()) return -1;
+        return document.getLineNumber(reviewBean.getContext().getStart());
     }
 
 
     public Project getProject() {
         return project;
     }
 
-    public VirtualFile getVirtualFile() {
-        final VirtualFile baseDir = project.getBaseDir();
-        if(baseDir == null)  {reviewBean.setValid(false); return null;}
-        return baseDir.findFileByRelativePath(reviewBean.getFilePath());
-    }
-
     public ReviewBean getReviewBean() {
         return reviewBean;
     }
@@ -129,18 +121,108 @@ public int hashCode() {
         return reviewBean != null ? reviewBean.hashCode() : 0;
     }
 
-    public void setValid(boolean valid) {
-        reviewBean.setValid(valid);
+    public void setValid() {
+        reviewBean.setValid(false);
     }
 
-    public void setLine(int line) {
-        Document document = FileDocumentManager.getInstance().getDocument(getVirtualFile());
-        if(document == null) return;
-        reviewBean.setStart(document.getLineStartOffset(line));
-        reviewBean.setEnd(document.getLineEndOffset(line));
-    }
+
 
     public void setReviewBean(ReviewBean reviewBean) {
         this.reviewBean = reviewBean;
     }
+
+    public String getFilePath() {
+        return filePath;
+    }
+
+    public void setFilePath(String filePath) {
+        this.filePath = filePath;
+    }
+
+     public void setLineText() {
+        Document document = Util.getInstance(project).getDocument(filePath);
+        if(document == null) return;
+        final Context context = reviewBean.getContext();
+        context.setLine(document.getText(new TextRange(context.getStart(), context.getEnd())));
+     }
+
+    public void setBeforeLineText() {
+        int beforeLineNumber = getLineNumber() - 1;
+        if(beforeLineNumber >=0) {
+            Document document = Util.getInstance(project).getDocument(filePath);
+            if(document == null) return;
+            int start = document.getLineStartOffset(beforeLineNumber);
+            int end = document.getLineEndOffset(beforeLineNumber);
+            final Context context = reviewBean.getContext();
+            context.setLineBefore(document.getText(new TextRange(start, end)));
+        }
+    }
+
+    public void setAfterLineText() {
+        int afterLineNumber = getLineNumber() + 1;
+        Document document = Util.getInstance(project).getDocument(filePath);
+        if(document == null) return;
+        if(afterLineNumber < document.getLineCount()) {
+            int start = document.getLineStartOffset(afterLineNumber);
+            int end = document.getLineEndOffset(afterLineNumber);
+            final Context context = reviewBean.getContext();
+            context.setLineAfter(document.getText(new TextRange(start, end)));
+        }
+    }
+
+    public void checkContext() {
+        Document document = Util.getInstance(project).getDocument(filePath);
+        if(document == null) return;
+        final Context context = reviewBean.getContext();
+        int start = context.getStart();
+        int end = context.getEnd();
+        final int beforeOffset = Util.find(document.getText(), context.getLineBefore());
+        final int afterOffset = Util.find(document.getText(), context.getLineAfter());
+        if(!context.getLine().equals(document.getText(new TextRange(context.getStart(), context.getEnd())))) {
+            int offset = Util.find(document.getText(), context.getLine());
+            if(offset > 0) {
+                if(offset != context.getStart()) {
+                    // todo check context around
+                    start = offset;
+                    end = document.getLineEndOffset(document.getLineNumber(offset));
+                    setBeforeLineText();
+                    setAfterLineText();
+                }
+            } else {
+                if(beforeOffset > 0 && afterOffset > 0) {
+                    final int beforeLineNumber = document.getLineNumber(beforeOffset);
+                    final int afterLineNumber = document.getLineNumber(afterOffset);
+
+                    if(beforeLineNumber < document.getLineCount() && afterLineNumber > 0 ) {
+                        if((beforeLineNumber + 2)==afterLineNumber) { // if between these two lines exactly one placed;
+                            start = document.getLineStartOffset(beforeLineNumber + 1);
+                            end = document.getLineEndOffset(beforeLineNumber + 1);
+                        } else {
+                            //todo best line between before and after lines should be found
+                            start = document.getLineStartOffset(beforeLineNumber + 1);
+                            end = document.getLineEndOffset(beforeLineNumber + 1);
+                        }
+                    } else {
+                        if (beforeLineNumber < document.getLineCount()) {
+                            start = document.getLineStartOffset(afterLineNumber - 1);
+                            end = document.getLineEndOffset(afterLineNumber - 1);
+                        } else {
+                            start = document.getLineStartOffset(beforeLineNumber - 1);
+                            end = document.getLineEndOffset(beforeLineNumber - 1);
+                        }
+                    }
+                }
+               //todo check at least for one
+            }
+        } else {
+            System.out.println("May be reviewPoint would'be wrond placed, because text was increeeedibly changed");
+            //todo show Message : May be reviewPoint would'be wrond placed, because text was increeeedibly changed
+        }
+        context.setStart(start);
+        context.setEnd(end);
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
 }

src/reviewresult/ReviewChangedAdapter.java

@@ -0,0 +1,18 @@
+package reviewresult;
+
+/**
+ * User: Alisa.Afonina
+ * Date: 8/19/11
+ * Time: 2:20 PM
+ */
+public abstract class ReviewChangedAdapter implements ReviewsChangedListener{
+    @Override
+    public void reviewAdded(Review review) {}
+
+    @Override
+    public void reviewDeleted(Review review) {}
+
+    @Override
+    public void reviewChanged(Review newReview) {}
+
+}