| /* |
| * |
| * 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 flex2.tools; |
| |
| import java.util.ArrayList; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Set; |
| |
| import flash.localization.LocalizationManager; |
| import flash.localization.ResourceBundleLocalizer; |
| import flash.localization.XLRLocalizer; |
| import flash.util.Trace; |
| import flex2.compiler.CompilerAPI; |
| import flex2.compiler.common.CompilerConfiguration; |
| import flex2.compiler.common.Configuration; |
| import flex2.compiler.common.DefaultsConfigurator; |
| import flex2.compiler.config.ConfigurationBuffer; |
| import flex2.compiler.config.ConfigurationException; |
| import flex2.compiler.config.ConfigurationInfo; |
| import flex2.compiler.config.ConfigurationValue; |
| import flex2.compiler.io.VirtualFile; |
| import flex2.compiler.swc.SwcException; |
| import flex2.compiler.util.SwcDependencyInfo; |
| import flex2.compiler.util.SwcDependencyUtil; |
| import flex2.compiler.util.SwcExternalScriptInfo; |
| import flex2.compiler.util.ThreadLocalToolkit; |
| |
| |
| /** |
| * SwcDependencies is the entry point for a command line tool to list a set of SWC dependencies on each other. |
| * |
| * This tool accepts all the command line options that mxmlc does but only uses the options to gather SWCs, it does |
| * not modify the file system in any way. |
| * |
| * @author dloverin |
| * |
| */ |
| public class SwcDependencies extends Tool |
| { |
| public static void main(String[] args) |
| { |
| swcDependencies(args); |
| System.exit(ThreadLocalToolkit.errorCount()); |
| } |
| |
| public static void swcDependencies(String[] args) |
| { |
| try |
| { |
| CompilerAPI.useAS3(); |
| |
| // setup the path resolver |
| CompilerAPI.usePathResolver(); |
| |
| // set up for localizing messages |
| LocalizationManager l10n = new LocalizationManager(); |
| l10n.addLocalizer( new XLRLocalizer() ); |
| l10n.addLocalizer( new ResourceBundleLocalizer() ); |
| ThreadLocalToolkit.setLocalizationManager(l10n); |
| |
| // setup the console logger. the configuration parser needs a logger. |
| CompilerAPI.useConsoleLogger(); |
| |
| // process configuration |
| ConfigurationBuffer cfgbuf = new ConfigurationBuffer(DependencyRootConfiguration.class, Configuration.getAliases()); |
| DefaultsConfigurator.loadDefaults( cfgbuf ); |
| |
| DependencyRootConfiguration configuration = (DependencyRootConfiguration) Mxmlc.processConfiguration( |
| l10n, "swcdepends", args, cfgbuf, DependencyRootConfiguration.class, "no-default-arg"); |
| |
| // well, setup the logger again now that we know configuration.getWarnings()??? |
| CompilerAPI.useConsoleLogger(true, true, configuration.getWarnings(), true); |
| CompilerAPI.setupHeadless(configuration); |
| |
| CompilerConfiguration compilerConfig = configuration.getCompilerConfiguration(); |
| VirtualFile[] virtualFiles = new VirtualFile[0]; |
| |
| VirtualFile[] moreFiles = compilerConfig.getLibraryPath(); |
| if (moreFiles != null) |
| virtualFiles = moreFiles; // first one, just assign reference |
| |
| moreFiles = Configuration.getAllExcludedLibraries(compilerConfig, configuration); |
| if (moreFiles != null) |
| virtualFiles = (VirtualFile[])CompilerConfiguration.merge(virtualFiles, moreFiles, VirtualFile.class); |
| |
| moreFiles = compilerConfig.getThemeFiles(); |
| if (moreFiles != null) |
| { |
| // remove the css files and keep the swcs |
| List<VirtualFile> themeSwcs = new ArrayList<VirtualFile>(moreFiles.length); |
| for (int i = 0; i < moreFiles.length; i++) |
| { |
| if (moreFiles[i].getName().endsWith(".swc")) |
| themeSwcs.add(moreFiles[i]); |
| } |
| |
| if (themeSwcs.size() > 0) |
| virtualFiles = (VirtualFile[])CompilerConfiguration.merge(virtualFiles, |
| themeSwcs.toArray(new VirtualFile[themeSwcs.size()]), |
| VirtualFile.class); |
| } |
| |
| moreFiles = compilerConfig.getIncludeLibraries(); |
| if (moreFiles != null) |
| virtualFiles = (VirtualFile[])CompilerConfiguration.merge(virtualFiles, moreFiles, VirtualFile.class); |
| |
| DependencyConfiguration dependencyConfig = configuration.getDependencyConfiguration(); |
| List<String> types = dependencyConfig.getDesiredScriptDependencyTypes(); |
| SwcDependencyInfo depInfo = SwcDependencyUtil.getSwcDependencyInfo(virtualFiles, |
| types.size() == 0 ? null : |
| types.toArray(new String[types.size()]), |
| dependencyConfig.getMinimizeDependencySet()); |
| List<String> depOrder = depInfo.getSwcDependencyOrder(); |
| List<String> showSwcs = dependencyConfig.getShowSwcs(); |
| |
| // list the swc dependencies |
| for (String swcLocation : depOrder) |
| { |
| // filter the swcs that are shown |
| if (showSwcs.size() != 0) |
| { |
| boolean skip = true; |
| for (String showSwc : showSwcs) |
| { |
| if (swcLocation.equals(showSwc) || swcLocation.endsWith(showSwc)) |
| { |
| skip = false; |
| break; |
| } |
| } |
| |
| if (skip) |
| continue; |
| } |
| |
| System.out.println(swcLocation + ":"); |
| |
| // list of swc dependencies on swcLocation |
| Set<String> depends = depInfo.getDependencies(swcLocation); |
| for (String swcDepName : depends) |
| { |
| System.out.println("\t" + swcDepName); |
| |
| // list the external scripts that caused the dependencies between |
| // swcLocation and swcDepName. |
| if (dependencyConfig.getShowExterns()) |
| { |
| SwcExternalScriptInfo swcExternalScriptInfo = depInfo.getSwcExternalScriptInfo(swcLocation); |
| for (String externalScriptName : swcExternalScriptInfo.getExternalScripts(swcDepName)) |
| { |
| if (dependencyConfig.getShowTypes()) |
| { |
| System.out.print("\t\t" + externalScriptName + "\t"); |
| |
| for (String type : swcExternalScriptInfo.getScriptDependencyTypes(externalScriptName)) |
| { |
| System.out.print(type + " "); |
| } |
| |
| System.out.println(); |
| } |
| else |
| System.out.println("\t\t" + externalScriptName); |
| |
| } |
| } |
| } |
| } |
| } |
| catch (ConfigurationException ex) |
| { |
| Mxmlc.processConfigurationException(ex, "swcdepends"); |
| } |
| catch (SwcException ex) |
| { |
| assert ThreadLocalToolkit.errorCount() > 0; |
| } |
| catch (Throwable t) // IOException, Throwable |
| { |
| ThreadLocalToolkit.logError(t.getLocalizedMessage()); |
| if (Trace.error) |
| { |
| t.printStackTrace(); |
| } |
| } |
| finally |
| { |
| CompilerAPI.removePathResolver(); |
| } |
| } |
| |
| |
| /** |
| * Used to setup the "dependency." prefix for the options in DependencyConfiguration. |
| * |
| */ |
| public static class DependencyRootConfiguration extends CommandLineConfiguration |
| { |
| public DependencyRootConfiguration() |
| { |
| dependencyConfiguration = new DependencyConfiguration(); |
| } |
| |
| /* |
| * Since we are filtering out a lot of command line options, we need to override validate to |
| * keep it from throwing an exception. |
| * |
| * (non-Javadoc) |
| * @see flex2.tools.CommandLineConfiguration#validate(flex2.compiler.config.ConfigurationBuffer) |
| */ |
| public void validate(ConfigurationBuffer cfgbuf) throws ConfigurationException |
| { |
| try |
| { |
| super.validate(cfgbuf); |
| } |
| catch (ConfigurationException.MustSpecifyTarget e) |
| { |
| // eat this error so we can run swcdepends without any args. |
| } |
| } |
| |
| // |
| // 'dependency.*' options |
| // |
| |
| private DependencyConfiguration dependencyConfiguration; |
| |
| public DependencyConfiguration getDependencyConfiguration() |
| { |
| return dependencyConfiguration; |
| } |
| |
| // |
| // 'version' option |
| // |
| |
| // dummy, just a trigger for version info |
| public void cfgVersion(ConfigurationValue cv, boolean dummy) |
| { |
| // intercepted upstream in order to allow version into to be printed even when required args are missing |
| } |
| |
| // |
| // 'help' option |
| // |
| |
| // dummy, just a trigger for help text |
| public void cfgHelp(ConfigurationValue cv, String[] keywords) |
| { |
| } |
| |
| public static ConfigurationInfo getHelpInfo() |
| { |
| return new ConfigurationInfo( -1, "keyword" ) |
| { |
| public boolean isGreedy() |
| { |
| return true; |
| } |
| |
| public boolean isDisplayed() |
| { |
| return false; |
| } |
| }; |
| } |
| } |
| |
| |
| /** |
| * dependency.* configuration options |
| * |
| */ |
| public static class DependencyConfiguration |
| { |
| |
| // |
| // 'show-external-classes' option |
| // |
| // Should we show the external scripts |
| // |
| |
| private boolean showExterns = false; |
| |
| public boolean getShowExterns() |
| { |
| return showExterns; |
| } |
| |
| public void cfgShowExternalClasses(ConfigurationValue cv, boolean showExterns) throws ConfigurationException |
| { |
| this.showExterns = showExterns; |
| } |
| |
| public static ConfigurationInfo getShowExternalClassesInfo() |
| { |
| return new ConfigurationInfo(); |
| } |
| |
| // |
| // 'show-types' option |
| // |
| // Should we show the external scripts |
| // |
| |
| private boolean showTypes = false; |
| |
| public boolean getShowTypes() |
| { |
| return showTypes; |
| } |
| |
| public void cfgShowTypes(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; |
| } |
| |
| public static ConfigurationInfo getShowTypesInfo() |
| { |
| return new ConfigurationInfo() |
| { |
| public String[] getSoftPrerequisites() |
| { |
| return new String[] { "show-external-classes" }; |
| } |
| }; |
| } |
| |
| // |
| // 'types' option |
| // |
| |
| private List<String> desiredTypes = new LinkedList<String>(); |
| |
| public List<String> getDesiredScriptDependencyTypes() |
| { |
| return desiredTypes; |
| } |
| |
| public void cfgTypes( ConfigurationValue cfgval, String[] types ) throws ConfigurationException |
| { |
| for (int i = 0; i < types.length; ++i) |
| { |
| desiredTypes.add( types[i] ); |
| } |
| } |
| |
| public static ConfigurationInfo getTypesInfo() |
| { |
| return new ConfigurationInfo( -1, new String[] { "type" } ) |
| { |
| public boolean allowMultiple() |
| { |
| return true; |
| } |
| }; |
| } |
| |
| |
| // |
| // 'show-swcs' option |
| // |
| // Filter which SWCs to show. |
| // |
| |
| private List<String> showSwcs = new LinkedList<String>(); |
| |
| public List<String> getShowSwcs() |
| { |
| return showSwcs; |
| } |
| |
| public void cfgShowSwcs( ConfigurationValue cfgval, String[] swcs ) throws ConfigurationException |
| { |
| for (int i = 0; i < swcs.length; ++i) |
| { |
| showSwcs.add( swcs[i] ); |
| } |
| } |
| |
| public static ConfigurationInfo getShowSwcsInfo() |
| { |
| return new ConfigurationInfo( -1, new String[] { "swc-name" } ) |
| { |
| public boolean allowMultiple() |
| { |
| return true; |
| } |
| }; |
| } |
| |
| |
| // |
| // '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. |
| // |
| |
| private boolean minimizeDependencySet = true; |
| |
| public boolean getMinimizeDependencySet() |
| { |
| return minimizeDependencySet; |
| } |
| |
| public void cfgMinimizeDependencySet(ConfigurationValue cv, boolean minimumSet) throws ConfigurationException |
| { |
| this.minimizeDependencySet = minimumSet; |
| } |
| |
| public static ConfigurationInfo getMinimizeDependencySetInfo() |
| { |
| return new ConfigurationInfo(); |
| } |
| |
| } |
| |
| } |