Free forrest gump software for linux

Apache Forrest is a publishing framework that transforms input from various sources into a unified presentation in one or more output formats.

The modular and extensible plugin architecture is based on Apache Cocoon and relevant standards, which separates presentation from content.

Forrest can generate static documents, be used as a dynamic server, or be deployed by its automated facility.

Forrest is designed with the new user in mind. Much effort has gone into making the process of generating a new site easy and simple:

Step 1: Do forrest seed to populate the directory with template site structure and contents.
Step 2: Add content by editing docs in task-specific, presentation-neutral XML.
Step 3: Do forrest run then use the web browser to immediately review changes at http://localhost:8888/
Step 4: Do forrest to generate the complete website from the XML sources. Various styles (known as skins) are available. Custom skins can be developed.
Step 5: For more information about installation and use, see the Using Forrest guide.

Forrests focus on low "startup cost" makes it ideal for rapid development of small sites, where time and budget constraints do not allow time-wasting HTML experiments. Of course, that same methodology can scale up to large projects. Your development team does not need Java experience, or even XML skills, to use Forrest. The framework lets you concentrate on content and design.

By separating content from presentation, providing content templates and pre-written skins, Forrest is unequalled at enabling content producers to get their message out fast. This separation of concerns makes Forrest excellent to publish project documentation (notably software projects), intranets, and home pages, and anything else you can think of.

Forrest is far from a quick and dirty solution however. Forrest is built on the worlds leading XML application framework, Apache Cocoon, which provides advanced users with extremely powerful publishing capabilities.

* Multiple task-specific source XML formats can be used (How-To, FAQ, changelogs and todo lists supported natively). Source formats include: Apache xdocs xml format, plain html documents, some Wiki formats, a subset of DocBook, ...
* Multiple output formats supported, for example HTML and PDF (using Apache FOP).
* SVG to PNG rendering (using Apache Batik). Simply drop the SVG in the appropriate directory and it will be rendered as PNG.
* Transparent inclusion and aggregation of external content, like RSS feeds.
* Anything else possible with the Cocoon sitemap. Using database queries, charting, web services integration; the possibilities are constantly growing as Cocoon grows. See the Cocoon Features list for the full suite of capabilities.
* Based on Java and XML standards, Forrest is platform-independent, making for a documentation system that is just as portable as the XML data that it processes.

Unique amongst comparable documentation tools, Forrest generates sites that can run both interactively as a dynamic web application, or as statically rendered pages.

This provides a path for site growth: start off small and static, and if dynamic features (user login, forms processing, runtime data, site search etc) are one day needed, these can be accommodated by switching to webapp mode.

Running as a webapp has a major advantage during development: content can be written, and then the rendered output viewed almost instantly in a web browser. This webapp technique enables Forrests edit/review cycle to be faster than command-line transformation tools.

Gump is Apaches continuous integration tool. Apache Gump is written in python and fully supports Apache Ant, Apache Maven and other build tools. Gump is unique in that it builds and compiles software against the latest development versions of those projects. This allows gump to detect potentially incompatible changes to that software just a few hours after those changes are checked into the version control system. Notifications are sent to the project team as soon as such a change is detected, referencing more detailed reports available online.

You can set up and run Gump on your own machine and run it on your own projects, however it is currently most famous for building most of Apaches java-based projects and their dependencies (which constitutes several million lines of code split up into hundreds of projects). For this purpose, the gump project maintains its own dedicated server.

How does Gump work?

With Traditional Gump, project definitions are converted from XML to scripts native to the platform on which you are running. With Python Gump the XML is mapped into in memory objects for processing. Scripts execute cvs or svn update commands for every module which contains a project being built, and invoke builds for each project in an order that ensures that dependencies are satisfied. Build outputs are processed and, if successful, dependent projects are then built on these outputs.

The commands use the actual build.xml files from the projects, but do not use the scripts or jar files checked into CVS/SVN. Instead, the CLASSPATH is set and properties are passed on the command line.

Note

Gump sets Ants build.sysclasspath to only and manages the system classpath:
To quote Ant: Only the system classpath is used and classpaths specified in build files, etc are ignored. This situation could be considered as the person running the build file knows more about the environment than the person writing the build file

The net effect is that every project is built every day with the latest version of every dependency - including the latest Ant, latest JUnit, latest XML parser.

The results are captured into html pages that largely are consistent with the style of the Jakarta project. An extensive amount of hypertext links are added to allow quick and easy navigation, and failures are color coded on the main build page.

A Perl script which is driven off of a naglist will optionally send e-mails to various newsgroups upon matching strings being found in the build output. This is typically used to alert developers of build failures.

