source: trunk/gli/src/org/greenstone/gatherer/util/Generator.java@ 4364

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */

 




package org.greenstone.gatherer.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.lang.Exception;
import java.lang.String;
import java.lang.StringBuffer;
import java.util.HashMap;
/** Automatically generates html help documents given an input text file using markup and a template defining what the markup means. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 1.0
 */
public class Generator {

    private FileOutputStream file_output_stream = null;

    private TemplateManager template_manager = null;

    public Generator(File test_file, File template_file) {
    template_manager = new TemplateManager(template_file);
    File files[] = null;
    // If test_file is a file, goody.
    if(test_file.isFile()) {
        files = new File[1];
        files[0] = test_file;
    }
    // Otherwise we use all of test_files children.
    else {
        files = test_file.listFiles();
    }
    // Its unfortunate we test this twice for the basic case, but we need to ensure that source managers are only contructed for non-directory files.
    for(int i = 0; i < files.length; i++) {
        if(files[i].isFile()) {
        SourceManager source_manager = new SourceManager(files[i]);
        source_manager = null;
        }
    }
    // All done.
    }

    public void exit() {
    if(file_output_stream != null) {
        try {
        file_output_stream.close();
        file_output_stream = null;
        }
        catch(Exception error) {
        error.printStackTrace();
        }
    }
    System.exit(0);
    }

    public void out(String msg) {
    System.err.println(msg);
    try {
        if(file_output_stream == null) {
        file_output_stream = new FileOutputStream("output.txt");
        }
        file_output_stream.write((msg + "\n").getBytes());
    }
    catch(Exception error) {
        error.printStackTrace();
        System.err.println("An error has occured. View output.txt for more information.");
        exit();
    }
    }

    static public void main(String args[]) {
    System.err.println("Rapid repeated HTML generation tool.");
    System.err.println("  written by John Thompson, 2002\n");
    boolean usage = false;
    // Attempt to generate html from text
    if(args.length == 2) {
        File text_file = new File(args[0]);
        File template_file = new File(args[1]);
        if(!text_file.exists() || !template_file.exists() || !template_file.isFile()) {
        usage = true;
        }
        else {
        Generator generator = new Generator(text_file, template_file);
        generator.exit();
        }
    }
    else {
        usage = true;
    }
    // Print usage message
    if(usage) {
        System.err.println("Usage: GenHelp <text_file> <template_file>");
        System.err.println("text_file     - A file containing text marked up using special tags.");
        System.err.println("template_file - An HTML file using tags to specify where to insert text.");
    }
    }

    /** An HTML block object is essentially a String buffer containing several places where it demands further text be appended. To this end you can ask if an HTML block is ready, and if not provide it with a further text fragment and try again. */
    private class HTMLBlock {
    /** Prevent the original HTML block being changed. */
    private boolean original;

