Header Ads Widget

Responsive Advertisement

string to xml or html Beautifier

Kartik Chandra Mandal July 03, 2017


The evolution of XML/HTML beautifiers and mathematical formula converters is deeply rooted in the history of computing and the development of markup languages and mathematical notation.

XML and HTML Beautifiers

Origins of Markup Languages:

Ø  SGML (Standard Generalized Markup Language): Developed in the 1970s by Charles Goldfarb, Ed Mosher, and Ray Lorie at IBM, SGML was designed to define descriptive markup languages for documents. It allowed the creation of vocabularies to mark up documents with structural tags.

Source: C. Collins

Ø  HTML (HyperText Markup Language): In 1993, Tim Berners-Lee introduced HTML as a simplified subset of SGML to facilitate the sharing of documents on the emerging World Wide Web. HTML enabled the creation of structured documents with hyperlinks, images, and other multimedia elements.

Source: University of Washington

Ø  XML (eXtensible Markup Language): In the late 1990s, a team led by James Clark developed XML as a simplified subset of SGML. XML was designed to be a flexible way to create information formats and electronically share structured data via the internet.

Source: Medium

Development of Beautifiers:

As the use of XML and HTML became widespread, the need for tools to format and beautify these documents emerged. Properly formatted code enhances readability and maintainability. Beautifiers, also known as pretty-printers, were developed to automatically format markup code according to standard indentation and styling rules. These tools have become essential for developers working with web technologies.

Mathematical Formula Converters

Evolution of Mathematical Notation:

Ø  Early Notation: Ancient civilizations, such as the Babylonians, used rudimentary symbols and notations for mathematical calculations. For instance, Babylonian mathematics utilized a sexagesimal (base-60) numeral system.

Source: Drexel Math

Ø  Development of Symbolic Algebra: The 17th and 18th centuries saw significant advancements in mathematical notation, including the development of symbolic algebra and calculus. Mathematicians like Leibniz introduced more symbolic versions of calculus, laying the foundation for modern mathematical notation.

Source: Encyclopaedia Britannica


The XmlBeautifier Java class provided here is designed to format (beautify) an XML file and write the formatted XML string to a file. The program reads an XML file, formats it with proper indentation and line breaks, and saves it to a new file.

 

Code Using Standard Libraries:

java

package com.kartik.xml.beauty;

 

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringReader;

import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

 

public class XmlBeautifier {

 

    public static void main(String[] args) {

        XmlBeautifier formatter = new XmlBeautifier();

        String book = convertXMLFileToString("C:\\Users\\kmandal\\Desktop\\breakFirst.xml");

        String formattedXml = formatter.format(book);

        System.out.println(formattedXml);

        fileWrite(formattedXml, "C:\\Users\\kmandal\\Desktop\\MyTestFile.xml");

    }

 

    // Convert XML file to String

    public static String convertXMLFileToString(String fileName) {

        try {

            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();

            InputStream inputStream = new FileInputStream(new File(fileName));

            Document doc = documentBuilderFactory.newDocumentBuilder().parse(inputStream);

            StringWriter stw = new StringWriter();

            Transformer serializer = TransformerFactory.newInstance().newTransformer();

            serializer.setOutputProperty(OutputKeys.INDENT, "yes");

            serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

            serializer.transform(new DOMSource(doc), new StreamResult(stw));

            return stw.toString();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

 

    // Format the XML string

    public String format(String unformattedXml) {

        try {

            Document document = parseXmlFile(unformattedXml);

            return makeXMLString(document);

        } catch (Exception e) {

            e.printStackTrace();

            return "";

        }

    }

 

    // Parse the XML string to a Document object

    private Document parseXmlFile(String in) {

        try {

            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

            DocumentBuilder db = dbf.newDocumentBuilder();

            InputSource is = new InputSource(new StringReader(in));

            return db.parse(is);

        } catch (ParserConfigurationException | SAXException | IOException e) {

            throw new RuntimeException(e);

        }

    }

 

    // Convert Document object back to a formatted XML string

    public String makeXMLString(Document doc) {

        try {

            TransformerFactory transfac = TransformerFactory.newInstance();

            Transformer trans = transfac.newTransformer();

            trans.setOutputProperty(OutputKeys.INDENT, "yes");

            trans.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

            StringWriter sw = new StringWriter();

            trans.transform(new DOMSource(doc), new StreamResult(sw));

            return sw.toString();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return "";

    }

 

    // Write formatted XML content to file

    public static void fileWrite(String strContent, String filePath) {

        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath))) {

            bufferedWriter.write(strContent);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

 

 

Code Breakdown:

  1. convertXMLFileToString method: This method reads an XML file from the file system and converts it to a String.

java

public static String convertXMLFileToString(String fileName) {

    // Reads the XML file and returns the file's content as a String

}

 

It uses the DocumentBuilderFactory and Transformer classes to parse the XML and serialize it into a string.

  1. format method: This method formats the raw XML string into a well-indented and readable structure using OutputFormat and XMLSerializer.

java

public String format(String unformattedXml) {

    // Format the XML String to a well-structured XML

}

 

The formatted XML is also written to a file using the fileWrite method.

  1. parseXmlFile method: This method converts an XML string into a Document object for further processing.

java

private Document parseXmlFile(String in) {

    // Parses XML string and returns it as a Document object

}

 

  1. makeXMLString method: This method is a utility to convert a Document object back into an XML string.

Java

public String makeXMLString(Document doc) {

    // Converts the DOM Document object back into an XML string

}

 

  1. fileWrite method: This method writes the formatted XML string to a file.

java

public static void fileWrite(String strContent) {

    // Writes the formatted XML content to a file

}

 

It checks if the file exists, creates it if necessary, and writes the content to the specified file path.

  1. Main method: The main method tests the class by reading an XML file located at C:\\Users\\kmandal\\Desktop\\breakFirst.xml, formatting it, and saving it to C:\\Users\\kmandal\\Desktop\\MyTestFile.xml.

Key Changes:

  1. Deprecated Classes Removed: OutputFormat and XMLSerializer have been replaced with javax.xml.transform.Transformer.
  2. Standard Indentation: The new transformer uses a custom indentation level (4 spaces) to format the XML.
  3. Dynamic File Writing: The fileWrite method now accepts a file path as a parameter, allowing dynamic file writing.

This  adheres to current Java standards and provides a cleaner, more flexible way of formatting and writing XML files.

Converters and Typesetting:

With the advent of digital typesetting and word processing, the need arose for tools to accurately represent mathematical formulas electronically. Systems like LaTeX were developed to allow precise formatting of complex mathematical expressions. LaTeX uses plain text files with markup tags to describe the structure and content of a document, making it a powerful tool for typesetting mathematical formulas.

In summary, the development of XML/HTML beautifiers and mathematical formula converters is closely linked to the historical progression of markup languages and mathematical notation. These tools have evolved to meet the growing demands for efficient data representation and presentation in both web development and academic publishing.



string to xml or html Beautifier
string to xml or html Beautifier 


 

Post a Comment

0 Comments

Post a Comment