class DynamicGroovyBean {
    
    private holder = null;
    
    Map called = [:]
    
    def propertyMissing(String name) {
        if (name == "foo") {
            return holder;
        } else {
            throw new MissingPropertyException(name, getClass())
        }
    }

    def propertyMissing(String name, value) {
        if (name == "foo") {
            holder = value;
        } else {

 */

package org.gradle.internal.metaobject

class BeanWithDynamicProperties {
    String prop

    Object propertyMissing(String name) {
        if (name == "dyno") {
            return "ok"
        }
        throw new MissingPropertyException(name, BeanWithDynamicProperties)
    }

    void propertyMissing(String name, Object value) {
        if (name == "dyno") {
            return
        }

 *
 * <li>Groovy Meta-programming methods implemented by the object's class, like <code>propertyMissing()</code>. Care must be taken by plugin authors to
 * ensure <code>propertyMissing()</code> is implemented such that if a property is not found a MissingPropertyException(String, Class) exception is thrown.
 * If <code>propertyMissing()</code> always returns a value for any property, Gradle will not search the rest of the scopes below.</li>

            @Override
            Map<String, ?> getProperties() {
                return [dyno: "ok"]
            }
        }
    }

    Object propertyMissing(String name) {
        throw new AssertionError("should not be called")
    }

    void propertyMissing(String name, Object value) {
        throw new AssertionError("should not be called")
    }

    Object getProperty(String property) {
        null
    }

    @Override
    Object invokeMethod(String name, Object args) {
        null
    }

    def propertyMissing(String name) {
        null
    }

    def propertyMissing(String name, def value) {
    }

    def methodMissing(String name, def args) {
    }

        connector.searchUpwards(searchUpwards)
        this
    }

    def methodMissing(String name, args) {
        connector."$name"(*args)
    }

    def propertyMissing(String name, value) {
        connector."$name" = value
    }

    def propertyMissing(String name) {
        connector."$name"
    }

    def forProjectDirectory(File projectDir) {
        connector.forProjectDirectory(projectDir)
        connector

    }

    def methodMissing(String name, args) {
        assertProject()
        project."$name"(*args)
    }

    def propertyMissing(String name) {
        project."$name"
    }

    def propertyMissing(String name, value) {
        project."$name" = value
    }

    def applyPlugin() {
        apply plugin: "signing"
    }

    def addProperties(Map props) {

     *
     * @param self the {@link MapProperty}
     * @param key the key
     * @return a {@link Provider} for the value
     */
    public static <V> Provider<V> propertyMissing(MapProperty<String, V> self, String key) {
        return self.getting(key);
    }

    /**
     * Adds a map entry to the property value.
     *

                def methodMissing(String name, args) {
                    methods[name] = args.toList()
                }

                def propertyMissing(String name) {
                    props[name]
                }

                def propertyMissing(String name, value) {
                    props[name] = value
                }
            }

            convention.plugins.test = new DynamicThing()

    }

    @Override
    public Map<String, Object> getAsMap() {
        return extensionsStorage.getAsMap();
    }

    public Object propertyMissing(String name) {
        return getByName(name);
    }

    public void propertyMissing(String name, Object value) {
        checkExtensionIsNotReassigned(name);
        add(name, value);
    }