org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/repository/RepositoryPropertySource.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.util.ArrayList;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.StringTokenizer;
  19
  20 import org.eclipse.core.runtime.preferences.InstanceScope;
  21 import org.eclipse.egit.core.Activator;
  22 import org.eclipse.egit.ui.UIText;
  23 import org.eclipse.jface.action.Action;
  24 import org.eclipse.jface.action.ActionContributionItem;
  25 import org.eclipse.jface.action.IAction;
  26 import org.eclipse.jface.window.Window;
  27 import org.eclipse.jgit.errors.ConfigInvalidException;
  28 import org.eclipse.jgit.lib.Config;
  29 import org.eclipse.jgit.lib.FileBasedConfig;
  30 import org.eclipse.jgit.lib.Repository;
  31 import org.eclipse.jgit.lib.RepositoryConfig;
  32 import org.eclipse.jgit.util.SystemReader;
  33 import org.eclipse.ui.IActionBars;
  34 import org.eclipse.ui.preferences.ScopedPreferenceStore;
  35 import org.eclipse.ui.views.properties.IPropertyDescriptor;
  36 import org.eclipse.ui.views.properties.IPropertySource;
  37 import org.eclipse.ui.views.properties.IPropertySource2;
  38 import org.eclipse.ui.views.properties.PropertyDescriptor;
  39 import org.eclipse.ui.views.properties.PropertySheetPage;
  40 import org.eclipse.ui.views.properties.TextPropertyDescriptor;
  41
  42 /**
  43  * Properties for repository configuration
  44  *
  45  */
  46 public class RepositoryPropertySource implements IPropertySource,
  47                 IPropertySource2 {
  48
  49         private static final String USER_ID_PREFIX = "user"; //$NON-NLS-1$
  50
  51         private static final String REPO_ID_PREFIX = "repo"; //$NON-NLS-1$
  52
  53         private static final String EFFECTIVE_ID_PREFIX = "effe"; //$NON-NLS-1$
  54
  55         private static final String PREFERENCE_KEYS = "RepositoryPropertySource.ConfiguredKeys"; //$NON-NLS-1$
  56
  57         private Action configureKeyAction;
  58
  59         private Action modeToggleAction;
  60
  61         private Action restoreKeyAction;
  62
  63         private final PropertySheetPage myPage;
  64
  65         private final FileBasedConfig userHomeConfig;
  66
  67         private final FileBasedConfig repositoryConfig;
  68
  69         private final RepositoryConfig effectiveConfig;
  70
  71         /**
  72          * @param rep
  73          *            the repository
  74          * @param page
  75          */
  76         public RepositoryPropertySource(Repository rep, PropertySheetPage page) {
  77
  78                 myPage = page;
  79
  80                 makeActions();
  81                 addActions();
  82
  83                 effectiveConfig = rep.getConfig();
  84                 userHomeConfig = SystemReader.getInstance().openUserConfig();
  85                 // TODO constant?
  86                 File configFile = new File(rep.getDirectory(), "config"); //$NON-NLS-1$
  87                 repositoryConfig = new FileBasedConfig(configFile);
  88
  89                 try {
  90                         effectiveConfig.load();
  91                         userHomeConfig.load();
  92                         repositoryConfig.load();
  93                 } catch (IOException e) {
  94                         showExceptionMessage(e);
  95                 } catch (ConfigInvalidException e) {
  96                         showExceptionMessage(e);
  97                 }
  98         }
  99
 100         private void makeActions() {
 101
 102                 configureKeyAction = new Action(
 103                                 UIText.RepositoryPropertySource_ConfigureKeysAction) {
 104
 105                         @Override
 106                         public String getId() {
 107                                 return "ConfigKeyActionId"; //$NON-NLS-1$
 108                         }
 109
 110                         @Override
 111                         public void run() {
 112                                 ConfigureKeysDialog dlg = new ConfigureKeysDialog(myPage
 113                                                 .getSite().getShell(), getConfiguredKeys());
 114                                 if (dlg.open() == Window.OK)
 115                                         try {
 116                                                 setConfiguredKeys(dlg.getActiveKeys());
 117                                                 myPage.refresh();
 118                                         } catch (IOException e) {
 119                                                 showExceptionMessage(e);
 120                                         }
 121
 122                         }
 123
 124                 };
 125
 126                 modeToggleAction = new Action(
 127                                 UIText.RepositoryPropertySource_EffectiveConfigurationAction) {
 128                         // TODO icon
 129                         @Override
 130                         public String getId() {
 131                                 return "ViewModeToggle"; //$NON-NLS-1$
 132                         }
 133
 134                         @Override
 135                         public void run() {
 136                                 myPage.refresh();
 137                         }
 138
 139                         @Override
 140                         public int getStyle() {
 141                                 return IAction.AS_CHECK_BOX;
 142                         }
 143
 144                 };
 145
 146                 restoreKeyAction = new Action(
 147                                 UIText.RepositoryPropertySource_RestoreStandardAction) {
 148
 149                         @Override
 150                         public String getId() {
 151                                 return "RestoreKeys"; //$NON-NLS-1$
 152                         }
 153
 154                         @Override
 155                         public void run() {
 156                                 try {
 157                                         setConfiguredKeys(new ArrayList<String>());
 158                                         myPage.refresh();
 159                                 } catch (IOException e) {
 160                                         showExceptionMessage(e);
 161                                 }
 162                         }
 163
 164                 };
 165         }
 166
 167         private void addActions() {
 168
 169                 boolean refreshToolbar = false;
 170                 IActionBars bars = myPage.getSite().getActionBars();
 171
 172                 if (bars.getToolBarManager().find(modeToggleAction.getId()) == null) {
 173                         bars.getToolBarManager().add(modeToggleAction);
 174                         refreshToolbar = true;
 175                 }
 176
 177                 if (bars.getMenuManager().find(configureKeyAction.getId()) == null)
 178                         bars.getMenuManager().add(configureKeyAction);
 179
 180                 if (bars.getMenuManager().find(restoreKeyAction.getId()) == null)
 181                         bars.getMenuManager().add(restoreKeyAction);
 182
 183                 if (refreshToolbar)
 184                         bars.getToolBarManager().update(false);
 185         }
 186
 187         private List<String> getConfiguredKeys() {
 188
 189                 List<String> result = new ArrayList<String>();
 190                 ScopedPreferenceStore store = new ScopedPreferenceStore(
 191                                 new InstanceScope(), Activator.getPluginId());
 192                 String keys = store.getString(PREFERENCE_KEYS);
 193                 if (keys.length() > 0) {
 194                         StringTokenizer tok = new StringTokenizer(keys, " "); //$NON-NLS-1$
 195                         while (tok.hasMoreTokens()) {
 196                                 result.add(tok.nextToken());
 197                         }
 198                 } else {
 199                         result.addAll(ConfigureKeysDialog.standardKeys);
 200                 }
 201                 return result;
 202         }
 203
 204         private void setConfiguredKeys(List<String> keys) throws IOException {
 205
 206                 StringBuilder sb = new StringBuilder();
 207                 for (String key : keys) {
 208                         sb.append(key);
 209                         sb.append(" "); //$NON-NLS-1$
 210                 }
 211                 ScopedPreferenceStore store = new ScopedPreferenceStore(
 212                                 new InstanceScope(), Activator.getPluginId());
 213                 store.putValue(PREFERENCE_KEYS, sb.toString());
 214                 store.save();
 215
 216         }
 217
 218         private Object getValueFromConfig(Config config, String keyString) {
 219
 220                 StringTokenizer tok = new StringTokenizer(keyString, "."); //$NON-NLS-1$
 221
 222                 String section;
 223                 String subsection;
 224                 String name;
 225
 226                 String[] valueList = null;
 227                 if (tok.countTokens() == 2) {
 228                         section = tok.nextToken();
 229                         subsection = null;
 230                         name = tok.nextToken();
 231                 } else if (tok.countTokens() == 3) {
 232                         section = tok.nextToken();
 233                         subsection = tok.nextToken();
 234                         name = tok.nextToken();
 235                 } else {
 236                         // TODO exception?
 237                         return null;
 238                 }
 239
 240                 valueList = config.getStringList(section, subsection, name);
 241
 242                 if (valueList == null || valueList.length == 0)
 243                         return null;
 244
 245                 if (valueList.length == 1) {
 246                         return valueList[0];
 247                 }
 248
 249                 StringBuilder sb = new StringBuilder();
 250                 for (String value: valueList){
 251                         sb.append('[');
 252                         sb.append(value);
 253                         sb.append(']');
 254                 }
 255
 256                 return sb.toString();
 257
 258         }
 259
 260         public Object getEditableValue() {
 261                 return null;
 262         }
 263
 264         public IPropertyDescriptor[] getPropertyDescriptors() {
 265
 266                 // initFromConfig();
 267
 268                 try {
 269                         userHomeConfig.load();
 270                         repositoryConfig.load();
 271                         effectiveConfig.load();
 272                 } catch (IOException e) {
 273                         showExceptionMessage(e);
 274                 } catch (ConfigInvalidException e) {
 275                         showExceptionMessage(e);
 276                 }
 277
 278                 List<IPropertyDescriptor> resultList = new ArrayList<IPropertyDescriptor>();
 279
 280                 List<String> configuredKeys = getConfiguredKeys();
 281
 282                 boolean effectiveMode = false;
 283
 284                 ActionContributionItem item = (ActionContributionItem) myPage.getSite()
 285                                 .getActionBars().getToolBarManager().find(
 286                                                 modeToggleAction.getId());
 287                 if (item != null) {
 288                         effectiveMode = ((Action) item.getAction()).isChecked();
 289                 }
 290
 291                 if (effectiveMode) {
 292                         for (String key : configuredKeys) {
 293
 294                                 for (String sub : getSubSections(effectiveConfig, key)) {
 295                                         PropertyDescriptor desc = new PropertyDescriptor(
 296                                                         EFFECTIVE_ID_PREFIX + sub, sub);
 297
 298                                         desc
 299                                                         .setCategory(UIText.RepositoryPropertySource_EffectiveConfigurationCategory);
 300                                         resultList.add(desc);
 301                                 }
 302
 303                         }
 304                 } else {
 305
 306                         String categoryString = UIText.RepositoryPropertySource_GlobalConfigurationCategory
 307                                         + userHomeConfig.getFile().getAbsolutePath();
 308                         for (String key : configuredKeys) {
 309
 310                                 // no remote configuration globally....
 311                                 if (key.startsWith(RepositoriesView.REMOTE + ".")) //$NON-NLS-1$
 312                                         continue;
 313
 314                                 for (String sub : getSubSections(effectiveConfig, key)) {
 315                                         TextPropertyDescriptor desc = new TextPropertyDescriptor(
 316                                                         USER_ID_PREFIX + sub, sub);
 317                                         desc.setCategory(categoryString);
 318                                         resultList.add(desc);
 319                                 }
 320                         }
 321                         categoryString = UIText.RepositoryPropertySource_RepositoryConfigurationCategory
 322                                         + repositoryConfig.getFile().getAbsolutePath();
 323
 324                         boolean editable = true;
 325
 326                         for (String key : configuredKeys) {
 327
 328                                 // remote stuff is not configurable
 329                                 editable = !key.startsWith("remote"); //$NON-NLS-1$
 330
 331                                 for (String sub : getSubSections(effectiveConfig, key)) {
 332                                         PropertyDescriptor desc;
 333                                         if (editable)
 334                                                 desc = new TextPropertyDescriptor(REPO_ID_PREFIX + sub,
 335                                                                 sub);
 336                                         else
 337                                                 desc = new PropertyDescriptor(REPO_ID_PREFIX + sub, sub);
 338                                         desc.setCategory(categoryString);
 339                                         resultList.add(desc);
 340                                 }
 341                         }
 342                 }
 343
 344                 return resultList.toArray(new IPropertyDescriptor[0]);
 345         }
 346
 347         private List<String> getSubSections(Config configuration, String key) {
 348
 349                 List<String> result = new ArrayList<String>();
 350
 351                 if (key.indexOf(".?.") < 0) { //$NON-NLS-1$
 352                         result.add(key);
 353                         return result;
 354                 }
 355
 356                 StringTokenizer stok = new StringTokenizer(key, "."); //$NON-NLS-1$
 357                 if (stok.countTokens() == 3) {
 358                         String section = stok.nextToken();
 359                         String subsection = stok.nextToken();
 360                         String name = stok.nextToken();
 361                         if (subsection.equals("?")) { //$NON-NLS-1$
 362                                 Set<String> subs = configuration.getSubsections(section);
 363                                 for (String sub : subs)
 364                                         result.add(section + "." + sub + "." + name); //$NON-NLS-1$ //$NON-NLS-2$
 365                                 return result;
 366                         } else {
 367                                 result.add(key);
 368                         }
 369                 }
 370                 return result;
 371         }
 372
 373         public Object getPropertyValue(Object id) {
 374                 String actId = ((String) id);
 375                 Object value = null;
 376                 if (actId.startsWith(USER_ID_PREFIX)) {
 377                         value = getValueFromConfig(userHomeConfig, actId.substring(4));
 378                 } else if (actId.startsWith(REPO_ID_PREFIX)) {
 379                         value = getValueFromConfig(repositoryConfig, actId.substring(4));
 380                 } else if (actId.startsWith(EFFECTIVE_ID_PREFIX)) {
 381                         value = getValueFromConfig(effectiveConfig, actId.substring(4));
 382                 }
 383                 if (value == null)
 384                         // the text editor needs this to work
 385                         return ""; //$NON-NLS-1$
 386
 387                 return value;
 388         }
 389
 390         public boolean isPropertySet(Object id) {
 391                 String actId = ((String) id);
 392                 Object value = null;
 393                 if (actId.startsWith(USER_ID_PREFIX)) {
 394                         value = getValueFromConfig(userHomeConfig, actId.substring(4));
 395                 } else if (actId.startsWith(REPO_ID_PREFIX)) {
 396                         value = getValueFromConfig(repositoryConfig, actId.substring(4));
 397                 } else if (actId.startsWith(EFFECTIVE_ID_PREFIX)) {
 398                         value = getValueFromConfig(effectiveConfig, actId.substring(4));
 399                 }
 400                 return value != null;
 401         }
 402
 403         public void resetPropertyValue(Object id) {
 404                 setPropertyValue(id, null);
 405         }
 406
 407         public void setPropertyValue(Object id, Object value) {
 408
 409                 String actId = (String) id;
 410                 try {
 411                         if (actId.startsWith(USER_ID_PREFIX)) {
 412                                 setConfigValue(userHomeConfig, actId.substring(4),
 413                                                 (String) value);
 414                         }
 415                         if (actId.startsWith(REPO_ID_PREFIX)) {
 416                                 setConfigValue(repositoryConfig, actId.substring(4),
 417                                                 (String) value);
 418                         }
 419                 } catch (IOException e) {
 420                         showExceptionMessage(e);
 421                 }
 422
 423         }
 424
 425         public boolean isPropertyResettable(Object id) {
 426                 return isPropertySet(id);
 427         }
 428
 429         private void setConfigValue(FileBasedConfig configuration, String key,
 430                         String value) throws IOException {
 431                 // we un-set empty strings, as the config API does not allow to
 432                 // distinguish this case
 433                 // (null is returned, even if the value is set to "", but in the
 434                 // effective configuration
 435                 // this results in shadowing of the base configured values
 436                 StringTokenizer tok = new StringTokenizer(key, "."); //$NON-NLS-1$
 437                 if (tok.countTokens() == 2) {
 438                         if (value == null || value.length() == 0) {
 439                                 configuration.unset(tok.nextToken(), null, tok.nextToken());
 440                         } else {
 441                                 configuration.setString(tok.nextToken(), null, tok.nextToken(),
 442                                                 value);
 443                         }
 444                 }
 445                 if (tok.countTokens() == 3) {
 446                         if (value == null || value.length() == 0) {
 447                                 configuration.unset(tok.nextToken(), tok.nextToken(), tok
 448                                                 .nextToken());
 449                         } else {
 450                                 configuration.setString(tok.nextToken(), tok.nextToken(), tok
 451                                                 .nextToken(), value);
 452                         }
 453
 454                 }
 455                 configuration.save();
 456         }
 457
 458         private void showExceptionMessage(Exception e) {
 459                 org.eclipse.egit.ui.Activator.handleError(UIText.RepositoryPropertySource_ErrorHeader, e, true);
 460         }
 461
 462 }