org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/repository/RepositoriesViewContentProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 SAP AG.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *    Mathias Kinzler (SAP AG) - initial implementation
  10  *******************************************************************************/
  11 package org.eclipse.egit.ui.internal.repository;
  12
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.net.URISyntaxException;
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.Collections;
  19 import java.util.Comparator;
  20 import java.util.List;
  21 import java.util.Set;
  22 import java.util.Map.Entry;
  23
  24 import org.eclipse.egit.ui.Activator;
  25 import org.eclipse.egit.ui.UIText;
  26 import org.eclipse.egit.ui.internal.repository.RepositoryTreeNode.RepositoryTreeNodeType;
  27 import org.eclipse.jface.viewers.ITreeContentProvider;
  28 import org.eclipse.jface.viewers.Viewer;
  29 import org.eclipse.jgit.lib.Constants;
  30 import org.eclipse.jgit.lib.Ref;
  31 import org.eclipse.jgit.lib.RefDatabase;
  32 import org.eclipse.jgit.lib.Repository;
  33 import org.eclipse.jgit.transport.RemoteConfig;
  34
  35 /**
  36  * Content Provider for the Git Repositories View
  37  */
  38 public class RepositoriesViewContentProvider implements ITreeContentProvider {
  39
  40         @SuppressWarnings("unchecked")
  41         public Object[] getElements(Object inputElement) {
  42
  43                 List<RepositoryTreeNode> nodes = (List<RepositoryTreeNode>) inputElement;
  44                 Collections.sort(nodes);
  45                 return nodes.toArray();
  46         }
  47
  48         public void dispose() {
  49                 // nothing
  50         }
  51
  52         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  53                 // nothing
  54         }
  55
  56         public Object[] getChildren(Object parentElement) {
  57
  58                 RepositoryTreeNode node = (RepositoryTreeNode) parentElement;
  59                 Repository repo = node.getRepository();
  60
  61                 switch (node.getType()) {
  62
  63                 case BRANCHES: {
  64
  65                         List<RepositoryTreeNode<Repository>> nodes = new ArrayList<RepositoryTreeNode<Repository>>();
  66
  67                         nodes.add(new RepositoryTreeNode<Repository>(node,
  68                                         RepositoryTreeNodeType.LOCALBRANCHES, repo, repo));
  69                         nodes.add(new RepositoryTreeNode<Repository>(node,
  70                                         RepositoryTreeNodeType.REMOTEBRANCHES, repo, repo));
  71
  72                         return nodes.toArray();
  73                 }
  74
  75                 case LOCALBRANCHES: {
  76                         List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
  77
  78                         try {
  79                                 for (Entry<String, Ref> refEntry : repo.getRefDatabase()
  80                                                 .getRefs(Constants.R_HEADS).entrySet()) {
  81                                         if (!refEntry.getValue().isSymbolic())
  82                                                 refs.add(new RepositoryTreeNode<Ref>(node,
  83                                                                 RepositoryTreeNodeType.REF, repo, refEntry
  84                                                                                 .getValue()));
  85                                 }
  86                         } catch (IOException e) {
  87                                 handleException(e, node);
  88                         }
  89
  90                         return refs.toArray();
  91                 }
  92
  93                 case REMOTEBRANCHES: {
  94                         List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
  95
  96                         try {
  97                                 for (Entry<String, Ref> refEntry : repo.getRefDatabase()
  98                                                 .getRefs(Constants.R_REMOTES).entrySet()) {
  99                                         if (!refEntry.getValue().isSymbolic())
 100                                                 refs.add(new RepositoryTreeNode<Ref>(node,
 101                                                                 RepositoryTreeNodeType.REF, repo, refEntry
 102                                                                                 .getValue()));
 103                                 }
 104                         } catch (IOException e) {
 105                                 handleException(e, node);
 106                         }
 107
 108                         return refs.toArray();
 109                 }
 110                 case TAGS: {
 111                         List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
 112
 113                         try {
 114                                 for (Entry<String, Ref> refEntry : repo.getRefDatabase()
 115                                                 .getRefs(Constants.R_TAGS).entrySet()) {
 116                                         refs.add(new RepositoryTreeNode<Ref>(node,
 117                                                         RepositoryTreeNodeType.TAG, repo, refEntry
 118                                                                         .getValue()));
 119                                 }
 120                         } catch (IOException e) {
 121                                 handleException(e, node);
 122                         }
 123
 124                         return refs.toArray();
 125                 }
 126
 127                 case SYMBOLICREFS: {
 128                         List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
 129
 130                         try {
 131                                 for (Entry<String, Ref> refEntry : repo.getRefDatabase()
 132                                                 .getRefs(RefDatabase.ALL).entrySet()) {
 133                                         if (refEntry.getValue().isSymbolic())
 134                                                 refs.add(new RepositoryTreeNode<Ref>(node,
 135                                                                 RepositoryTreeNodeType.SYMBOLICREF, repo,
 136                                                                 refEntry.getValue()));
 137                                 }
 138                         } catch (IOException e) {
 139                                 handleException(e, node);
 140                         }
 141
 142                         return refs.toArray();
 143                 }
 144
 145                 case REMOTES: {
 146                         List<RepositoryTreeNode<String>> remotes = new ArrayList<RepositoryTreeNode<String>>();
 147
 148                         Repository rep = node.getRepository();
 149
 150                         Set<String> configNames = rep.getConfig().getSubsections(
 151                                         RepositoriesView.REMOTE);
 152
 153                         for (String configName : configNames) {
 154                                 remotes.add(new RepositoryTreeNode<String>(node,
 155                                                 RepositoryTreeNodeType.REMOTE, repo, configName));
 156                         }
 157
 158                         return remotes.toArray();
 159                 }
 160
 161                 case REPO: {
 162
 163                         List<RepositoryTreeNode<? extends Object>> nodeList = new ArrayList<RepositoryTreeNode<? extends Object>>();
 164
 165                         nodeList.add(new RepositoryTreeNode<Repository>(node,
 166                                         RepositoryTreeNodeType.BRANCHES, node.getRepository(), node
 167                                                         .getRepository()));
 168
 169                         nodeList.add(new RepositoryTreeNode<Repository>(node,
 170                                         RepositoryTreeNodeType.TAGS, repo, repo));
 171
 172                         nodeList.add(new RepositoryTreeNode<Repository>(node,
 173                                         RepositoryTreeNodeType.SYMBOLICREFS, repo, repo));
 174
 175                         nodeList.add(new RepositoryTreeNode<Repository>(node,
 176                                         RepositoryTreeNodeType.WORKINGDIR, node.getRepository(),
 177                                         node.getRepository()));
 178
 179                         nodeList.add(new RepositoryTreeNode<Repository>(node,
 180                                         RepositoryTreeNodeType.REMOTES, node.getRepository(), node
 181                                                         .getRepository()));
 182
 183                         return nodeList.toArray();
 184                 }
 185
 186                 case WORKINGDIR: {
 187                         List<RepositoryTreeNode<File>> children = new ArrayList<RepositoryTreeNode<File>>();
 188
 189                         File workingDir = repo.getWorkDir();
 190                         if (workingDir == null || !workingDir.exists())
 191                                 return null;
 192
 193                         File[] childFiles = workingDir.listFiles();
 194                         Arrays.sort(childFiles, new Comparator<File>() {
 195                                 public int compare(File o1, File o2) {
 196                                         if (o1.isDirectory()) {
 197                                                 if (o2.isDirectory()) {
 198                                                         return o1.compareTo(o2);
 199                                                 }
 200                                                 return -1;
 201                                         } else if (o2.isDirectory()) {
 202                                                 return 1;
 203                                         }
 204                                         return o1.compareTo(o2);
 205                                 }
 206                         });
 207                         for (File file : childFiles) {
 208                                 if (file.isDirectory()) {
 209                                         children.add(new RepositoryTreeNode<File>(node,
 210                                                         RepositoryTreeNodeType.FOLDER, repo, file));
 211                                 } else {
 212                                         children.add(new RepositoryTreeNode<File>(node,
 213                                                         RepositoryTreeNodeType.FILE, repo, file));
 214                                 }
 215                         }
 216
 217                         return children.toArray();
 218                 }
 219
 220                 case FOLDER: {
 221                         List<RepositoryTreeNode<File>> children = new ArrayList<RepositoryTreeNode<File>>();
 222
 223                         File parent = ((File) node.getObject());
 224
 225                         File[] childFiles = parent.listFiles();
 226                         Arrays.sort(childFiles, new Comparator<File>() {
 227                                 public int compare(File o1, File o2) {
 228                                         if (o1.isDirectory()) {
 229                                                 if (o2.isDirectory()) {
 230                                                         return o1.compareTo(o2);
 231                                                 }
 232                                                 return -1;
 233                                         } else if (o2.isDirectory()) {
 234                                                 return 1;
 235                                         }
 236                                         return o1.compareTo(o2);
 237                                 }
 238                         });
 239                         for (File file : childFiles) {
 240                                 if (file.isDirectory()) {
 241                                         children.add(new RepositoryTreeNode<File>(node,
 242                                                         RepositoryTreeNodeType.FOLDER, repo, file));
 243                                 } else {
 244                                         children.add(new RepositoryTreeNode<File>(node,
 245                                                         RepositoryTreeNodeType.FILE, repo, file));
 246                                 }
 247                         }
 248
 249                         return children.toArray();
 250                 }
 251
 252                 case REMOTE: {
 253
 254                         List<RepositoryTreeNode<String>> children = new ArrayList<RepositoryTreeNode<String>>();
 255
 256                         String remoteName = (String) node.getObject();
 257                         RemoteConfig rc;
 258                         try {
 259                                 rc = new RemoteConfig(node.getRepository().getConfig(),
 260                                                 remoteName);
 261                         } catch (URISyntaxException e) {
 262                                 handleException(e, node);
 263                                 return children.toArray();
 264                         }
 265
 266                         if (!rc.getURIs().isEmpty())
 267                                 children.add(new RepositoryTreeNode<String>(node,
 268                                                 RepositoryTreeNodeType.FETCH, node.getRepository(), rc
 269                                                                 .getURIs().get(0).toPrivateString()));
 270
 271                         if (!rc.getPushURIs().isEmpty())
 272                                 if (rc.getPushURIs().size() == 1)
 273                                         children.add(new RepositoryTreeNode<String>(node,
 274                                                         RepositoryTreeNodeType.PUSH, node.getRepository(),
 275                                                         rc.getPushURIs().get(0).toPrivateString()));
 276                                 else
 277                                         children.add(new RepositoryTreeNode<String>(node,
 278                                                         RepositoryTreeNodeType.PUSH, node.getRepository(),
 279                                                         rc.getPushURIs().get(0).toPrivateString() + "...")); //$NON-NLS-1$
 280
 281                         return children.toArray();
 282
 283                 }
 284
 285                 case FILE:
 286                         // fall through
 287                 case REF:
 288                         // fall through
 289                 case PUSH:
 290                         // fall through
 291                 case TAG:
 292                         // fall through
 293                 case FETCH:
 294                         // fall through
 295                 case ERROR:
 296                         // fall through
 297                 case SYMBOLICREF:
 298                         return null;
 299
 300                 }
 301
 302                 return null;
 303
 304         }
 305
 306         private void handleException(Exception e, RepositoryTreeNode parentNode) {
 307                 Activator.handleError(e.getMessage(), e, false);
 308                 // add a node indicating that there was an Exception
 309                 new RepositoryTreeNode<String>(parentNode,
 310                                 RepositoryTreeNodeType.ERROR, parentNode.getRepository(),
 311                                 UIText.RepositoriesViewContentProvider_ExceptionNodeText);
 312         }
 313
 314         public Object getParent(Object element) {
 315
 316                 return ((RepositoryTreeNode) element).getParent();
 317         }
 318
 319         public boolean hasChildren(Object element) {
 320                 Object[] children = getChildren(element);
 321                 return children != null && children.length > 0;
 322         }
 323
 324 }