Example usage for org.apache.commons.io FileUtils writeLines

List of usage examples for org.apache.commons.io FileUtils writeLines

Introduction

In this page you can find the example usage for org.apache.commons.io FileUtils writeLines.

Prototype

public static void writeLines(File file, Collection lines) throws IOException 

Source Link

Document

Writes the toString() value of each item in a collection to the specified File line by line.

Usage

From source file:edu.cmu.cs.lti.ark.fn.identification.latentmodel.LatentAlphabetCreationThreaded.java

public static void writeAlphabetFile(Set<String> alphabet, String filename) throws IOException {
    FileUtils.writeLines(new File(filename), alphabet);
}

From source file:mx.itesm.imb.ImbOperationsImpl.java

/**
 * @see mx.itesm.imb.ImbCommands#generateEntitiesSchemas()
 *//*from   w  w w  .  j  a v a  2s.  c om*/
@SuppressWarnings("unchecked")
public void generateEntitiesSchemas() {
    String tns;
    int tnsIndex;
    File srcFile;
    String antPath;
    int processCode;
    Process process;
    File schemaFile;
    File schemasDir;
    String entityName;
    String packageName;
    File schemagenFile;
    int rootElementIndex;
    String rootElementName;
    List<String> enumNames;
    String schemagenContents;
    String schemaFileContents;
    List<String> outputContents;
    SortedSet<FileDetails> entries;
    List<String> typesSchemaContents;
    List<String> detailsSchemaContents;

    try {
        // Identify the classes that should generate schemas
        antPath = pathResolver.getRoot(Path.SRC_MAIN_JAVA) + File.separatorChar + "**" + File.separatorChar
                + "*_Roo_JavaBean.aj";
        entries = fileManager.findMatchingAntPath(antPath);

        // Clean directory where the schemas will be generated
        schemasDir = new File(pathResolver.getRoot(Path.SRC_MAIN_JAVA) + "/schema_temp");

        // Generate Java Beans for the identified schemas
        for (FileDetails file : entries) {
            srcFile = file.getFile();
            entityName = srcFile.getName().replace("_Roo_JavaBean.aj", "");
            outputContents = new ArrayList<String>();

            // Format file
            packageName = "";
            for (String line : (List<String>) FileUtils.readLines(srcFile)) {
                // Remove annotations
                if (!line.contains("@")) {
                    // Change form aspect to class declaration
                    if (line.startsWith("privileged")) {
                        outputContents.add("@javax.xml.bind.annotation.XmlRootElement(namespace =\"http://"
                                + packageName + "\")\n");
                        outputContents.add(line.replace("privileged", "public").replace("aspect", "class")
                                .replace("_Roo_JavaBean", ""));
                    } else {
                        // Remove aspect details
                        outputContents.add(line.replace(entityName + ".", ""));
                    }
                }

                if (line.startsWith("package")) {
                    packageName = line.replace("package", "").replace(";", "").trim() + ".imb";
                }
            }

            // Write file
            FileUtils.writeLines(new File(schemasDir, entityName + ".java"), outputContents);
            logger.log(Level.INFO, "Generating XML schema for " + srcFile);
        }

        // Copy enum types to avoid compilation errors
        antPath = pathResolver.getRoot(Path.SRC_MAIN_JAVA) + File.separatorChar + "**" + File.separatorChar
                + "*.java";
        entries = fileManager.findMatchingAntPath(antPath);
        enumNames = new ArrayList<String>();
        for (FileDetails file : entries) {
            if (FileUtils.readFileToString(file.getFile()).contains("enum")) {
                enumNames.add(file.getFile().getName().replace(".java", "").toLowerCase());
                FileUtils.copyFile(file.getFile(), new File(schemasDir, file.getFile().getName()));
            }
        }

        // Execute schemagen
        schemagenFile = new File(schemasDir, "build.xml");
        schemagenContents = FileUtils.readFileToString(ImbOperationsImpl.schemagenBuildFile);
        schemagenContents = schemagenContents.replace("${output.dir}", schemasDir.getAbsolutePath());
        schemagenContents = schemagenContents.replace("${src.dir}", schemasDir.getAbsolutePath());
        FileUtils.writeStringToFile(schemagenFile, schemagenContents);
        process = Runtime.getRuntime().exec("ant -buildfile " + schemagenFile.getAbsolutePath());
        processCode = process.waitFor();

        // Error while executing schemagen
        if (processCode != 0) {
            throw new RuntimeException();
        }

        // Merge schemas and clean up
        typesSchemaContents = FileUtils.readLines(new File(schemasDir, "schema1.xsd"));
        detailsSchemaContents = FileUtils.readLines(new File(schemasDir, "schema2.xsd"));
        outputContents = new ArrayList<String>(typesSchemaContents.size() + detailsSchemaContents.size());

        // Elements
        for (String line : typesSchemaContents) {
            if (!line.contains("<xs:import") && !line.contains("</xs:schema")) {
                if (line.contains("<xs:schema")) {
                    tnsIndex = line.indexOf("targetNamespace=") + "targetNamespace=".length() + 1;
                    tns = line.substring(tnsIndex, line.indexOf("\"", tnsIndex));
                    logger.log(Level.INFO, "index: " + tnsIndex + ", tns: " + tns);
                    outputContents.add(line.substring(0, line.length() - 1) + " xmlns:tns=\"" + tns + "\">");
                } else {
                    outputContents.add(line.replace("type=\"", "type=\"tns:"));
                }
            }
        }

        // Details
        for (String line : detailsSchemaContents) {
            if (!line.contains("<xs:import") && !line.contains("<?xml") && !line.contains("<xs:schema")) {
                if (line.contains("type=")) {
                    // References to other types in the same schema
                    if (!line.contains("type=\"xs:")) {
                        outputContents.add(line.replace("type=\"", "type=\"tns:"));
                    } else {
                        outputContents.add(line);
                    }
                } else {
                    outputContents.add(line);
                    // IMB Id
                    if (line.contains("<xs:sequence")) {
                        outputContents.add("<xs:element name=\"imbId\" type=\"xs:long\" minOccurs=\"0\"/>");
                    }
                }
            }
        }

        // Schema file
        schemaFile = new File(pathResolver.getRoot(Path.SRC_MAIN_RESOURCES), "/schema.xsd");
        FileUtils.writeLines(schemaFile, outputContents);

        // Root element
        schemaFileContents = FileUtils.readFileToString(schemaFile);
        rootElementIndex = schemaFileContents.indexOf("xs:element name=\"");
        rootElementName = schemaFileContents.substring(rootElementIndex + "xs:element name=\"".length(),
                schemaFileContents.indexOf("\"", rootElementIndex + "xs:element name=\"".length() + 1));
        schemaFileContents = schemaFileContents.replace("type=\"tns:" + rootElementName + "\"/>", ">");
        schemaFileContents = schemaFileContents.replace("<xs:complexType name=\"" + rootElementName + "\">",
                "<xs:complexType>");
        schemaFileContents = schemaFileContents.replace("</xs:complexType>", "</xs:complexType></xs:element>");
        FileUtils.writeStringToFile(schemaFile, schemaFileContents);

        FileUtils.forceDelete(schemasDir);
        logger.log(Level.INFO, "XML schemas correctly generated");
    } catch (Exception e) {
        logger.log(Level.SEVERE, "Error while generating entities schemas: " + e.getMessage(), e);
    }
}

