DialyzerPreferences.java

package org.erlide.dialyzer.builder;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.preferences.IPreferencesService;
import org.erlide.core.ErlangCore;
import org.erlide.engine.util.PreferencesHelper;
import org.erlide.util.PreferencesUtils;
import org.osgi.service.prefs.BackingStoreException;

import com.google.common.base.Charsets;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.io.Files;

public final class DialyzerPreferences {

    private static final String QUALIFIER = ErlangCore.PLUGIN_ID + "/dialyzer";

    private final PreferencesHelper helper;

    private String pltPaths;
    private Collection<String> pltPathsFromPrefs;
    private String enabledPltPaths;
    private boolean fromSource;
    private boolean dialyzeOnCompile;
    private boolean noCheckPLT;
    private boolean removeWarningsOnClean;

    public static DialyzerPreferences get(final IProject project) {
        final DialyzerPreferences prefs = new DialyzerPreferences();
        prefs.load();
        if (project != null) {
            final DialyzerPreferences projectPrefs = new DialyzerPreferences(project);
            projectPrefs.load();
            projectPrefs.pltPaths = prefs.pltPaths;
            return projectPrefs;
        }
        return prefs;
    }

    private DialyzerPreferences() {
        helper = PreferencesHelper.getHelper(QUALIFIER);
    }

    private DialyzerPreferences(final IProject project) {
        helper = PreferencesHelper.getHelper(QUALIFIER, project);
    }

    public boolean hasOptionsAtLowestScope() {
        return helper.hasAnyAtLowestScope();
    }

    public void store() throws BackingStoreException {
        helper.putString(DialyzerPreferencesConstants.PLT_PATHS, pltPaths);
        helper.putString(DialyzerPreferencesConstants.ENABLED_PLT_PATHS, enabledPltPaths);
        helper.putBoolean(DialyzerPreferencesConstants.FROM_SOURCE, getFromSource());
        helper.putBoolean(DialyzerPreferencesConstants.DIALYZE_ON_COMPILE,
                getDialyzeOnCompile());
        helper.putBoolean(DialyzerPreferencesConstants.NO_CHECK_PLT, noCheckPLT);
        helper.putBoolean(DialyzerPreferencesConstants.REMOVE_WARNINGS_ON_CLEAN,
                removeWarningsOnClean);
        helper.flush();
    }

    private static Collection<String> getPLTPathsFromPreferences() {
        final IPreferencesService service = Platform.getPreferencesService();
        final String key = "default_plt_files";
        final String pluginId = "org.erlide.ui";
        final String pltFilesString = service.getString(pluginId, key, "", null);
        return getPltFiles(pltFilesString);
    }

    public static String getAlternatePLTFileDirectoryFromPreferences() {
        final IPreferencesService service = Platform.getPreferencesService();
        final String key = "alternate_plt_file_directory";
        final String pluginId = "org.erlide.ui";
        return service.getString(pluginId, key, "", null);
    }

    public void load() {
        pltPaths = helper.getString(DialyzerPreferencesConstants.PLT_PATHS, "");
        pltPathsFromPrefs = getPLTPathsFromPreferences();
        enabledPltPaths = helper.getString(DialyzerPreferencesConstants.ENABLED_PLT_PATHS,
                pltPaths);
        setFromSource(helper.getBoolean(DialyzerPreferencesConstants.FROM_SOURCE, true));
        setDialyzeOnCompile(helper
                .getBoolean(DialyzerPreferencesConstants.DIALYZE_ON_COMPILE, false));
        noCheckPLT = helper.getBoolean(DialyzerPreferencesConstants.NO_CHECK_PLT, true);
        removeWarningsOnClean = helper
                .getBoolean(DialyzerPreferencesConstants.REMOVE_WARNINGS_ON_CLEAN, true);
    }

    @Override
    public String toString() {
        return pltPaths + ", " + getFromSource() + ", " + getDialyzeOnCompile();
    }

    public void removeAllProjectSpecificSettings() {
        helper.removeAllAtLowestScope();
    }

    public void setFromSource(final boolean fromSource) {
        this.fromSource = fromSource;
    }

    public boolean getFromSource() {
        return fromSource;
    }

    public void setPltPaths(final Collection<String> pltPaths) {
        final List<String> paths = Lists.newArrayList(pltPaths);
        if (pltPathsFromPrefs != null) {
            for (final String path : pltPathsFromPrefs) {
                paths.remove(path);
            }
        }
        this.pltPaths = PreferencesUtils.packList(paths);
    }

    public Collection<String> getPltPaths() {
        final Set<String> result = Sets.newHashSet();
        result.addAll(PreferencesUtils.unpackList(pltPaths));
        if (pltPathsFromPrefs != null) {
            result.addAll(pltPathsFromPrefs);
        }
        return result;
    }

    public void setDialyzeOnCompile(final boolean dialyzeOnCompile) {
        this.dialyzeOnCompile = dialyzeOnCompile;
    }

    public boolean getDialyzeOnCompile() {
        return dialyzeOnCompile;
    }

    public boolean getNoCheckPLT() {
        return noCheckPLT;
    }

    public void setEnabledPltPaths(final Collection<String> enabledPltPaths) {
        this.enabledPltPaths = PreferencesUtils.packList(enabledPltPaths);
    }

    public Collection<String> getEnabledPltPaths() {
        return PreferencesUtils.unpackList(enabledPltPaths);
    }

    public void setNoCheckPLT(final boolean noCheckPLT) {
        this.noCheckPLT = noCheckPLT;
    }

    public void setRemoveWarningsOnClean(final boolean removeWarningsOnClean) {
        this.removeWarningsOnClean = removeWarningsOnClean;
    }

    public boolean getRemoveWarningsOnClean() {
        return removeWarningsOnClean;
    }

    private static Collection<String> getPltFiles(final String pltFilesString) {
        final Iterable<String> files = Splitter.on(",").split(pltFilesString);
        return getPltFiles(files);
    }

    private static Collection<String> getPltFiles(final Iterable<String> files) {
        final List<String> result = Lists.newArrayList();
        for (final String fileName : files) {
            final File file = new File(fileName);
            final IPath p = new Path(fileName);
            if ("plt".equals(p.getFileExtension())) {
                if (file.exists()) {
                    result.add(fileName);
                }
            } else {
                try {
                    final List<String> lines = Files.readLines(file, Charsets.UTF_8);
                    result.addAll(getPltFiles(lines));
                } catch (final IOException e) {
                    // ignore
                }
            }
        }
        return result;
    }
}