plugins/git4idea/src/git4idea/rebase/GitRebaseEditor.java

   1 /*
   2  * Copyright 2000-2008 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package git4idea.rebase;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.ui.DialogWrapper;
  20 import com.intellij.openapi.util.SystemInfo;
  21 import com.intellij.openapi.util.io.FileUtil;
  22 import com.intellij.openapi.vfs.VirtualFile;
  23 import com.intellij.util.ListWithSelection;
  24 import com.intellij.util.ui.ComboBoxTableCellEditor;
  25 import com.intellij.util.ui.ComboBoxTableCellRenderer;
  26 import git4idea.actions.GitShowAllSubmittedFilesAction;
  27 import git4idea.commands.StringScanner;
  28 import git4idea.config.GitConfigUtil;
  29 import git4idea.i18n.GitBundle;
  30 import org.jetbrains.annotations.NonNls;
  31
  32 import javax.swing.*;
  33 import javax.swing.event.ListSelectionEvent;
  34 import javax.swing.event.ListSelectionListener;
  35 import javax.swing.event.TableModelEvent;
  36 import javax.swing.event.TableModelListener;
  37 import javax.swing.table.AbstractTableModel;
  38 import javax.swing.table.TableColumn;
  39 import java.awt.event.ActionEvent;
  40 import java.awt.event.ActionListener;
  41 import java.io.*;
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44
  45 /**
  46  * Editor for rebase entries. It allows reordering of
  47  * the entries and changing commit status.
  48  */
  49 public class GitRebaseEditor extends DialogWrapper {
  50   /**
  51    * The table that lists all commits
  52    */
  53   private JTable myCommitsTable;
  54   /**
  55    * The move up button
  56    */
  57   private JButton myMoveUpButton;
  58   /**
  59    * The move down button
  60    */
  61   private JButton myMoveDownButton;
  62   /**
  63    * The view commit button
  64    */
  65   private JButton myViewButton;
  66   /**
  67    * The root panel
  68    */
  69   private JPanel myPanel;
  70   /**
  71    * Table model
  72    */
  73   private final MyTableModel myTableModel;
  74   /**
  75    * The file name
  76    */
  77   private final String myFile;
  78   /**
  79    * The project
  80    */
  81   private final Project myProject;
  82   /**
  83    * The git root
  84    */
  85   private final VirtualFile myGitRoot;
  86   /**
  87    * The cygwin drive prefix
  88    */
  89   @NonNls private static final String CYGDRIVE_PREFIX = "/cygdrive/";
  90
  91   /**
  92    * The constructor
  93    *
  94    * @param project the project
  95    * @param gitRoot the git root
  96    * @param file    the file to edit
  97    * @throws IOException if file could not be loaded
  98    */
  99   protected GitRebaseEditor(final Project project, final VirtualFile gitRoot, String file) throws IOException {
 100     super(project, true);
 101     myProject = project;
 102     myGitRoot = gitRoot;
 103     setTitle(GitBundle.getString("rebase.editor.title"));
 104     setOKButtonText(GitBundle.getString("rebase.editor.button"));
 105     if (SystemInfo.isWindows && file.startsWith(CYGDRIVE_PREFIX)) {
 106       final int prefixSize = CYGDRIVE_PREFIX.length();
 107       file = file.substring(prefixSize, prefixSize + 1) + ":" + file.substring(prefixSize + 1);
 108     }
 109     myFile = file;
 110     myTableModel = new MyTableModel();
 111     myTableModel.load(file);
 112     myCommitsTable.setModel(myTableModel);
 113     myCommitsTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 114     TableColumn actionColumn = myCommitsTable.getColumnModel().getColumn(MyTableModel.ACTION);
 115     actionColumn.setCellEditor(ComboBoxTableCellEditor.INSTANCE);
 116     actionColumn.setCellRenderer(ComboBoxTableCellRenderer.INSTANCE);
 117     myCommitsTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
 118       public void valueChanged(final ListSelectionEvent e) {
 119         boolean selected = myCommitsTable.getSelectedRowCount() != 0;
 120         myMoveUpButton.setEnabled(selected);
 121         if (selected) {
 122           myViewButton.setEnabled(true);
 123           int row = myCommitsTable.getSelectedRow();
 124           myMoveUpButton.setEnabled(row != 0);
 125           myMoveDownButton.setEnabled(row != myTableModel.myEntries.size() - 1);
 126         }
 127         else {
 128           myMoveUpButton.setEnabled(false);
 129           myMoveDownButton.setEnabled(false);
 130           myViewButton.setEnabled(false);
 131         }
 132       }
 133     });
 134     myViewButton.addActionListener(new ActionListener() {
 135       public void actionPerformed(final ActionEvent e) {
 136         int row = myCommitsTable.getSelectedRow();
 137         if (row < 0) {
 138           return;
 139         }
 140         GitRebaseEntry entry = myTableModel.myEntries.get(row);
 141         GitShowAllSubmittedFilesAction.showSubmittedFiles(project, entry.getCommit(), gitRoot);
 142       }
 143     });
 144     myMoveUpButton.addActionListener(new ActionListener() {
 145       public void actionPerformed(final ActionEvent e) {
 146         final int row = myCommitsTable.getSelectedRow();
 147         if (myTableModel.moveUp(row)) {
 148           myCommitsTable.getSelectionModel().setSelectionInterval(row - 1, row - 1);
 149         }
 150       }
 151     });
 152     myMoveDownButton.addActionListener(new ActionListener() {
 153       public void actionPerformed(final ActionEvent e) {
 154         final int row = myCommitsTable.getSelectedRow();
 155         if (myTableModel.moveDown(row)) {
 156           myCommitsTable.getSelectionModel().setSelectionInterval(row + 1, row + 1);
 157         }
 158       }
 159     });
 160     myTableModel.addTableModelListener(new TableModelListener() {
 161       public void tableChanged(final TableModelEvent e) {
 162         validateFields();
 163       }
 164     });
 165     init();
 166   }
 167
 168   /**
 169    * Validate fields
 170    */
 171   private void validateFields() {
 172     final ArrayList<GitRebaseEntry> entries = myTableModel.myEntries;
 173     if (entries.size() == 0) {
 174       setErrorText(GitBundle.getString("rebase.editor.invalid.entryset"));
 175       setOKActionEnabled(false);
 176       return;
 177     }
 178     int i = 0;
 179     while (i < entries.size() && entries.get(i).getAction() == GitRebaseEntry.Action.skip) {
 180       i++;
 181     }
 182     if (i < entries.size() && entries.get(i).getAction() == GitRebaseEntry.Action.squash) {
 183       setErrorText(GitBundle.getString("rebase.editor.invalid.squash"));
 184       setOKActionEnabled(false);
 185       return;
 186     }
 187     setErrorText(null);
 188     setOKActionEnabled(true);
 189   }
 190
 191   /**
 192    * Save entries back to the file
 193    *
 194    * @throws IOException if there is IO problem with saving
 195    */
 196   public void save() throws IOException {
 197     myTableModel.save(myFile);
 198   }
 199
 200   /**
 201    * {@inheritDoc}
 202    */
 203   protected JComponent createCenterPanel() {
 204     return myPanel;
 205   }
 206
 207   /**
 208    * {@inheritDoc}
 209    */
 210   @Override
 211   protected String getDimensionServiceKey() {
 212     return getClass().getName();
 213   }
 214
 215   /**
 216    * {@inheritDoc}
 217    */
 218   @Override
 219   protected String getHelpId() {
 220     return "reference.VersionControl.Git.RebaseCommits";
 221   }
 222
 223   /**
 224    * Cancel rebase
 225    *
 226    * @throws IOException if file cannot be reset to empty one
 227    */
 228   public void cancel() throws IOException {
 229     myTableModel.cancel(myFile);
 230   }
 231
 232
 233   /**
 234    * The table model for the commits
 235    */
 236   private class MyTableModel extends AbstractTableModel {
 237     /**
 238      * The action column
 239      */
 240     private static final int ACTION = 0;
 241     /**
 242      * The commit hash column
 243      */
 244     private static final int COMMIT = 1;
 245     /**
 246      * The subject column
 247      */
 248     private static final int SUBJECT = 2;
 249
 250     /**
 251      * The entries
 252      */
 253     final ArrayList<GitRebaseEntry> myEntries = new ArrayList<GitRebaseEntry>();
 254
 255     /**
 256      * {@inheritDoc}
 257      */
 258     @Override
 259     public Class<?> getColumnClass(final int columnIndex) {
 260       return columnIndex == ACTION ? ListWithSelection.class : String.class;
 261     }
 262
 263     /**
 264      * {@inheritDoc}
 265      */
 266     @Override
 267     public String getColumnName(final int column) {
 268       switch (column) {
 269         case ACTION:
 270           return GitBundle.getString("rebase.editor.action.column");
 271         case COMMIT:
 272           return GitBundle.getString("rebase.editor.commit.column");
 273         case SUBJECT:
 274           return GitBundle.getString("rebase.editor.comment.column");
 275         default:
 276           throw new IllegalArgumentException("Unsupported column index: " + column);
 277       }
 278     }
 279
 280     /**
 281      * {@inheritDoc}
 282      */
 283     public int getRowCount() {
 284       return myEntries.size();
 285     }
 286
 287     /**
 288      * {@inheritDoc}
 289      */
 290     public int getColumnCount() {
 291       return SUBJECT + 1;
 292     }
 293
 294     /**
 295      * {@inheritDoc}
 296      */
 297     public Object getValueAt(final int rowIndex, final int columnIndex) {
 298       GitRebaseEntry e = myEntries.get(rowIndex);
 299       switch (columnIndex) {
 300         case ACTION:
 301           return new ListWithSelection<GitRebaseEntry.Action>(Arrays.asList(GitRebaseEntry.Action.values()), e.getAction());
 302         case COMMIT:
 303           return e.getCommit();
 304         case SUBJECT:
 305           return e.getSubject();
 306         default:
 307           throw new IllegalArgumentException("Unsupported column index: " + columnIndex);
 308       }
 309     }
 310
 311     /**
 312      * {@inheritDoc}
 313      */
 314     @Override
 315     @SuppressWarnings({"unchecked"})
 316     public void setValueAt(final Object aValue, final int rowIndex, final int columnIndex) {
 317       assert columnIndex == ACTION;
 318       GitRebaseEntry e = myEntries.get(rowIndex);
 319       e.setAction((GitRebaseEntry.Action)aValue);
 320       fireTableCellUpdated(rowIndex, columnIndex);
 321     }
 322
 323     /**
 324      * {@inheritDoc}
 325      */
 326     @Override
 327     public boolean isCellEditable(final int rowIndex, final int columnIndex) {
 328       return columnIndex == ACTION;
 329     }
 330
 331     /**
 332      * Load data from the file
 333      *
 334      * @param file the file to load
 335      * @throws IOException if file could not be loaded
 336      */
 337     public void load(final String file) throws IOException {
 338       String encoding = GitConfigUtil.getLogEncoding(myProject, myGitRoot);
 339       final StringScanner s = new StringScanner(new String(FileUtil.loadFileText(new File(file), encoding)));
 340       while (s.hasMoreData()) {
 341         if (s.isEol() || s.startsWith('#') || s.startsWith("noop")) {
 342           s.nextLine();
 343           continue;
 344         }
 345         String action = s.spaceToken();
 346         assert "pick".equals(action) : "Initial action should be pick: " + action;
 347         String hash = s.spaceToken();
 348         String comment = s.line();
 349         myEntries.add(new GitRebaseEntry(hash, comment));
 350       }
 351     }
 352
 353     /**
 354      * Save text to the file
 355      *
 356      * @param file the file to save to
 357      * @throws IOException if there is IO problem
 358      */
 359     public void save(final String file) throws IOException {
 360       String encoding = GitConfigUtil.getLogEncoding(myProject, myGitRoot);
 361       PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), encoding));
 362       try {
 363         for (GitRebaseEntry e : myEntries) {
 364           if (e.getAction() != GitRebaseEntry.Action.skip) {
 365             out.println(e.getAction().toString() + " " + e.getCommit() + " " + e.getSubject());
 366           }
 367         }
 368       }
 369       finally {
 370         out.close();
 371       }
 372     }
 373
 374     /**
 375      * Save text to the file
 376      *
 377      * @param file the file to save to
 378      * @throws IOException if there is IO problem
 379      */
 380     public void cancel(final String file) throws IOException {
 381       PrintWriter out = new PrintWriter(new FileWriter(file));
 382       try {
 383         //noinspection HardCodedStringLiteral
 384         out.println("# rebase is cancelled");
 385       }
 386       finally {
 387         out.close();
 388       }
 389     }
 390
 391
 392     /**
 393      * Move selected row up. If row cannot be moved up, do nothing and return false.
 394      *
 395      * @param row a row to move
 396      * @return true if row was moved
 397      */
 398     public boolean moveUp(final int row) {
 399       if (row < 1 || row >= myEntries.size()) {
 400         return false;
 401       }
 402       myCommitsTable.removeEditor();
 403       GitRebaseEntry e = myEntries.get(row);
 404       myEntries.set(row, myEntries.get(row - 1));
 405       myEntries.set(row - 1, e);
 406       fireTableRowsUpdated(row - 1, row);
 407       return true;
 408     }
 409
 410     /**
 411      * Move selected row down. If row cannot be moved down, do nothing and return false.
 412      *
 413      * @param row a row to move
 414      * @return true if row was moved
 415      */
 416     public boolean moveDown(final int row) {
 417       if (row < 0 || row >= myEntries.size() - 1) {
 418         return false;
 419       }
 420       myCommitsTable.removeEditor();
 421       GitRebaseEntry e = myEntries.get(row);
 422       myEntries.set(row, myEntries.get(row + 1));
 423       myEntries.set(row + 1, e);
 424       fireTableRowsUpdated(row, row + 1);
 425       return true;
 426     }
 427   }
 428 }