Free java html parser software for linux

HTMLParser is a super-fast real-time parser for real-world HTML. What has attracted most developers to HTMLParser has been its simplicity in design, speed and ability to handle streaming real-world html.
The two fundamental use-cases that are handled by the parser are extraction and transformation (the syntheses use-case, where HTML pages are created from scratch, is better handled by other tools closer to the source of data). While prior versions concentrated on data extraction from web pages, Version 1.4 of the HTMLParser has substantial improvements in the area of transforming web pages, with simplified tag creation and editing, and verbatim toHtml() method output.
In order to use HTMLParser you will need to be able to write code in the Java programming language. Although some example programs are provided that may be useful as they stand, its more than likely you will need (or want) to create your own programs or modify the ones provided to match your intended application.
To use the library, you will need to add either the htmllexer.jar or htmlparser.jar to your classpath when compiling and running. The htmllexer.jar provides low level access to generic string, remark and tag nodes on the page in a linear, flat, sequential manner. The htmlparser.jar, which includes the classes found in htmllexer.jar, provides access to a page as a sequence of nested differentiated tags containing string, remark and other tag nodes. So where the output from calls to the lexer nextNode() method might be:
< html>
< head>
< title>
"Welcome"
< /title>
< /head>
< body>
etc...
The output from the parser NodeIterator would nest the tags as children of the , and other nodes (here represented by indentation):
< html>
< head>
< title>
"Welcome"
< /title>
< /head>
< body>
etc...
The parser attempts to balance opening tags with ending tags to present the structure of the page, while the lexer simply spits out nodes. If your application requires only modest structural knowledge of the page, and is primarily concerned with individual, isolated nodes, you should consider using the lightweight lexer. But if your application requires knowledge of the nested structure of the page, for example processing tables, you will probably want to use the full parser.
Extraction
Extraction encompasses all the information retrieval programs that are not meant to preserve the source page. This covers uses like:
- text extraction, for use as input for text search engine databases for example
- link extraction, for crawling through web pages or harvesting email addresses
- screen scraping, for programmatic data input from web pages
- resource extraction, collecting images or sound
- a browser front end, the preliminary stage of page display
- link checking, ensuring links are valid
- site monitoring, checking for page differences beyond simplistic diffs
There are several facilities in the HTMLParser codebase to help with extraction, including filters, visitors and JavaBeans.
Transformation
Transformation includes all processing where the input and the output are HTML pages. Some examples are:
- URL rewriting, modifying some or all links on a page
- site capture, moving content from the web to local disk
- censorship, removing offending words and phrases from pages
- HTML cleanup, correcting erroneous pages
- ad removal, excising URLs referencing advertising
- conversion to XML, moving existing web pages to XML
During or after reading in a page, operations on the nodes can accomplish many transformation tasks "in place", which can then be output with the toHtml() method. Depending on the purpose of your application, you will probably want to look into node decorators, visitors, or custom tags in conjunction with the PrototypicalNodeFactory.
The HTML Parser is an open source library released under GNU Lesser General Public License, which basically says you are free to use the library "as is" in other (even proprietary) products, as long as due credit is given to the authors and the source code for the HTMLParser is included or available with the other product. For modified or embedded use, please consult the LGPL license.

