*

*  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.

*

*/

* swcdepends command line utility.

*

* Use this utility to see the dependency order of all SWCs in your configuration.

* You can also see:

*

* - the swcs a swc is dependent on (on by default).

* - the scripts that are causing the dependency (off by default).

* - the dependency types of the scripts (off by default).

*

*/

    // XML names

    public static final String SWC_DEPENDENCY_ORDER_ELEMENT = "swc-dependency-order";

    public static final String SWC_DEPENDENCIES_ELEMENT = "swc-dependencies";

    public static final String SWC_ELEMENT = "swc";

    public static final String DEFINITION_DEPENDENCIES_ELEMENT = "definition-dependencies";

    public static final String DEFINITION_ELEMENT = "def";

    public static final String PATH_ATTRIBUTE = "path";

    public static final String ID_ATTRIBUTE = "id";

   

    static final String NEWLINE = System.getProperty("line.separator");

    private static final String DEFAULT_VAR = "no-default-arg";

    private static final String L10N_CONFIG_PREFIX = "org.apache.flex.compiler.internal.config.configuration";

    protected Workspace workspace;

    protected FlexProject project;

    protected DependencyConfiguration config;

    protected ProblemQuery problems;

    protected ConfigurationBuffer configBuffer;

    protected Configurator projectConfigurator;

    protected ICompilationUnit mainCU;

    protected SWFTarget target;

    protected ITargetSettings targetSettings;

   

    private List<String> dependencyOrder;     // of all discovered swcs

   

    /**

     * Entry point for <code>swcdepends</code> tool.

     *

     * @param args command line arguments

     */

    public static void main(final String[] args)

    {

        int exitCode = staticMainNoExit(args);

        System.exit(exitCode);

    }

    public static int staticMainNoExit(final String[] args)

    {

        final SWCDepends swcDepends = new SWCDepends();

        return swcDepends.mainNoExit(args);

    }

    public SWCDepends()

    {

        workspace = new Workspace();

        project = new FlexProject(workspace);

        problems = new ProblemQuery();

    }

    public int mainNoExit(final String[] args)

    {

        int result = 0;

       

        if (configure(args))

        {

            XMLStreamWriter xmlWriter = null;

            try

            {

                List<String> showSwcs = config.getShowSwcs();

                DependencyTypeSet dependencyTypes = getDependencyTypeSet();

                LibraryDependencyGraph graph = project.createLibraryDependencyGraph(dependencyTypes);

               

               

                xmlWriter = new XMLFormatter(getXMLWriter());

                xmlWriter.writeStartDocument();

               

                // write SWCDependencyOrder

                xmlWriter.writeStartElement(SWC_DEPENDENCY_ORDER_ELEMENT);

                dependencyOrder = graph.getDependencyOrder();

                for (String swcName : dependencyOrder)

                {

                    if (!showSwc(swcName, showSwcs))

                        continue;

                   

                    println(swcName + ":");

                    xmlWriter.writeStartElement(SWC_ELEMENT);

                    xmlWriter.writeAttribute(PATH_ATTRIBUTE, swcName);

                    // Show the dependencies of this swc.

                    printDependencies(swcName, xmlWriter, graph);

                   

                    xmlWriter.writeEndElement(); // SWC

                }

               

                xmlWriter.writeEndElement(); // SWC_DEPENDENCY_ORDER

                xmlWriter.writeEndDocument();

                xmlWriter.flush();

                xmlWriter.close();

            }

            catch (IOException e)

            {

                final FileIOProblem problem = new FileIOProblem(e);

                problems.add(problem);

            }

            catch (Exception e)

            {

                final ICompilerProblem problem = new InternalCompilerProblem(e);

                problems.add(problem);

            }

            finally

            {

                if (xmlWriter != null)

                {

                    try

                    {

                        xmlWriter.close();

                    }

                    catch (XMLStreamException e)

                    {

                        // ignore

                    }

                }

            }

        }

        else

        {

            result = 1;

        }

        // Print out any errors we may have encountered

        ProblemFormatter formatter = new WorkspaceProblemFormatter(workspace, null);

        ProblemPrinter printer = new ProblemPrinter(formatter, System.err);

        printer.printProblems(problems.getFilteredProblems());

        if( problems.hasErrors() )

            result = 1;

        return result;

    }

   

    /**

     * @param swcName name of swc

     * @param swcs list of swcs to show. An empty list means show all.

     * @return true if the swc should be shown, false otherwise.

     */

    private boolean showSwc(String swcName, List<String>swcs)

    {

        // filter the swcs that are shown

        boolean show = true;

        if (swcs.size() != 0)

        {

            show = false;

            for (String showSwc : swcs)

            {

                if (swcName.endsWith(showSwc))

                {

                    show = true;

                    break;

                }

            }

        }

     

        return show;

    }

    /**

     * Print the dependencies of a SWC.

     *

     * @param xmlWriter

     * @param graph

     * @throws XMLStreamException

     */

    private void printDependencies(String swcName, XMLStreamWriter xmlWriter, LibraryDependencyGraph graph) throws XMLStreamException

    {

        // show swc dependencies

        if (config.getShowDependencyList())

        {

            Set<String> dependencies = graph.getDependencies(swcName);

           

            if (dependencies.size() > 0)

            {

                xmlWriter.writeStartElement(SWC_DEPENDENCIES_ELEMENT);

               

                // Sort by dependency order so the swcs are always

                // in the same order.

                List<String> swcDependencies = new ArrayList<String>(graph.getDependencies(swcName));

                Collections.sort(swcDependencies,

                        new Comparator<String>()

                        {

                            @Override

                            public int compare(String o1, String o2)

                            {

                                return dependencyOrder.indexOf(o1) - dependencyOrder.indexOf(o2);

                            }

                           

                        });

               

                List<String> swcFilter = config.getShowDependentSwcs();

                for (String swcDependency : swcDependencies)

                {

                    if (!showSwc(swcDependency, swcFilter))

                        continue;

                   

                    println("\t" + swcDependency);

                   

                    xmlWriter.writeStartElement(SWC_ELEMENT);

                    xmlWriter.writeAttribute(PATH_ATTRIBUTE, swcDependency);

                    printExterns(swcName, swcDependency, xmlWriter, graph);

                   

                    xmlWriter.writeEndElement(); // SWC

                }

                xmlWriter.writeEndElement(); // SWC_DEPENDENCY_ORDER

            }

        }

       

    }

    /**

     * Print the external scripts that are causing the dependency.

     *

     * @param swcDependency

     * @param xmlWriter

     * @param graph

     * @throws XMLStreamException

     */

    private void printExterns(String swcName, String swcDependency,

            XMLStreamWriter xmlWriter, LibraryDependencyGraph graph)

            throws XMLStreamException

    {

        // list the external scripts that caused the dependencies between

        // swcLocation and swcDepName.

        if (config.getShowExterns())

        {

            xmlWriter.writeStartElement(DEFINITION_DEPENDENCIES_ELEMENT);

           

            Map<String, DependencyTypeSet> dependencyMap = graph.getDependencySet(swcName, swcDependency);

            for (Map.Entry<String, DependencyTypeSet> entry : dependencyMap.entrySet())

            {

                xmlWriter.writeStartElement(DEFINITION_ELEMENT);

                xmlWriter.writeAttribute(ID_ATTRIBUTE, entry.getKey());

                if (config.getShowTypes())

                {

                    System.out.print("\t\t" + entry.getKey() + "\t");

                   

                    StringBuilder sb = new StringBuilder();

                    for (Iterator<DependencyType>iter = entry.getValue().iterator();

                         iter.hasNext();)

                    {

                        DependencyType type = iter.next();

                       

                        System.out.print(type.getSymbol());

                        sb.append(type.getSymbol());

                       

                        if (iter.hasNext())

                        {

                            sb.append(",");

                            System.out.print(" ");

                        }

                    }

                   

                    println("");

                    xmlWriter.writeAttribute("types", sb.toString());

                }

                else

                {

                    println("\t\t" + entry.getKey());

                }

               

                xmlWriter.writeEndElement(); // SCRIPT_NAME

            }

           

            xmlWriter.writeEndElement(); // DEPENDENT_SCRIPTS

        }

    }

    /**

     * @return A writer for the xml-based dependency report.

     *

     * @throws XMLStreamException

     * @throws IOException

     */

    private XMLStreamWriter getXMLWriter() throws XMLStreamException, IOException

    {

        Writer writer = null;

        if (config.getDependencyReport() != null)

            writer = new FileWriter(config.getDependencyReport());

        else

            writer = new StringWriter();    // throw away output

        final XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();

        assert xmlOutputFactory != null : "Expect XMLOutputFactory implementation.";

        return xmlOutputFactory.createXMLStreamWriter(writer);

    }

    /**

     * @return the dependency set requested by the user. The default to

     * to show all dependency types.

     */

    private DependencyTypeSet getDependencyTypeSet()

    {

        List<String> desiredDependencies = config.getDesiredScriptDependencyTypes();

        if (desiredDependencies != null)

        {

            DependencyTypeSet dependencySet = DependencyTypeSet.noneOf();

            List<String> validDependencies = new ArrayList<String>();

            for (DependencyType type : DependencyTypeSet.allOf())

            {

                validDependencies.add(String.valueOf(type.getSymbol()));

            }

           

            // convert strings to a enum set.

            for (String desiredDependency : desiredDependencies)

            {

                if (validDependencies.contains(desiredDependency))

                    dependencySet.add(DependencyType.get(desiredDependency.charAt(0)));

            }

           

            return dependencySet;

        }

       

        return DependencyTypeSet.allOf();

    }

    /**

     * Load configurations from all the sources.

     *

     * @param args command line arguments

     * @return True if mxmlc should continue with compilation.

     */

    protected boolean configure(final String[] args)

    {

        projectConfigurator = createConfigurator();

       

        try

        {

            ConfigurationPathResolver resolver = new ConfigurationPathResolver(System.getProperty("user.dir"));

            projectConfigurator.setConfigurationPathResolver(resolver);

            projectConfigurator.setConfiguration(args, getConfigurationDefaultVariable());

            projectConfigurator.applyToProject(project);

            problems = new ProblemQuery(projectConfigurator.getCompilerProblemSettings());

           

            // Get the configuration and configBuffer which are now initialized.

            config = (DependencyConfiguration)projectConfigurator.getConfiguration();

            Messages.setLocale(config.getToolsLocale());

            configBuffer = projectConfigurator.getConfigurationBuffer();

            problems.addAll(projectConfigurator.getConfigurationProblems());

            // Print version if "-version" is present.

            if (configBuffer.getVar("version") != null)

            {

                println(VersionInfo.buildMessage());

                return false;

            }

            // Print help if "-help" is present.

            final List<ConfigurationValue> helpVar = configBuffer.getVar("help");

            if (helpVar != null)

            {

                processHelp(helpVar);

                return false;

            }

           

            for (String fileName : projectConfigurator.getLoadedConfigurationFiles())

            {

                println(Messages.getString("MXMLC.Loading_configuration_format",

                        Collections.<String,Object>singletonMap("configurationName", fileName)));               

            }

           

            // Add a blank line between the configuration list and the rest of

            // the output to make the start of the output easier to detect.

            println("");

           

            // If we have configuration errors then exit before trying to

            // validate the target.

            if (problems.hasErrors())

                return false;

           

            return true;

        }

        catch (Exception e)

        {

            final ICompilerProblem problem = new ConfigurationProblem(null, -1, -1, -1, -1, e.getMessage());

            problems.add(problem);

            return false;

        }

    }

   

    /**

     * Print detailed help information if -help is provided.

     */

    private void processHelp(final List<ConfigurationValue> helpVar)

    {

        final Set<String> keywords = new LinkedHashSet<String>();

        for (final ConfigurationValue val : helpVar)

        {

            for (final Object element : val.getArgs())

            {

                String keyword = (String)element;

                while (keyword.startsWith("-"))

                    keyword = keyword.substring(1);

                keywords.add(keyword);

            }

        }

        if (keywords.size() == 0)

            keywords.add("help");

        final String usages = CommandLineConfigurator.usage(

                    getProgramName(),

                    DEFAULT_VAR,

                    configBuffer,

                    keywords,

                    LocalizationManager.get(),

                    L10N_CONFIG_PREFIX);

        println(getStartMessage());

        println(usages);

    }

   

    /**

     * Print a message.

     *

     * @param msg Message text.

     */

    protected void println(final String msg)

    {

        System.out.println(msg);

    }

    /**

     * Get the start up message that contains the program name with the

     * copyright notice.

     *

     * @return the start up message.

     */

    private String getStartMessage()

    {

        // This must not be localized.

        String message = "SWC Dependency utility (swcdepends)" + NEWLINE +

            VersionInfo.buildMessage() + NEWLINE;

        return message;

    }

    private String getConfigurationDefaultVariable()

    {

        return DEFAULT_VAR;

    }

    private Configurator createConfigurator()

    {

        return new Configurator(DependencyConfiguration.class);

    }

    /**

     * @return always "swcdepends"

     */

    private String getProgramName()

    {

        return "swcdepends";

    }

    /**

     * dependency.* configuration options

     *

     */

    public static class DependencyConfiguration extends Configuration

    {

        //

        // 'show-external-classes' option

        //

        //  Should we show the external scripts

        //

       

        private boolean showExterns = false;

        public boolean getShowExterns()

        {

            return showExterns;

        }

        @Config

        @Mapping({"dependency", "show-external-classes"})

        public void setShowExternalClasses(ConfigurationValue cv, boolean showExterns) throws ConfigurationException

        {

            this.showExterns = showExterns;

        }

        //

        // 'show-dependency-list' option

        //

        //  Should swc dependencies be shown in addition to the dependency

        //  order?

        //

       

        private boolean showDependencyList = true;

        public boolean getShowDependencyList()

        {

            return showDependencyList;

        }

        @Config

        @Mapping({"dependency", "show-dependency-list"})

        public void setShowDependencyList(ConfigurationValue cv, boolean showSwcDependencies) throws ConfigurationException

        {

            this.showDependencyList = showSwcDependencies;

        }

        //

        // 'show-types' option

        //

        //  Should we show the external scripts

        //

       

        private boolean showTypes = false;

        public boolean getShowTypes()

        {

            return showTypes;

        }

        @Config

        @Mapping({"dependency", "show-types"})

        @SoftPrerequisites("show-external-classes")

        public void setShowTypes(ConfigurationValue cv, boolean showTypes) throws ConfigurationException

        {

            this.showTypes = showTypes;

           

            // if showTypes is set, then turn on show-external-classes show the types will be seen.

            if (showTypes)

                showExterns = true;

        }

        //

        // 'types' option

        //

       

        private List<String> desiredTypes = new LinkedList<String>();

       

        public List<String> getDesiredScriptDependencyTypes()

        {

            return desiredTypes;

        }

       

        @Config(allowMultiple=true)

        @Mapping({"dependency", "types"})

        @Arguments("type")

        @InfiniteArguments

        public void setTypes( ConfigurationValue cfgval, String[] types ) throws ConfigurationException

        {

            for (int i = 0; i < types.length; ++i)

            {

                desiredTypes.add( types[i] );

            }

        }

        //

        // 'show-swcs' option

        //

        //  Filter which SWCs to show in the dependency order.

        //

       

        private List<String> showSwcs = new LinkedList<String>();

       

        public List<String> getShowSwcs()

        {

            return showSwcs;

        }

       

        @Config(allowMultiple = true)

        @Mapping({"dependency", "show-swcs"})

        @Arguments("swc-name")

        @InfiniteArguments

        public void setShowSwcs(ConfigurationValue cfgval, String[] swcs) throws ConfigurationException

        {

            for (int i = 0; i < swcs.length; ++i)

            {

                showSwcs.add(swcs[i]);

            }

        }

        //

        // 'show-swcs' option

        //

        //  Filter which SWCs to show in the "dependent SWCs" list.

        //

       

        private List<String> showDependentSwcs = new LinkedList<String>();

       

        public List<String> getShowDependentSwcs()

        {

            return showDependentSwcs;

        }

       

        @Config(allowMultiple = true)

        @Mapping({"dependency", "show-dependent-swcs"})

        @Arguments("swc-name")

        @InfiniteArguments

        public void setShowDependentSwcs(ConfigurationValue cfgval, String[] swcs) throws ConfigurationException

        {

            for (int i = 0; i < swcs.length; ++i)

            {

                showDependentSwcs.add(swcs[i]);

            }

        }

        //

        // 'minimize-dependency-set' option

        //

        //  Removes a SWC from the dependency set if the scripts resolved in a SWC are a subset of the scripts resolved in another dependent SWC.

        //  No longer supported, the dependency set is always minimized.

        //

       

        @Config(removed=true)

        @Mapping({"dependency", "minimize-dependency-set"})

        public void setMinimizeDependencySet(ConfigurationValue cv, boolean minimumSet) throws ConfigurationException

        {

            // leave configuration option here so old scripts do not error.

        }

       

        //

        // -dependency-report option

        //

        // Takes a path that specifies a filename where an xml version of the report

        // is written.

       

        private String dependencyReportFileName;

       

        public File getDependencyReport()

        {

            return dependencyReportFileName != null ? new File(dependencyReportFileName) : null;

        }

        @Config()

        @Mapping({"dependency", "dependency-report"})

        @Arguments("filename")

        public void setDependencyReport(ConfigurationValue cv, String filename)

        {

            this.dependencyReportFileName = getOutputPath(cv, filename);

        }

       

    }

}