| /* |
| * Licensed to the Apache Software Foundation (ASF) under one * |
| * or more contributor license agreements. See the NOTICE file * |
| * distributed with this work for additional information * |
| * regarding copyright ownership. The ASF licenses this file * |
| * to you 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 org.apache.rat; |
| |
| import org.apache.commons.cli.CommandLine; |
| import org.apache.commons.cli.HelpFormatter; |
| import org.apache.commons.cli.Option; |
| import org.apache.commons.cli.OptionBuilder; |
| import org.apache.commons.cli.OptionGroup; |
| import org.apache.commons.cli.Options; |
| import org.apache.commons.cli.ParseException; |
| import org.apache.commons.cli.PosixParser; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.filefilter.NotFileFilter; |
| import org.apache.commons.io.filefilter.OrFileFilter; |
| import org.apache.commons.io.filefilter.RegexFileFilter; |
| import org.apache.commons.io.filefilter.WildcardFileFilter; |
| import org.apache.rat.api.RatException; |
| import org.apache.rat.report.IReportable; |
| import org.apache.rat.report.RatReport; |
| import org.apache.rat.report.claim.ClaimStatistic; |
| import org.apache.rat.report.xml.XmlReportFactory; |
| import org.apache.rat.report.xml.writer.IXmlWriter; |
| import org.apache.rat.report.xml.writer.impl.base.XmlWriter; |
| import org.apache.rat.walker.ArchiveWalker; |
| import org.apache.rat.walker.DirectoryWalker; |
| |
| import javax.xml.transform.TransformerConfigurationException; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PipedReader; |
| import java.io.PipedWriter; |
| import java.io.PrintStream; |
| import java.io.Writer; |
| import java.util.List; |
| |
| |
| public class Report { |
| private static final char EXCLUDE_CLI = 'e'; |
| private static final char EXCLUDE_FILE_CLI = 'E'; |
| private static final char STYLESHEET_CLI = 's'; |
| |
| //@SuppressWarnings("unchecked") |
| public static final void main(String args[]) throws Exception { |
| final ReportConfiguration configuration = new ReportConfiguration(); |
| configuration.setHeaderMatcher(Defaults.createDefaultMatcher()); |
| configuration.setApproveDefaultLicenses(true); |
| Options opts = buildOptions(); |
| |
| PosixParser parser = new PosixParser(); |
| CommandLine cl = null; |
| try { |
| cl = parser.parse(opts, args); |
| } catch (ParseException e) { |
| System.err.println("Please use the \"--help\" option to see a list of valid commands and options"); |
| System.exit(1); |
| return; // dummy return (won't be reached) to avoid Eclipse complaint about possible NPE for "cl" |
| } |
| |
| if (cl.hasOption('h')) { |
| printUsage(opts); |
| } |
| |
| args = cl.getArgs(); |
| if (args == null || args.length != 1) { |
| printUsage(opts); |
| } else { |
| Report report = new Report(args[0]); |
| |
| if (cl.hasOption('a') || cl.hasOption('A')) { |
| configuration.setAddingLicenses(true); |
| configuration.setAddingLicensesForced(cl.hasOption('f')); |
| configuration.setCopyrightMessage(cl.getOptionValue("c")); |
| } |
| |
| if (cl.hasOption(EXCLUDE_CLI)) { |
| String[] excludes = cl.getOptionValues(EXCLUDE_CLI); |
| if (excludes != null) { |
| final FilenameFilter filter = new NotFileFilter(new WildcardFileFilter(excludes)); |
| report.setInputFileFilter(filter); |
| } |
| } else if (cl.hasOption(EXCLUDE_FILE_CLI)) { |
| String excludeFileName = cl.getOptionValue(EXCLUDE_FILE_CLI); |
| if (excludeFileName != null) { |
| List<String> excludes = FileUtils.readLines(new File(excludeFileName)); |
| final OrFileFilter orFilter = new OrFileFilter(); |
| for (String exclude : excludes) { |
| orFilter.addFileFilter(new RegexFileFilter(exclude)); |
| } |
| final FilenameFilter filter = new NotFileFilter(orFilter); |
| report.setInputFileFilter(filter); |
| } |
| } |
| if (cl.hasOption('x')) { |
| report.report(System.out, configuration); |
| } else { |
| if (!cl.hasOption(STYLESHEET_CLI)) { |
| report.styleReport(System.out, configuration); |
| } else { |
| String[] style = cl.getOptionValues(STYLESHEET_CLI); |
| if (style.length != 1) { |
| System.err.println("please specify a single stylesheet"); |
| System.exit(1); |
| } |
| try { |
| report(System.out, |
| report.getDirectory(System.out), |
| new FileInputStream(style[0]), |
| configuration); |
| } catch (FileNotFoundException fnfe) { |
| System.err.println("stylesheet " + style[0] |
| + " doesn't exist"); |
| System.exit(1); |
| } |
| } |
| } |
| } |
| } |
| |
| private static Options buildOptions() { |
| Options opts = new Options(); |
| |
| Option help = new Option("h", "help", false, |
| "Print help for the Rat command line interface and exit"); |
| opts.addOption(help); |
| |
| OptionGroup addLicenseGroup = new OptionGroup(); |
| String addLicenseDesc = "Add the default license header to any file with an unknown license that is not in the exclusion list. " + |
| "By default new files will be created with the license header, " + |
| "to force the modification of existing files use the --force option."; |
| |
| // RAT-85/RAT-203: Deprecated! added only for convenience and for backwards compatibility |
| Option addLicence = new Option( |
| "a", |
| "addLicence", |
| false, |
| addLicenseDesc); |
| addLicenseGroup.addOption(addLicence); |
| Option addLicense = new Option( |
| "A", |
| "addLicense", |
| false, |
| addLicenseDesc); |
| addLicenseGroup.addOption(addLicense); |
| opts.addOptionGroup(addLicenseGroup); |
| |
| Option write = new Option( |
| "f", |
| "force", |
| false, |
| "Forces any changes in files to be written directly to the source files (i.e. new files are not created)"); |
| opts.addOption(write); |
| |
| Option copyright = new Option( |
| "c", |
| "copyright", |
| true, |
| "The copyright message to use in the license headers, usually in the form of \"Copyright 2008 Foo\""); |
| opts.addOption(copyright); |
| |
| @SuppressWarnings("static-access") // ignore OptionBuilder design fault |
| final Option exclude = OptionBuilder |
| .withArgName("expression") |
| .withLongOpt("exclude") |
| .hasArgs() |
| .withDescription("Excludes files matching wildcard <expression>. " + |
| "Note that --dir is required when using this parameter. " + |
| "Allows multiple arguments.") |
| .create(EXCLUDE_CLI); |
| opts.addOption(exclude); |
| |
| @SuppressWarnings("static-access") // ignore OptionBuilder design fault |
| final Option excludeFile = OptionBuilder |
| .withArgName("fileName") |
| .withLongOpt("exclude-file") |
| .hasArgs() |
| .withDescription("Excludes files matching regular expression in <file> " + |
| "Note that --dir is required when using this parameter. ") |
| .create(EXCLUDE_FILE_CLI); |
| opts.addOption(excludeFile); |
| |
| Option dir = new Option( |
| "d", |
| "dir", |
| false, |
| "Used to indicate source when using --exclude"); |
| opts.addOption(dir); |
| |
| OptionGroup outputType = new OptionGroup(); |
| |
| Option xml = new Option( |
| "x", |
| "xml", |
| false, |
| "Output the report in raw XML format. Not compatible with -s"); |
| outputType.addOption(xml); |
| |
| Option xslt = new Option(String.valueOf(STYLESHEET_CLI), |
| "stylesheet", |
| true, |
| "XSLT stylesheet to use when creating the" |
| + " report. Not compatible with -x"); |
| outputType.addOption(xslt); |
| opts.addOptionGroup(outputType); |
| |
| return opts; |
| } |
| |
| private static final void printUsage(Options opts) { |
| HelpFormatter f = new HelpFormatter(); |
| String header = "Options"; |
| |
| StringBuilder footer = new StringBuilder("\nNOTE:\n"); |
| footer.append("Rat is really little more than a grep ATM\n"); |
| footer.append("Rat is also rather memory hungry ATM\n"); |
| footer.append("Rat is very basic ATM\n"); |
| footer.append("Rat highlights possible issues\n"); |
| footer.append("Rat reports require interpretation\n"); |
| footer.append("Rat often requires some tuning before it runs well against a project\n"); |
| footer.append("Rat relies on heuristics: it may miss issues\n"); |
| |
| f.printHelp("java rat.report [options] [DIR|TARBALL]", |
| header, opts, footer.toString(), false); |
| System.exit(0); |
| } |
| |
| private final String baseDirectory; |
| |
| private FilenameFilter inputFileFilter = null; |
| |
| private Report(String baseDirectory) { |
| this.baseDirectory = baseDirectory; |
| } |
| |
| /** |
| * Gets the current filter used to select files. |
| * |
| * @return current file filter, or null when no filter has been set |
| */ |
| public FilenameFilter getInputFileFilter() { |
| return inputFileFilter; |
| } |
| |
| /** |
| * Sets the current filter used to select files. |
| * |
| * @param inputFileFilter filter, or null when no filter has been set |
| */ |
| public void setInputFileFilter(FilenameFilter inputFileFilter) { |
| this.inputFileFilter = inputFileFilter; |
| } |
| |
| /** |
| * @param out - the output stream to receive the styled report |
| * @return the currently collected numerical statistics. |
| * @throws Exception in case of errors. |
| * @deprecated use {@link #report(PrintStream, ReportConfiguration)} instead |
| */ |
| @Deprecated |
| public ClaimStatistic report(PrintStream out) throws Exception { |
| final ReportConfiguration configuration = new ReportConfiguration(); |
| configuration.setHeaderMatcher(Defaults.createDefaultMatcher()); |
| configuration.setApproveDefaultLicenses(true); |
| return report(out, configuration); |
| } |
| |
| /** |
| * @param out - the output stream to receive the styled report |
| * @param configuration - current configuration options. |
| * @return the currently collected numerical statistics. |
| * @throws Exception in case of errors. |
| * @since Rat 0.8 |
| */ |
| public ClaimStatistic report(PrintStream out, |
| ReportConfiguration configuration) |
| throws Exception { |
| final IReportable base = getDirectory(out); |
| if (base != null) { |
| return report(base, new OutputStreamWriter(out), configuration); |
| } |
| return null; |
| } |
| |
| private IReportable getDirectory(PrintStream out) { |
| File base = new File(baseDirectory); |
| if (!base.exists()) { |
| out.print("ERROR: "); |
| out.print(baseDirectory); |
| out.print(" does not exist.\n"); |
| return null; |
| } |
| |
| if (base.isDirectory()) { |
| return new DirectoryWalker(base, inputFileFilter); |
| } |
| |
| try { |
| return new ArchiveWalker(base, inputFileFilter); |
| } catch (IOException ex) { |
| out.print("ERROR: "); |
| out.print(baseDirectory); |
| out.print(" is not valid gzip data.\n"); |
| return null; |
| } |
| } |
| |
| /** |
| * Output a report in the default style and default license |
| * header matcher. |
| * |
| * @param out - the output stream to receive the styled report |
| * @throws Exception in case of errors. |
| * @deprecated use {@link #styleReport(PrintStream, ReportConfiguration)} instead |
| */ |
| @Deprecated |
| public void styleReport(PrintStream out) throws Exception { |
| final ReportConfiguration configuration = new ReportConfiguration(); |
| configuration.setHeaderMatcher(Defaults.createDefaultMatcher()); |
| configuration.setApproveDefaultLicenses(true); |
| styleReport(out, configuration); |
| } |
| |
| /** |
| * Output a report in the default style and default license |
| * header matcher. |
| * |
| * @param out - the output stream to receive the styled report |
| * @param configuration the configuration to use |
| * @throws Exception in case of errors. |
| * @since Rat 0.8 |
| */ |
| public void styleReport(PrintStream out, |
| ReportConfiguration configuration) |
| throws Exception { |
| final IReportable base = getDirectory(out); |
| if (base != null) { |
| InputStream style = Defaults.getDefaultStyleSheet(); |
| report(out, base, style, configuration); |
| } |
| } |
| |
| /** |
| * Output a report that is styled using a defined stylesheet. |
| * |
| * @param out the stream to write the report to |
| * @param base the files or directories to report on |
| * @param style an input stream representing the stylesheet to use for styling the report |
| * @param pConfiguration current report configuration. |
| * @throws IOException in case of I/O errors. |
| * @throws TransformerConfigurationException in case of XML errors. |
| * @throws InterruptedException in case of threading errors. |
| * @throws RatException in case of internal errors. |
| */ |
| public static void report(PrintStream out, IReportable base, final InputStream style, |
| ReportConfiguration pConfiguration) |
| throws IOException, TransformerConfigurationException, InterruptedException, RatException { |
| report(new OutputStreamWriter(out), base, style, pConfiguration); |
| } |
| |
| /** |
| * Output a report that is styled using a defined stylesheet. |
| * |
| * @param out the writer to write the report to |
| * @param base the files or directories to report on |
| * @param style an input stream representing the stylesheet to use for styling the report |
| * @param pConfiguration current report configuration. |
| * @return the currently collected numerical statistics. |
| * @throws IOException in case of I/O errors. |
| * @throws TransformerConfigurationException in case of XML errors. |
| * @throws InterruptedException in case of threading errors. |
| * @throws RatException in case of internal errors. |
| */ |
| public static ClaimStatistic report(Writer out, IReportable base, final InputStream style, |
| ReportConfiguration pConfiguration) |
| throws IOException, TransformerConfigurationException, InterruptedException, RatException { |
| PipedReader reader = new PipedReader(); |
| PipedWriter writer = new PipedWriter(reader); |
| ReportTransformer transformer = new ReportTransformer(out, style, reader); |
| Thread transformerThread = new Thread(transformer); |
| transformerThread.start(); |
| final ClaimStatistic statistic = report(base, writer, pConfiguration); |
| writer.flush(); |
| writer.close(); |
| transformerThread.join(); |
| return statistic; |
| } |
| |
| /** |
| * @param container the files or directories to report on |
| * @param out the writer to write the report to |
| * @param pConfiguration current report configuration. |
| * @return the currently collected numerical statistics. |
| * @throws IOException in case of I/O errors. |
| * @throws RatException in case of internal errors. |
| */ |
| public static ClaimStatistic report(final IReportable container, final Writer out, |
| ReportConfiguration pConfiguration) throws IOException, RatException { |
| IXmlWriter writer = new XmlWriter(out); |
| final ClaimStatistic statistic = new ClaimStatistic(); |
| RatReport report = XmlReportFactory.createStandardReport(writer, statistic, pConfiguration); |
| report.startReport(); |
| container.run(report); |
| report.endReport(); |
| writer.closeDocument(); |
| return statistic; |
| } |
| } |
