/**
   * Switches the builder's proxyBuilder during the execution of a closure.<br>
   * This is useful to temporary change the building context to another builder without the need for
   * a contrived setup. It will also take care of restoring the previous proxyBuilder when the
   * execution finishes, even if an exception was thrown from inside the closure.
   *
   * @param builder the temporary builder to switch to as proxyBuilder.
   * @param closure the closure to be executed under the temporary builder.
   * @return the execution result of the closure.
   * @throws RuntimeException - any exception the closure might have thrown during execution.
   */
  public Object withBuilder(FactoryBuilderSupport builder, Closure closure) {
    if (builder == null || closure == null) {
      return null;
    }

    Object result = null;
    Object previousContext = getProxyBuilder().getContext();
    FactoryBuilderSupport previousProxyBuilder = localProxyBuilder.get();
    try {
      localProxyBuilder.set(builder);
      closure.setDelegate(builder);
      result = closure.call();
    } catch (RuntimeException e) {
      // remove contexts created after we started
      localProxyBuilder.set(previousProxyBuilder);
      if (getProxyBuilder().getContexts().contains(previousContext)) {
        Map<String, Object> context = getProxyBuilder().getContext();
        while (context != null && context != previousContext) {
          getProxyBuilder().popContext();
          context = getProxyBuilder().getContext();
        }
      }
      throw e;
    } finally {
      localProxyBuilder.set(previousProxyBuilder);
    }

    return result;
  }
Exemple #2
0
 /**
  * The field tag is a helper, based on the spirit of Don't Repeat Yourself.
  *
  * @param args tag attributes
  * @param body tag inner body
  * @param out the output writer
  * @param template enclosing template
  * @param fromLine template line number where the tag is defined
  */
 public static void _field(
     Map<?, ?> args, Closure body, PrintWriter out, ExecutableTemplate template, int fromLine) {
   Map<String, Object> field = new HashMap<String, Object>();
   String _arg = args.get("arg").toString();
   field.put("name", _arg);
   field.put("id", _arg.replace('.', '_'));
   field.put("flash", Flash.current().get(_arg));
   field.put(
       "flashArray",
       field.get("flash") != null && !StringUtils.isEmpty(field.get("flash").toString())
           ? field.get("flash").toString().split(",")
           : new String[0]);
   field.put("error", Validation.error(_arg));
   field.put("errorClass", field.get("error") != null ? "hasError" : "");
   String[] pieces = _arg.split("\\.");
   Object obj = body.getProperty(pieces[0]);
   if (obj != null) {
     if (pieces.length > 1) {
       try {
         String path = _arg.substring(_arg.indexOf(".") + 1);
         Object value = PropertyUtils.getProperty(obj, path);
         field.put("value", value);
       } catch (Exception e) {
         // if there is a problem reading the field we dont set any value
       }
     } else {
       field.put("value", obj);
     }
   }
   body.setProperty("field", field);
   body.call();
 }
  protected void applyPropertyToBeanDefinition(String name, Object value) {
    if (value instanceof GString) {
      value = value.toString();
    }
    if (addDeferredProperty(name, value)) {
      return;
    } else if (value instanceof Closure) {
      GroovyBeanDefinitionWrapper current = this.currentBeanDefinition;
      try {
        Closure callable = (Closure) value;
        Class<?> parameterType = callable.getParameterTypes()[0];
        if (Object.class == parameterType) {
          this.currentBeanDefinition = new GroovyBeanDefinitionWrapper("");
          callable.call(this.currentBeanDefinition);
        } else {
          this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(null, parameterType);
          callable.call((Object) null);
        }

        value = this.currentBeanDefinition.getBeanDefinition();
      } finally {
        this.currentBeanDefinition = current;
      }
    }
    this.currentBeanDefinition.addProperty(name, value);
  }
Exemple #4
0
 @Override
 public V call(Object... args) {
   Object temp = first.call(args);
   if (temp instanceof List && second.getParameterTypes().length > 1)
     temp = ((List) temp).toArray();
   return temp instanceof Object[] ? second.call((Object[]) temp) : second.call(temp);
 }
