@Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    if (Metadata.getCurrent().isWarDeployed()) {
      localResourceLoader = resourceLoader;
    } else {
      // The "settings" may be null in some of the Grails unit tests.
      BuildSettings settings = BuildSettingsHolder.getSettings();

      String location = null;
      if (settings != null) {
        location = settings.getResourcesDir().getPath();
      } else if (Environment.getCurrent().isReloadEnabled()) {
        location = Environment.getCurrent().getReloadLocation();
      }

      if (location != null) {
        localResourceLoader = new DevelopmentResourceLoader(application, location);
      } else {
        localResourceLoader = resourceLoader;
      }
    }
    super.setResourceLoader(localResourceLoader);

    if (resourceResolver == null) {
      resourceResolver = new PathMatchingResourcePatternResolver(localResourceLoader);
    }
  }
Ejemplo n.º 2
0
  private static ScriptAndArgs processAndReturnArguments(CommandLine commandLine) {
    ScriptAndArgs info = new ScriptAndArgs();
    if (Environment.isSystemSet()) {
      info.env = Environment.getCurrent().getName();
    } else if (commandLine.getEnvironment() != null) {
      info.env = commandLine.getEnvironment();
    }

    info.inputName = commandLine.getCommandName();
    info.name = GrailsNameUtils.getNameFromScript(commandLine.getCommandName());
    return info;
  }
Ejemplo n.º 3
0
 private static List getBindingIncludeList(final Object object) {
   List includeList = Collections.emptyList();
   try {
     final Class<? extends Object> objectClass = object.getClass();
     if (CLASS_TO_BINDING_INCLUDE_LIST.containsKey(objectClass)) {
       includeList = CLASS_TO_BINDING_INCLUDE_LIST.get(objectClass);
     } else {
       final Field whiteListField =
           objectClass.getDeclaredField(DefaultASTDatabindingHelper.DEFAULT_DATABINDING_WHITELIST);
       if (whiteListField != null) {
         if ((whiteListField.getModifiers() & Modifier.STATIC) != 0) {
           final Object whiteListValue = whiteListField.get(objectClass);
           if (whiteListValue instanceof List) {
             includeList = (List) whiteListValue;
           }
         }
       }
       if (!Environment.getCurrent().isReloadEnabled()) {
         CLASS_TO_BINDING_INCLUDE_LIST.put(objectClass, includeList);
       }
     }
   } catch (Exception e) {
   }
   return includeList;
 }
