AssetsMetaModel.java

/*
 * Copyright 2013 eXo Platform SAS
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package juzu.impl.plugin.asset;

import juzu.impl.asset.AssetServer;
import juzu.impl.common.MethodInvocation;
import juzu.impl.common.MethodInvocationResolver;
import juzu.impl.common.Name;
import juzu.impl.compiler.ElementHandle;
import juzu.impl.compiler.MessageCode;
import juzu.impl.compiler.ProcessingContext;
import juzu.impl.compiler.ProcessingException;
import juzu.impl.metamodel.Key;
import juzu.impl.metamodel.MetaModelObject;
import juzu.impl.plugin.application.metamodel.ApplicationMetaModel;

import javax.tools.FileObject;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;

/** @author Julien Viet */
public class AssetsMetaModel extends MetaModelObject implements MethodInvocationResolver {

  /** . */
  public static final MessageCode UNRESOLVED_ASSET = new MessageCode("UNRESOLVED_ASSET", "The application asset %1s cannot be resolved");

  /** . */
  public final static Key<AssetsMetaModel> KEY = Key.of(AssetsMetaModel.class);

  /** . */
  private final HashMap<AssetKey, Asset> assets = new HashMap<AssetKey, Asset>();

  /**
   * Links resource URLs to target: some resources may have the same target, it should
   * be an issue that we detect in the resolving phase and produce an error.
   */
  private final HashMap<String, URL> resources = new HashMap<String, URL>();

  /** . */
  private final ElementHandle.Package pkg;

  public AssetsMetaModel(ElementHandle.Package pkg) {
    this.pkg = pkg;
  }

  public void addAsset(Asset asset) {
    assets.put(asset.key, asset);
  }

  public void removeAsset(Asset asset) {
    assets.remove(asset.key);
  }

  /**
   * Associate a resource with a physical path in the application.
   *
   * @param path the resource path
   * @param resource the resource
   */
  public void addResource(String path, URL resource) {
    URL existing = resources.get(path);
    if (existing != null) {
      throw new UnsupportedOperationException("Cannot add resource " + path + " : added " + resource + " != existing " + existing);
    } else {
      resources.put(path, resource);
    }
  }

  /**
   * Remove a resource association from the application.
   *
   * @param path the resource path
   * @param resource the resource
   */
  public void removeResource(String path, URL resource) {
    URL existing = resources.get(path);
    if (resource.equals(existing)) {
      resources.remove(path);
    } else {
      throw new UnsupportedOperationException("Resource conflict for resource " + path + " : removed " + resource +
          " not matched by existing " + existing);
    }
  }

  /**
   * Resolve a relative resource for this application, this method does not modify the current application.
   *
   * @param path the resource value
   * @return the related resource URL or null if it cannot be resolved
   * @throws ProcessingException relate any processing issue
   */
  public URL resolveResource(String path) throws ProcessingException {
    ApplicationMetaModel application = (ApplicationMetaModel)metaModel;
    ProcessingContext context = application.getProcessingContext();
    boolean relative = path.length() == 0 || path.charAt(0) != '/';
    if (relative) {
      context.info("Resolving classpath asset " + path);
      Name qn = application.getHandle().getPackageName().append("assets");
      FileObject src;
      try {
        src = context.resolveResourceFromSourcePath(pkg, qn, path);
      }
      catch (Exception e) {
        throw UNRESOLVED_ASSET.failure(path).initCause(e);
      }
      if (src != null) {
        URI uri = src.toUri();
        context.info("Found asset " + path + " on source path " + uri);
        try {
          String scheme = uri.getScheme();
          if (scheme == null) {
            uri = new URI("file:" + uri);
          }
          return uri.toURL();
        }
        catch (URISyntaxException e) {
          throw UNRESOLVED_ASSET.failure(uri).initCause(e);
        }
        catch (MalformedURLException e) {
          throw UNRESOLVED_ASSET.failure(uri).initCause(e);
        }
      } else {
        context.info("Could not find asset " + path + " on source path");
        return null;
      }
    } else {
      return null;
    }
  }

  public Map<String, URL> getResources() {
    return resources;
  }

  public Iterable<Asset> getAssets() {
    return assets.values();
  }

  public Iterable<Asset> getAssets(final String type) {
    return new Iterable<Asset>() {
      public Iterator<Asset> iterator() {
        final Iterator<Asset> i = assets.values().iterator();
        return new Iterator<Asset>() {
          Asset next = null;
          public boolean hasNext() {
            while (next == null && i.hasNext()) {
              Asset asset = i.next();
              if (asset.type.equals(type)) {
                next = asset;
              }
            }
            return next != null;
          }
          public Asset next() {
            if (hasNext()) {
              Asset tmp = next;
              next = null;
              return tmp;
            } else {
              throw new NoSuchElementException();
            }
          }
          public void remove() {
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }

  public void removeAssets(String type) {
    for (Iterator<Asset> i = assets.values().iterator();i.hasNext();) {
      Asset asset = i.next();
      if (asset.type.equals(type)) {
        i.remove();
      }
    }
  }

  public MethodInvocation resolveMethodInvocation(String typeName, String methodName, Map<String, String> parameterMap) {
    if ("Assets".equals(typeName) && methodName.equals("url")) {
      String path = parameterMap.get("path");
      if (path != null) {
        return new MethodInvocation(AssetServer.class.getName(), "renderAssetURLByPath", Collections.singletonList(path));
      } else {
        String id = parameterMap.get("id");
        if (id != null) {
          return new MethodInvocation(AssetServer.class.getName(), "renderAssetURLById", Collections.singletonList(id));
        }
      }
    }
    return null;
  }
}