CopyrightFileConfigManager.java

/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package consulo.copyright.config;

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.FileTypeRegistry;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.openapi.util.JDOMExternalizable;
import com.intellij.openapi.util.WriteExternalException;
import com.maddyhome.idea.copyright.CopyrightUpdaters;
import com.maddyhome.idea.copyright.psi.UpdateCopyrightsProvider;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;

import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 */
public class CopyrightFileConfigManager implements JDOMExternalizable, Cloneable {
  public static final Logger LOGGER = Logger.getInstance(CopyrightFileConfigManager.class);

  public abstract class LoadedOption {
    public abstract CopyrightFileConfig getConfig();

    public abstract void read(Element element) throws InvalidDataException;

    public abstract void write(Element element) throws WriteExternalException;
  }

  public class TemplateLoadedOption extends LoadedOption {
    private CopyrightFileConfig myCopyrightFileConfig;

    public TemplateLoadedOption() {
      this(new CopyrightFileConfig());
    }

    public TemplateLoadedOption(CopyrightFileConfig copyrightFileConfig) {
      myCopyrightFileConfig = copyrightFileConfig;
    }

    @Override
    public CopyrightFileConfig getConfig() {
      return myCopyrightFileConfig;
    }

    @Override
    public void read(Element element) throws InvalidDataException {
      myCopyrightFileConfig.readExternal(element);
    }

    @Override
    public void write(Element element) throws WriteExternalException {
      myCopyrightFileConfig.writeExternal(element);
    }
  }

  public class ValidLoadedOption extends LoadedOption {
    private CopyrightFileConfig myCopyrightFileConfig;

    protected ValidLoadedOption(@NotNull CopyrightFileConfig options) {
      myCopyrightFileConfig = options;
    }

    @Override
    public CopyrightFileConfig getConfig() {
      return myCopyrightFileConfig;
    }

    @Override
    public void read(Element element) throws InvalidDataException{
      myCopyrightFileConfig.readExternal(element);
    }

    @Override
    public void write(Element element) throws WriteExternalException {
      myCopyrightFileConfig.writeExternal(element);
    }
  }

  public class UnknownLoadedOption extends LoadedOption {
    private Element myElement;

    @Override
    public CopyrightFileConfig getConfig() {
      return new CopyrightFileConfig();
    }

    @Override
    public void read(Element element) throws InvalidDataException {
      myElement = element;
    }

    @Override
    public void write(Element element) throws WriteExternalException {
      element.addContent(myElement.cloneContent());
    }
  }

  public static final String LANG_TEMPLATE = "__TEMPLATE__";

  private Map<String, LoadedOption> myConfigs = new TreeMap<String, LoadedOption>();

  @NotNull
  public CopyrightFileConfig getOptions(@NotNull FileType type) {
    LoadedOption copyrightFileConfig = myConfigs.get(type.getName());
    if (copyrightFileConfig == null) {
      UpdateCopyrightsProvider updateCopyrightsProvider = CopyrightUpdaters.INSTANCE.forFileType(type);
      if (updateCopyrightsProvider == null) {
        return CopyrightFileConfig.DEFAULT_SETTINGS_HOLDER;
      }
      return updateCopyrightsProvider.createDefaultOptions();
    }
    return copyrightFileConfig.getConfig();
  }

  @NotNull
  public CopyrightFileConfig getTemplateOptions() {
    LoadedOption copyrightFileConfig = myConfigs.get(LANG_TEMPLATE);
    if (copyrightFileConfig == null) {
      return CopyrightFileConfig.DEFAULT_SETTINGS_HOLDER;
    }
    return copyrightFileConfig.getConfig();
  }

  public void setTemplateOptions(@NotNull CopyrightFileConfig options) {
    myConfigs.put(LANG_TEMPLATE, new TemplateLoadedOption(options));
  }

  public void setOptions(@NotNull FileType fileType, @NotNull CopyrightFileConfig options) {
    myConfigs.put(fileType.getName(), new ValidLoadedOption(options));
  }

  @NotNull
  public CopyrightFileConfig getMergedOptions(@NotNull FileType fileType) {
    try {
      CopyrightFileConfig lang = getOptions(fileType).clone();
      CopyrightFileConfig temp = getTemplateOptions().clone();
      switch (lang.getFileTypeOverride()) {
        case CopyrightFileConfig.USE_TEMPLATE:
          temp.setFileLocation(lang.getFileLocation());
          temp.setFileTypeOverride(lang.getFileTypeOverride());
          lang = temp;
          break;
        case CopyrightFileConfig.USE_TEXT:
          break;
      }

      return lang;
    }
    catch (CloneNotSupportedException e) {
      // This shouldn't happen
    }

    return new CopyrightFileConfig();
  }

  @Override
  public void readExternal(Element element) throws InvalidDataException {
    List<Element> langs = element.getChildren("LanguageOptions");
    for (Element configElement : langs) {
      String name = configElement.getAttributeValue("name");

      final LoadedOption option;

      if(LANG_TEMPLATE.equals(name)) {
        option = new TemplateLoadedOption();
      }
      else {
        FileType fileTypeByName = FileTypeRegistry.getInstance().findFileTypeByName(name);
        if (fileTypeByName == null) {
          option = new UnknownLoadedOption();
        }
        else {
          UpdateCopyrightsProvider updateCopyrightsProvider = CopyrightUpdaters.INSTANCE.forFileType(fileTypeByName);
          if(updateCopyrightsProvider == null) {
            option = new UnknownLoadedOption();
          }
          else {
            option = new ValidLoadedOption(updateCopyrightsProvider.createDefaultOptions());
          }
        }
      }

      option.read(configElement);

      myConfigs.put(name, option);
    }
  }

  @Override
  public void writeExternal(Element element) throws WriteExternalException {
    for (Map.Entry<String, LoadedOption> entry : myConfigs.entrySet()) {
      Element elem = new Element("LanguageOptions");
      elem.setAttribute("name", entry.getKey());
      element.addContent(elem);

      entry.getValue().write(elem);
    }
  }
}