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                         if (node.getRepository().getConfig().getBoolean(
 190                                         "core", "bare", false)) //$NON-NLS-1$ //$NON-NLS-2$
 191                                 return children.toArray();
 192                         File workingDir = repo.getWorkDir();
 193                         if (workingDir == null || !workingDir.exists())
 194                                 return null;
 195
 196                         File[] childFiles = workingDir.listFiles();
 197                         Arrays.sort(childFiles, new Comparator<File>() {
 198                                 public int compare(File o1, File o2) {
 199                                         if (o1.isDirectory()) {
 200                                                 if (o2.isDirectory()) {
 201                                                         return o1.compareTo(o2);
 202                                                 }
 203                                                 return -1;
 204                                         } else if (o2.isDirectory()) {
 205                                                 return 1;
 206                                         }
 207                                         return o1.compareTo(o2);
 208                                 }
 209                         });
 210                         for (File file : childFiles) {
 211                                 if (file.isDirectory()) {
 212                                         children.add(new RepositoryTreeNode<File>(node,
 213                                                         RepositoryTreeNodeType.FOLDER, repo, file));
 214                                 } else {
 215                                         children.add(new RepositoryTreeNode<File>(node,
 216                                                         RepositoryTreeNodeType.FILE, repo, file));
 217                                 }
 218                         }
 219
 220                         return children.toArray();
 221                 }
 222
 223                 case FOLDER: {
 224                         List<RepositoryTreeNode<File>> children = new ArrayList<RepositoryTreeNode<File>>();
 225
 226                         File parent = ((File) node.getObject());
 227
 228                         File[] childFiles = parent.listFiles();
 229                         Arrays.sort(childFiles, new Comparator<File>() {
 230                                 public int compare(File o1, File o2) {
 231                                         if (o1.isDirectory()) {
 232                                                 if (o2.isDirectory()) {
 233                                                         return o1.compareTo(o2);
 234                                                 }
 235                                                 return -1;
 236                                         } else if (o2.isDirectory()) {
 237                                                 return 1;
 238                                         }
 239                                         return o1.compareTo(o2);
 240                                 }
 241                         });
 242                         for (File file : childFiles) {
 243                                 if (file.isDirectory()) {
 244                                         children.add(new RepositoryTreeNode<File>(node,
 245                                                         RepositoryTreeNodeType.FOLDER, repo, file));
 246                                 } else {
 247                                         children.add(new RepositoryTreeNode<File>(node,
 248                                                         RepositoryTreeNodeType.FILE, repo, file));
 249                                 }
 250                         }
 251
 252                         return children.toArray();
 253                 }
 254
 255                 case REMOTE: {
 256
 257                         List<RepositoryTreeNode<String>> children = new ArrayList<RepositoryTreeNode<String>>();
 258
 259                         String remoteName = (String) node.getObject();
 260                         RemoteConfig rc;
 261                         try {
 262                                 rc = new RemoteConfig(node.getRepository().getConfig(),
 263                                                 remoteName);
 264                         } catch (URISyntaxException e) {
 265                                 handleException(e, node);
 266                                 return children.toArray();
 267                         }
 268
 269                         if (!rc.getURIs().isEmpty())
 270                                 children.add(new RepositoryTreeNode<String>(node,
 271                                                 RepositoryTreeNodeType.FETCH, node.getRepository(), rc
 272                                                                 .getURIs().get(0).toPrivateString()));
 273
 274                         if (!rc.getPushURIs().isEmpty())
 275                                 if (rc.getPushURIs().size() == 1)
 276                                         children.add(new RepositoryTreeNode<String>(node,
 277                                                         RepositoryTreeNodeType.PUSH, node.getRepository(),
 278                                                         rc.getPushURIs().get(0).toPrivateString()));
 279                                 else
 280                                         children.add(new RepositoryTreeNode<String>(node,
 281                                                         RepositoryTreeNodeType.PUSH, node.getRepository(),
 282                                                         rc.getPushURIs().get(0).toPrivateString() + "...")); //$NON-NLS-1$
 283
 284                         return children.toArray();
 285
 286                 }
 287
 288                 case FILE:
 289                         // fall through
 290                 case REF:
 291                         // fall through
 292                 case PUSH:
 293                         // fall through
 294                 case TAG:
 295                         // fall through
 296                 case FETCH:
 297                         // fall through
 298                 case ERROR:
 299                         // fall through
 300                 case SYMBOLICREF:
 301                         return null;
 302
 303                 }
 304
 305                 return null;
 306
 307         }
 308
 309         private void handleException(Exception e, RepositoryTreeNode parentNode) {
 310                 Activator.handleError(e.getMessage(), e, false);
 311                 // add a node indicating that there was an Exception
 312                 new RepositoryTreeNode<String>(parentNode,
 313                                 RepositoryTreeNodeType.ERROR, parentNode.getRepository(),
 314                                 UIText.RepositoriesViewContentProvider_ExceptionNodeText);
 315         }
 316
 317         public Object getParent(Object element) {
 318
 319                 return ((RepositoryTreeNode) element).getParent();
 320         }
 321
 322         public boolean hasChildren(Object element) {
 323                 Object[] children = getChildren(element);
 324                 return children != null && children.length > 0;
 325         }
 326
 327 }