ScanAndCompileBootstrapper.java

package com.google.sitebricks;

import com.google.common.collect.HashBiMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.inject.Binding;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Stage;
import com.google.sitebricks.compiler.Compilers;
import com.google.sitebricks.compiler.TemplateCompileException;
import com.google.sitebricks.headless.Service;
import com.google.sitebricks.rendering.Decorated;
import com.google.sitebricks.rendering.EmbedAs;
import com.google.sitebricks.rendering.Templates;
import com.google.sitebricks.rendering.With;
import com.google.sitebricks.rendering.control.WidgetRegistry;
import com.google.sitebricks.rendering.resource.ResourcesService;
import com.google.sitebricks.routing.PageBook;
import com.google.sitebricks.routing.PageBook.Page;
import com.google.sitebricks.routing.SystemMetrics;

import java.lang.annotation.Annotation;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import static com.google.inject.matcher.Matchers.annotatedWith;
import static com.google.sitebricks.SitebricksModule.BindingKind.ACTION;
import static com.google.sitebricks.SitebricksModule.BindingKind.EMBEDDED;
import static com.google.sitebricks.SitebricksModule.BindingKind.PAGE;
import static com.google.sitebricks.SitebricksModule.BindingKind.SERVICE;
import static com.google.sitebricks.SitebricksModule.BindingKind.STATIC_RESOURCE;

/**
 * @author Dhanji R. Prasanna (dhanji@gmail.com)
 */
class ScanAndCompileBootstrapper implements Bootstrapper {
  private final PageBook pageBook;
  private final List<Package> packages;
  private final ResourcesService resourcesService;
  private final WidgetRegistry registry;
  private final SystemMetrics metrics;
  private final Compilers compilers;

  @Inject
  private final Templates templates = null;
  
  @Inject @Bricks
  private final List<SitebricksModule.LinkingBinder> bindings = null;

  @Inject @Bricks
  private final Map<String, Class<? extends Annotation>> methodMap = null;

  @Inject
  private final Stage currentStage = null;

  @Inject
  private final Injector injector = null;

  private final Logger log = Logger.getLogger(ScanAndCompileBootstrapper.class.getName());

  @Inject
  public ScanAndCompileBootstrapper(PageBook pageBook,
                                    @Bricks List<Package> packages,
                                    ResourcesService resourcesService,
                                    WidgetRegistry registry,
                                    SystemMetrics metrics,
                                    Compilers compilers) {

    this.pageBook = pageBook;
    this.packages = packages;
    this.resourcesService = resourcesService;
    this.registry = registry;

    this.metrics = metrics;
    this.compilers = compilers;
  }

  public void start() {
    Set<Class<?>> set = Sets.newHashSet();
    for (Package pkg : packages) {

      //look for any classes annotated with @At, @EmbedAs and @With
      set.addAll(Classes.matching(
    		  annotatedWith(At.class).or(
    		  annotatedWith(EmbedAs.class)).or(
    		  annotatedWith(With.class)).or(
          annotatedWith(Show.class))
      ).in(pkg));
    }

    //we need to scan all the pages first (do not collapse into the next loop)
    Set<PageBook.Page> pagesToCompile = scanPagesToCompile(set);
    collectBindings(bindings, pagesToCompile);
    extendedPages(pagesToCompile);

    // Compile templates for scanned classes (except in dev mode, where faster startup
    // time is more important and compiles are amortized across visits to each page).
    // TODO make this configurable separately to stage for GAE
    if (Stage.DEVELOPMENT != currentStage) {
      compilePages(pagesToCompile);
    }

    // Start all services.
    List<Binding<Aware>> bindings = injector.findBindingsByType(AWARE_TYPE);
    for (Binding<Aware> binding : bindings) {
      binding.getProvider().get().startup();
    }

    //set application mode to started (now debug mechanics can kick in)
    metrics.activate();
  }

  private void extendedPages(Set<Page> pagesToCompile) {
    Set<Page> pageExtensions = Sets.newHashSet();
    for (Page page : pagesToCompile) {
      if (page.pageClass().isAnnotationPresent(Decorated.class)) {
        // recursively add extension pages
        analyseExtension(pageExtensions, page.pageClass());
      }
    }
    pagesToCompile.addAll(pageExtensions);
  }

  //processes all explicit bindings, including static resources.
  private void collectBindings(List<SitebricksModule.LinkingBinder> bindings,
                               Set<PageBook.Page> pagesToCompile) {

    // Reverse the method map for easy lookup of HTTP method annotations.
    Map<Class<? extends Annotation>, String> methodSet = null;

    //go thru bindings and obtain pages from them.
    for (SitebricksModule.LinkingBinder binding : bindings) {

      if (EMBEDDED == binding.bindingKind) {
        if (null == binding.embedAs) {
          // This can happen if embed() is not followed by an .as(..)
          throw new IllegalStateException("embed() missing .as() clause: " + binding.pageClass);
        }
        registry.addEmbed(binding.embedAs);
        pagesToCompile.add(pageBook.embedAs(binding.pageClass, binding.embedAs));

      } else if (PAGE == binding.bindingKind) {
        pagesToCompile.add(pageBook.at(binding.uri, binding.pageClass));

      } else if (STATIC_RESOURCE == binding.bindingKind) {
        //localize the resource to the SitebricksModule's package.
        resourcesService.add(SitebricksModule.class, binding.getResource());
      } else if (SERVICE == binding.bindingKind) {
        pagesToCompile.add(pageBook.serviceAt(binding.uri, binding.pageClass));
      } else if (ACTION == binding.bindingKind) {
        // Lazy create this inverse lookup map, once.
        if (null == methodSet) {
          methodSet = HashBiMap.create(methodMap).inverse();
        }
        pageBook.at(binding.uri, binding.actionDescriptors, methodSet);
      }
    }
  }