Ejemplo n.º 4
0
  public GroovyPageParser(
      String name, String uri, String filename, String gspSource, String expressionCodecName)
      throws IOException {
    Config config = Holders.getConfig();
    if (config != null) {
      setEnableSitemeshPreprocessing(
          config.getProperty(
              GroovyPageParser.CONFIG_PROPERTY_GSP_SITEMESH_PREPROCESS,
              Boolean.class,
              enableSitemeshPreprocessing));
    }

    GrailsPluginInfo pluginInfo = null;
    //        TODO: figure out a way to restore plugin metadata for GSP
    //        if (filename != null && BuildSettingsHolder.getSettings() != null) {
    //            pluginInfo =
    // GrailsPluginUtils.getPluginBuildSettings().getPluginInfoForSource(filename);
    //            if (pluginInfo != null) {
    //                pluginAnnotation = "@GrailsPlugin(name='" + pluginInfo.getName() + "',
    // version='" +
    //                    pluginInfo.getVersion() + "')";
    //            }
    //        }

    OutputEncodingSettings gspConfig = new OutputEncodingSettings(config);

    this.expressionCodecDirectiveValue = expressionCodecName;
    if (expressionCodecDirectiveValue == null) {
      expressionCodecDirectiveValue =
          gspConfig.getCodecSettings(pluginInfo, OutputEncodingSettings.EXPRESSION_CODEC_NAME);
    }
    staticCodecDirectiveValue =
        gspConfig.getCodecSettings(pluginInfo, OutputEncodingSettings.STATIC_CODEC_NAME);
    outCodecDirectiveValue =
        gspConfig.getCodecSettings(pluginInfo, OutputEncodingSettings.OUT_CODEC_NAME);
    taglibCodecDirectiveValue =
        gspConfig.getCodecSettings(pluginInfo, OutputEncodingSettings.TAGLIB_CODEC_NAME);

    Map<String, String> directives = parseDirectives(gspSource);

    if (isSitemeshPreprocessingEnabled(directives.get(SITEMESH_PREPROCESS_DIRECTIVE))) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(
            "Preprocessing "
                + uri
                + " for sitemesh. Replacing head, title, meta and body elements with sitemesh:capture*.");
      }
      // GSP preprocessing for direct sitemesh integration: replace head -> g:captureHead, title ->
      // g:captureTitle, meta -> g:captureMeta, body -> g:captureBody
      gspSource = sitemeshPreprocessor.addGspSitemeshCapturing(gspSource);
      sitemeshPreprocessMode = true;
    }
    scan = new GroovyPageScanner(gspSource, uri);
    pageName = uri;
    environment = Environment.getCurrent();
    makeName(name);
    makeSourceName(filename);
  }
 private Resource getResourceWithinContext(String uri) {
   if (resourceLoader == null)
     throw new IllegalStateException(
         "TemplateEngine not initialised correctly, no [resourceLoader] specified!");
   if (Environment.getCurrent().isReloadEnabled() && Metadata.getCurrent().isWarDeployed()) {
     return resourceLoader.getResource(uri);
   }
   Resource r = servletContextLoader.getResource(uri);
   if (r.exists()) return r;
   return resourceLoader.getResource(uri);
 }
 @Override
 public Resource findResourceForURI(String uri) {
   Resource resource = uriResolveCache.get(uri);
   if (resource == null) {
     resource = super.findResourceForURI(uri);
     if (resource == null && Environment.isWarDeployed()) {
       resource = NULL_RESOURCE;
     }
     if (resource != null) uriResolveCache.put(uri, resource);
   }
   return resource == NULL_RESOURCE ? null : resource;
 }
  public void afterPropertiesSet() throws Exception {
    resourceLoader = GrailsResourceLoaderHolder.getResourceLoader();
    if (resourceLoader != null) {
      return;
    }

    if (Environment.getCurrent().isReloadEnabled()) {
      ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
      try {
        Resource[] resources =
            resolver.getResources(
                "file:" + Environment.getCurrent().getReloadLocation() + "/grails-app/**/*.groovy");
        resourceLoader = new GrailsResourceLoader(resources);
      } catch (IOException e) {
        createDefaultInternal();
      }
    } else {
      createDefaultInternal();
    }
    GrailsResourceLoaderHolder.setResourceLoader(resourceLoader);
  }
 /**
  * Get the default Compass connection (ie, Lucene index dir)
  *
  * @param grailsApplication the GrailsApplication - may be null
  * @return {user.home}/.grails/projects/{project-name}/searchable-index/{grails.env}
  */
 public static String getDefaultConnection(GrailsApplication grailsApplication) {
   String appName = SearchableUtils.getAppName(grailsApplication);
   return new StringBuilder(System.getProperty("user.home"))
       .append(File.separator)
       .append(".grails")
       .append(File.separator)
       .append("projects")
       .append(File.separator)
       .append(appName)
       .append(File.separator)
       .append("searchable-index")
       .append(File.separator)
       .append(Environment.getCurrent().getName())
       .toString();
 }
 /**
  * Returns the absolute path to the provided Grails plugin if it is being used "inline" or {@code
  * null} if the plugin is <b>not</b> being used "inline".
  *
  * @param grailsPlugin The Grails plugin.
  * @return The absolute path to the "inline" plugin or {@code null} if the plugin is not being
  *     used "inline".
  */
 protected String getInlinePluginPath(GrailsPlugin grailsPlugin) {
   if (Environment.isWarDeployed()) return null;
   try {
     final GrailsPluginInfo pluginInfo =
         pluginBuildSettings.getPluginInfoForName(grailsPlugin.getFileSystemShortName());
     if (pluginInfo != null) {
       return new File(
               pluginBuildSettings.getBuildSettings().getResourcesDir(),
               "plugins/" + pluginInfo.getFullName())
           .getCanonicalPath();
     }
   } catch (final IOException e) {
     LOG.debug(
         "Unable to retrieve plugin directory for plugin " + grailsPlugin.getFileSystemShortName(),
         e);
   }
   return null;
 }
 @Override
 public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
     throws BeansException {
   if (Environment.isInitializing()) {
     return;
   }
   if (autowireMode == AUTOWIRE_BY_NAME) {
     if (DISABLE_AUTOWIRE_BY_NAME_OPTIMIZATIONS
         || dependencyCheck
         || existingBean instanceof Aware) {
       super.autowireBeanProperties(existingBean, autowireMode, dependencyCheck);
     } else {
       populateBeanInAutowireByName(existingBean);
     }
   } else {
     super.autowireBeanProperties(existingBean, autowireMode, dependencyCheck);
   }
 }
  /** Default constructor. */
  public ReloadAwareAutowireCapableBeanFactory() {
    reloadEnabled = GrailsUtil.isDevelopmentEnv() || Environment.getCurrent().isReloadEnabled();
    if (reloadEnabled) {

      // Implementation note: The default Spring InstantiationStrategy caches constructors.
      // This is no good at development time because if the class reloads then Spring
      // continues to use the old class. We deal with this here by disabling the caching
      // for development time only
      setInstantiationStrategy(
          new CglibSubclassingInstantiationStrategy() {
            @Override
            public Object instantiate(
                RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
              // Don't override the class with CGLIB if no overrides.
              if (beanDefinition.getMethodOverrides().isEmpty()) {
                Constructor<?> constructorToUse;
                Class<?> clazz = beanDefinition.getBeanClass();
                if (clazz.isInterface()) {
                  throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }
                try {
                  constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
                } catch (Exception ex) {
                  throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                }

                return BeanUtils.instantiateClass(constructorToUse);
              }
              // Must generate CGLIB subclass.
              return instantiateWithMethodInjection(beanDefinition, beanName, owner);
            }
          });
    }

    setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
    setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
    ignoreDependencyType(Closure.class);
  }
