Parent Directory
| 
Revision Log
| Links to HEAD: | (view) (annotate) |
| Sticky Revision: |
Move Commons TLP changes
Moving to TLP
Moving back :)
Moving to TLP
apply patch for JELLY-272 from ltheussl
Fixed copyright header (committing in parts as the full commit timed out)
Including a comment about upgrading gump's descriptor. paul
fix the directly where crlf is performed
Little fixes for the binary distribution: - support for arguments with spaces - a readme dedicated for the binary distribution with an explanation about extensibility (which looks good). paul
include xdocs in src distribution
correct file modes and line endings
include release notes in distro
include NOTICE.txt in src/bin distribution and parent-project.xml in src
distribution builder
svn:keywords correction
adjust generation of version/timestamp
Adding jelly -h and -v. (help and current-version). paul
changes for gump
Fix taglib sites being broken after top level parent-project.xml was introduced.
Default to only building jelly site, not all taglibs.
Pack-fat-jar now always includes the jelly in snapshot form... otherwise mismatches occur... paul
delete install directory before copying
detab
All tags now have nav
Just do site. JellyDoc has been added to the tag lib common project defn
Add clean-build goal
Allow main site only to be built as well as all
Don't use fixed ant props in loops
Adding postGoal to copy css stylesheets from commons-build when site is generated. Please maintain this modification for consistent look and feel across commons subprojects.
Guess mavenCmd based on OS
Fix typo
Add a comment for windows users
indenting
Remove comment
fix busted reactor tag
detab
Adding the pack-fat-jar with a full set of default values. paul
Upgrading to dom4j 1.5-beta-2, thereby to jaxen 1.1 beta-2. Updated all build.xml. The whole project seems to build fine. Using maven rc3 may be a good advice. paul
ASL v2
Fix formatting on an echo. Add directory to install message
Now with the production of a classpath file and configurable paths. paul
Now does not try to build the tags... just packing. paul
Adding a goal named pack-fat-jar so that one can pack a binary of jelly and all its dependent in one double-clickable jar. Use as follows: maven pack-fat-jar -DtagLibs=xml,util java -jar target/jellypack.jar myFile.jelly Not much tested, thanks to comment! paul
Website is now built with maven site but this takes very long (about an hour) and relies on being able to invoke maven executable back (!). Fixed many inaccuracies in the presentation pages. Some of these pages could be moved to their taglib as was done with JellySwing. Paul
detab
* Remove postgoals and use native maven features now. it has been long enough * Add explicit sourceDirectory and unitTestSourceDirectory
Make default jar:jar
patches to get the website generation working. It does tend to run out of RAM - I found it needs to be about 400Mb! Clearly somethings a bit amis in Maven/reactor somewhere. Will investigate further.
removed the old doclet for generating documentation - this has migrated over to the jellydoc plugin for maven. almost got the new website build working - so we can nearly build the whole site & all the libraries. Nearly there...
Use dependencty type instead of hard coding jars
Fix directories to use correct name
Add tags-do goal
removed lots of cruft from the maven build; these goals have been moved into the jelly-tags builds
moved the swing demo goals into the swing library build and added the necessary dependencies required to run the demo:swing example
Removed some old cruft from the maven.xml file.
Removed util taglib usage from demo.
Added goal to build all tags. NOTE: This doesn't work yet, due to the relative directory inclusion of the common dependencies
Applied patch from Nick Minutello
Patch to allow the HTML tag library full control over NeckoHTML's ability to convert elements or attributes to upper or lowercase.
You can now specify if you wish case conversion to be applied when parsing HTML.
e.g. to upper case the elements but lowercase the attributes you can do...
<html:parse var="doc" html="index.html" element="upper" attribute="lower"/>
or to make everything lower case
<html:parse var="doc" html="index.html" element="lower" attribute="lower"/>
The default is to leave case as it was but to match element case (so that open and close elements have the same case).
Added an initial implementation of JellySWT which is an XML language for creating rich user interfaces using SWT.
Added some catch-all post goals that should work whatever version of Maven folks are using
I've enabled the JellyUnit test case that Peter wrote and added another to both test for a regular nested <filterset> and one using a refid. Also added a fix for it too! The short answer is the problem was due to treating <filter> as a new task rather than a nested property of <filterset> Again this is due to the complexity of the Ant behaviour. Sometimes Ant tags are meant to be Tasks, sometimes they are meant to be nested properties, and this can get confusing. I think the correct logic right now is that... a tag should be considered task if it is the root node in the tree of Ant tags and the name of the tag is a valid Ant task name, otherwise treat it as a nested property or datatype. So the root tag can be a <filterset id="...">. Also there are times when a task shouldn't be treated as a task but instead as a nested property. e.g. <filter> and <manifest> are tasks but should be treated as nested properties.
Minor patch to the Radio to PDA tool (that creates a HTML view of Radio's news aggregator that can be read on a small PDA screen) so that the directory where the generated file goes can be customized in a build.properties file
Patched the copyright year to indicate when Jelly actually came to be, which was 2002. Thanks for bringing this up Stefan.
Added a simple Maven Wizard using JellySwing which allows a simple menu to be used to choose goals to invoke
Added Aslak's example from this JIRA report... http://jira.werken.com/secure/ViewIssue.jspa?key=JELLY-9 which can be ran via the command maven demo:task plus I've applied a minor fix to the Ant tag library that fixes this issue now.
added a simlpe benchmark goal that can be used for performance tuning of the core Jelly engine
Added a simple Jelly script which converts the HTML output by Radio Userland's RSS aggregator to a simple HTML format without any tables that is readable by PDAs such as my Sharp Zaurus. This little script enables me to download RSS news feeds to my PDA and read it on the commute to work! Hooary!
Added SOAP support via Apache Axis. This is based on a patch submitted by Jim Birchfield which allows SOAP services to be invoked using Apache Axis and the results output. Its early days and we'll improve this support considerably over time but at least the basics are working for now. There's a demo invokable via maven demo:soap which invokes a sample Axis echo service and an xmethods.net service.
Added some JellyUnit test cases for the <util:tokenize> tag which also helped highlight the bug in Jexl Robert found. Will be adding some more unit test cases to Jexl shortly...
Patches to fix Vincent's problem when trying to invoke goals asynchronously in other threads. This seems to work fine now. Added helper tag, <util:sleep millis="1000"/> to be able to get one thread to sleep for a certain time. Adding some kind of <waitFor> would be much more appropriate instead. Also there's a sample of this in action via maven demo:async
Committed patches submitted by Jason Horman to provide a decent command line interface using commons-cli to Jelly.
So usage is like this...
Usage: jelly [scriptFile] [-script scriptFile -o outputFile -Dsysprop=syspropval]
Additional command line options are available in jelly scripts by using the
commandLine.getOptionValue(optionName) method. Args is also still available.
context.setVariable("args", args);
context.setVariable("commandLine", cmdLine);
Also there's a sample target to demonstrate this in action. Type
maven demo:cmdline
and you'll see Jason's test script run, using beanshell in a Jelly script to display the options and system properties etc.
Added support in JellySwing for simple TableModels which use any pluggable Jelly Expressions for defining the columns. This allows any List of objects to be easily rendered in a table in JellySwing without any programming involved. Its hoped this kind of thing could be ported to SWT too! A simple example has been added which will display all the variables in the current context in a table. This could be improved somewhat, but shows that a List of property names can be displayed in a table, showing the value, type, row index and the name of the variable; all powered by a List of Strings. Another good demo could be to render a table of beans (such as some Maven POM objects) in a table. Or to use commons-beanutils or commons-sql to get some DynaBeans and render those in a table using expressions.
- Rearranged dependencies into alpha order on dep name - Added extra files to copy for postGoal on test:test
Some JellySwing changes. Firstly added support for <borderLayout> and <borderAlign align="center"> style of tags to use the Swing BorderLayout. Added support for <vbox> and <hbox> to create Swing Box panels (which have their own inbuilt BoxLayout) Also added colfill="true" and rowfill="true" options on <td> so that columns can stretch Finally I've improved the JellyRunner so that its a little dialog, with a history field and a button so that reevaluating the same script can be much easier. Just hit save in your editor and hit the button and the Jelly script executes immediately - no more waiting for a JVM to start.
Added Otto's groovy demo that shows how Jelly can be used as a templating system. To run it type maven demo:embed What would be interesting would be to write the demo in JellySwing rather than Java :-)
Applied Robert Leftwich's patch setting the proxy host and port before running the jellyunit test cases
Added a sample test case to demonstrate the new <test:run> behaviour.
added patch for the new commons-discovery test cases...
Patched to use Ant 1.5. Also removed the local copy of Ant's IntrospectionHelper that was added as a temporary hack. Added a patch for Ant tags which can be both a Task and a nested object. For example the <manifest> tag can be a ManifestTask if used by itself, of if it is embedded inside a <jar> Task then the Jar.addConfiguredManifest() is called instead. This fixes the manifest bug that was introduced by the move of Maven to Ant 1.5.
Patch so that Tag instances stay around after the run() method has been invoked. This allows tags to work properly when asynchronous excecution takes place or if dynamic scripts or tags are used, where they may invoke after their parent's run() method has been called. This should finally fix the last of the bugs introduced by making Script objects shareable across threads and Tag instances pooled per thread. Also for good measure, added a new demo:werkz target that demonstrates the werkz tag library in action.
minor patch to make the demo:tagdef demo a little cleaner; though this demo only works with a recent build of CVS HEAD of Maven, since its demonstrating the use of <tagdef> inside Maven, rather than spawning another JVM and using the local Jelly build.
Patched the Script implementation mechanism for 2 reasons (i) to try make a single Script instance cacheable and multi-threaded so that in server side deployments, the scripts can be cached and reused across multiple threads to boost performance and lower RAM usage (ii) to introduce the TagFactory so that a tag can be bound to a Tag instance at runtime, rather than just at parse time. This makes many things much simpler, particularly in the area of dynamic tags. For example the Jeez library unifies the define tag library with the ant tag library, both of which can create dynamic tags, at run time. Until this change was done, it was not possible to return a single efficient Tag implementation at parse time. So now at parse time a TagLibrary can create a TagFactory which at runtime decides which Tag instance to use. This chance helps the multi-threaded nature also, so that different threads can create their own tag implemention. Right now the current policy is for a Script object to be reusable across threads (which needs testing), then each thread will create & cache 1 Java object per tag on the page. Each Tag is cached in ThreadLocal storage. If a Script goes out of scope then all this should be GC'd. So we've a neat, simple, multi-threaded, pooled solution that should cause minimum object allocation yet allow flexible bean style coding and not require byte code generation (and all the classloading / GC issues that entails). Also for the Maven users, the <tagdef> is now working and can be used inside Maven now, which simplifies things greatly - no need to create a new tag library & new tag, just use <tagdef> and add a new tag dynamically to the maven (Jeez) tag library.
Pached the betwixt tags so that the <betwixt:parse> tag can either take a URI to the XML or can parse its body. Added a JellyUnit test case of both these ways of using the <betwixt:parse> tag.
Patched the <j:file> tag so that the XML declaration can now be omitted if required. Also the output can be pretty-printed if required. The XML encoding mode can be specified as can the output mode, so HTML output is now supported. Also added a log4j.properties so that tests can log again.
Added quartz (http://quartz.sf.net/) taglib. <job>, <trigger>, and <wait-for-scheduler> are now available in the jelly:quartz namespace.
add helper target demo:junitui to show the JUnit Swing TestRunner front end. We should try make this a standard target in Maven...
Added a simple Swing library for Jelly which means that Swing UIs can be scripted very easily via Jelly script. To get a taste for how this library works, try running the 'demo:swing' target in the Maven build by typing maven demo:swing and you should see a full Swing UI appear. It could be that this library could help form the basis of implementing XUL on the Swing platform?
patched the distribution goal to work with new projectId property
patched the SQL demos so that the demo:sql target now properly demonstrates the SQL tags in action, without the user needing to know anything or mess around with properties, or have a HSQLDB server running or anything. the demo:sql target now creates an in-memory HSQLDB database, creates a table, inserts some data, then demonstrates generating some XML from the result set.
patched the tag generation mechanism so that the HTML documentation in the javadoc appears nicely in the generated tag reference.
patched the XML and JSL tag library so that the <copy> tag works properly when creating declarative XSLT-like scripts in Jelly
Enhanced the JUnit tag library so that TestSuite and TestCase objects can be created in Jelly script so that unit testing becomes easy to do via Jelly scripts. This also means that Jelly can be integrated easily into existing test runners. See the src/test/org/apache/commons/jelly/junit/ directory for details of how this works; there you'll find a suite.jelly which is the test suite and a TestJUnit.java class which is a simple class to bind the suite.jelly into Ant's default JUnit test runner. This class should be usable in any JUnit test runner, since it provides a class with a static suite() method, yet internally it uses one or more Jelly scripts to actually create the individual TestCase objects. So the new JellyUnit capabilities can be seamlessly integrated with traditional Java test cases. So users can now use either Java or Jelly; intermixing the two to use the best tool for the job. So now Jelly could be used for XML, SOAP, SQL, HTTP & JMS testing and such like.
Patched the HTML parser so that the default behaviour is to preserve case of the HTML tags, using the first tag as the decider if the cases are different. Also created a demo to show how the NekoHTML parser can handle plain text too; so we could use this mechanism to parse text files containing Jelly script
Added a HTML Jelly library so that regular HTML documents can be parsed and then processed via Jelly, via XPath etc. This library uses Andy Clark's excellent NekoHTML SAX parser
Added a "dist:install" goal to install Jelly on the user's system.
This creates a ${maven.dist.install.dir} dir, and copies all the files
needed by Jelly to run (which are generated in "dist:build"'s preGoal.
Though, I can't generate the JELLY_HOME and the PATH, so I added a
big warning telling the user that he needs to set those variables.
Note : I defaulted the ${maven.dist.install.dir} to /usr/local/jelly,
which is a Linux path. I should add a system detection, so that
both worlds are happy :)
* Added support for <define:attribute> qualifiers in <define:jellybean> tag so that default values can be specified, or attributes can be marked as being required. * also <define:jellybean> now expects an invoke method to be specified, otherwise an exception is thrown * the new <define:bean> tag allows regular java beans to be created and bound to a variable, which is useful for entity based beans such as working with OJB or parsing config files etc. There are examples of the above, try running maven demo:bean maven demo:jellybean and it will make much more sense.
Now using patched version of dom4j so that we output namespace declarations on static content in a Jelly script. This should fix dIon's recent issue with SOAP namespaces.
Make the jelly script executable. Unfortunately, the distributions get created before this runs
Remove tabs
Formatting changes
Fixed the build so that the jelly scripts now appear to work - so Jelly can now be run from the command line like Ant and Maven - provided that the JELLY_HOME is set
Patched the dist:build target so that now all the dependent jars go into the lib directory and the binary scripts to the bin directory. For some reason the jelly.bat script doesn't quite work yet; it could be a minor issue with forehead. We're nearly there...
Improved the lexing on strings to allow for $${foo} literals to be
passed (double that dollar!), and for things like ${ a.b("}") }
to no longer trick jelly into finding the end of the expression
too early.
Mmmm... lexers.
Plus, modified slightly to support the maven-ng moving target.
If you define a <goal> in maven.xml, it must be within a <project> tag.
added use of the <jelly> task to generate the tag documentation
Added maven-ng mechanisms for generating tag library documentation
added an empty maven.xml which we'll fill in later with some callbacks etc
This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, enter a numeric revision.
| apache@apache.org | ViewVC Help |
| Powered by ViewVC 1.1.2 |