Exemple #5
0
 /**
  * Sends a message and execute continuation when reply became available.
  *
  * @param message message to send
  * @param closure closure to execute when reply became available
  * @return The message that came in reply to the original send.
  */
 @SuppressWarnings({"AssignmentToMethodParameter"})
 public final <T> MessageStream sendAndContinue(final T message, Closure closure) {
   closure = (Closure) closure.clone();
   closure.setDelegate(this);
   closure.setResolveStrategy(Closure.DELEGATE_FIRST);
   return send(message, new DataCallback(closure, parallelGroup));
 }
  public static QueryBuilder prepare(
      SearchService service,
      final @DelegatesTo(value = QueryBuilder.class, strategy = Closure.DELEGATE_FIRST) Closure<?>
              c) {
    final QueryBuilder builder =
        new QueryBuilder(
            c.getThisObject() instanceof Script
                ? ((Script) c.getThisObject()).getBinding()
                : new Binding());

    GroovyCategorySupport.use(
        SearchQueryStringCategory.class,
        new Closure<Object>(builder) {
          public Object call(Object... args) {
            return DefaultGroovyMethods.with(builder, c);
          };
        });

    if (builder.getIndexName() == null) {
      throw new IllegalStateException("Index name cannot be null");
    }
    ;
    if (builder.getQueryString() == null) {
      throw new IllegalStateException("Query String name cannot be null");
    }
    ;

    return builder;
  }
  /**
   * 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;
    }
  }
Exemple #8
0
 public static void _set(
     Map<?, ?> args, Closure body, PrintWriter out, ExecutableTemplate template, int fromLine) {
   // Simple case : #{set title:'Yop' /}
   for (Map.Entry<?, ?> entry : args.entrySet()) {
     Object key = entry.getKey();
     if (!key.toString().equals("arg")) {
       BaseTemplate.layoutData
           .get()
           .put(
               key,
               (entry.getValue() != null && entry.getValue() instanceof String)
                   ? __safe(template.template, entry.getValue())
                   : entry.getValue());
       return;
     }
   }
   // Body case
   Object name = args.get("arg");
   if (name != null && body != null) {
     Object oldOut = body.getProperty("out");
     StringWriter sw = new StringWriter();
     body.setProperty("out", new PrintWriter(sw));
     body.call();
     BaseTemplate.layoutData.get().put(name, sw.toString());
     body.setProperty("out", oldOut);
   }
 }
 public T parseNotation(Object notation) {
   if (notation == null) {
     return null;
   }
   if (notation instanceof CharSequence
       || notation instanceof Number
       || notation instanceof Boolean) {
     return (T) notation.toString();
   }
   if (notation instanceof Closure) {
     final Closure closure = (Closure) notation;
     final Object called = closure.call();
     return parseNotation(called);
   }
   if (notation instanceof Callable) {
     try {
       final Callable callableNotation = (Callable) notation;
       final Object called = callableNotation.call();
       return parseNotation(called);
     } catch (Exception e) {
       throw UncheckedException.throwAsUncheckedException(e);
     }
   }
   DeprecationLogger.nagUserOfDeprecated(
       String.format(
           "Converting class %s to path using toString() method", notation.getClass().getName()),
       "Please use java.io.File, java.lang.CharSequence, java.lang.Number, java.util.concurrent.Callable or groovy.lang.Closure");
   return (T) notation.toString();
 }
Exemple #10
0
 /**
  * Returns a copy of this closure where the "owner", "delegate" and "thisObject" fields are null,
  * allowing proper serialization when one of them is not serializable.
  *
  * @return a serializable closure.
  * @since 1.8.5
  */
 @SuppressWarnings("unchecked")
 public Closure<V> dehydrate() {
   Closure<V> result = (Closure<V>) this.clone();
   result.delegate = null;
   result.owner = null;
   result.thisObject = null;
   return result;
 }
