TODO.txt

!!!!!! Obsolete file!! Don't add anything here, use Jira instead.

TODO: remove irrelevant entries, add others to Jira.

Things to Test
==============

* test synchronized statement

Core Groovy Tasks
=================

* new GroovyMethods	to be added
	- File.grep(pattern) -> List
	- File.grep(pattern) { closure } 
		allow iteration through a file for each line matching a regex pattern
		
	- List.first(), List.last(), pop()
	- Collection.removeIf { x | x > 0 }
	- Collection.count(foo) -> returns number of objects that equal foo

	- Map.get(key, defaultValue)
	- Map.setDefault(key, defaultValue) for things like
  		 map.setDefault(key, []).add(newValue)
	
	- Object.eachProperty
	- Object.eachPropertyName { object.getProperty(it) }
	- Object.setProperties(foo:'abc', x:123)
	
	- some kind of Regexp iterator of strings like Ruby's scan
	- maybe support Pythons' zip and reduce functions?
	
		maybe add the various readonly List APIs to Object[] and *[] types
		if we ever support the DTD / Xed style type*, type+ then we can do the same
		there too

* SQL builder

sql.table("users") {
ÊÊÊ column('user-id') { autoinc(), primaryKey(), references('foo'), initialValue(1234) }
ÊÊÊ column('nickname') { varchar(200) }
	column(name:'foo', type:'varchar(200)', references:['a', 'b'], initialValue:1234)
  }
}

* using mixin for adding using style behaviour to any object??

	mixin Using {
	
		static using(yield) {
			object = this.newInstance()
			try {
				yield(object)
				object.close()
			}
			catch (Exception e) {
				try {
					object.close()
				}
				catch (Exception e2)
					// ignore e2
					throw e
				}
			}
		}
		
		or
		
		using(yield) {
			try {
				yield(this)
				close()
			}
			catch (Exception e) {
				try {
					close()
				}
				catch (Exception e2)
					// ignore e2
					throw e
				}
			}
		}
	}
	
	then use it as 
	
		new FileInputStream().using { in |
			...
		}

* looks like a bug on generated methods, should use param name over any field name
	- also it looks like there's various unnecessary stuff (creation of tuples) when invoking
	methods
	
* test identity -> hashCode + equals methods

* support for property converters, based on type

* to support dynamic mixins we should use dynamic proxies to allow
	a groovy object to change metaclass at runtime

* groovy dynamic proxy of any Java object in Java-land?
	NullObject pattern
	
* immutable bean

* support static newInstance() method for constructors

* maybe split up ClassGenerator - do code gen & class gen separately

* mixin support...

	SomeClass.addMixin(Foo);
	
	MetaClass.addInterceptor( new Interceptor() {
		filter(method) {
			return method.isPublic();
		}
		invoke(method, args) {
			// do something
			method.invoke(args);
		}
	});

	* allow meta classes to be added dynamically using closure syntax?
	e.g. Map?
	

STUFF TO PONDER
===============

* Support multiple return values...

	String, Number cheese() {
		"hello", 7
	}
	
	a, b = cheese()
	
	also if we do this we should do assignment / swapping
	
		a, b = 1, 2
		a, b = b, a

* using macros to avoid dependencies on logging stuff (say)

	class GroovyLog {
		switch (System.getProperty('groovy.log.impl', 'useCommonsLogging')) {
			case 'useCommonsLogging': {
				// lets define the new instance method
				newInstance() {
					return new CommonsLoggingThingy()
				}
			}
			default {
				newInstance() {
					return new SimpleGroovyLog()
				}
			}
		}
	}
	
	doing things like this at compile time means no runtime dependencies. Ditto to do JDK based compiles
	
UI WORK
=======

* tree demo...

* when named method calls are supported with default values, refactor SwingBuilder
	so that all the creations of widgets occur with SwingFactory which would be 
	useful in and of itself
	- plus we should be using normal method call mechanism & for groovy to do the rest to avoid
	the long laborious Map coding
	
* FormModel.addPropertyModel(property)
	FormModel.addClosureModel(readClosure, writeClosure)

* ListModel is-a List but delegates to an underlying list and has events

* rename tableLayout -> table and table -> grid

* add sortableGrid

* create a GroovyUI
	-> interactive script + allows scripts to be run & objects explored


JUNIT WORK
==========

* patch GroovyTestCase so that methods which return Object are included in the test. This avoids us having to
specify void for method return types.This requires a clever static method when we generate the
	bytecode which can instantiate a special kind of TestSuite
	unless there's another way?


OPTIMISATIONS
=============
* method invocations - if foo instanceof GroovyObject
then generate bytecode

foo.invokeMethod(method, args);

* could code generate the MetaClass with very efficient dynamic dispatch
	e.g. could switch() on the method name & then use real method invocation
	on the method instance