Delegate property is ignored by closure

I forgot to mention that if I don't touch the metaclass of the Script class, everything works fine.

There is a small bug in the unit test. Unfortunately I can't edit the issue.

The line: File file = new File($expectedFileResult)
should be: File file = new File('$expectedFileResult')

Now the testDelegateFileMethodAccess succeeds and we have a simple rule. Method access works, property access not.

For me this is a very serious bug. Actually I wanted to release my build tool this week, but I have to wait until this is fixed. To use ant from my build scripts I have to specify the delegate to make things work:

ant.copy(toDir: distSamplesDir)

Constructs like this don't work at all:

ant.copy(toDir: distSrcDir) {
[srcDirs + resourceDirs + groovySrcDirs].each

}

Any idea when someone has time to look into this?

I cut down the number of errors from 9 of 10 tests to 2 of 10 tests by:

1) Not using .metaClass and .class (using the setter/getter instead) on classes where I'm not totally sure your might not be dealing with a map.

2) Compiling the script so that the Circle class can be found by Class.forName (putting Circle.groovy in a separate file also works). There is already a JIRA for this problem, but I forget the number. But currently a script cannot find classes that are defined in it by Class.forName.

The remaining 2 failing tests try to access a 'path' property on g.l.Script which doesn't exist. (in 1.5.5 anyhow)

There was also a discussion on the mailing list about this.

http://www.nabble.com/Delegate-property-is-ignored-by-closure-to15733032.html#a15733032

Would the script mentioned there run for you (Here I have replaced .metaclass with the setter):

def scriptText = '''
AntBuilder ant = new AntBuilder()
Closure cl = {
    // access property of AntBuilder from closure
    antProject
}
cl.delegate = ant
cl.call()
'''

GroovyShell groovyShell = new GroovyShell()
Script script = groovyShell.parse(scriptText)
replaceMetaclass(script)
script.run()


def replaceMetaclass(Script script) {
    ExpandoMetaClass emc = new ExpandoMetaClass(script.class, false)
    emc.methodMissing = {String name, args ->
        throw new MissingMethodException(name, Script, args)
    }
    emc.propertyMissing = {String name ->
        throw new MissingPropertyException(name, Script)
    }
    emc.initialize()
    script.setMetaClass(emc)
}

Hi Jim,

with all the changes you have mentioned I still have 5 failing tests (with the latest build from trunk).

I'm wondering why this is the case.

Could you attach your more successful testcase to this issue?

made the edit to the script

I attached the script I used for testing.
It doesn't have the issue with using groovyc.
It shows 5 errors for 1.5.5-SNAPSHOT and HEAD for me.

If I comment out the three lines overriding propertyMissing (file attached), then it works fine on 1.5.5-SNAPSHOT and HEAD. That would seem to indicate that propertyMissing is being triggered prior to looking for get/set methods.

is there a way to reduce this test case to something that does not use AntBuilder? That would give us a more solid base to find the problem

I have attached a shortened version of the testcases which includes only the test methods that do not use AntBuilder.

looks like in Closure:202 a MissingPropertyException should have been thrown, but the Exception really is an InvocationTargetException with the correct MissingPropertyException nested. I think this problem is related to GROOVY-2666

But GROOVY-2643 happens also for 1.5.4. GROOVY-2666 is only for > 1.5.4

I see... but still, the exception I debugged was incorrect, so it is related to 2666 in 1.6 and fixing that bug is needed to make fixing this bug possible in 1.6

I used your short test with the small change where GroovyShell is used "GroovyShell groovyShell = new GroovyShell(this.class.classLoader)". After this change 3 of the 6 tests do fail and that is the same for 1.5.4 and 1.6 in all these cases Groovy claims that propX does not exist for the script. I very much think this happens, because the real MissingPropertyException is wrapped in a InvokerInvocatationException. But this is nothing new, Groovy 1.0 behaved that way already. So I do guess that construction above never worked before.

But it should, shouldn't it?

Before EMC was introduces this problem was probably more hidden. What I do is nothing exotic. Things you need to do for many DSL scenarios.

without EMC this problem does happen, because it is special to closures... even if missing method is used from the current class this will not happen. But a fix is to be expected in a matter of hours.

ok, both 1.5.x and 1.6 now have fixes for this issue. It would be nice of you to test this to be sure it fixes your original issue

The tests run now, but in my real code I still have a problem. I've used the GROOVY_1_5_X branch from this morning. I could not build HEAD, as I got test failures.

Here is a script to reproduce my problem. It gives the following error:

[echo] closureCall
testprop
testMeth
     [echo] directCall
Caught: groovy.lang.MissingMethodException: No signature of method: Parent.echo() is applicable for argument types: (java.util.LinkedHashMap) values: {["message":"closureCall"]}
groovy.lang.MissingMethodException: No signature of method: Parent.echo() is applicable for argument types: (java.util.LinkedHashMap) values: {["message":"closureCall"]}

What is also confusing! When I uncomment: cl.resolveStrategy(Closure.DELEGATE_ONLY), I get the exception:

Caught: groovy.lang.MissingMethodException: No signature of method: MyScript.resolveStrategy() is applicable for argument types: (java.lang.Integer) values: {3}
groovy.lang.MissingMethodException: No signature of method: MyScript.resolveStrategy() is applicable for argument types: (java.lang.Integer) values: {3}

class BuildScriptProcessor {
    void evaluate(def parent, String text) {
        GroovyShell groovyShell = new GroovyShell()
        Script script = groovyShell.parse(text)
        replaceMetaclass(script, parent)
        script.run()
    }

    private void replaceMetaclass(Script script, def parent) {
        ExpandoMetaClass projectScriptExpandoMetaclass = new ExpandoMetaClass(script.class, false)
        projectScriptExpandoMetaclass.methodMissing = {String name, args ->
            parent.invokeMethod(name, args)
        }
        projectScriptExpandoMetaclass.propertyMissing = {String name ->
            if (name == 'out') {
                return System.out
            }
            parent."$name"
        }
        projectScriptExpandoMetaclass.initialize()
        script.metaClass = projectScriptExpandoMetaclass
    }
}

class Parent {
    AntBuilder ant = new AntBuilder()
    String testProp = 'testprop'

    String testMeth() {
        'testMeth'
    }

    void ant(Closure cl) {
//        cl.resolveStrategy(Closure.DELEGATE_ONLY)
        cl.delegate = ant
        cl.call()
    }
}

Parent parent = new Parent()

parent.ant {
   echo(message: 'closureCall')  
}

String script = """
println testProp
println testMeth()
ant.echo(message: 'directCall')
ant {
    echo(message: 'closureCall') 
}
"""

new BuildScriptProcessor().evaluate(parent, script)