Exemple #11
0
 /**
  * Returns a copy of this closure for which the delegate, owner and thisObject are replaced with
  * the supplied parameters. Use this when you want to rehydrate a closure which has been made
  * serializable thanks to the {@link #dehydrate()} method.
  *
  * @param delegate the closure delegate
  * @param owner the closure owner
  * @param thisObject the closure "this" object
  * @return a copy of this closure where owner, delegate and thisObject are replaced
  * @since 1.8.5
  */
 @SuppressWarnings("unchecked")
 public Closure<V> rehydrate(Object delegate, Object owner, Object thisObject) {
   Closure<V> result = (Closure<V>) this.clone();
   result.delegate = delegate;
   result.owner = owner;
   result.thisObject = thisObject;
   return result;
 }
 Object callClosure(Object entity, Closure callable) {
   if (cloneFirst) {
     callable = (Closure) callable.clone();
   }
   callable.setResolveStrategy(Closure.DELEGATE_FIRST);
   callable.setDelegate(entity);
   return callable.call();
 }
  private void invokeClosureNode(Object args) {
    if (args instanceof Closure) {

      Closure callable = (Closure) args;
      callable.setDelegate(this);
      callable.setResolveStrategy(Closure.DELEGATE_FIRST);
      callable.call();
    }
  }
 @Override
 public void doWithWebDescriptor(GPathResult webXml) {
   if (pluginBean.isReadableProperty(DO_WITH_WEB_DESCRIPTOR)) {
     Closure c = (Closure) plugin.getProperty(DO_WITH_WEB_DESCRIPTOR);
     c.setResolveStrategy(Closure.DELEGATE_FIRST);
     c.setDelegate(this);
     c.call(webXml);
   }
 }
  private List<?> evaluateMappings(GroovyObject go, Closure<?> mappings, Binding binding) {
    UrlMappingBuilder builder = new UrlMappingBuilder(binding, servletContext);
    mappings.setDelegate(builder);
    mappings.call();
    builder.urlDefiningMode = false;

    configureUrlMappingDynamicObjects(go);

    return builder.getUrlMappings();
  }
 @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;
 }
Exemple #17
0
 private static DocumentDefinitions applyDefinitionsClosure(
     @DelegatesTo(value = DocumentDefinitions.class, strategy = Closure.DELEGATE_FIRST)
         Closure<?> closure) {
   Closure<?> docDefClosure = (Closure<?>) closure.clone();
   docDefClosure.setResolveStrategy(Closure.DELEGATE_FIRST);
   DocumentDefinitions definitions = new DocumentDefinitions();
   docDefClosure.setDelegate(definitions);
   docDefClosure.call();
   return definitions;
 }
  @DSLMethod(production = "if  (  p0  )  then  {  p1  }  else  {  p2  }")
  public boolean ifThenElse(boolean check, Closure thenBlock, Closure elseBlock) {
    if (check) {
      thenBlock.call();
    } else {
      elseBlock.call();
    }

    return check;
  }
 @SuppressWarnings("rawtypes")
 public List evaluateMappings(Closure closure) {
   UrlMappingBuilder builder = new UrlMappingBuilder(null, servletContext);
   closure.setDelegate(builder);
   closure.setResolveStrategy(Closure.DELEGATE_FIRST);
   closure.call(applicationContext);
   builder.urlDefiningMode = false;
   configureUrlMappingDynamicObjects(closure);
   return builder.getUrlMappings();
 }
  /*
   * @see org.eclipse.swt.browser.ProgressListener#completed(org.eclipse.swt.browser.ProgressEvent)
   */
  public void completed(ProgressEvent event) {
    if (closure == null) {
      throw new NullPointerException("No closure has been configured for this Listener");
    }

    if ("completed".equals(type)) {
      closure.setProperty("event", new CustomProgressEvent(event));
      closure.call(event);
    }
  }
