Examples with Closure groovy.lang.Closure used on opensource projects

Example 36 with Closure

use of groovy.lang.Closure in project gradle by gradle.

the class ConfigureUtil method configureTarget.

private static <T> void configureTarget(Closure configureClosure, T target, ConfigureDelegate closureDelegate) {
    if (!(configureClosure instanceof GeneratedClosure)) {
        new ClosureBackedAction<T>(configureClosure, Closure.DELEGATE_FIRST, false).execute(target);
        return;
    }
    // Hackery to make closure execution faster, by short-circuiting the expensive property and method lookup on Closure
    Closure withNewOwner = configureClosure.rehydrate(target, closureDelegate, configureClosure.getThisObject());
    new ClosureBackedAction<T>(withNewOwner, Closure.OWNER_ONLY, false).execute(target);
}

Example 37 with Closure

use of groovy.lang.Closure in project spring-framework by spring-projects.

the class GroovyBeanDefinitionReader method invokeBeanDefiningMethod.

/**
	 * This method is called when a bean definition node is called.
	 * @param beanName the name of the bean to define
	 * @param args the arguments to the bean. The first argument is the class name, the last
	 * argument is sometimes a closure. All the arguments in between are constructor arguments.
	 * @return the bean definition wrapper
	 */
private GroovyBeanDefinitionWrapper invokeBeanDefiningMethod(String beanName, Object[] args) {
    boolean hasClosureArgument = (args[args.length - 1] instanceof Closure);
    if (args[0] instanceof Class) {
        Class<?> beanClass = (Class<?>) args[0];
        if (args.length >= 1) {
            if (hasClosureArgument) {
                if (args.length - 1 != 1) {
                    this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, beanClass, resolveConstructorArguments(args, 1, args.length - 1));
                } else {
                    this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, beanClass);
                }
            } else {
                this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, beanClass, resolveConstructorArguments(args, 1, args.length));
            }
        }
    } else if (args[0] instanceof RuntimeBeanReference) {
        this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
        this.currentBeanDefinition.getBeanDefinition().setFactoryBeanName(((RuntimeBeanReference) args[0]).getBeanName());
    } else if (args[0] instanceof Map) {
        // named constructor arguments
        if (args.length > 1 && args[1] instanceof Class) {
            List constructorArgs = resolveConstructorArguments(args, 2, hasClosureArgument ? args.length - 1 : args.length);
            this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, (Class) args[1], constructorArgs);
            Map namedArgs = (Map) args[0];
            for (Object o : namedArgs.keySet()) {
                String propName = (String) o;
                setProperty(propName, namedArgs.get(propName));
            }
        } else // factory method syntax
        {
            this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
            //First arg is the map containing factoryBean : factoryMethod
            Map.Entry factoryBeanEntry = (Map.Entry) ((Map) args[0]).entrySet().iterator().next();
            // If we have a closure body, that will be the last argument.
            // In between are the constructor args
            int constructorArgsTest = hasClosureArgument ? 2 : 1;
            // If we have more than this number of args, we have constructor args
            if (args.length > constructorArgsTest) {
                // factory-method requires args
                int endOfConstructArgs = (hasClosureArgument ? args.length - 1 : args.length);
                this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, null, resolveConstructorArguments(args, 1, endOfConstructArgs));
            } else {
                this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
            }
            this.currentBeanDefinition.getBeanDefinition().setFactoryBeanName(factoryBeanEntry.getKey().toString());
            this.currentBeanDefinition.getBeanDefinition().setFactoryMethodName(factoryBeanEntry.getValue().toString());
        }
    } else if (args[0] instanceof Closure) {
        this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
        this.currentBeanDefinition.getBeanDefinition().setAbstract(true);
    } else {
        List constructorArgs = resolveConstructorArguments(args, 0, hasClosureArgument ? args.length - 1 : args.length);
        currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, null, constructorArgs);
    }
    if (hasClosureArgument) {
        Closure callable = (Closure) args[args.length - 1];
        callable.setDelegate(this);
        callable.setResolveStrategy(Closure.DELEGATE_FIRST);
        callable.call(new Object[] { currentBeanDefinition });
    }
    GroovyBeanDefinitionWrapper beanDefinition = currentBeanDefinition;
    this.currentBeanDefinition = null;
    beanDefinition.getBeanDefinition().setAttribute(GroovyBeanDefinitionWrapper.class.getName(), beanDefinition);
    getRegistry().registerBeanDefinition(beanName, beanDefinition.getBeanDefinition());
    return beanDefinition;
}

Example 38 with Closure

use of groovy.lang.Closure in project spring-framework by spring-projects.

the class GroovyBeanDefinitionReader method loadBeanDefinitions.