    private int insertion_position = -1;
    /** The name of this HTML block as taken from the template file. */
    private String name = null;
    private String paragraph_tag = null;
    /** The HTML block itself. */
    private StringBuffer data = null;
    /** Constructor takes the HTML blocks name as extracted from the template file.
     * @param name The name of this HTML block as a <strong>String</strong>.
     */
    public HTMLBlock(String name) {
        this.data = new StringBuffer("");
        this.name = name;
        this.original = true;
    }
    /** Copy constructor takes the HTML block and its name as extracted from the template file.
     * @param name The name of this HTML block as a <strong>String</strong>.
     * @param raw The raw HTML code as a <strong>String</strong>.
     */
    public HTMLBlock(String name, String raw) {
        this.data = new StringBuffer(raw);
        this.name = name;
        this.original = false;
    }
    /** Append this text to the end of the current block.
     * @param text The <strong>String</strong> to add.
     */
    public void addLine(String text) {
        if(original) {
        data.append(text);
        data.append("\n");
        }
    }
    /** Retrieve the name of this HTML block.
     * @return A <strong>String</strong> representing the name.
     */
    public String getName() {
        return name;
    }
    /** Insert a text fragment into this HTML block.
     * @param fragment The <strong>String</strong> to insert.
     * @return <i>true</i> if an insertion occured, <i>false</i> otherwise.
     */
    public boolean insert(String fragment) {
        if(!original) {
                // Find the start of an insertion tag.
        int start = data.indexOf("<$");
        if(start != -1) {
            // Find the end of an insertion tag.
            int end = data.indexOf(">", start) + 1;
            // Determine the tag, and search for any paragraphing information.
            String tag = data.substring(start, end);
            if(tag.length() > 7) {
            paragraph_tag = "<p " + tag.substring(7) + "\n";
            fragment = paragraph_tag + fragment + "\n</p>\n";
            }
            // Substitue the fragment for the tag.
            data.replace(start, end, fragment);
            // Now set insertion position
            insertion_position = start + fragment.length();
            return true;
        }
                // Its possible that we've already got enough text to output this block. Essentially this new fragment is meant to be another paragraph. Such fragments are always added immediately after the last fragment inserted.
        else if(insertion_position != -1) {
            if(paragraph_tag != null) {
            fragment = paragraph_tag + fragment + "\n</p>\n";
            }
            data.insert(insertion_position, fragment);
            insertion_position = insertion_position + fragment.length();
        }
        }
        return false;
    }
    /** Is this block ready to written out.
     * @return <i>true</i> if we can write this block out, <i>false</i> if text insertion points still exist.
     */
    public boolean ready() {
        return data.indexOf("<$") == -1;
    }
    /** Produce a copy of this block with all text insertions intact.
     * @return A new <strong>HTMLBlock</strong>.
     */
    public HTMLBlock spawn() {
        return new HTMLBlock(name, data.toString());
    }
    /** Return the HTML block within this object.
     * @return A <strong>String</strong> containing the HTML code.
     */
    public String toString() {
        return data.toString();
    }
    }
    /** Reads in the given text file, outputing HTML by utilizing HTML blocks stored in the TemplateManager. The manager understands one extra tag <$FILE name=<filename>> which is used to indicate the presence of several output files within one input file. If this tag is not found the default name for the output file is "<text_file_name>.htm". */
    private class SourceManager {
    private File text_file = null;

    private FileOutputStream output_file = null;