Ejemplo n.º 12
0
  @SuppressWarnings("unchecked")
  private void evaluateOnChangeListener() {
    if (pluginBean.isReadableProperty(ON_SHUTDOWN)) {
      onShutdownListener =
          (Closure) GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, ON_SHUTDOWN);
    }
    if (pluginBean.isReadableProperty(ON_CONFIG_CHANGE)) {
      onConfigChangeListener =
          (Closure)
              GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, ON_CONFIG_CHANGE);
    }
    if (pluginBean.isReadableProperty(ON_CHANGE)) {
      onChangeListener =
          (Closure) GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, ON_CHANGE);
    }

    final boolean warDeployed = Metadata.getCurrent().isWarDeployed();
    final boolean reloadEnabled = Environment.getCurrent().isReloadEnabled();

    if (!((reloadEnabled || !warDeployed) && onChangeListener != null)) {
      return;
    }

    Object referencedResources =
        GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, WATCHED_RESOURCES);

    try {
      List resourceList = null;
      if (referencedResources instanceof String) {
        if (LOG.isDebugEnabled()) {
          LOG.debug(
              "Configuring plugin "
                  + this
                  + " to watch resources with pattern: "
                  + referencedResources);
        }
        resourceList = new ArrayList();
        resourceList.add(referencedResources.toString());
      } else if (referencedResources instanceof List) {
        resourceList = (List) referencedResources;
      }

      if (resourceList != null) {
        List<String> resourceListTmp = new ArrayList<String>();
        PluginBuildSettings pluginBuildSettings = GrailsPluginUtils.getPluginBuildSettings();

        if (pluginBuildSettings != null) {

          final Resource[] pluginDirs = pluginBuildSettings.getPluginDirectories();
          final Environment env = Environment.getCurrent();
          final String baseLocation = env.getReloadLocation();

          for (Object ref : resourceList) {
            String stringRef = ref.toString();
            if (!warDeployed) {
              for (Resource pluginDir : pluginDirs) {
                if (pluginDir != null) {
                  String pluginResources =
                      getResourcePatternForBaseLocation(
                          pluginDir.getFile().getCanonicalPath(), stringRef);
                  resourceListTmp.add(pluginResources);
                }
              }
              addBaseLocationPattern(resourceListTmp, baseLocation, stringRef);
            } else {
              addBaseLocationPattern(resourceListTmp, baseLocation, stringRef);
            }
          }

          watchedResourcePatternReferences = new String[resourceListTmp.size()];
          for (int i = 0; i < watchedResourcePatternReferences.length; i++) {
            String resRef = resourceListTmp.get(i);
            watchedResourcePatternReferences[i] = resRef;
          }

          watchedResourcePatterns =
              new WatchPatternParser()
                  .getWatchPatterns(Arrays.asList(watchedResourcePatternReferences));
        }
      }
    } catch (IllegalArgumentException e) {
      if (GrailsUtil.isDevelopmentEnv()) {
        LOG.debug(
            "Cannot load plug-in resource watch list from ["
                + ArrayUtils.toString(watchedResourcePatternReferences)
                + "]. This means that the plugin "
                + this
                + ", will not be able to auto-reload changes effectively. Try runnng grails upgrade.: "
                + e.getMessage());
      }
    } catch (IOException e) {
      if (GrailsUtil.isDevelopmentEnv()) {
        LOG.debug(
            "Cannot load plug-in resource watch list from ["
                + ArrayUtils.toString(watchedResourcePatternReferences)
                + "]. This means that the plugin "
                + this
                + ", will not be able to auto-reload changes effectively. Try runnng grails upgrade.: "
                + e.getMessage());
      }
    }
  }
