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