import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public CustomModelBuilder(Model model) {
    ExecuteManager executeManager = new ExecuteManagerImpl();
    setProp(executeManager.getClass(), executeManager, "log",
            new PlexusLoggerAdapter(LoggerFactory.getLogger(ExecuteManagerImpl.class)));
    setProp(ModelBuilder.class, this, "executeManager", executeManager);
    setProp(ModelBuilder.class, this, "log",
            new PlexusLoggerAdapter(LoggerFactory.getLogger(ModelBuilder.class)));
    try {
        initialize();
    } catch (InitializationException e) {
        throw new RuntimeException(e);
    }
    Map factories = (Map) getProp(FactoryBuilderSupport.class, this, "factories");
    factories.remove("project");
    ModelFactory modelFactory = new ModelFactory(model);
    registerFactory(modelFactory.getName(), null, modelFactory);
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public Object postCompleteNode(final FactoryBuilderSupport factory, final Object parent, final Object node) {
    if (node instanceof Map) {
        Map map = (Map) node;
        ProxyGeneratorAdapter adapter = new ProxyGeneratorAdapter(
                map,
                map.containsKey("superClass")?(Class)map.get("superClass"):CompilationCustomizer.class,
                map.containsKey("interfaces")?(Class[])map.get("interfaces"):null,
                this.getClass().getClassLoader(),
                false,
                null
        );
        Object phase = map.get("phase");
        if (!(phase instanceof CompilePhase)) {
            phase = CompilePhase.valueOf(phase.toString());
        }
        return adapter.proxy(map, phase);
    }
    return node;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public Object postCompleteNode(final FactoryBuilderSupport factory, final Object parent, final Object node) {
    SourceOptions data = (SourceOptions) node;
    SourceAwareCustomizer sourceAwareCustomizer = new SourceAwareCustomizer(data.delegate);
    if (data.extensionValidator !=null && (data.extension!=null || data.extensions!=null)) {
        throw new RuntimeException("You must choose between an extension name validator or an explicit extension name");
    }
    if (data.basenameValidator!=null && (data.basename!=null || data.basenames!=null)) {
        throw new RuntimeException("You must choose between an base name validator or an explicit base name");
    }

    addExtensionValidator(sourceAwareCustomizer, data);
    addBasenameValidator(sourceAwareCustomizer, data);
    if (data.unitValidator!=null) sourceAwareCustomizer.setSourceUnitValidator(data.unitValidator);
    if (data.classValidator!=null) sourceAwareCustomizer.setClassValidator(data.classValidator);
    return sourceAwareCustomizer;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public Object newInstance(FactoryBuilderSupport builder, Object name, Object value, Map attributes) throws InstantiationException, IllegalAccessException {
    Object icon = attributes.remove("icon");
    if (icon == null) {
        icon = value;
    }

    if (icon == null) {
        throw new IllegalArgumentException("In " + name + " you must define a node value or icon:");
    }

    int size = 16;
    if (attributes.containsKey("size")) {
        size = (int) attributes.remove("size");
    }

    if (icon instanceof CharSequence) {
        return new FatcowIcon(Fatcow.findByDescription(icon.toString()), size);
    } else if (icon instanceof Fatcow) {
        return new FatcowIcon((Fatcow) icon, size);
    }

    throw new IllegalArgumentException(name + " cannot parse " + icon + " as a FatcowIcon description.");
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public Object newInstance(FactoryBuilderSupport builder, Object name, Object value, Map attributes) throws InstantiationException, IllegalAccessException {
    Object iconName = attributes.remove("icon");
    if (iconName == null) {
        iconName = value;
    }

    if (iconName == null) {
        throw new IllegalArgumentException("In " + name + " you must define a node value or icon:");
    }
    if (iconName instanceof CharSequence) {
        return new FontAwesomeIcon(iconName.toString());
    } else if (iconName instanceof FontAwesome) {
        return new FontAwesomeIcon((FontAwesome) iconName);
    }

    throw new IllegalArgumentException(name + " cannot parse " + iconName + " as a fontawesome icon description.");
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public ConsoleGriffonAddon() {
    super(ApplicationHolder.getApplication());
    factories.put("bean", new BeanFactory(Object.class, true));
    factories.put("list", new CollectionFactory());

    attributeDelegates.add(new RunnableWithArgsClosure(new RunnableWithArgs() {
        public void run(Object[] args) {
            FactoryBuilderSupport builder = (FactoryBuilderSupport) args[0];
            Object node = args[1];
            Map attributes = (Map) args[2];
            if (attributes.containsKey("id")) {
                String id = attributes.remove("id").toString();
                builder.setVariable(id, node);
            }
        }
    }));
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Nonnull
@Override
@SuppressWarnings("unchecked")
protected Map<String, Object> instantiateMembers(@Nonnull Map<String, ClassHolder> classMap, @Nonnull Map<String, Object> args) {
    Map<String, Object> map = super.instantiateMembers(classMap, args);
    FactoryBuilderSupport builder = createBuilder(getApplication());
    map.put(BUILDER, builder);

    for (Object member : map.values()) {
        // all scripts get the builder as their binding
        if (member instanceof Script) {
            builder.getVariables().putAll(((Script) member).getBinding().getVariables());
            ((Script) member).setBinding(builder);
        }
    }

    return map;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public Object newInstance(final FactoryBuilderSupport builder, final Object name, final Object value, final Map attributes) throws InstantiationException, IllegalAccessException {
    if (attributes.isEmpty() || !attributes.containsKey("phase")) {
        throw new RuntimeException("You must specify a CompilePhase to run at, using the [phase] attribute");
    }
    Map result = new HashMap(1+attributes.size());
    result.putAll(attributes);
    return result;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public boolean onNodeChildren(final FactoryBuilderSupport builder, final Object node, final Closure childContent) {
    if (node instanceof Map) {
        ((Map)node).put("call", childContent.clone());
    }
    return false;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void setChild(final FactoryBuilderSupport builder, final Object parent, final Object child) {
    if (parent instanceof Collection && child instanceof CompilationCustomizer) {
        ((Collection) parent).add(child);
    }
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Object postCompleteNode(final FactoryBuilderSupport factory, final Object parent, final Object node) {
    if (node instanceof List) {
        List col = (List) node;
        return col.toArray(new CompilationCustomizer[col.size()]);
    }
    return node;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public boolean onNodeChildren(final FactoryBuilderSupport builder, final Object node, final Closure childContent) {
    if (node instanceof SecureASTCustomizer) {
        Closure clone = (Closure) childContent.clone();
        clone.setDelegate(node);
        clone.setResolveStrategy(Closure.DELEGATE_FIRST);
        clone.call();
    }
    return false;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public boolean onNodeChildren(final FactoryBuilderSupport builder, final Object node, final Closure childContent) {
    if (node instanceof ImportCustomizer) {
        Closure clone = (Closure) childContent.clone();
        clone.setDelegate(new ImportHelper((ImportCustomizer) node));
        clone.call();
    }
    return false;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public Object newInstance(final FactoryBuilderSupport builder, final Object name, final Object value, final Map attributes) throws InstantiationException, IllegalAccessException {
    SourceOptions data = new SourceOptions();
    if (value instanceof CompilationCustomizer) {
        data.delegate = (CompilationCustomizer) value;
    }
    return data;
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public void setChild(FactoryBuilderSupport builder, Object parent, Object child) {
    if (child instanceof Authentication) {
        getRepository(parent).addAuthentication((Authentication) child);
    } else if (child instanceof Proxy) {
        getRepository(parent).addProxy((Proxy) child);
    } else if (child instanceof RepositoryPolicy) {
        if (builder.getCurrentName().equals("snapshots")) {
            getRepository(parent).addSnapshots((RepositoryPolicy) child);
        } else {
            getRepository(parent).addReleases((RepositoryPolicy) child);
        }
    }
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
public void registerBeanFactory(FactoryBuilderSupport builder, String name, String groupName, Class<?> beanClass) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Registering " + name + " with " + beanClass + " using default factory");
    }
    builder.registerBeanFactory(name, groupName, beanClass);
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
@SuppressWarnings("ConstantConditions")
protected void adjustMvcArguments(@Nonnull MVCGroup group, @Nonnull Map<String, Object> args) {
    super.adjustMvcArguments(group, args);
    FactoryBuilderSupport builder = (FactoryBuilderSupport) group.getMember(BUILDER);
    args.put(BUILDER, builder);
    for (Map.Entry<String, Object> variable : args.entrySet()) {
        builder.setVariable(variable.getKey(), variable.getValue());
    }
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
@Override
protected void destroyMembers(@Nonnull MVCGroup group, boolean fireDestructionEvents) {
    super.destroyMembers(group, fireDestructionEvents);

    try {
        FactoryBuilderSupport builder = (FactoryBuilderSupport) group.getMember(BUILDER);
        if (builder != null) {
            builder.dispose();
            builder.getVariables().clear();
        }
    } catch (Exception e) {
        // TODO find out why this call breaks applet mode on shutdown
        LOG.error("Application encountered an error while destroying group '" + group.getMvcId() + "'", sanitize(e));
    }
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public void onInitializeMVCGroup(@Nonnull MVCGroupConfiguration configuration, @Nonnull MVCGroup group) {
    GriffonController controller = group.getController();
    if (controller == null) return;
    FactoryBuilderSupport builder = (FactoryBuilderSupport) group.getMember("builder");
    if (builder == null) return;
    Map<String, Action> actions = application.getActionManager().actionsFor(controller);
    for (Map.Entry<String, Action> action : actions.entrySet()) {
        String actionKey = application.getActionManager().normalizeName(action.getKey()) + ActionManager.ACTION;
        getLog().trace("Adding action {} to {}:{}:builder", actionKey, configuration.getMvcType(), group.getMvcId());
        builder.setVariable(actionKey, action.getValue().getToolkitAction());
    }
}
 

import groovy.util.FactoryBuilderSupport; //导入依赖的package包/类
public void make(@Nonnull FactoryBuilderSupport builder) {
    requireNonNull(builder, "Cannot make binding with a null builder!");
    requireNonNull(source, "Unspecified value for: source");
    requireNonNull(target, "Unspecified value for: target");

    Map<String, Object> attributes = new LinkedHashMap<>();

    if (isBlank(sourceProperty)) sourceProperty = targetProperty;
    if (isBlank(sourceProperty)) {
        throw new IllegalArgumentException("Unspecified values for: sourceProperty, targetProperty");
    }
    if (isBlank(targetProperty)) targetProperty = sourceProperty;

    attributes.put("source", source);
    attributes.put("target", target);
    attributes.put("sourceProperty", sourceProperty);
    attributes.put("targetProperty", targetProperty);
    attributes.put("mutual", mutual);

    if (converter != null) {
        attributes.put("converter", makeClosure(builder, converter));
    }
    if (validator != null) {
        attributes.put("validator", makeClosure(builder, validator));
    }

    builder.invokeMethod("bind", attributes);
}