/**
 * Default ResourceLocator implementation that doesn't take into account servlet loading.
 *
 * @author Graeme Rocher
 * @since 2.0
 */
public class DefaultResourceLocator
    implements ResourceLocator, ResourceLoaderAware, PluginManagerAware {

  public static final String WILDCARD = "*";
  public static final String FILE_SEPARATOR = File.separator;
  public static final String CLOSURE_MARKER = "$";
  public static final String WEB_APP_DIR = "web-app";

  protected static final Resource NULL_RESOURCE = new ByteArrayResource("null".getBytes());

  protected PathMatchingResourcePatternResolver patchMatchingResolver;
  protected List<String> classSearchDirectories = new ArrayList<String>();
  protected List<String> resourceSearchDirectories = new ArrayList<String>();
  protected Map<String, Resource> classNameToResourceCache =
      new ConcurrentHashMap<String, Resource>();
  protected Map<String, Resource> uriToResourceCache = new ConcurrentHashMap<String, Resource>();
  protected ResourceLoader defaultResourceLoader = new FileSystemResourceLoader();
  protected GrailsPluginManager pluginManager;
  protected boolean warDeployed = Environment.isWarDeployed();

  public void setSearchLocation(String searchLocation) {
    ResourceLoader resourceLoader = getDefaultResourceLoader();
    patchMatchingResolver = new CachingPathMatchingResourcePatternResolver(resourceLoader);
    initializeForSearchLocation(searchLocation);
  }

  protected ResourceLoader getDefaultResourceLoader() {
    return defaultResourceLoader;
  }

  public void setSearchLocations(Collection<String> searchLocations) {
    patchMatchingResolver =
        new CachingPathMatchingResourcePatternResolver(getDefaultResourceLoader());
    for (String searchLocation : searchLocations) {
      initializeForSearchLocation(searchLocation);
    }
  }

  private void initializeForSearchLocation(String searchLocation) {
    String searchLocationPlusSlash =
        searchLocation.endsWith("/") ? searchLocation : searchLocation + FILE_SEPARATOR;
    try {
      File[] directories =
          new File(searchLocationPlusSlash + GrailsResourceUtils.GRAILS_APP_DIR)
              .listFiles(
                  new FileFilter() {
                    public boolean accept(File file) {
                      return file.isDirectory() && !file.isHidden();
                    }
                  });
      if (directories != null) {
        for (File directory : directories) {
          classSearchDirectories.add(directory.getCanonicalPath());
        }
      }
    } catch (IOException e) {
      // ignore
    }

    classSearchDirectories.add(searchLocationPlusSlash + "src/main/java");
    classSearchDirectories.add(searchLocationPlusSlash + "src/main/groovy");
    resourceSearchDirectories.add(searchLocationPlusSlash);
  }

  public Resource findResourceForURI(String uri) {
    Resource resource = uriToResourceCache.get(uri);
    if (resource == null) {

      PluginResourceInfo info = inferPluginNameFromURI(uri);
      if (warDeployed) {
        Resource defaultResource = defaultResourceLoader.getResource(uri);
        if (defaultResource != null && defaultResource.exists()) {
          resource = defaultResource;
        }
      } else {
        String uriWebAppRelative = WEB_APP_DIR + uri;

        for (String resourceSearchDirectory : resourceSearchDirectories) {
          Resource res = resolveExceptionSafe(resourceSearchDirectory + uriWebAppRelative);
          if (res.exists()) {
            resource = res;
          } else if (!warDeployed) {
            Resource dir = resolveExceptionSafe(resourceSearchDirectory);
            if (dir.exists() && info != null) {
              try {
                String filename = dir.getFilename();
                if (filename != null && filename.equals(info.pluginName)) {
                  Resource pluginFile = dir.createRelative(WEB_APP_DIR + info.uri);
                  if (pluginFile.exists()) {
                    resource = pluginFile;
                  }
                }
              } catch (IOException e) {
                // ignore
              }
            }
          }
        }
      }

      if (resource == null && info != null) {
        resource = findResourceInBinaryPlugins(info);
      }

      if (resource == null || !resource.exists()) {
        Resource tmp =
            defaultResourceLoader != null ? defaultResourceLoader.getResource(uri) : null;
        if (tmp != null && tmp.exists()) {
          resource = tmp;
        }
      }

      if (resource != null) {
        uriToResourceCache.put(uri, resource);
      } else if (warDeployed) {
        uriToResourceCache.put(uri, NULL_RESOURCE);
      }
    }
    return resource == NULL_RESOURCE ? null : resource;
  }

  protected Resource findResourceInBinaryPlugins(PluginResourceInfo info) {
    if (pluginManager != null) {
      String fullPluginName = info.pluginName;
      for (GrailsPlugin plugin : pluginManager.getAllPlugins()) {
        if (plugin.getFileSystemName().equals(fullPluginName)
            && (plugin instanceof BinaryGrailsPlugin)) {
          return ((BinaryGrailsPlugin) plugin).getResource(info.uri);
        }
      }
    }
    return null;
  }

  private PluginResourceInfo inferPluginNameFromURI(String uri) {
    if (uri.startsWith("/plugins/")) {
      String withoutPluginsPath = uri.substring("/plugins/".length(), uri.length());
      int i = withoutPluginsPath.indexOf('/');
      if (i > -1) {
        PluginResourceInfo info = new PluginResourceInfo();
        info.pluginName = withoutPluginsPath.substring(0, i);
        info.uri = withoutPluginsPath.substring(i, withoutPluginsPath.length());
        return info;
      }
    }
    return null;
  }

  public Resource findResourceForClassName(String className) {

    if (className.contains(CLOSURE_MARKER)) {
      className = className.substring(0, className.indexOf(CLOSURE_MARKER));
    }
    Resource resource = classNameToResourceCache.get(className);
    if (resource == null) {
      String classNameWithPathSeparator = className.replace(".", FILE_SEPARATOR);
      for (String pathPattern :
          getSearchPatternForExtension(classNameWithPathSeparator, ".groovy", ".java")) {
        resource = resolveExceptionSafe(pathPattern);
        if (resource != null && resource.exists()) {
          classNameToResourceCache.put(className, resource);
          break;
        }
      }
    }
    return resource != null && resource.exists() ? resource : null;
  }

  private List<String> getSearchPatternForExtension(
      String classNameWithPathSeparator, String... extensions) {

    List<String> searchPatterns = new ArrayList<String>();
    for (String extension : extensions) {
      String filename = classNameWithPathSeparator + extension;
      for (String classSearchDirectory : classSearchDirectories) {
        searchPatterns.add(classSearchDirectory + FILE_SEPARATOR + filename);
      }
    }

    return searchPatterns;
  }

  private Resource resolveExceptionSafe(String pathPattern) {
    try {
      Resource[] resources = patchMatchingResolver.getResources("file:" + pathPattern);
      if (resources != null && resources.length > 0) {
        return resources[0];
      }
    } catch (IOException e) {
      return null;
    }
    return null;
  }

  public void setResourceLoader(ResourceLoader resourceLoader) {
    defaultResourceLoader = resourceLoader;
  }

  public void setPluginManager(GrailsPluginManager pluginManager) {
    this.pluginManager = pluginManager;
  }

  class PluginResourceInfo {
    String pluginName;
    String uri;
  }
}
  @SuppressWarnings("rawtypes")
  @Override
  public GrailsClass getArtefactForFeature(Object featureId) {
    if (artefactInfo == null) {
      return null;
    }

    String uri;
    String pluginName = null;

    if (featureId instanceof Map) {
      Map featureIdMap = (Map) featureId;
      uri = (String) featureIdMap.get("uri");
      pluginName = (String) featureIdMap.get("pluginName");
    } else {
      uri = featureId.toString();
    }

    GrailsClass controllerClass = uriToControllerClassCache.get(uri);
    if (controllerClass == null) {
      final ApplicationContext mainContext = grailsApplication.getMainContext();
      GrailsPluginManager grailsPluginManager = null;
      if (mainContext.containsBean(GrailsPluginManager.BEAN_NAME)) {
        final Object pluginManagerBean = mainContext.getBean(GrailsPluginManager.BEAN_NAME);
        if (pluginManagerBean instanceof GrailsPluginManager) {
          grailsPluginManager = (GrailsPluginManager) pluginManagerBean;
        }
      }
      final GrailsClass[] controllerClasses = artefactInfo.getGrailsClasses();
      // iterate in reverse in order to pick up application classes first
      for (int i = (controllerClasses.length - 1); i >= 0; i--) {
        GrailsClass c = controllerClasses[i];
        if (((GrailsControllerClass) c).mapsToURI(uri)) {
          boolean foundController = false;
          if (pluginName != null && grailsPluginManager != null) {
            final GrailsPlugin pluginForClass = grailsPluginManager.getPluginForClass(c.getClazz());
            if (pluginForClass != null && pluginName.equals(pluginForClass.getName())) {
              foundController = true;
            }
          } else {
            foundController = true;
          }
          if (foundController) {
            controllerClass = c;
            break;
          }
        }
      }
      if (controllerClass == null) {
        controllerClass = NO_CONTROLLER;
      }

      // don't cache for dev environment
      if (Environment.getCurrent() != Environment.DEVELOPMENT) {
        uriToControllerClassCache.put(uri, controllerClass);
      }
    }

    if (controllerClass == NO_CONTROLLER) {
      controllerClass = null;
    }
    return controllerClass;
  }