iBookshelf is an application for cataloging your book collection and designing bookshelves based for it. Written in C#/Mono using the Gtk# graphical toolkit. This project is specifically an experiment in computer aided design
Main features:
- ISBN entry using CueCat, standard barcode scanner, or manual entry.
- Automatic data fetch using Amazon web services
- Manual book entry for non-catalogued books
- Bookshelf design based on most efficient book order.

Wolfpack project is a server-side Ultima Online MMORPG software.
Wolfpack is software for an Ultima Online MMORPG server. Gameplay is scripted using Python and XML. You need EAs Ultima Online to play on Wolfpack servers.
The Wolfpack project is an effort to develop and maintain an open-source Ultima Online server that is secure, stable and extensible, providing users with the ability to create their own unique shards.
Enhancements:
- ixed meditation skillcheck in mana regeneration code.
- Changed GM talk color.
- Implemented the onCheckVictim event.
- Implemented the onDoDamage event.
- Stablemasters now remove the stabled pets from the follower list.
- Corpses now decay in multis too.
- Implemented a walktest command for testing walking.
- Fixed several other walking bugs.
- Implemented onRemoteUse for checking if an object that is in the belonging
- of another char may be used. First called for the using char, then for the
- owner of the object.
- Implemented onSnooping that is called for the owner and for the player trying to
- open a container.
- Fixed shop restock.
- Fixed bug #0000364. (Vendors not selling items they bought)
- Rewrote the vendor buy handler code.
- Improved the configure script:
- Translations are disabled by default now.
- Cleaner output.
- Fixed a bug with MySQL library reporting.
- The SectorMaps singleton has been renamed to MapObjects.
- The deprecated RegionIterators have been removed.
- The SectorIterators have also been replaced with a much faster iterator.
- The new iterators dont allocate/copy memory anymore.
- The "range" lookup now looks for items within a real circle.
- Multis now have their own structure, and are now separate from items.
- Region calls now list online and offline chars in sperate lists.
- Implemented player collision stamina loss in Felucca.
- Fixed lightlevel calculation.
- Fixed the pythonscript* integer conversion warnings by using size_t instead.
- Fixed adding items to the MapObjects.
- Fixed a bug in the new ContainerCopyIterator.
- Fixed movement not correctly being sent to other characters.
- Fixed Multi Update range.
- Added .reload muls and added a broadcast message to the reload commands.
- Fixed handling of a fixed z value for spawnregions.
- Fixed an exploit (dropping without dragging first)
- Changed the semantics of onLogin/onLogout (character entering/leaving the world).
- Added onConnect/onDisconnect (socket attaching/detaching to/from a player).
- Its no longer possible to login with a char if another char in
- the same account is still online.
- Fixed a bug that would cause onLogout not to be called.
- A skill of 100% or more in Spirit Speaking now allows you to talk
- freely as a ghost and hear everything dead players have to say.
- All geometrical bodies for spawnregions now support the except="true"
- tag that makes the rectangle, circle or point not be included in finding
- a random position within the region.
- Fix with spawnregion data. UShort != UInt
- Added socket.denymove to send packets to deny movement
- Fixed a crashbug with invalid function names passed to .addtimer()
- Added the ability to make yourself visible to other players.
- Guildbutton now triggers onGuildButton(player) python event.
- Fixed bug #0000376. (Stablemasters dont take money from the bank)
- Added "Refresh Characters Maximum Values" setting. Setting this to "false"
- will disable the automatic recalculation of Maxhitpoints/Maxmana/Maxstamina.
- Added a warning in the console if translation file could not be found.
- Fixed monsters not attacking players pets.
- Fixed bug #0000363. (Pets dont attack a target if its already fighting)
- More tag documentation in the code.
- Definition Tag Cleanups.
- Using skills no longer unhides by default, unhide moved to python.
- Fixed a nasty bug in the map sector code which caused objects not
- to be in the map objects when moved between maps.
- Fixed a walking bug that caused monsters to walk trough certain objects.
- type="3" in bodyinfo.xml is now correctly interpreted by the core.
- Exploit bugfix for locked containers.
- The status only shows the gold directly in your backpack now. (performance issues)
- Added bladespirit and energyvortex ai.
- Fixed a vision range bug with walking.
- Fixed many compiler warnings for GCC 3.4 versions, and general warnings.
- Updated SQLite to 2.8.15 and defaulted SQLite to encode data with UTF-8.
- Added a new feature to random:
- This will select a random value from a random list.
- Added new features to container items (made list work as well):
-
- Disabled verdata.mul support as this is no longer included in the latest
- releases of Ultima Online. Note: Commented out the source code only.
- Implemented an onSelectAbility event for the weapon special moves.
- Corrected the NINJITSU and BUSHIDO skill ids.
- Small cleanup to wolfpack.xml: Database options follow the same option
- names are are given in account options.
- Implemented a "karmalock" property to player objects. If its True, the player will not
- gain any positive karma anymore.
- Added Commoner AI.
- Fixed mul path detection on windows in release builds.
- * Definition Changes:
- Added the mage AI to most creatures.
- Adjusted carving sheep.
- Fixed leatherworkers and tanners not buying leather and hides.
- Male NPCs now have a 75% chance of getting a beard when created.
- Made shrink potions craftable.
- Changed the color of shrink potions.
- Added Tokuno includes for regions and spawnregions.
- Removed the "Pink Spawn" from decoration.
- Fixed skeletal steeds stats and skills.
- Added stackable burned food that is used when cooking fails.
- Added ranged weapons + ammo to orc scout, ratmen archer, meer captain and juka lord.
- Added colored samurai armor.
- Reorganized base armor categories.
- New folder for defines: definitions/defines/
- Applied the index.xml branches to colored armor.
- Added lightsources to fire elementals, wisps and horde minions.
- Added bones to bone_magi and body parts to horde minions, zombies and others.
- Added colored weapons. Note: Only the metallic weapons.
- Sorted out the samurai weapons by type and fixed properties.
- Ranged weapons set to 10 instead of 12.
- Price fixes for arrows/bolts.
- Fixed potion kegs.
- Gave guards colored hair.
- NPC skill defines are now: value
- Gold now has weight.
- Corrected the bushido and ninjitsu skill ids.
- All mounts now have the event npc.mount
- * Python Script Changes:
- Fixed bug #0000369. (Equip possible although item.movable = 3)
- Fixed bug #0000361. (Pets dont follow trough gate)
- Added xoffset, yoffset and zoffset to socket.attachmultitarget. (housing.deed)
- Fixed a runebook bug. (Refuses to work when full)
- Rewrote parts of the runebook.
- Added support for creature based poison immunity.
- Added support for hit based poisoning.
- Fixed several bugs in lumberjacking.
- Chars will now get revealed when using training dummy or archery butte.
- Fixed blood created at carving not decaying for a long time.
- Fixed fishing pole not wearing out.
- Fixed gainfactor for skills always beeing 1.0
- Fixed a skill check bug with lumberjacking.
- Implemented shrink potions.
- Fixed the tooltip of alchemy tools not being resend.
- Fixed the input system trying to call not existent scripts.
- Fixed the color of shrunken pets.
- Implemented shrink command.
- Implemented telem command.
- Added onConnect to system.players
- Fixes for moongate.py
- Guild button now opens guildstone menu by default.
- Fixed resistances for dragon scale armors.
- Fixed the open door macro.
- Fixed bug #0000310. (Invis spell duration too brief, Players will now be able to use stealth
- if they are hidden by the invisibility spell, even if they dont have 80.0 Hiding )
- Fixed bug #0000321. (Info Gump not setting boolean values to True if input is 1)
- Poisoning now accepts stacked potions.
- Reorganized the potion scripts.
- Added possibility to cut bone parts into usable bones using scissors.
- Fixed potion kegs.
- Added tilecolorz command. Same as tilecolor, but limited to one z coordinate.
- Added nukez command. Same as nuke, but limited to one z coordinate.
- Added tilemove command.
- Increased energyvortex and bladespirit casting time.
- Implemented the bleeding wound system.
- Implemented the weapon special moves.
- Implemented the SelfRepair item property.
- Implemented the Enhance Potions item property.
- Implemented the Splash Damage item properties.
- Implemented the On Hit spell effect item properties.
- Implemented support for dispel difficulty/dispel focus (see playguide).
- Enabled tithing of gold, resurrection and karma locking at ankhs.
- * Misc. Changes:
- FAQ Updates.
- Now compiling with the KDE Cygwin QT version on Windows. (http://kde-cygwin.sf.net)
- Updated the gm tool a little. It now has support for the samurai empire maps.
- In addition to fixing some bugs, it also has an experimental region rectangle generator
- on the settings tab.
- * Known Issues, Bugs, and Missing Features:
- Some skills are still incomplete.
- Spawn regions are incomplete.
- We welcome donated OSI-like spawn scripts!
- Town/World regions are incomplete.
- We welcome donated OSI-like region scripts!
- Possible that a few monsters are missing and/or incomplete.
- Multis (Houses/Boats) are not currently supported.

Rhizome is a Wiki-like content management and delivery system that exposes the entire site -- content, structure, and metadata as editable RDF. This means that instead of just creating a site with URLs that correspond to a page of HTML, with Rhizome you can create URLs that represent just about anything, such as:
- structural components of content (such as a bullet point or a definition).
- abstract entities that can be presented in different ways depending on the context.
- relationships between entities or content, such as annotations or categories.
Rhizome is designed to enable non-technical users to create these representations in an easy, ad-hoc manner. To this end, it includes a text formatting language which similar to a Wikis but lets you author arbitrary XML content and RDF metadata. And for developers, this allows both content and structure to be easily repurposed and complex web applications rapidly developed.
The long-term vision is that each Rhizome site will intertwine together, forming an emergent fuzzy taxonomy over a peer-to-peer network.
The nearer-term goals of Rhizome are:
- To allow (relatively) non-technical folk to create "Semantic web"-enabled web sites.
- To provide a platform for the rapid-development of web applications
- To provide a test-bed for experimenting with new forms of collaborative knowledge production and communication
- A showcase and test-bed for its underlying technologies: Rx4RDF, ZML, and Raccoon
Main features:
Wiki ease
- All the functionality of a Wiki: public and automatic creation of pages and links using simple text formatting rules
- But the same formatting rules can used to author arbitrary HTML, XML and RDF
- And you can create and edit not just content but also the metadata, site structure and appearance, even application behavior
- Including dynamic pages: supports XSLT, RxSLT, Python, RxUpdate
- Thus enabling dynamic, rule and context based presentation of content
Advanced Content Management functionality
- pages can consist of any content: xml, html, binary, etc.
- content, metadata and site structure is a stored as RDF: enabling it be repurposable, human editable, application agnostic, etc.
- flexible authorization and security model
- staging/release workflow
- native versioning of content and metadata, conflict detection
- supports local file system or browser-based development
- can generate static websites
- import/export of content and metadata
- flexible backend: supports multiple RDF engines (Redland, 4Suite, RDFLib) with multiple datastores: file based, SQL databases, embeddable databases (Sleepycat, Metakit)
XHTML or arbitrary XML can be authored in ZML in a manner very similar to Wiki text formatting rules. Rhizome comes with built-in support for Apache Forrest document types and has preliminary support for DocBook. You can also easily view and edit RDF metadata for the site using RxML.
Almost all of Rhizomes functionality can be found its dynamic pages, which are written in RxSLT, XSLT, and RxUpdate. These can be edited like any other page, making it easy to add and change functionality without restarting the server. You can use RxUpdate to migrate the underlying schema at run-time. Rhizome supports fine-grained authorization and versioning of both metadata and content, so you have some guard rails too.
Enhancements:
- This release adds "shredding": a framework (including GRDDL support) for extracting RDF from content and maintaining the relationship between them over time.
- It also includes better support for viewing and editing RDF directly with most RDF formats.
- There are also several UI enhancements, including a new UI for managing users and roles, more Wiki features, and page and comment spam detection via the Akismet service.
- Last but not least, it is several times faster than previous releases.

Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a projects build, reporting and documentation from a central piece of information.
Main features:
Model based builds
- Maven is able to build any number of projects into predefined output types such as a JAR, WAR, or distribution based on metadata about the project, without any need to do any scripting in most cases.
Coherent site of project information
- Using the same metadata as for the build process, Maven is able to generate a web site or PDF including any documentation you care to add, and adds to that standard reports about the state of development of the project. Examples of this information can be seen at the bottom of the left-hand navigation of this site under the "Project Information" and "Project Reports" submenus.
Release management and distribution publication
- Without much additional configuration, Maven will integrate with your source control system such as CVS and manage the release of a project based on a certain tag. It can also publish this to a distribution location for use by other projects. Maven is able to publish individual outputs such as a JAR, an archive including other dependencies and documentation, or as a source distribution.
Dependency management
- Maven encourages the use of a central repository of JARs and other dependencies. Maven comes with a mechanism that your projects clients can use to download any JARs required for building your project from a central JAR repository much like Perls CPAN. This allows users of Maven to reuse JARs across projects and encourages communication between projects to ensure backward compatibility issues are dealt with. We are collaborating with the folks at Ibiblio who have graciously allowed the central repository to live on their servers.
Gump integration
- Integration with Gump. For those who are not familiar with Gump it is a tool used at Apache to help projects maintain backward compatibility with their clients. If you have a Maven project descriptor then you can easily participate in nightly Gump builds that will help your project stay abreast of the impact your changes actually have in Java developer community. We are working on our own massive build tool but integration with Gump comes at no cost to Maven users.