From source file:net.nifheim.beelzebu.coins.common.utils.FileManager.java

private void updateMessages() {
    try {/*from www . j  a v a 2 s  .  c om*/
        List<String> lines = FileUtils.readLines(messagesFiles.get("default"), Charsets.UTF_8);
        int index;
        if (core.getMessages("").getInt("version") == 6) {
            index = lines.indexOf("version: 6");
            lines.set(index, "version: 7");
            index = lines.indexOf("Multipliers:");
            lines.remove(index);
            index = lines.indexOf("  Menu:");
            lines.add(index, "Multipliers:");
            core.log("Updated messages.yml file to v7");
        }
        if (core.getMessages("").getInt("version") == 7) {
            index = lines.indexOf("version: 7");
            lines.set(index, "version: 8");
            index = lines.indexOf("  Menu:") + 2;
            lines.addAll(index,
                    Arrays.asList("    Confirm:", "      Title: '&8Are you sure?'", "      Accept: '&aYES!'",
                            "      Decline: '&cNope'", "    Multipliers:",
                            "      Name: '&6Multiplier &cx%amount%'", "      Lore:", "      - ''",
                            "      - '&7Amount: &c%amount%'", "      - '&7Server: &c%server%'",
                            "      - '&7Minutes: &c%minutes%'", "      - ''", "      - '&7ID: &c#%id%'",
                            "    No Multipliers:", "      Name: '&cYou don''t have any multiplier :('",
                            "      Lore:", "      - ''", "      - '&7You can buy multipliers in our store'",
                            "      - '&6&nstore.servername.net'"));
            core.log("Updated messages.yml file to v8");
        }
        if (core.getMessages("").getInt("version") == 8) {
            index = lines.indexOf("version: 8");
            lines.set(index, "version: 9");
            lines.removeAll(Arrays.asList("# Coins messages file.",
                    "# If you need support or find a bug open a issuse in",
                    "# the official github repo https://github.com/Beelzebu/Coins/issuses/", "",
                    "# The version of this file, don't edit!"));
            lines.addAll(0,
                    Arrays.asList("# Coins messages file.",
                            "# If you need support or find a bug open a issuse in",
                            "# the official github repo https://github.com/Beelzebu/Coins/issuses/", "",
                            "# The version of this file, is used to auto update this file, don't change it",
                            "# unless you know what you do."));
            core.log("Updated messages.yml file to v9");
        }
        if (core.getMessages("").getInt("version") == 9) {
            index = lines.indexOf("version: 9");
            lines.set(index, "version: 10");
            index = lines.indexOf(
                    "  Multiplier Create: '" + core.getMessages("").getString("Help.Multiplier Create") + "'")
                    + 1;
            lines.add(index,
                    "  Multiplier Set: '%prefix% &cPlease use &f/coins multiplier set <amount> <enabler> <minutes> (server)'");
            lines.addAll(Arrays.asList("  Set:",
                    "  - '%prefix% A multiplier with the following data was set for %server%'",
                    "  - '  &7Enabler: &c%enabler%'", "  - '  &7Amount: &c%amount%'",
                    "  - '  &7Minutes: &c%minutes%'"));
            core.log("Updated messages.yml file to v10");
        }
        FileUtils.writeLines(messagesFiles.get("default"), lines);
    } catch (IOException ex) {
        core.log("An unexpected error occurred while updating the messages.yml file.");
        core.debug(ex.getMessage());
    }
    try {
        List<String> lines = FileUtils.readLines(messagesFiles.get("es"), Charsets.UTF_8);
        int index;
        if (core.getMessages("es").getInt("version") == 6) {
            index = lines.indexOf("version: 6");
            lines.set(index, "version: 7");
            index = lines.indexOf("Multipliers:");
            lines.remove(index);
            index = lines.indexOf("  Menu:");
            lines.add(index, "Multipliers:");
            core.log("Updated messages_es.yml file to v7");
        }
        if (core.getMessages("es").getInt("version") == 7) {
            index = lines.indexOf("version: 7");
            lines.set(index, "version: 8");
            index = lines.indexOf("  Menu:") + 2;
            lines.addAll(index, Arrays.asList("    Confirm:", "      Title: '&8Ests seguro?'",
                    "      Accept: '&aSI!'", "      Decline: '&cNo'", "    Multipliers:",
                    "      Name: '&6Multiplicador &cx%amount%'", "      Lore:", "      - ''",
                    "      - '&7Cantidad: &c%amount%'", "      - '&7Servidor: &c%server%'",
                    "      - '&7Minutos: &c%minutes%'", "      - ''", "      - '&7ID: &c#%id%'",
                    "    No Multipliers:", "      Name: '&cNo tienes ningn multiplicador :('", "      Lore:",
                    "      - ''", "      - '&7Puedes comprar multiplicadores en nuestra tienda'",
                    "      - '&6&nstore.servername.net'"));
            core.log("Updated messages_es.yml file to v8");
        }
        index = lines.indexOf("      - '&6&nstore.servername.net'\"");
        if (index != -1) {
            lines.set(index, "      - '&6&nstore.servername.net'");
        }
        if (core.getMessages("es").getInt("version") == 8) {
            index = lines.indexOf("version: 8");
            lines.set(index, "version: 9");
            lines.removeAll(Arrays.asList("# Coins messages file.",
                    "# If you need support or find a bug open a issuse in",
                    "# the official github repo https://github.com/Beelzebu/Coins/issuses/", "",
                    "# The version of this file, don't edit!"));
            lines.addAll(0, Arrays.asList("# Coins messages file.",
                    "# Si necesitas soporte o encuentras un error por favor abre un ticket en el",
                    "# repositorio oficial de github https://github.com/Beelzebu/Coins/issuses/", "",
                    "# La versin de este archivo, es usado para actualizarlo automticamente, no lo cambies",
                    "# a menos que sepas lo que haces."));
            core.log("Updated messages_es.yml file to v9");
        }
        if (core.getMessages("es").getInt("version") == 9) {
            index = lines.indexOf("version: 9");
            lines.set(index, "version: 10");
            index = lines.indexOf(
                    "  Multiplier Create: '" + core.getMessages("es").getString("Help.Multiplier Create") + "'")
                    + 1;
            lines.add(index,
                    "  Multiplier Set: '%prefix% &cPor favor usa &f/coins multiplier set <cantidad> <activador> <minutos> (server)'");
            lines.addAll(Arrays.asList("  Set:",
                    "  - '%prefix% Un multiplicador con la siguiente informacin fue establecido en %server%'",
                    "  - '  &7Activador: &c%enabler%'", "  - '  &7Cantidad: &c%amount%'",
                    "  - '  &7Minutos: &c%minutes%'"));
            core.log("Updated messages_es.yml file to v10");
        }
        if (lines.get(0).startsWith("  Multiplier Set:")) {
            lines.remove(0);
            index = lines.indexOf(
                    "  Multiplier Create: '" + core.getMessages("es").getString("Help.Multiplier Create") + "'")
                    + 1;
            lines.add(index,
                    "  Multiplier Set: '%prefix% &cPor favor usa &f/coins multiplier set <cantidad> <activador> <minutos> (server)'");
        }
        FileUtils.writeLines(messagesFiles.get("es"), lines);
    } catch (IOException ex) {
        core.log("An unexpected error occurred while updating the messages_es.yml file.");
        core.debug(ex.getMessage());
    }
}