Ejemplo n.º 15
0
 public boolean supportsEnvironment(Environment environment) {
   return supportsValueInIncludeExcludeMap(pluginEnvs, environment.getName());
 }
/**
 * Enhances controller classes with a method missing implementation for tags at compile time.
 *
 * @author Graeme Rocher
 * @since 2.0
 */
public class ControllerTagLibraryApi extends CommonWebApi {

  private static final long serialVersionUID = 1;

  private transient TagLibraryLookup tagLibraryLookup;
  private boolean developmentMode = Environment.isDevelopmentMode();

  public ControllerTagLibraryApi(GrailsPluginManager pluginManager) {
    super(pluginManager);
  }

  public ControllerTagLibraryApi() {
    super(null);
  }

  @Autowired
  public void setTagLibraryLookup(TagLibraryLookup lookup) {
    tagLibraryLookup = lookup;
  }

  @Autowired
  public void setGspTagLibraryLookup(TagLibraryLookup lookup) {
    tagLibraryLookup = lookup;
  }

  /**
   * Method missing implementation that handles tag invocation by method name
   *
   * @param instance The instance
   * @param methodName The method name
   * @param argsObject The arguments
   * @return The result
   */
  public Object methodMissing(Object instance, String methodName, Object argsObject) {
    Object[] args =
        argsObject instanceof Object[] ? (Object[]) argsObject : new Object[] {argsObject};
    TagLibraryLookup lookup = getTagLibraryLookup();
    if (lookup != null) {
      GroovyObject tagLibrary = lookup.lookupTagLibrary(GroovyPage.DEFAULT_NAMESPACE, methodName);
      if (tagLibrary != null) {
        if (!developmentMode) {
          MetaClass controllerMc = GrailsMetaClassUtils.getMetaClass(instance);
          WebMetaUtils.registerMethodMissingForTags(
              controllerMc, lookup, GroovyPage.DEFAULT_NAMESPACE, methodName);
        }
        List<MetaMethod> respondsTo =
            tagLibrary.getMetaClass().respondsTo(tagLibrary, methodName, args);
        if (respondsTo.size() > 0) {
          return respondsTo.get(0).invoke(tagLibrary, args);
        }
      }
    }

    throw new MissingMethodException(methodName, instance.getClass(), args);
  }