  //goes through the set of scanned classes and builds pages out of them.
  private Set<PageBook.Page> scanPagesToCompile(Set<Class<?>> set) {
    Set<Templates.Descriptor> templates = Sets.newHashSet();
    Set<PageBook.Page> pagesToCompile = Sets.newHashSet();
    for (Class<?> pageClass : set) {
      EmbedAs embedAs = pageClass.getAnnotation(EmbedAs.class);
      if (null != embedAs) {
        final String embedName = embedAs.value();
      
        //is this a text rendering or embedding-style widget?
        if (Renderable.class.isAssignableFrom(pageClass)) {
          @SuppressWarnings("unchecked")
          Class<? extends Renderable> renderable = (Class<? extends Renderable>) pageClass;
          registry.add(embedName, renderable);
        } else {
          pagesToCompile.add(embed(embedName, pageClass));
        }
      }
      
      At at = pageClass.getAnnotation(At.class);
      if (null != at) {
        if (pageClass.isAnnotationPresent(Service.class)) {
          pagesToCompile.add(pageBook.serviceAt(at.value(), pageClass));
        } else if (pageClass.isAnnotationPresent(Export.class)) {
          //localize the resource to the SitebricksModule's package.
          resourcesService.add(SitebricksModule.class, pageClass.getAnnotation(Export.class));
        }
        else {
          pagesToCompile.add(pageBook.at(at.value(), pageClass));
        }
      }

      if (pageClass.isAnnotationPresent(Show.class)) {
        // This has a template associated with it.
        templates.add(new Templates.Descriptor(pageClass,
            pageClass.getAnnotation(Show.class).value()));
      }
    }

    // Eagerly load all detected templates in production mode.
    if (Stage.DEVELOPMENT != currentStage) {
      this.templates.loadAll(templates);
    }

    return pagesToCompile;
  }

  private void analyseExtension(Set<PageBook.Page> pagesToCompile, final Class<?> extendClassArgument) {
    // store the page with a special page name used by ExtendWidget
    Class<?> extendClass = extendClassArgument;
    pagesToCompile.add(pageBook.decorate(extendClass));
    
    // recursively analyse super class
    while (extendClass != Object.class) {
      extendClass = extendClass.getSuperclass();
      if (extendClass.isAnnotationPresent(Decorated.class)) {
        analyseExtension(pagesToCompile, extendClass);
      }
      else if (extendClass.isAnnotationPresent(Show.class)) {
        // there is a @Show with no @Extension so this is the outer template
        return;
      }
    }
    throw new IllegalStateException("Could not find super class annotated with @Show on parent of class: " + extendClassArgument);
  }

  private void compilePages(Set<PageBook.Page> pagesToCompile) {
    final List<TemplateCompileException> failures = Lists.newArrayList();

    //perform a compilation pass over all the pages and their templates
    for (PageBook.Page page : pagesToCompile) {
      Class<?> pageClass = page.pageClass();

      // Headless web services need to be analyzed but not page-compiled.
      if (page.isHeadless()) {
        // TODO(dhanji): Feedback errors as return rather than throwing.
        compilers.analyze(pageClass);
        continue;
      }

      if (log.isLoggable(Level.FINEST)) {
        log.finest("Compiling template for page " + pageClass.getName());
      }

      try {
        compilers.compilePage(page);
        compilers.analyze(pageClass);
      } catch (TemplateCompileException e) {
        failures.add(e);
      }
    }

    //log failures if any (we don't abort the app startup)
    if (!failures.isEmpty()) {
      logFailures(failures);
    }
  }

  private PageBook.Page embed(String embedAs, Class<?> page) {
    //store custom page wrapped as an embed widget
    registry.addEmbed(embedAs);

    //store argument name(s) wrapped as an Argument (multiple aliases allowed)
    if (page.isAnnotationPresent(With.class)) {
      for (String callWith : page.getAnnotation(With.class).value()) {
        registry.addArgument(callWith);
      }
    }

    //...add as an unbound (to URI) page
    return pageBook.embedAs(page, embedAs);
  }

  private void logFailures(List<TemplateCompileException> failures) {
    StringBuilder builder = new StringBuilder();
    for (TemplateCompileException failure : failures) {
      builder.append(failure.getMessage());
      builder.append("\n\n");
    }

    log.severe(builder.toString());
  }
}