Exemple #21
0
  private Object evaluateCondition(Closure condition) {
    condition.setDelegate(new PreconditionContext());
    condition.setResolveStrategy(Closure.DELEGATE_ONLY);

    try {
      return condition.call();
    } catch (Exception e) {
      throw new ExtensionException("Failed to evaluate @Requires condition", e);
    }
  }
 public void testFindAllAndCurry() {
   Map<String, Integer> expected = new HashMap<String, Integer>(zoo);
   expected.remove("Lions");
   Closure<Boolean> keyBiggerThan =
       new Closure<Boolean>(null) {
         public Boolean doCall(Map.Entry<String, Integer> e, Integer size) {
           return e.getKey().length() > size;
         }
       };
   Closure<Boolean> keyBiggerThan6 = keyBiggerThan.rcurry(6);
   assertEquals(expected, findAll(zoo, keyBiggerThan6));
 }
            @Override
            public Class<?>[] visitGroovy(Map<String, Object> p) {
              @SuppressWarnings("unchecked")
              Closure<Object> transactOn = (Closure<Object>) p.get(GVY_PROCEDURE_ENTRY_CLOSURE);

              // closure with no parameters has an object as the default parameter
              Class<?>[] parameterTypes = transactOn.getParameterTypes();
              if (parameterTypes.length == 1 && parameterTypes[0] == Object.class) {
                return new Class<?>[0];
              }
              return transactOn.getParameterTypes();
            }
  /**
   * Times the execution of a closure, which can include a target. For example,
   *
   * <p>profile("compile", compile)
   *
   * <p>where 'compile' is the target.
   */
  public void profile(String name, Closure<?> callable) {
    if (enableProfile) {
      long now = System.currentTimeMillis();
      GrailsConsole console = GrailsConsole.getInstance();
      console.addStatus("Profiling [" + name + "] start");

      callable.call();
      long then = System.currentTimeMillis() - now;
      console.addStatus("Profiling [" + name + "] finish. Took " + then + " ms");
    } else {
      callable.call();
    }
  }
 protected Object doInvokeMethod(String s, Object name, Object args) {
   // TODO use setDelegate() from Groovy JSR
   Object answer = super.doInvokeMethod(s, name, args);
   List list = InvokerHelper.asList(args);
   if (!list.isEmpty()) {
     Object o = list.get(list.size() - 1);
     if (o instanceof Closure) {
       Closure closure = (Closure) o;
       closure.setDelegate(answer);
     }
   }
   return answer;
 }
  private void invokeOnChangeListener(Map event) {
    onChangeListener.setDelegate(this);
    onChangeListener.call(new Object[] {event});

    // Apply any factory post processors in case the change listener has changed any
    // bean definitions (GRAILS-5763)
    if (applicationContext instanceof GenericApplicationContext) {
      GenericApplicationContext ctx = (GenericApplicationContext) applicationContext;
      ConfigurableListableBeanFactory beanFactory = ctx.getBeanFactory();
      for (BeanFactoryPostProcessor postProcessor : ctx.getBeanFactoryPostProcessors()) {
        postProcessor.postProcessBeanFactory(beanFactory);
      }
    }
  }
 public void registerExplicitProperty(
     String name, String groupName, Closure getter, Closure setter) {
   // set the delegate to FBS so the closure closes over the builder
   if (getter != null) getter.setDelegate(this);
   if (setter != null) setter.setDelegate(this);
   explicitProperties.put(name, new Closure[] {getter, setter});
   String methodNameBase = MetaClassHelper.capitalize(name);
   if (getter != null) {
     getRegistrationGroup(groupName).add("get" + methodNameBase);
   }
   if (setter != null) {
     getRegistrationGroup(groupName).add("set" + methodNameBase);
   }
 }
 protected boolean checkExplicitMethod(String methodName, Object args, Reference result) {
   Closure explicitMethod = resolveExplicitMethod(methodName, args);
   if (explicitMethod != null) {
     if (args instanceof Object[]) {
       result.set(explicitMethod.call((Object[]) args));
     } else {
       // todo push through InvokerHelper.asList?
       result.set(explicitMethod.call(args));
     }
     return true;
   } else {
     return false;
   }
 }
 /** @throws DSLException . */
 @Test
 public void testPropertyInCustomCommand() throws DSLException {
   final File testParsingExtendDslFile =
       new File(TEST_PARSING_RESOURCE_PATH + "test_property_in_custom_command-service.groovy");
   final File testParsingExtendWorkDir = new File(TEST_PARSING_RESOURCE_PATH);
   final Service service =
       ServiceReader.getServiceFromFile(testParsingExtendDslFile, testParsingExtendWorkDir)
           .getService();
   final Closure<?> customCommand =
       ((ClosureExecutableEntry) service.getCustomCommands().get("custom_command")).getCommand();
   final String[] params = new String[2];
   params[0] = "name";
   params[1] = "port";
   customCommand.call((Object[]) params);
   customCommand.call((Object[]) params);
 }
Exemple #30
0
 public GPathResult find(final Closure closure) {
   if (DefaultTypeTransformation.castToBoolean(closure.call(new Object[] {this}))) {
     return this;
   } else {
     return new NoChildren(this, "", this.namespaceTagHints);
   }
 }