  /**
   * Looks up namespaces on missing property
   *
   * @param instance The instance
   * @param propertyName The property name
   * @return The namespace or a MissingPropertyException
   */
  public Object propertyMissing(Object instance, String propertyName) {
    TagLibraryLookup lookup = getTagLibraryLookup();
    NamespacedTagDispatcher namespacedTagDispatcher =
        lookup.lookupNamespaceDispatcher(propertyName);
    if (namespacedTagDispatcher != null) {
      if (!developmentMode) {
        WebMetaUtils.registerPropertyMissingForTag(
            GrailsMetaClassUtils.getMetaClass(instance), propertyName, namespacedTagDispatcher);
      }
      return namespacedTagDispatcher;
    }

    throw new MissingPropertyException(propertyName, instance.getClass());
  }

  public TagLibraryLookup getTagLibraryLookup() {
    if (tagLibraryLookup == null) {
      ApplicationContext applicationContext = getApplicationContext(null);
      if (applicationContext != null) {
        try {
          tagLibraryLookup = applicationContext.getBean(TagLibraryLookup.class);
        } catch (BeansException e) {
          return null;
        }
      }
    }
    return tagLibraryLookup;
  }

  public Object withCodec(Object instance, Object codecInfo, Closure body) {
    return WithCodecHelper.withCodec(getGrailsApplication(null), codecInfo, body);
  }
}
Ejemplo n.º 17
0
 public boolean supportsCurrentScopeAndEnvironment() {
   BuildScope bs = BuildScope.getCurrent();
   Environment e = Environment.getCurrent();
   return supportsEnvironment(e) && supportsScope(bs);
 }
