Parent Directory
| 
Revision Log
| Links to HEAD: | (view) (annotate) |
| Sticky Revision: |
getTagLibrary > getTagLib thus avoiding the conflict with tag-libs' tags which had their own getTagLibrary (returning their own tag-lib-class!). Added BaseJellyTest's addCustomTagLib which allows the remaining tests of John Spackman to be working (as reported on JELLY-286. Hopefully the first part of this fix solves the gump issues. paul
Further patch from JELLY-286. paul
JELLY-286 from John Spackman: should fix a few others but had to avoid some tests. paul
Moving to TLP
Moving back :)
Moving to TLP
Remove jakarta references from m1 and m2 builds
apply patch for JELLY-272 from ltheussl
Fixed copyright header (committing in parts as the full commit timed out)
Switching viewcvs url to viewvc
Use groupId/artifactId consistently instead of simply id
Version names 1.1-SNAPSHOT and 1.2-SNAPSHOT. paul
Opening commit for the next version... Will probably be called 1.1, or ? paul
fix invalid developer entry
include NOTICE.txt in the JAR
[maven-scm-plugin] prepare release 1.0
start to prepare a 1.0 pre-release
[maven-scm-plugin] prepare release 1.0-RC2
setup deployment properties
Fix site address
Remove duplicate package element
svn:keywords correction
fix IDs
set SVN URL for Jelly
Moved Hans Gilde to Developer rather than Contributor
Added Hans Gilde as contributor
update gump properties
fix gump generation
gump dependencies
Remove nagoya
Disabling TestCoreMemoryLeak currently... but I'd really like to make it a checked test... looks like Windows is the target OS where it needs to be fixed. paul
bump version
replace entities with inheritence for dependencies
And now my turn
Fix up entity stuffup via scm:prep
Put back entity that scm:prepare-release removed
Jelly-159 - Share BaseJellyTest class
Add jstl dependency
Open up the next release, be it beta-5 or what ever
Bump version and add tag
Add dev conn
Add checkstyle report
detab
upgrade to forehead 1.0-beta-5
Add coverage report
Upgrade to CL2
Add PMD report
Move off snapshots
The <component/> tag was not registered in SwingTagLibrary but was listed in the documentation as being a JellySwing tag. I had a need to use the tag and took the liberty of adding the registration of the tag in the SwingTagLibrary constructor. After verifying it worked properly, I'm committing the change and adding myself to the project developers list in project.xml. The convention for unit testing JellySwing tags was non-obvious to me, so I did not add a test at this time.
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
Changed a broken url and changed the link from apache to jakarta (to bring jelly in line with most other commons sites).
added missing build and report sections to subproject project.xml files, subprojects are responsible for generating the reports they want to have published and subproject define build parameters they require.
Changed connection so that it can be override by a property and so allow the change log to be correctly generated when using an ssh-agent.
Added myself to list of developers
ASL v2
Moving the issue tracking. Paul
Adding myself as a developer. Changing the organization logo to match the white background of the new site. Paul
Adding myself as developer.
[JELLY-64] Remove maven POM inheritance to simply project checkouts
fixed bug tracking URL
* Remove postgoals and use native maven features now. it has been long enough * Add explicit sourceDirectory and unitTestSourceDirectory
Add JUnit dependency
* Extend base commons POM * Resulting cleanup to remove what is duplicated in parent * Add self to developers * Update to released versions of some dependencies
added Pete to contributor list (though hey, Pete should probably be a committer by now :)
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...
updated the descriptor to point to commons proper and tidied up the dependencies some
Jelly is no longer sandbox :)
Remove beanshell from the dependencies
Remove bsf dependencies from core
Remove email deps from core
Remove jms from core
Remove jdbc and quartz dependencies
Remove sql taglib from tests Move soap tests to taglib
Added a breakdown of the packages used in Jelly to make it more clear what is the supported, public end user API, what packages are to be used by tag implementators and what packages are implementation details. This change is only used by CVS HEAD of Maven.
added back nekohtml which is required for the custom doclet. Though its not really a core Jelly dependency. We can probably implement a better mechanism for generating the tag documentation and to remove this dependency later.
removed some commented out dependencies
updated to most recent Maven version of Xerces and nekohtml
Change current version to reflect: a) It's a snapshot b) It's not yet 1.0-beta-4
Altered dependencies inline with extracted tags
Remove xmlunit from dependencies. At some point soon we should: 1) regen the gump descriptor 2) redeploy commons-jelly on ibiblio 3) Update Maven's dependencies to include the new tag jars
moved ojb tags to separate build
Remove antlr dependency
moved ant and jsl to separate taglibs, removed dependencies on ant, ant-optional, and grant, changed version name to SNAPSHOT
removed hsqldb - no longer necessary
moved jeez into a separate build, removed unused dependency on werkz
added the common dependency entity and removed dependencies for betwixt, http, and jetty, which now live in separate builds
o Moving Werkz jelly tags into in Werkz itself. During some Maven refactoring it became obvious that the Werkz tags don't belong in Jelly as testing took forever because everything is together. Definitely have some ideas for some busting up in Jelly land.
Added an initial implementation of JellySWT which is an XML language for creating rich user interfaces using SWT.
Applied patch supplied by Todd Jonker to improve the error reporting when a Tag library cannot be loaded and fixed a typeo in the exception message
Patch to use the latest Maven way of specifying resources. Also patched the URL of the jakarta logo
patch to use consistent version of Ant and Ant+optional
Patched to use Ant 1.5.1 for Peter Lynch's maven issues
Applied patch supplied by Kelvin Tan to provide a Servlet for evaluating Jelly scripts inside a servlet engine.
updated dependencies to jetty 4.2.3 to fix alexi's build problem
updated dependency to the latest JUnit release
* allow <new> to invoke constructors with arguments, as specified by <arg> tags * allow <new> and <useBean> as <arg>s, in addition to basic <arg> * extract BaseJellyTest and BaseClassLoaderTag classes * add tests for <new> and <arg> * NB: this makes jelly depend upon "nightly" versions of commons-beanutils dated 2002-11-27 or later, the maven repository needs to be updated to support this (about to send a note to commons-dev regarding that)
Applied Knut Wannheden's patch that allows XML documents to be compared for equality within a JellyUnit test case. Now JellyUnit has most bases covered for XML testing * XPath based assertions via <test:assert xpath="..."/> * schema validation via the jelly:validate library, testing XML against DTDs, XML Schema, RelaxNG etc * comparing 2 documents for equality * performing XSLT on some XML and then then performing any of the above
Patch to use the latest version of Jetty which should hopefully fix the GUMP build problems.
Update to the correct version of xml-apis as well as regenerated the Ant build
Fixes for the GUMP build. We now use the latest commons-collections library 2.1 to remove deprecation warnings Also moved to OJB 0.9.6 to avoid compile errors
Added a new helper tag, <util:available> which can be used to test for files or URIs being available and conditionally executing its body. so its like a simplified version of the <available> Ant task without requiring the use of a seperate property to define whether the file is available or not.
Added a JUnit test case to demonstrate the bug spotted by J. Matthew Pryor, then added a fix for the bug. The <x:attribute> when used inside an <x:element> was not working correctly. Now we've a JellyUnit test case to ensure this works correctly.
Added patch supplied by Theo Niemeijer that avoids the body of an Ant tag being invoked twice by accident. The getBodyText() invokes the tags body but was incorrectly being called twice. Many thanks Theo!
Patch so that the autogenerated Ant build will now run all the unit test cases! Also fixed a few typeos in the readme.
Added a ConsumerTag interface to allow JMS message consumers to be nested to implement different behaviours such as transactions, message adornment and transformation and simple stuff like timing. Also added a simple <stopwatch> tag which can be used to time the throughput of messages for a subscription
Committed patch supplied by Robert Leftwich which creates a Jetty tag library for creating HTTP servers for testing web requests using an embedded Jetty instance. It could be that there is some crossover with Latka http://jakarta.apache.org/commons/latka/index.html Anteater http://aft.sourceforge.net/ or Cactus http://jakarta.apache.org/cactus/ I'm not personally expert enough to know what should be done in this area. So I'm committing this and then the discussion between the various groups can start. It might be that one of the above projects could be a better home for the above code - lets see what the community at large thinks.
Added Tim as a contributor
add switch/case/default tags, and tests
Jelly uses the latest'n'greatest werkz now.
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.
Fixed issue tracking URL
Added Jason Horman's email tag library submission so that email can be sent from a Jelly script. Many thanks Jason! Also added Jason and Morgan to the development team page
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.
Applied Jim Birchfield's patches to support both a jelly.properties file when running Jelly from the command line as well as a new <properties> tag to load properties from a file or URI in Jelly script.
Applied Robert Leftwich's patches to support efficent SAX based XSLT pipelines via nested <x:transform> tags. Groovy stuff! This turns Jelly into a flexible, fast XSLT pipeline engine! Nice work Robert! There's still a couple of issue to work out but this is looking really neat
- Rearranged dependencies into alpha order on dep name - Added extra files to copy for postGoal on test:test
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 :-)
Added support for LayoutManagers to JellySwing. This is vital to providing form like JellySwing front ends.
This patch includes numerous patches kindly supplied by a new contributor, Paul Libbrecht. There is also support for a new Colour converter to more easily work with colors.
There are 2 primary layouts supported right now.
The first is a HTML style <tableLayout> <tr> <td> style approach which all HTML or XHTML developers will be accustomed to.
It allows you to create Swing forms like this...
<panel>
<tableFormat>
<tr>
<td colspan="2">
<label text="hello"/>
</td>
<td align="center" valign="bottom">
...
<textField text="whatever"/>
</td>
The second layouts are provided by Paul and implement full support for GridBagLayouts and their constraints with added support for inheritence of settings from parent/child constraints.
<gridBagLayout>
<gbc x="0" y="1" weightx="12">
<panel>
etc.
The demo that can be run via
maven demo:swing
Uses by default the tableLayout approach. Then if you click on the Demo menu you can run a sample using the <gridBagLayout> approach.
Applied Robert Leftwich's excellent patches to add full support for <x:transform> for executing XSLT on some XML.
The XML or the XSLT can come from the tags body just like the <x:transform> tag in JSTL.
Ultimately this tag can be used to implement sophisticated XSLT pipelining such as...
<x:transform xslt="a.xsl">
<x:transform xslt="b.xsl">
<foo>
<bar name="${some.expression}"/>
</foo>
</x:transform>
</x:transform>
which can then be used in association with servlet engines, SOAP services or just generating static content.
It'd be nice to optimize the implementation at some point so that it can work totally on SAX in the above example. But this is an awesome start.
Also do check out the groovy unit test cases such as the Schematron examples. It'd be nice to maybe generate a native Jelly implementaiton of Schematron...
Added Otto as a contributor
incremented the pre-release snapshot build number
Added the common-user list
Added Joe's email address and organization
Added Joe as a contributor after inventing Mock Tags...
removed unnecessary Velocity dependency
Added Theo as a contributor...
Applied Stephen Haberman's patch adding better Ant support, allowing Jelly to invoke Ant using commons-grant and cleanly integrating properties.
Added Vinay as a contributor
Added new TagLibraryResolver interface and an implementation using commons-discovery
Applied Stephen Haberman's patches to add a new <classLoader> tag for creating class loaders and using this mechanism to dynamically loading/creating tags.
Added Calvin and Stephen to list of contributors
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.
o bumping up the version and pushing another copy to the repository
set first version to be 1.0-beta-1
fixed typeo - meant Logo designer ;-)
patched Erik's role
added Martin and Erik to the contributors page
patched to use the new jelly logo.
used latest dom4j build which fixes the <x:if test=""> and <assert xpath=""/> use cases due to an old Jaxen bug with boolean evaluations of XPath expressions.
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.
patched the logo
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.
Added the initial cut of the Betwixt library. This allows Betwixt to be used to parse XML inside a Jelly script. Once the SAXWriter has been added to Betwixt we'll be able to use it for outputting XML as well. I'll be testing this code tomorrow but at least right now it compiles ;-)
Added quartz (http://quartz.sf.net/) taglib. <job>, <trigger>, and <wait-for-scheduler> are now available in the jelly:quartz namespace.
patched dependency list to work nicely with the new ID naming scheme for optional jars on projects
patched the XML and JSL tag library so that the <copy> tag works properly when creating declarative XSLT-like scripts in Jelly
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
Jar needs a jar extension AFAIK so correcting the one for ant-optional PR: Obtained from: Submitted by: Reviewed by:
Antlr taglib now -- <antlr> (<grammar>)+ </antlr> Util taglib with -- <tokenize delim="," var="foo">stuff, to, tokenize</tokenize>
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.
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...
Updated project.xml to newer repository style. Added a getReason() to get the original message without locators.
o More fixups in project.xml and adding generated gump descriptor.
o Updating deps to use <id> and not <name>.
o Remove the dev-5 thing, the snapshots work again in maven.
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.
added correct unit testing patterns for maven-ng
added javadoc jar so that doclets build in maven-ng
added XML APIs for maven-ng
patched to work with new maven-ng
Patched the <forEach> tag so that it works for simple numerical for loops. Also added the <file> tag which will generate a file of the given name with the contents of its body, which is good for generating multiple files from inside a Jelly script
added explicit <jar> elements to the dependencies to work around a temp bug in Maven
Sticking to either id or name, but not both
First cut of the http tag library using commons-httpclient to script HTTP operations inside Jelly.
Its not quite working yet but its close.
When this library is working properly we should be able to use this to perform HTTP based SOAP scripting and unit testing.
For example we should be able to do
<babelfish:translate from="en" to="fr">Hello there my friend</babelfish:translate>
and for the tag to do all the SOAP and HTTP malarkey inside the tag definition, which could be written in Jelly script itself.
Similarly we could build macros for testing web applications. Maybe iterating over test data in XML documents to test that web applications perform properly.
e.g.
<x:forEach select="$tests/testcase">
<x:set var="url" select="string(url)"/>
<test:httpGet url="${url}" expects="100"/>
etc.
Allowing for descriptions and default targets.
Added the first cut of the validate tag library. This tag library is used to perform XML validation using a variety of schema languages such as DTDs, XML Schema, RelaxNG, Relax or TREX. The tag library uses the JARV API which abstracts away the details of different validation libraries and schemas and uses the MSV library from Sun as the default runtime implementation. The RelaxNG demo works fine though DTDs are not currently working yet. More work is required to support neat filtering (indeed we need to be able to construct Jelly-SAX-Filters using XMLFilter from SAX).
Added the first cut of the JMS tag library for using Jelly to script the production and consumption of JMS messages.
Provided factory methods for XMLOutput which does not escape XML output. This is useful for using XMLOutput in cases when the output is textual rather than XML such as when using Jelly inside Maven or Ant, where there is no need to escape '<' or '>' in output logs.
Added back the OJB tags for scripting the loading of beans into OJB.
Added first cut of generation of tag library documentation using the XMLDoclet. Still some way to go to get nice output but at least this is a start.
Lots of tweaks to allow for better jelly+ant integration.
Working with ant's outputting. Jellywerkz now pretty much produces output not unlike ant's.
Added remote repo for fetching werkz jars.
Moved the beanshell and BSF tag libraries back into the main source tree, until Maven can handle sub-projects more gracefully. So now beanshell and BSF tag libraries are included in Jelly by default. We may make these libraries optional again in the future
removed unnecessary dependency on log4j which is no longer needed (now werkz isn't using it directly)
Added jakarta-ant as a <dependency> in order to decrease the amount of exceptions thrown by demo.werkz2.
Jelly now references latest werkz. Attempted (but pretty much failed) to fix the demo.werkz target. Added demo.werkz2 target and a demo.werkz2.callback target which is a post-compile-callback. This is exactly why maven-ng is needed.
Added first cut of the Werkz tag library which implements goal orientated processing, not unlike Ant's <target> tags except there's full support for callbacks in a nice way. This could provide a nice mechanism for implementing flexible pre/post callbacks and introduce new dependency mechanisms in a Maven build from inside a project. Its not quite working yet, the <target> never gets fired, though the pre-callbacks do.
supposed to add my name before committing to the project :)
Updated the build and project POM to the latest Maven CVS HEAD
Added an Ant tag library which can invoke Ant tasks from inside a Jelly script. Invoking Tasks is working fine, though support for Ant DataTypes isn't quite working yet (like nested <classpath> elements). Should have that working soon. Also added a new DynaBeanTagSupport class for developers wishing to use a DynaBean to hold tag attribute values.
added distribution directory
Build and unit tests all seem to work fine now. The LinkageError that was occurring on the unit tests has now gone away; the trick is not to put any JAXP / Xerces related dependencies in project.xml
Updated the build so that it now reuses the classpath created by the Maven build to allow compiled code to be run as part of the projects build.xml easily, without having to replicate the JAR dependencies that are inside the project.xml definition. So its easy to add a new build target that runs a new Jelly script; the 'compile' task defines a new <jelly> task using the current build and Maven's classpath.
Commented out XML based dependencies which cause a class loading problem when running the unit tests
Imported the old build targets from the old pre-Maven build so that the SQL scripts can now be run properly. For example ant demo.sql will run various example SQL scripts on a database (using Ant properties to connect) and generate some XML documents in the target directory.
Ported the old build system back into the Maven build so that common sample programs can be ran as Ant targets such as ant demo.hw for the hello world script or ant demo.ant for the Ant based demo.
Updated documentation a touch and started porting the old build system into the new Maven build.
Ported the build system to Maven. Also moved the non-core taglibs into src/taglibs where there will be seperate build files for each optional taglib.
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 |