/**
	 * Load bean definitions from the specified Groovy script or XML file.
	 * <p>Note that {@code ".xml"} files will be parsed as XML content; all other kinds
	 * of resources will be parsed as Groovy scripts.
	 * @param encodedResource the resource descriptor for the Groovy script or XML file,
	 * allowing specification of an encoding to use for parsing the file
	 * @return the number of bean definitions found
	 * @throws BeanDefinitionStoreException in case of loading or parsing errors
	 */
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    // Check for XML files and redirect them to the "standard" XmlBeanDefinitionReader
    String filename = encodedResource.getResource().getFilename();
    if (StringUtils.endsWithIgnoreCase(filename, ".xml")) {
        return this.standardXmlBeanDefinitionReader.loadBeanDefinitions(encodedResource);
    }
    Closure beans = new Closure(this) {

        public Object call(Object[] args) {
            invokeBeanDefiningClosure((Closure) args[0]);
            return null;
        }
    };
    Binding binding = new Binding() {

        @Override
        public void setVariable(String name, Object value) {
            if (currentBeanDefinition != null) {
                applyPropertyToBeanDefinition(name, value);
            } else {
                super.setVariable(name, value);
            }
        }
    };
    binding.setVariable("beans", beans);
    int countBefore = getRegistry().getBeanDefinitionCount();
    try {
        GroovyShell shell = new GroovyShell(getResourceLoader().getClassLoader(), binding);
        shell.evaluate(encodedResource.getReader(), "beans");
    } catch (Throwable ex) {
        throw new BeanDefinitionParsingException(new Problem("Error evaluating Groovy script: " + ex.getMessage(), new Location(encodedResource.getResource()), null, ex));
    }
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

Example 39 with Closure

use of groovy.lang.Closure in project spring-framework by spring-projects.

the class GroovyBeanDefinitionReader method bean.

/**
	 * Define an inner bean definition.
	 * @param type the bean type
	 * @param args the constructors arguments and closure configurer
	 * @return the bean definition
	 */
public AbstractBeanDefinition bean(Class<?> type, Object... args) {
    GroovyBeanDefinitionWrapper current = this.currentBeanDefinition;
    try {
        Closure callable = null;
        Collection constructorArgs = null;
        if (!ObjectUtils.isEmpty(args)) {
            int index = args.length;
            Object lastArg = args[index - 1];
            if (lastArg instanceof Closure) {
                callable = (Closure) lastArg;
                index--;
            }
            if (index > -1) {
                constructorArgs = resolveConstructorArguments(args, 0, index);
            }
        }
        this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(null, type, constructorArgs);
        if (callable != null) {
            callable.call(this.currentBeanDefinition);
        }
        return this.currentBeanDefinition.getBeanDefinition();
    } finally {
        this.currentBeanDefinition = current;
    }
}

Example 40 with Closure

use of groovy.lang.Closure in project spring-framework by spring-projects.

the class GroovyBeanDefinitionReader method invokeMethod.

// INTERNAL HANDLING OF GROOVY CLOSURES AND PROPERTIES
/**
	 * This method overrides method invocation to create beans for each method name that
	 * takes a class argument.
	 */
public Object invokeMethod(String name, Object arg) {
    Object[] args = (Object[]) arg;
    if ("beans".equals(name) && args.length == 1 && args[0] instanceof Closure) {
        return beans((Closure) args[0]);
    } else if ("ref".equals(name)) {
        String refName;
        if (args[0] == null)
            throw new IllegalArgumentException("Argument to ref() is not a valid bean or was not found");
        if (args[0] instanceof RuntimeBeanReference) {
            refName = ((RuntimeBeanReference) args[0]).getBeanName();
        } else {
            refName = args[0].toString();
        }
        boolean parentRef = false;
        if (args.length > 1) {
            if (args[1] instanceof Boolean) {
                parentRef = (Boolean) args[1];
            }
        }
        return new RuntimeBeanReference(refName, parentRef);
    } else if (this.namespaces.containsKey(name) && args.length > 0 && args[0] instanceof Closure) {
        GroovyDynamicElementReader reader = createDynamicElementReader(name);
        reader.invokeMethod("doCall", args);
    } else if (args.length > 0 && args[0] instanceof Closure) {
        // abstract bean definition
        return invokeBeanDefiningMethod(name, args);
    } else if (args.length > 0 && (args[0] instanceof Class || args[0] instanceof RuntimeBeanReference || args[0] instanceof Map)) {
        return invokeBeanDefiningMethod(name, args);
    } else if (args.length > 1 && args[args.length - 1] instanceof Closure) {
        return invokeBeanDefiningMethod(name, args);
    }
    MetaClass mc = DefaultGroovyMethods.getMetaClass(getRegistry());
    if (!mc.respondsTo(getRegistry(), name, args).isEmpty()) {
        return mc.invokeMethod(getRegistry(), name, args);
    }
    return this;
}