Free uml 2.1 specification software for linux

libFoundation is an Objective-C library that provides an almost complete implementation of the OpenStep specification. libFoundation also has many other extensions that can be found in the Apples Mac OS X Foundation library.
Enhancements:
- This release works with the libobjc provided by GCC (3.0 and up), and has been ported to 64-bit platforms.
- A few minor bugs have been fixed, and support for OpenBSD has been improved.

uml2svg is an XSLT-based tool for converting XMI-compliant UML Diagrams into SVG.
We started the developing uml2svg with six main goals in mind:
- Standard conformance
- Good Documentation
- Modularity
- Extensibility
- Comprehensible SVG
- Multiple diagrams per XMI-file
SVG is a standard language for describing two-dimensional vector graphics in XML. As the open SVG standard gains in popularity and gradually replaces proprietary formats for vectorial graphics, the support provided by the Web browsers is getting better.
Plugins to display SVG exist for most browsers and it is most likely that the next generation of Web browser will provide built-in support for SVG. When that happens there will be no better way to distribute vector graphics on the web. Furthermore, not only web browsers can process SVG in a meaningful way; in fact that is just the tip of the iceberg. SVG can be easily read in, processed, and then transformed into many other formats, being well suited for both text and graphic tools as well as for web agents and screen readers.
UML diagrams are composed of lines, polygons, ellipses and text labels, so they are inherently vectorial. However, the SVG is not very well suited for direct use by UML tools. While some of them can in fact export UML diagrams directly to SVG, they do that by discarding all the information about structure, and converting everything into a shape. Moreover, some tools use the screen-capture function provided by their environment (such as java2d) and then they apply a filter to generate SVG out of the "screenshot".
What comes out of that is a pile of meaningless information, which by accident happens to draw a gorgeous diagram. How will a screen reader interpret such a file? How will a web crawler be able to index it? How will a web agent process it in a meaningful way? A program needs the semantic information that the humans can extract just by looking at a picture. For a machine, an obfuscated SVG file is not easier to process than a PNG file or any other image.
Although for humans it is better to be able to scale the image, for a program this is irrelevant. Programs need a way to "understand" the semantics of the UML models to be able to process and interchange them in a meaningfull way. This was the main idea behind the XML Metadata Interchange (XMI), an OMG specification for model interchange. And probably the best use that XMI has found so far is the exchange of UML models between different modeling tools. And while the XMI provides a standard way for tools to represent models as XML documents, it is still limited to the model elements only.
With the introduction of the UML 2.0 Diagram Interchange Specification as part of the upcoming UML 2.0 standard, it will become possible for tools to exchange the models together with the layout of the diagrams. We think that, once this specification appears, XMI will be used averywhere. Not only will the tools be able to exchange diagrams, but could even represent them internaly as DOM trees. Have you ever considered drawing your UML diagrams online, using only a web browser? This could be done even now by using a custom SVG syntax for the DOM tree, but a solution based on XMI could do even better and be a standard at the same time.
Therefore, we believe that with the advent of UML 2.0 and the increase in the use of SVG, the need for transformations between XMI and SVG will be great. Nevertheless when the uml2svg project was started, there was hardly any good open-source solution to convert XMI diagams into SVG.
The UML 2.0 Diagram Interchange Adopted Specification in its current incipient form references a set of XSL transformations. Although the standard draft covers them to a large extent, the link is actually broken (you can try for yourself). It has been broken for more than a year and most likely it will stay like that forever.
The personal webpage of Professor Mario Jeckle provides an online transformation service capable of dynamically generating SVG from XMI-compliant XML files. The XSL files accomplishing the transformations are also available on that website. These transformations are monolithic and not well documented (the only documentation is in the code, and it is generally written in German). With the tragic accident that took the life of Professor Jeckle, the transformations have no longer been maintained.
Finally, the STZ-IDA research center in Karlsruhe had to convert UML diagrams to SVG, as part of one of their projects. The XSLT stylesheet they created for this purpose was named xmi2svg and is available under the terms of the MIT license. At the time we started work on uml2svg the only type of diagrams supported was class diagrams.
Recently the package reached version 0.2 and it supports more diagram types, without major changes in the code (the opposite of what we were expecting). Andreas Junghans, the author of xmi2svg, provided us with a lot of insightful hints which helped us eliminate many glitches in uml2svg. It looks that the development of uml2svg and xmi2svg will continue in parallel, at least for a while. The good thing about this is that the two (quite different) implementations prove each others validity and the features tend to propagate freely from one side to the other. However, this comes with the prize of having to maintain two different code-trees and possibly confusing some users.
We did not like the two existing solutions because they were:
incomplete - just prototypes, not well suited for production environment
monolithic - hard to maintain and extend
not documented - hard to understand
At first sight, we thought we could find a way to improve one of the existing solutions and just add the features we needed. However, we slowly came to the conclusion that it would be better if we started anew. There are things one can fix in a project, but that does not include what we thought is was bad design. The fact that the two implementations presented above are open source helped us get quickly on the way with our own project.
Enhancements:
- Two annoying bugs were fixed.
- The site and documentation were updated.

PPM is a Perl Package Manager: locate, install, upgrade software packages.

SYNOPSIS