HTML Purifier project is the premiere PHP solution for all your HTML filtering needs. Tired of forcing users to use BBCode or some other obscure custom markup language due to the current landscape of deficient or hole-ridden HTML filterers? Look no further: HTMLPurifier will not only remove all malicious code (the stuff of XSS), it will also make sure the HTML is standards compliant.
There are a number of ad hoc HTML filtering solutions out there on the web (some examples including PEARs HTML_Safe, kses and SafeHtmlChecker.class.php) that claim to filter HTML properly, preventing malicious JavaScript and layout breaking HTML from getting through the parser. None of them, however, demonstrates a thorough knowledge of the DTD that defines HTML or the caveats of HTML that cannot be expressed by a DTD.
Configurable filters (such as kses or PHPs built-in striptags() function) have trouble validating the contents of attributes and can be subject to security attacks due to poor configuration. Other filters take the naive approach of blacklisting known threats and tags, failing to account for the introduction of new technologies, new tags, new attributes or quirky browser behavior.
However, HTML Purifier takes a different approach, one that doesnt use specification-ignorant regexes or narrow blacklists. HTML Purifier will decompose the whole document into tokens, and rigorously process the tokens by: removing non-whitelisted elements, transforming bad practice tags like font into span, properly checking the nesting of tags and their children and validating all attributes according to their RFCs.
To my knowledge, there is nothing like this on the web yet. Not even MediaWiki, which allows an amazingly diverse mix of HTML and wikitext in its documents, gets all the nesting quirks right. Existing solutions hope that no JavaScript will slip through, but either do not attempt to ensure that the resulting output is valid XHTML or send the HTML through a draconic XML parser (and yet still get the nesting wrong: SafeHtmlChecker.class.php does not prevent a tags from being nested within each other).
Enhancements:
- This version amends a few bugs in some of newly introduced features for 2.1, namely running the standalone download version in PHP4 and %URI.MakeAbsolute.

ShaniXmlParser is an XML/HTML DOM/SAX parser that can be validating. It can parse badly formed XML files.
ShaniXmlParser can parse files with inverted tags and bad escaped &,< and >. ShaniXmlParser expands all HTML entities. ShaniXmlParser is well suited to parse HTML files.
It is up to 3 times faster than the internal JDK 1.5 xerces parser and as fast as the internal JDK 1.4 Crimson parser, compliant with the jaxp/w3c DOM interfaces, and very small.
Enhancements:
- Support of DOM 2 HTML interfaces.
- 668/685 succeeded tests on DOM 2 HTML Test Validation suite.

C++ WSDL Parser is an efficient C++ Web services library that includes a standards compliant WSDL parser API, a Schema parser and validator, an XML parser and serializer, and an API for dynamically inspecting and invoking WSDL Web services.
Enhancements:
- Many WSDLs can now be dynamically invoked.
- Added documentation (doxygen for the API).
- Better error reporting when types are found missing.

Test::Parser is a collection of parsers for different test output file formats. These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.

Test-Parser can also export tests in SpikeSources TRPI test description XML language.

Makefile::Parser is a Simple Parser for Makefiles.

SYNOPSIS

use Makefile::Parser;

$parser = Makefile::Parser->new;

# Equivalent to ->parse(Makefile);
$parser->parse or
die Makefile::Parser->error;

# Get last value assigned to the specified variable CC:
print $parser->var(CC);

# Get all the variable names defined in the Makefile:
@vars = $parser->vars;
print join( , sort @vars);

@roots = $parser->roots; # Get all the "root targets"
print $roots[0]->name;

@tars = $parser->targets; # Get all the targets
$tar = join("n", $tars[0]->commands);

# Get the default target, say, the first target defined in Makefile:
$tar = $parser->target;

$tar = $parser->target(install);
# Get the name of the target, say, install here:
print $tar->name;

# Get the dependencies for the target install:
@depends = $tar->depends;

# Access the shell command used to build the current target.
@cmds = $tar->commands;

# Parse another file using the same Parser object:
$parser->parse(Makefile.old) or
die Makefile::Parser->error;

# Get the target who is specified by variable EXE_FILE
$tar = $parser->target($parser->var(EXE_FILE));

This is a parser for Makefiles. At this very early stage, the parser only supports a limited set of features, so it may not recognize some advanced features provided by certain make tools like GNU make. Its initial purpose is to provide basic support for another module named Makefile::GraphViz, which is aimed to render the building process specified by a Makefile using the amazing GraphViz library. The Make module is not satisfactory for this purpose, so I decided to build one of my own.