    public SourceManager(File text_file) {
        out("Building Source Manager:");
        this.text_file = text_file;
        try {
        out("  reading from: " + text_file.getName());
                // Create input stream from the text file which we read a line at a time.
        FileReader file_reader = new FileReader(text_file);
        BufferedReader buffered_reader = new BufferedReader(file_reader);
        HTMLBlock block = null;
        String line = null;
        StringBuffer paragraph = null;
        while((line = buffered_reader.readLine()) != null) {
            boolean done = false;
            // What we do here depends on what state we are in and what tag or text we are reading.
            // The first case to consider is a file open command tag. This tells us the next block of html should be written to a certain file.
            if(line.startsWith("<$FILE")) {
            // Close any existing output file.
            if(output_file != null) {
                // Write any existing block
                if(block != null) {
                if(paragraph != null) {
                    block.insert(paragraph.toString());
                    paragraph = null;
                }
                out("  write: " + block.getName());
                output_file.write((block.toString()).getBytes());
                block = null;
                }
                output_file.close();
                output_file = null;
            }
            // Determine the new file name.
            String name = line.substring(12, line.lastIndexOf(">"));
            // Create new file.
            output_file = new FileOutputStream(name);
            // Dealt with
            out("  writing to: " + name);
            name = null;
            done = true;
            }
            else if(line.startsWith("<$")) {
            // If we have a block open its time to write it out.
            if(block != null) {
                if(paragraph != null) {
                block.insert(paragraph.toString());
                paragraph = null;
                }
                // Check we have somewhere to write to.
                if(output_file == null) {
                output_file = new FileOutputStream(text_file.getName() + ".htm");
                }
                out("  write: " + block.getName());
                output_file.write((block.toString()).getBytes());
                block = null;
            }
            // Now determine the new blocks name.
            String name = line.substring(2, line.lastIndexOf(">"));
            // Retrieve that block
            block = template_manager.getHTMLBlock(name);
            if(block == null) {
                // Somethings gone wrong, most likely an unidentified block name.
                out("  no such block: " + name);
            }
            name = null;
            done = true;
            }
            // Its just text. However we want text in paragraph blocks. A paragraph is delimited by a "\n\n" or the start of a tag.
            if(!done) {
            // If the line read is "" it means we've encountered a "\n\n".
            if(line.equals("")) {
                // Add paragraph to open block.
                if(block != null && paragraph != null) {
                block.insert(paragraph.toString());
                paragraph = null;
                }
            }
            // Any other case just add to paragraph. Ensure that there is at least one space between the two fragments
            else {
                if(paragraph == null) {
                paragraph = new StringBuffer(line);
                }
                else {
                if(paragraph.charAt(paragraph.length() - 1) != ' ' && line.charAt(0) != ' ') {
                    paragraph.append(" ");
                }
                paragraph.append(line);
                }
            }
            }
        }
                // Write out any outstanding blocks.
        if(block != null) {
            if(paragraph != null) {
            block.insert(paragraph.toString());
            paragraph = null;
            }
            // Check we have somewhere to write to.
            if(output_file == null) {
            output_file = new FileOutputStream(text_file.getName() + ".htm");
            }
            out("  write: " + block.getName());
            output_file.write((block.toString()).getBytes());
        }
        block = null;
        paragraph = null;
        line = null;
        output_file.close();
        output_file = null;
        }
        catch (Exception error) {
        error.printStackTrace();
        System.err.println("An error has occured. View output.txt for more information.");
        exit();
        }
    }
    }
    /** Reads in a template file, extracting HTMLBlocks and storing them. It then allows the program to retrieve a block by its name and process it accordingly. */
    private class TemplateManager
    extends HashMap {
    /** Constructor.
     * @param template_file The <strong>File</strong> template information will be extracted from.
     */
    public TemplateManager(File template_file) {
        out("Building Template Manager:");
        try {
        FileReader file_reader = new FileReader(template_file);
        BufferedReader buffered_reader = new BufferedReader(file_reader);
        HTMLBlock block = null;
        String line = null;
        while((line = buffered_reader.readLine()) != null) {
            boolean done = false;
            // Detect a template command.
            if(line.startsWith("<$")) {
            // See if this is an open block tag, text insertion tag, or a block closing tag and react appropriately.
            if(line.startsWith("<$TEXT")) {
                // Text tag. deal with it below.
            }
            else if(line.startsWith("<$/")) {
                // Block closing tag. If we have an open block close it.
                if(block != null) {
                out("  parsed: " + block.getName());
                // Add to our hashmapping of known blocks.
                put(block.getName(), block);
                block = null;
                done = true;
                }
                // Otherwise deal with it below.
            }
            // The last option is an open block tag.
            else {
                // If have a block open, close it.
                if(block != null) {
                out("  parsed: " + block.getName());
                put(block.getName(), block);
                block = null;
                }
                // Now create a new block with the appropriate name.
                String name = line.substring(2, line.indexOf(">"));
                block = new HTMLBlock(name);
                done = true;
            }
            }
            // Otherwise its just HTML.
            if(!done) {
            // If we are building a block append this line.
            if(block != null) {
                block.addLine(line);
            }
            // Otherwise we just ignore it.
            else {
                if(line.length() > 0) {
                out("  can't parse: " + line);
                }
                // Otherwise we're just chewing up blank space.
            }
            }
        }
                // If we have a block open close it.
        if(block != null) {
            out("  parsed: " + block.getName());
            put(block.getName(), block);
        }
        line = null;
        block = null;
        buffered_reader.close();
        buffered_reader = null;
        file_reader.close();
        file_reader = null;
        }
        catch (Exception error) {
        error.printStackTrace();
        System.err.println("An error has occured. View output.txt for more information.");
        exit();
        }
    }
    /** Retrieve the block indicated by the given name.
     * @param name The name of the block as a <strong>String</strong>.
     * @return The <strong>HTMLBlock</strong> asked for or <i>null</i> if no such block.
     */
    public HTMLBlock getHTMLBlock(String name) {
        HTMLBlock block = (HTMLBlock) get(name);
        // Don't return the original, but a copy.
        if(block != null) {
        block = block.spawn();
        }
        return block;
    }
    }
}