From source file:com.daphne.es.maintain.staticresource.web.controller.StaticResourceVersionController.java

private StaticResource switchStaticResourceContent(String rootRealPath, String versionedResourceRealPath,
        String fileName, String content, boolean isMin) throws IOException {

    StaticResource resource = extractResource(fileName, content);
    String filePath = resource.getUrl();
    filePath = filePath.replace("${ctx}", rootRealPath);

    if (isMin) {/*w  ww. ja  v  a 2 s .co  m*/
        File file = new File(YuiCompressorUtils.getCompressFileName(filePath));
        if (!file.exists()) {
            throw new RuntimeException("" + resource.getUrl());
        }
    } else {
        File file = new File(YuiCompressorUtils.getNoneCompressFileName(filePath));
        if (!file.exists()) {
            throw new RuntimeException("?" + resource.getUrl());
        }
    }

    content = StringEscapeUtils.unescapeXml(content);

    File file = new File(versionedResourceRealPath + fileName);

    List<String> contents = FileUtils.readLines(file);

    for (int i = 0, l = contents.size(); i < l; i++) {
        String fileContent = contents.get(i);
        if (content.equals(fileContent)) {
            Matcher matcher = scriptPattern.matcher(content);
            if (!matcher.matches()) {
                matcher = linkPattern.matcher(content);
            }
            String newUrl = isMin ? YuiCompressorUtils.getCompressFileName(resource.getUrl())
                    : YuiCompressorUtils.getNoneCompressFileName(resource.getUrl());

            content = matcher.replaceAll("$1" + Matcher.quoteReplacement(newUrl) + "$3$4$5");
            contents.set(i, content);

            resource.setContent(content);
            resource.setUrl(newUrl);

            break;
        }
    }
    FileUtils.writeLines(file, contents);

    return resource;
}