/**
 * An immutable ConverterConfiguration which chains the lookup calls for ObjectMarshallers for
 * performance reasons.
 *
 * @author Siegfried Puchbauer
 * @author Graeme Rocher
 * @since 1.1
 */
@SuppressWarnings("rawtypes")
public class ChainedConverterConfiguration<C extends Converter>
    implements ConverterConfiguration<C> {

  private List<ObjectMarshaller<C>> marshallerList;
  private ChainedObjectMarshaller<C> root;
  private final String encoding;
  private final Converter.CircularReferenceBehaviour circularReferenceBehaviour;
  private final boolean prettyPrint;
  private ProxyHandler proxyHandler;
  private final boolean cacheObjectMarshallerByClass;
  private Map<Integer, ObjectMarshaller<C>> objectMarshallerForClassCache;
  private final boolean developmentMode = Environment.isDevelopmentMode();
  private final ObjectMarshaller<C> NULL_HOLDER =
      new ObjectMarshaller<C>() {
        public boolean supports(Object object) {
          return false;
        }

        public void marshalObject(Object object, C converter) throws ConverterException {}
      };

  public ChainedConverterConfiguration(ConverterConfiguration<C> cfg) {
    this(cfg, new DefaultProxyHandler());
  }

  public ChainedConverterConfiguration(ConverterConfiguration<C> cfg, ProxyHandler proxyHandler) {
    marshallerList = cfg.getOrderedObjectMarshallers();
    this.proxyHandler = proxyHandler;

    encoding = cfg.getEncoding();
    prettyPrint = cfg.isPrettyPrint();
    cacheObjectMarshallerByClass = cfg.isCacheObjectMarshallerByClass();
    if (cacheObjectMarshallerByClass) {
      objectMarshallerForClassCache = new ConcurrentHashMap<Integer, ObjectMarshaller<C>>();
    }
    circularReferenceBehaviour = cfg.getCircularReferenceBehaviour();

    List<ObjectMarshaller<C>> oms = new ArrayList<ObjectMarshaller<C>>(marshallerList);
    Collections.reverse(oms);
    ChainedObjectMarshaller<C> prev = null;
    for (ObjectMarshaller<C> om : oms) {
      prev = new ChainedObjectMarshaller<C>(om, prev);
    }
    root = prev;
  }

  public ObjectMarshaller<C> getMarshaller(Object o) {
    ObjectMarshaller<C> marshaller = null;

    Integer cacheKey = null;
    if (!developmentMode && cacheObjectMarshallerByClass && o != null) {
      cacheKey = System.identityHashCode(o.getClass());
      marshaller = objectMarshallerForClassCache.get(cacheKey);
      if (marshaller != NULL_HOLDER && marshaller != null && !marshaller.supports(o)) {
        marshaller = null;
      }
    }
    if (marshaller == null) {
      marshaller = root.findMarhallerFor(o);
      if (cacheKey != null) {
        objectMarshallerForClassCache.put(cacheKey, marshaller != null ? marshaller : NULL_HOLDER);
      }
    }
    return marshaller != NULL_HOLDER ? marshaller : null;
  }

  public String getEncoding() {
    return encoding;
  }

  public Converter.CircularReferenceBehaviour getCircularReferenceBehaviour() {
    return circularReferenceBehaviour;
  }

  public boolean isPrettyPrint() {
    return prettyPrint;
  }

  public List<ObjectMarshaller<C>> getOrderedObjectMarshallers() {
    return marshallerList;
  }

  @SuppressWarnings("hiding")
  public class ChainedObjectMarshaller<C extends Converter> implements ObjectMarshaller<C> {

    private ObjectMarshaller<C> om;
    private ChainedObjectMarshaller<C> next;

    public ChainedObjectMarshaller(ObjectMarshaller<C> om, ChainedObjectMarshaller<C> next) {
      this.om = om;
      this.next = next;
    }

    public ObjectMarshaller<C> findMarhallerFor(Object o) {
      if (supports(o)) {
        return om;
      }

      return next != null ? next.findMarhallerFor(o) : null;
    }

    public boolean supports(Object object) {
      return om.supports(object);
    }

    public void marshalObject(Object object, C converter) throws ConverterException {
      om.marshalObject(object, converter);
    }
  }

  public ProxyHandler getProxyHandler() {
    return proxyHandler;
  }

  public boolean isCacheObjectMarshallerByClass() {
    return cacheObjectMarshallerByClass;
  }
}