ppm genconfig
ppm help [command]
ppm install [--location=location] package1 [... packageN]
ppm query [--case|nocase] [--abstract|author] PATTERN
ppm remove package1 [... packageN]
ppm search [--case|nocase] [--location=location] [--abstract|author] PATTERN
ppm set [option]
ppm verify [--location=location] [--upgrade] [--force] [package1 ... packageN]
ppm version
ppm [--location=location]

ppm is a utility intended to simplify the tasks of locating, installing, upgrading and removing software packages. It is a front-end to the functionality provided in PPM.pm. It can determine if the most recent version of a software package is installed on a system, and can install or upgrade that package from a local or remote host.

ppm runs in one of two modes: an interactive shell from which commands may be entered; and command-line mode, in which one specific action is performed per invocation of the program.

ppm uses files containing an extended form of the Open Software Description (OSD) specification for information about software packages. These description files, which are written in Extensible Markup Language (XML) code, are referred to as PPD files. Information about OSD can be found at the W3C web site (at the time of this writing, http://www.w3.org/TR/NOTE-OSD.html). The extensions to OSD used by ppm are documented in PPM.ppd.

Pathan is an XPath processing library. Pathan library is written in C++, and uses the Xerces-C DOM XML Parser by the Apache Foundation.

The Pathan project incorporates Pathan 1, implementing the W3C XPath 1 recommendation, and Pathan 2, implementing the W3C XPath 2 draft specification.

Pathan has been developed jointly by DecisionSoft, Sleepycat Software , Stylus Studio and Parthenon Computing .

Pathan 2 aims for XPath 2 compliance.

The beta release is conformant to the the November 2003 release of the specification. It conforms to the February 2004 publication of the W3C DOM Level 3 XPath working note.

UML::Sequence is a Perl module to render UML sequence diagrams, often by running the code.

SYNOPSIS

use UML::Sequence;

my $tree = UML::Sequence->new(@methods, @outline, &parse_method);
print $tree->build_xml_sequence(Title);

To use this package, or see how to use it, see genericseq.pl and seq2svg.pl.
This class helps produce UML sequence diagrams. build_xml_sequence returns a string (suitable for printing to a file) which the seq2svg.pl script converts into svg.

To control the appearance of the sequence diagram, pass to the constructor:
1 a reference to an array containing the signatures you want to hear about or a reference to a hash whose keys are the signatures you want 2 a reference to an array containing the lines in the outline of calls 3 a reference to a sub which takes signatures and returns class and method names

To build the array references and supply the code reference consult UML::Sequence::SimpleSeq, UML::Sequence::JavaSeq, or UML::Sequence::PerlSeq. To see one way to call these look in the supplied genericseq script.

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.

XINS is a technology used to define, create, and invoke remote APIs. XINS is specification-oriented.
When API specifications are written (in XML), XINS will transform them to HTML-based documentation and Java code for both the client-side and the server-side.
The communication is based on HTTP. XINS competes with the complex SOAP technology. Main design goals include simplicity, scalability, and testability.
XINS is not only a specification technology, but also an application development framework. It offers transaction logging, unique log documentation, and active code generation.
Whats New in 2.0 Stable Release:
- This release adds support for JSON calling conventions, shared error codes, and import of WSDL and XML Schema.
- Integration with the Spring framework and GWT has been improved.
- New examples with Groovy, REST, and the Dojo toolkit have been added.
- Many other small features and improvements have been done.
Whats New in 2.1 Alpha 2 Release:
XINS/Java Common Library:
- Fixed null values were put in the Map when using the BeanUtils#getParameters method.
- The ServletClassLoader can detect the xins-common.jar using the XINS_HOME environment variable if needed.
- Added automatic detection of the WAR file in the HTTPServletStarter when not passed as paramter.
- Added possibility to pass the ClassLoader mode to the HTTPServletStarter.
- Added new Ant task similar to the < xslt / > task with the option to never overwrite the destination files.
- Added possibility to handle several request at the same time in the internal Servlet container (multi-threaded).
XINS/Java Server Framework:
- Fixed the way the xins.properties was loaded when no org.xins.server.config is set was incorrect.
- Implement RFE #1624142: ACLs for calling conventions. /! The allow methods have a new argument (that can be null).
- Added getName and setName methods in the calling convention classes.
Generation of the opendoc:
- Added colors to the examples.
- Enlarged the example tables.
- Added colors to the table headers.
- Added the categories after the API description.
- Use Courier New font for element names.
- Added light gray borders to the tables.
- Reduce the use of bold fonts.
- Fixed missing uppercase for input and output section.
- Fixed the description of the function, parameters and error was just the first sentence.
- Fixed support for < em > element in descriptions.
- Fixed the "4" appearing before closing an element example.
Generated build file:
- Added javadoc-test-< api name > to get the Javadoc of the unit tests.
- Added possibility to execute the API using java -jar < api name >.war
- Replaced create-project.xslt and tools.xslt with build-create.xml and build-tools.xml as most of the code doesnt need to be dynamically generated.
- Added build-apis.xml which contains static content of the old generated build.xml. This result in the reduction of the size of the generated build.xml.
- Several bug fixes and optimalization during the refactoring.
- The dependency libraries have been added to the classpath for the run and test targets.
Documentation:
- Changed < style / > in < xslt / > in the xins-docs/build.xml.
Build- and release-process:
- Fixed incorrect location of the icon for the Windows installer.
Other:
- Fixed the package list for XINS and log4j.
- Added the package-list for JUnit.
- Added more debug sources for the nbbuild.xml of the petstore.