From source file:edu.ku.brc.specify.tools.LocalizerSearchHelper.java

/**
 * @param baseDir/*  ww w  .j  av  a 2 s .c  om*/
 * @return
 */
public Vector<Pair<String, String>> findOldL10NKeys(final String[] fileNames) {
    initLucene(true);

    //if (srcCodeFilesDir == null)
    {
        JFileChooser chooser = new JFileChooser();
        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        if (srcCodeFilesDir != null) {
            chooser.setSelectedFile(new File(FilenameUtils.getName(srcCodeFilesDir.getAbsolutePath())));
            chooser.setSelectedFile(new File(srcCodeFilesDir.getParent()));
        }

        if (chooser.showOpenDialog(UIRegistry.getMostRecentWindow()) == JFileChooser.APPROVE_OPTION) {
            srcCodeFilesDir = new File(chooser.getSelectedFile().getAbsolutePath());
        } else {
            return null;
        }
    }

    indexSourceFiles();

    Vector<Pair<String, String>> fullNotFoundList = new Vector<Pair<String, String>>();

    try {
        ConversionLogger convLogger = new ConversionLogger();
        convLogger.initialize("resources", "Resources");

        for (String fileName : fileNames) {
            Vector<Pair<String, String>> notFoundList = new Vector<Pair<String, String>>();

            Vector<String> terms = new Vector<String>();

            String propFileName = baseDir.getAbsolutePath() + "/" + fileName;

            File resFile = new File(propFileName + ".properties");
            if (resFile.exists()) {
                List<?> lines = FileUtils.readLines(resFile);
                for (String line : (List<String>) lines) {
                    if (!line.startsWith("#")) {
                        int inx = line.indexOf("=");
                        if (inx > -1) {
                            String[] toks = StringUtils.split(line, "=");
                            if (toks.length > 1) {
                                terms.add(toks[0]);
                            }
                        }
                    }
                }
            } else {
                System.err.println("Doesn't exist: " + resFile.getAbsolutePath());
            }

            String field = "contents";
            QueryParser parser = new QueryParser(Version.LUCENE_36, field, analyzer);

            for (String term : terms) {
                Query query;
                try {
                    if (term.equals("AND") || term.equals("OR"))
                        continue;

                    query = parser.parse(term);

                    String subTerm = null;
                    int hits = getTotalHits(query, 10);
                    if (hits == 0) {
                        int inx = term.indexOf('.');
                        if (inx > -1) {
                            subTerm = term.substring(inx + 1);
                            hits = getTotalHits(parser.parse(subTerm), 10);

                            if (hits == 0) {
                                int lastInx = term.lastIndexOf('.');
                                if (lastInx > -1 && lastInx != inx) {
                                    subTerm = term.substring(lastInx + 1);
                                    hits = getTotalHits(parser.parse(subTerm), 10);
                                }
                            }
                        }
                    }

                    if (hits == 0 && !term.endsWith("_desc")) {
                        notFoundList.add(new Pair<String, String>(term, subTerm));

                        log.debug("'" + term + "' was not found "
                                + (subTerm != null ? ("SubTerm[" + subTerm + "]") : ""));
                    }

                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }

            String fullName = propFileName + ".html";
            TableWriter tblWriter = convLogger.getWriter(FilenameUtils.getName(fullName), propFileName);
            tblWriter.startTable();
            tblWriter.logHdr("Id", "Full Key", "Sub Key");
            int cnt = 1;
            for (Pair<String, String> pair : notFoundList) {
                tblWriter.log(Integer.toString(cnt++), pair.first,
                        pair.second != null ? pair.second : "&nbsp;");
            }
            tblWriter.endTable();

            fullNotFoundList.addAll(notFoundList);

            if (notFoundList.size() > 0 && resFile.exists()) {
                List<String> lines = (List<String>) FileUtils.readLines(resFile);
                Vector<String> linesCache = new Vector<String>();

                for (Pair<String, String> p : notFoundList) {
                    linesCache.clear();
                    linesCache.addAll(lines);

                    int lineInx = 0;
                    for (String line : linesCache) {
                        if (!line.startsWith("#")) {
                            int inx = line.indexOf("=");
                            if (inx > -1) {
                                String[] toks = StringUtils.split(line, "=");
                                if (toks.length > 1) {
                                    if (toks[0].equals(p.first)) {
                                        lines.remove(lineInx);
                                        break;
                                    }
                                }
                            }
                        }
                        lineInx++;
                    }
                }
                FileUtils.writeLines(resFile, linesCache);
            }

        }
        convLogger.closeAll();

    } catch (IOException ex) {
        edu.ku.brc.af.core.UsageTracker.incrHandledUsageCount();
        edu.ku.brc.exceptions.ExceptionTracker.getInstance().capture(LocalizerSearchHelper.class, ex);
        ex.printStackTrace();
    }

    return fullNotFoundList;
}

From source file:com.demonwav.mcdev.buildsystem.gradle.GradleBuildSystem.java

private void setupWrapper(@NotNull Project project, @NotNull ProgressIndicator indicator) {
    // Setup gradle wrapper
    // We'll write the properties file to ensure it sets up with the right version
    Util.runWriteTask(() -> {//from  w w w.ja  v a 2 s.  co  m
        try {
            String wrapperDirPath = rootDirectory.createChildDirectory(this, "gradle")
                    .createChildDirectory(this, "wrapper").getPath();
            FileUtils.writeLines(new File(wrapperDirPath, "gradle-wrapper.properties"),
                    Collections.singletonList(
                            "distributionUrl=https\\://services.gradle.org/distributions/gradle-2.14.1-bin.zip"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    });

    // Use gradle tooling to run the wrapper task
    GradleConnector connector = GradleConnector.newConnector();
    connector.forProjectDirectory(new File(rootDirectory.getPath()));
    ProjectConnection connection = connector.connect();
    BuildLauncher launcher = connection.newBuild();
    try {
        Pair<String, Sdk> sdkPair = ExternalSystemJdkUtil.getAvailableJdk(project);
        if (sdkPair != null && sdkPair.getSecond() != null && sdkPair.getSecond().getHomePath() != null
                && !ExternalSystemJdkUtil.USE_INTERNAL_JAVA.equals(sdkPair.getFirst())) {

            launcher.setJavaHome(new File(sdkPair.getSecond().getHomePath()));
        }

        launcher.forTasks("wrapper")
                .addProgressListener(
                        (ProgressListener) progressEvent -> indicator.setText(progressEvent.getDescription()))
                .run();
    } finally {
        connection.close();
    }
}

From source file:es.uvigo.ei.sing.adops.operations.running.ExecuteExperimentBySteps.java

@Port(direction = Direction.OUTPUT, order = 5000)
public ExperimentOutput getResult() throws OperationException {
    try {/*  ww  w. j ava 2 s  .  c  o m*/
        this.progress.setStatus("Generating summary file");

        this.checkInterrupted();

        FileUtils.writeLines(this.experimentOutput.getSummaryFile(),
                Arrays.asList("--- EXPERIMENT NOTES",
                        FileUtils.readFileToString(this.experiment.getNotesFile()), "\n--- WARNINGS",
                        this.experiment.getWarnings(), "\n--- EXPERIMENT PROPERTIES",
                        this.experiment.getConfiguration().toString(), "\n--- PSRF SUMMARY",
                        FileUtils.readFileToString(this.experimentOutput.getPsrfFile()), "\n--- CODEML SUMMARY",
                        FileUtils.readFileToString(this.experimentOutput.getCodeMLSummaryFile())));

        if (this.logPS != null)
            this.logPS.close();

        this.experimentOutput.setFinished(true);
        this.experiment.setRunning(false);

        return this.experimentOutput;
    } catch (IOException ioe) {
        this.clearWhenException();
        throw new OperationException("Error generating result", ioe);
    } catch (InterruptedException ie) {
        this.clearWhenInterrupted();

        return null;
    } catch (Exception e) {
        this.clearWhenException();
        throw new OperationException("Unexpected error summarizing results", e);
    }
}

From source file:com.adguard.android.service.FilterServiceImpl.java

@Override
public void applyNewSettings() {
    setShowUsefulAds(preferencesService.isShowUsefulAds());

    List<String> rules = getAllEnabledRules(true);
    Set<String> userRules = getUserRules();
    if (!userRules.isEmpty()) {
        for (String userRule : userRules) {
            userRule = StringUtils.trim(userRule);

            if (validateRuleText(userRule)) {
                rules.add(userRule);//from  w ww  .j  a v  a2s . co m
            }
        }
    }

    cachedFilterRuleCount = rules.size();

    try {
        LOG.info("Saving {} filters...", cachedFilterRuleCount);
        FileUtils.writeLines(new File(context.getFilesDir().getAbsolutePath() + "/filters.txt"), rules);
        preferencesService.setFilterRuleCount(cachedFilterRuleCount);
        enableContentBlocker(context);
    } catch (IOException e) {
        LOG.warn("Unable to save filters to file!!!", e);
    }
}

From source file:com.blackducksoftware.tools.commonframework.core.config.ConfigurationFile.java

/**
 * Save the file, encrypting passwords that need it. Does not change the
 * state of this object (lines and props continue to contain the original
 * file contents).// w w w .  ja  v a  2  s  .c  om
 *
 * @return
 * @throws IllegalArgumentException
 *             to avoid the need to change ConfigurationManager too much.
 */
public List<String> saveWithEncryptedPasswords() {
    if (!isInNeedOfUpdate()) {
        return null;
    }
    log.info("Updating configuration file " + file.getAbsolutePath()
            + "; encrypting passwords and adjusting password properties.");
    List<String> updatedLines = null;
    try {
        updatedLines = encryptPasswords();
    } catch (final Exception e) {
        final String msg = "Error encrypting passwords for file: " + file.getAbsolutePath() + ": "
                + e.getMessage();
        log.error(msg);
        throw new IllegalArgumentException(msg);
    }
    try {
        FileUtils.writeLines(file, updatedLines);
    } catch (final IOException e) {
        final String msg = "Error saving file: " + file.getAbsolutePath() + ": " + e.getMessage();
        log.error(msg);
        throw new IllegalArgumentException(msg);
    }
    return updatedLines;
}

From source file:ml.shifu.shifu.core.processor.ExportModelProcessor.java

@Override
public int run() throws Exception {
    setUp(ModelStep.EXPORT);/*w  ww  .  j a  v  a 2s. c o  m*/

    int status = 0;
    File pmmls = new File("pmmls");
    FileUtils.forceMkdir(pmmls);

    if (StringUtils.isBlank(type)) {
        type = PMML;
    }

    String modelsPath = pathFinder.getModelsPath(SourceType.LOCAL);
    if (type.equalsIgnoreCase(ONE_BAGGING_MODEL)) {
        if (!"nn".equalsIgnoreCase(modelConfig.getAlgorithm())
                && !CommonUtils.isTreeModel(modelConfig.getAlgorithm())) {
            log.warn("Currently one bagging model is only supported in NN/GBT/RF algorithm.");
        } else {
            List<BasicML> models = ModelSpecLoaderUtils.loadBasicModels(modelsPath,
                    ALGORITHM.valueOf(modelConfig.getAlgorithm().toUpperCase()));
            if (models.size() < 1) {
                log.warn("No model is found in {}.", modelsPath);
            } else {
                log.info("Convert nn models into one binary bagging model.");
                Configuration conf = new Configuration();
                Path output = new Path(pathFinder.getBaggingModelPath(SourceType.LOCAL),
                        "model.b" + modelConfig.getAlgorithm());
                if ("nn".equalsIgnoreCase(modelConfig.getAlgorithm())) {
                    BinaryNNSerializer.save(modelConfig, columnConfigList, models, FileSystem.getLocal(conf),
                            output);
                } else if (CommonUtils.isTreeModel(modelConfig.getAlgorithm())) {
                    List<List<TreeNode>> baggingTrees = new ArrayList<List<TreeNode>>();
                    for (int i = 0; i < models.size(); i++) {
                        TreeModel tm = (TreeModel) models.get(i);
                        // TreeModel only has one TreeNode instance although it is list inside
                        baggingTrees.add(tm.getIndependentTreeModel().getTrees().get(0));
                    }

                    int[] inputOutputIndex = DTrainUtils
                            .getNumericAndCategoricalInputAndOutputCounts(this.columnConfigList);
                    // numerical + categorical = # of all input
                    int inputCount = inputOutputIndex[0] + inputOutputIndex[1];

                    BinaryDTSerializer.save(modelConfig, columnConfigList, baggingTrees,
                            modelConfig.getParams().get("Loss").toString(), inputCount,
                            FileSystem.getLocal(conf), output);
                }
                log.info("Please find one unified bagging model in local {}.", output);
            }
        }
    } else if (type.equalsIgnoreCase(PMML)) {
        // typical pmml generation
        List<BasicML> models = ModelSpecLoaderUtils.loadBasicModels(modelsPath,
                ALGORITHM.valueOf(modelConfig.getAlgorithm().toUpperCase()));

        PMMLTranslator translator = PMMLConstructorFactory.produce(modelConfig, columnConfigList, isConcise(),
                false);

        for (int index = 0; index < models.size(); index++) {
            String path = "pmmls" + File.separator + modelConfig.getModelSetName() + Integer.toString(index)
                    + ".pmml";
            log.info("\t Start to generate " + path);
            PMML pmml = translator.build(Arrays.asList(new BasicML[] { models.get(index) }));
            PMMLUtils.savePMML(pmml, path);
        }
    } else if (type.equalsIgnoreCase(ONE_BAGGING_PMML_MODEL)) {
        // one unified bagging pmml generation
        log.info("Convert models into one bagging pmml model {} format", type);
        if (!"nn".equalsIgnoreCase(modelConfig.getAlgorithm())) {
            log.warn("Currently one bagging pmml model is only supported in NN algorithm.");
        } else {
            List<BasicML> models = ModelSpecLoaderUtils.loadBasicModels(modelsPath,
                    ALGORITHM.valueOf(modelConfig.getAlgorithm().toUpperCase()));
            PMMLTranslator translator = PMMLConstructorFactory.produce(modelConfig, columnConfigList,
                    isConcise(), true);
            String path = "pmmls" + File.separator + modelConfig.getModelSetName() + ".pmml";
            log.info("\t Start to generate one unified model to: " + path);
            PMML pmml = translator.build(models);
            PMMLUtils.savePMML(pmml, path);
        }
    } else if (type.equalsIgnoreCase(COLUMN_STATS)) {
        saveColumnStatus();
    } else if (type.equalsIgnoreCase(WOE_MAPPING)) {
        List<ColumnConfig> exportCatColumns = new ArrayList<ColumnConfig>();
        List<String> catVariables = getRequestVars();
        for (ColumnConfig columnConfig : this.columnConfigList) {
            if (CollectionUtils.isEmpty(catVariables) || isRequestColumn(catVariables, columnConfig)) {
                exportCatColumns.add(columnConfig);
            }
        }

        if (CollectionUtils.isNotEmpty(exportCatColumns)) {
            List<String> woeMappings = new ArrayList<String>();
            for (ColumnConfig columnConfig : exportCatColumns) {
                String woeMapText = rebinAndExportWoeMapping(columnConfig);
                woeMappings.add(woeMapText);
            }
            FileUtils.write(new File("woemapping.txt"), StringUtils.join(woeMappings, ",\n"));
        }
    } else if (type.equalsIgnoreCase(WOE)) {
        List<String> woeInfos = new ArrayList<String>();
        for (ColumnConfig columnConfig : this.columnConfigList) {
            if (columnConfig.getBinLength() > 1 && ((columnConfig.isCategorical()
                    && CollectionUtils.isNotEmpty(columnConfig.getBinCategory()))
                    || (columnConfig.isNumerical() && CollectionUtils.isNotEmpty(columnConfig.getBinBoundary())
                            && columnConfig.getBinBoundary().size() > 1))) {
                List<String> varWoeInfos = generateWoeInfos(columnConfig);
                if (CollectionUtils.isNotEmpty(varWoeInfos)) {
                    woeInfos.addAll(varWoeInfos);
                    woeInfos.add("");
                }
            }
            FileUtils.writeLines(new File("varwoe_info.txt"), woeInfos);
        }
    } else if (type.equalsIgnoreCase(CORRELATION)) {
        // export correlation into mapping list
        if (!ShifuFileUtils.isFileExists(pathFinder.getLocalCorrelationCsvPath(), SourceType.LOCAL)) {
            log.warn("The correlation file doesn't exist. Please make sure you have ran `shifu stats -c`.");
            return 2;
        }
        return exportVariableCorr();
    } else {
        log.error("Unsupported output format - {}", type);
        status = -1;
    }

    clearUp(ModelStep.EXPORT);

    log.info("Done.");

    return status;
}