krysalis-viprom/src/java/core/org/krysalis/viprom/tool ModelTool.java,NONE,1.1 Tool.java,NONE,1.1

Update of /cvsroot/metamorphosis/krysalis-viprom/src/java/core/org/krysalis/viprom/tool
In directory sc8-pr-cvs1:/tmp/cvs-serv26154/src/java/core/org/krysalis/viprom/tool

Added Files:
	ModelTool.java Tool.java 
Log Message:
1) Load XSLT from resource (using ClassLoaderContext)
2) Added XSLT for gump (later for gump to viprom cooking)
3) 'Cook' raw metadata via XSLT (into ViPrOM form)
4) Query into cooked prior to raw
5) Allow metedata 'type' to define queries for raw
6) Standard queries into cooked.

--- NEW FILE: ModelTool.java ---
/**
 * Copyright (C) The Apache Software Foundation. All rights reserved.        *
 * ------------------------------------------------------------------------- *
 * This software is published under the terms of the Apache Software License *
 * version 1.1, a copy of which has been included  with this distribution in *
 * the LICENSE file.                                                         *
 */
package org.krysalis.viprom.tool;

import java.io.FileInputStream;
import java.io.PrintWriter;
import java.util.Iterator;

import org.krysalis.version.log.Logger;
import org.krysalis.version.util.SystemUtils;
import org.krysalis.version.util.cli.CommandLine;
import org.krysalis.version.util.cli.Option;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.dom.DOMUtils;
import org.krysalis.viprom.NamedProperties;
import org.krysalis.viprom.VirtualProjectModel;
import org.krysalis.viprom.metadata.MetadataModel;
import org.krysalis.viprom.metadata.MetadataModelFactory;

/**
 */
public class ModelTool extends Tool {

	private static Option l_modelOption = null;
	private static Option l_typeOption = null;
	private static Option l_listOption = null;

	static {
		l_modelOption = new Option("m", "model", true, "Repository");
		l_typeOption =
			new Option("t", "type", true, "A specified resources type");
		l_listOption =
			new Option("l", "list", false, "List resources or types");
	}

	protected String getTitle() {
		return "ViPrOM Model Tool";
	}

	protected void init() {
		getOptions().addOption(l_modelOption);
		getOptions().addOption(l_typeOption);
		getOptions().addOption(l_listOption);
	}

	public void execute(CommandLine cmdline) throws Exception {
		String modelFile = cmdline.getMandatoryOptionValue(l_modelOption);
		String type = MetadataModelFactory.GUMP;

		if (cmdline.isSet(l_typeOption))
			type = cmdline.getOptionValue(l_typeOption);

		PrintWriter out = SystemUtils.getSystemOut();

		//DebugUtils.printSeparator();
		//DebugUtils.dump(cmdline);

		MetadataModel model = MetadataModelFactory.getModelFor(type);

		DebugUtils.dump(model);

		VirtualProjectModel project =
			new VirtualProjectModel(
				DOMUtils.deserialize(new FileInputStream(modelFile)),
				model,
				null);

		DebugUtils.dump(project);

		if (cmdline.isSet(l_listOption)) {
			for (Iterator i = NamedProperties.getPropertyNames().iterator();
				i.hasNext();
				) {
				String property = (String) i.next();

				String value = project.getProperty(property);

				Logger.getLogger().info(
					property
						+ " -> "
						+ ((null == value) ? ("${" + property + "}") : value));
			}

		}
	}

	public static void main(String[] args) {
		(new ModelTool()).run(args);
	}
}
--- NEW FILE: Tool.java ---
/*
 * Created on Aug 29, 2003
 */
package org.krysalis.viprom.tool;

import java.io.PrintWriter;

import org.krysalis.version.log.LogConstants;
import org.krysalis.version.log.Logger;
import org.krysalis.version.log.StandardLogListener;
import org.krysalis.version.util.SystemUtils;
import org.krysalis.version.util.cli.CommandLine;
import org.krysalis.version.util.cli.CommandLineParser;
import org.krysalis.version.util.cli.Option;
import org.krysalis.version.util.cli.Options;
import org.krysalis.version.util.cli.ParseException;

/**
 * @author ajack
 */
public abstract class Tool {

	private static Option l_debugOption = null;
	private static Option l_verboseOption = null;
	private static Option l_helpOption = null;
	private static Option l_versionOption = null;
	private static Options l_options = null;

	private static boolean l_debug = false;
	private static boolean l_verbose = false;
	private static boolean l_help = false;
	private static boolean l_version = false;


	static {
		l_versionOption = new Option("V", "version", false, "print version, and exit");
		l_helpOption = new Option("h", "help", false, "print help, and exit");
		l_debugOption = new Option("d", "debug", false, "debug output");
		l_verboseOption = new Option("v", "verbose", false, "verbose output");


		l_options = new Options();
		l_options.addOption(l_helpOption);
		l_options.addOption(l_versionOption);
		l_options.addOption(l_debugOption);
		l_options.addOption(l_verboseOption);
	}

	protected Options getOptions() {
		return l_options;
	}

	protected PrintWriter getOutput() {
		return SystemUtils.getSystemOut();
	}

	protected abstract String getTitle();
	protected abstract void init();

	protected void printVersion() {
		String version = "TDB"; //Version.VERSION.getLongVersion();		
		System.out.println(getTitle() + " : " + version);
		
	}
	
	protected void printHelp() {
			printVersion();		
			getOptions().display();
		}
	
	protected abstract void execute(CommandLine cmdline) throws Exception;

	protected CommandLine parseCommandLine(String args[]) {
		CommandLine cmdline = null;

		try {
			CommandLineParser parser = new CommandLineParser();

			parser.setStrict(true);
			cmdline = parser.parse(l_options, args);

			l_help = cmdline.isSet(l_helpOption);
			l_version = cmdline.isSet(l_versionOption);
			l_verbose = cmdline.isSet(l_verboseOption);
			l_debug = cmdline.isSet(l_debugOption);
		}
		catch (ParseException exp) {
			System.err.println("Bad Command Line. Reason: " + exp.getMessage());
			printHelp();
			System.exit(1);
		}

		return cmdline;
	}

	public void run(String args[]) {

		//:TODO:Hack
		//DebugUtils.enableCommonsLogging();
		//DebugUtils.enableHttpClientDebug();

		init();

		CommandLine cmdline = parseCommandLine(args);

		if (l_help) {
			printHelp();
			System.exit(0);
		}
		if (l_version) {
			printVersion();
			System.exit(0);
		}

		// Set logging context
		int level = LogConstants.INFO;
		if (l_verbose || l_debug)
			level = l_debug ? LogConstants.DEBUG : LogConstants.VERBOSE;
		Logger logger = Logger.pushContext(level, new StandardLogListener());

		try {
			execute(cmdline);
		}
		catch (ParseException pe) {
			SystemUtils.getSystemErr().println(
				"Error: " + pe.getLocalizedMessage());
			printHelp();
			cmdline.print();
			System.exit(1);
		}
		catch (Exception exc) {
			exc.printStackTrace();
		}
		finally {
			Logger.popContext(logger);			
		}
	}
}




-------------------------------------------------------
This SF.net email is sponsored by: SF.net Giveback Program.
Does SourceForge.net help you be more productive?  Does it
help you create better code?   SHARE THE LOVE, and help us help
YOU!  Click Here: http://sourceforge.net/donate/