Example #1
0
  @SuppressWarnings("unchecked")
  public List<String> getResourcePaths(String path) {
    List<String> result = CollectionFactory.newList();
    Stack<String> queue = CollectionFactory.newStack();

    queue.push(path);

    while (!queue.isEmpty()) {
      String current = queue.pop();

      Set<String> matches = servletContext.getResourcePaths(current);

      // Tomcat 5.5.20 inside JBoss 4.0.2 has been observed to do this!
      // Perhaps other servers do as well.

      if (matches == null) continue;

      for (String match : matches) {
        // Folders are queued up for further expansion.

        if (match.endsWith("/")) queue.push(match);
        else result.add(match);
      }
    }

    Collections.sort(result);

    return result;
  }
Example #2
0
/**
 * Contains all the work-state related to the {@link PageLoaderImpl}.
 *
 * <p><em>This is the Tapestry heart, this is the Tapestry soul ...</em>
 */
class PageLoaderProcessor {
  /** Special prefix for parameters that are inherited from named parameters of their container. */
  private static final String INHERIT_PREFIX = "inherit:";

  private static final Runnable NO_OP =
      new Runnable() {
        public void run() {
          // Do nothing.
        }
      };

  private static final Pattern COMMA_PATTERN = Pattern.compile(",");

  private Stack<ComponentPageElement> activeElementStack = CollectionFactory.newStack();

  private boolean addAttributesAsComponentBindings = false;

  private boolean dtdAdded;

  private final Stack<BodyPageElement> bodyPageElementStack = CollectionFactory.newStack();

  // You can use a stack as a queue
  private final Stack<ComponentPageElement> componentQueue = CollectionFactory.newStack();

  private final Stack<Boolean> discardEndTagStack = CollectionFactory.newStack();

  private final Stack<Runnable> endElementCommandStack = CollectionFactory.newStack();

  /** Used as a queue of Runnable objects used to handle final setup. */
  private final List<Runnable> finalization = CollectionFactory.newList();

  private final IdAllocator idAllocator = new IdAllocator();

  private final LinkFactory linkFactory;

  private final ComponentClassResolver componentClassResolver;

  private ComponentModel loadingComponentModel;

  private ComponentPageElement loadingElement;

  private final Map<String, Map<String, Binding>> componentIdToBindingMap =
      CollectionFactory.newMap();

  private Locale locale;

  private final OneShotLock lock = new OneShotLock();

  private Page page;

  private final PageElementFactory pageElementFactory;

  private final PersistentFieldManager persistentFieldManager;

  private final ComponentTemplateSource templateSource;

  private static final PageElement END_ELEMENT =
      new PageElement() {
        public void render(MarkupWriter writer, RenderQueue queue) {
          writer.end();
        }

        @Override
        public String toString() {
          return "End";
        }
      };

  private static class RenderBodyElement implements PageElement {
    private final ComponentPageElement component;

    public RenderBodyElement(ComponentPageElement component) {
      this.component = component;
    }

    public void render(MarkupWriter writer, RenderQueue queue) {
      component.enqueueBeforeRenderBody(queue);
    }

    @Override
    public String toString() {
      return String.format("RenderBody[%s]", component.getNestedId());
    }
  }

  PageLoaderProcessor(
      ComponentTemplateSource templateSource,
      PageElementFactory pageElementFactory,
      LinkFactory linkFactory,
      PersistentFieldManager persistentFieldManager,
      ComponentClassResolver componentClassResolver) {
    this.templateSource = templateSource;
    this.pageElementFactory = pageElementFactory;
    this.linkFactory = linkFactory;
    this.persistentFieldManager = persistentFieldManager;
    this.componentClassResolver = componentClassResolver;
  }

  private void bindParameterFromTemplate(ComponentPageElement component, AttributeToken token) {
    String name = token.getName();
    ComponentResources resources = component.getComponentResources();

    // If already bound (i.e., from the component class, via @Component), then
    // ignore the value in the template. This may need improving to just ignore
    // the value if it is an unprefixed literal string.

    if (resources.isBound(name)) return;

    // Meta default of literal for the template.

    String defaultBindingPrefix =
        determineDefaultBindingPrefix(component, name, BindingConstants.LITERAL);

    Binding binding =
        findBinding(
            loadingElement,
            component,
            name,
            token.getValue(),
            defaultBindingPrefix,
            token.getLocation());

    if (binding != null) {
      component.bindParameter(name, binding);

      Map<String, Binding> bindingMap = componentIdToBindingMap.get(component.getCompleteId());
      bindingMap.put(name, binding);
    }
  }

  private void addMixinsToComponent(
      ComponentPageElement component, EmbeddedComponentModel model, String mixins) {
    if (model != null) {
      for (String mixinClassName : model.getMixinClassNames())
        pageElementFactory.addMixinByClassName(component, mixinClassName);
    }

    if (mixins != null) {
      for (String type : COMMA_PATTERN.split(mixins))
        pageElementFactory.addMixinByTypeName(component, type);
    }
  }

  /**
   * @param model embededded model defining the new component, from an {@link
   *     org.apache.tapestry5.annotations.Component} annotation
   * @param loadingComponent the currently loading container component
   * @param newComponent the new child of the container whose parameters are being bound
   * @param newComponentBindings map of bindings for the new component (used to handle inheriting of
   *     informal parameters)
   */
  private void bindParametersFromModel(
      EmbeddedComponentModel model,
      ComponentPageElement loadingComponent,
      ComponentPageElement newComponent,
      Map<String, Binding> newComponentBindings) {
    for (String name : model.getParameterNames()) {
      String value = model.getParameterValue(name);

      String defaultBindingPrefix =
          determineDefaultBindingPrefix(newComponent, name, BindingConstants.PROP);

      Binding binding =
          findBinding(
              loadingComponent,
              newComponent,
              name,
              value,
              defaultBindingPrefix,
              newComponent.getLocation());

      if (binding != null) {
        newComponent.bindParameter(name, binding);

        // So that the binding can be shared if inherited by a subcomponent
        newComponentBindings.put(name, binding);
      }
    }
  }

  /**
   * Creates a new binding, or returns an existing binding (or null) for the "inherit:" binding prefix. Mostly a
   * wrapper around {@link BindingSource#newBinding(String, ComponentResources, ComponentResources, String, String,
   * Location)
   *
   * @return the new binding, or an existing binding (if inherited), or null (if inherited, and the containing
   *         parameter is not bound)
   */
  private Binding findBinding(
      ComponentPageElement loadingComponent,
      ComponentPageElement component,
      String name,
      String value,
      String defaultBindingPrefix,
      Location location) {
    if (value.startsWith(INHERIT_PREFIX)) {
      String loadingParameterName = value.substring(INHERIT_PREFIX.length());
      Map<String, Binding> loadingComponentBindingMap =
          componentIdToBindingMap.get(loadingComponent.getCompleteId());

      // This may return null if the parameter is not bound in the loading component.

      Binding existing = loadingComponentBindingMap.get(loadingParameterName);

      if (existing == null) return null;

      String description =
          String.format(
              "InheritedBinding[parameter %s %s(inherited from %s of %s)]",
              name,
              component.getCompleteId(),
              loadingParameterName,
              loadingComponent.getCompleteId());

      // This helps with debugging, and re-orients any thrown exceptions
      // to the location of the inherited binding, rather than the container component's
      // binding.

      return new InheritedBinding(description, existing, location);
    }

    return pageElementFactory.newBinding(
        name,
        loadingComponent.getComponentResources(),
        component.getComponentResources(),
        defaultBindingPrefix,
        value,
        location);
  }

  /**
   * Determines the default binding prefix for a particular parameter.
   *
   * @param component the component which will have a parameter bound
   * @param parameterName the name of the parameter
   * @param informalParameterBindingPrefix the default to use for informal parameters
   * @return the binding prefix
   */
  private String determineDefaultBindingPrefix(
      ComponentPageElement component, String parameterName, String informalParameterBindingPrefix) {
    String defaultBindingPrefix = component.getDefaultBindingPrefix(parameterName);

    return defaultBindingPrefix != null ? defaultBindingPrefix : informalParameterBindingPrefix;
  }

  private void addToBody(PageElement element) {
    bodyPageElementStack.peek().addToBody(element);
  }

  private void attribute(AttributeToken token) {
    // This kind of bookkeeping is ugly, we probably should have distinct (if very similar)
    // tokens for attributes and for parameter bindings.

    if (addAttributesAsComponentBindings) {
      ComponentPageElement activeElement = activeElementStack.peek();

      bindParameterFromTemplate(activeElement, token);
      return;
    }

    PageElement element =
        pageElementFactory.newAttributeElement(loadingElement.getComponentResources(), token);

    addToBody(element);
  }

  private void body() {
    addToBody(new RenderBodyElement(loadingElement));

    // BODY tokens are *not* matched by END_ELEMENT tokens. Nor will there be
    // text or comment content "inside" the BODY.
  }

  private void comment(CommentToken token) {
    PageElement commentElement = new CommentPageElement(token.getComment());

    addToBody(commentElement);
  }

  /**
   * Invoked whenever a token (start, startComponent, etc.) is encountered that will eventually have
   * a matching end token. Sets up the behavior for the end token.
   *
   * @param discard if true, the end is discarded (if false the end token is added to the active
   *     body element)
   * @param command command to execute to return processor state back to what it was before the
   *     command executed
   */
  private void configureEnd(boolean discard, Runnable command) {
    discardEndTagStack.push(discard);
    endElementCommandStack.push(command);
  }

  private void endElement() {
    // discard will be false if the matching start token was for a static element, and will be
    // true otherwise (component, block, parameter).

    boolean discard = discardEndTagStack.pop();

    if (!discard) addToBody(END_ELEMENT);

    Runnable command = endElementCommandStack.pop();

    // Used to return environment to prior state.

    command.run();
  }

  private void expansion(ExpansionToken token) {
    PageElement element =
        pageElementFactory.newExpansionElement(loadingElement.getComponentResources(), token);

    addToBody(element);
  }

  private String generateEmbeddedId(String embeddedType, IdAllocator idAllocator) {
    // Component types may be in folders; strip off the folder part for starters.

    int slashx = embeddedType.lastIndexOf("/");

    String baseId = embeddedType.substring(slashx + 1).toLowerCase();

    // The idAllocator is pre-loaded with all the component ids from the template, so even
    // if the lower-case type matches the id of an existing component, there won't be a name
    // collision.

    return idAllocator.allocateId(baseId);
  }

  /**
   * As currently implemented, this should be invoked just once and then the PageLoaderProcessor
   * instance should be discarded.
   */
  public Page loadPage(String logicalPageName, String pageClassName, Locale locale) {
    // Ensure that loadPage() may only be invoked once.

    lock.lock();

    this.locale = locale;

    // Todo: Need a resources object for Pages, not just ComponentPageElement ... too many
    // parameters here.

    page =
        new PageImpl(
            logicalPageName,
            this.locale,
            linkFactory,
            persistentFieldManager,
            componentClassResolver);

    loadRootComponent(pageClassName);

    workComponentQueue();

    // Take care of any finalization logic that's been deferred out.

    for (Runnable r : finalization) {
      r.run();
    }

    // The page is *loaded* before it is attached to the request.
    // This is to help ensure that no client-specific information leaks
    // into the page.

    page.loaded();

    return page;
  }

  private void loadRootComponent(String className) {
    ComponentPageElement rootComponent =
        pageElementFactory.newRootComponentElement(page, className, locale);

    page.setRootElement(rootComponent);

    componentQueue.push(rootComponent);
  }

  /**
   * Do you smell something? I'm smelling that this class needs to be redesigned to not need a
   * central method this large and hard to test. I think a lot of instance and local variables need
   * to be bundled up into some kind of process object. This code is effectively too big to be
   * tested except through integration testing.
   */
  private void loadTemplateForComponent(final ComponentPageElement loadingElement) {
    this.loadingElement = loadingElement;
    loadingComponentModel = loadingElement.getComponentResources().getComponentModel();

    String componentClassName = loadingComponentModel.getComponentClassName();
    ComponentTemplate template = templateSource.getTemplate(loadingComponentModel, locale);

    // When the template for a component is missing, we pretend it consists of just a RenderBody
    // phase. Missing is not an error ... many component simply do not have a template.

    if (template.isMissing()) {
      this.loadingElement.addToTemplate(new RenderBodyElement(this.loadingElement));
      return;
    }

    // Pre-allocate ids to avoid later name collisions.

    // Don't have a case-insensitive Set, so we'll make due with a Map
    Map<String, Boolean> embeddedIds = collectedEmbeddedComponentIds(loadingComponentModel);

    idAllocator.clear();

    final Map<String, Location> componentIdsMap = template.getComponentIds();

    for (String id : componentIdsMap.keySet()) {
      idAllocator.allocateId(id);
      embeddedIds.remove(id);
    }

    if (!embeddedIds.isEmpty())
      throw new RuntimeException(
          ServicesMessages.embeddedComponentsNotInTemplate(
              embeddedIds.keySet(), componentClassName, template.getResource()));

    addAttributesAsComponentBindings = false;

    // The outermost elements of the template belong in the loading component's template list,
    // not its body list. This shunt allows everyone else to not have to make that decision,
    // they can add to the "body" and (if there isn't an active component), the shunt will
    // add the element to the component's template.

    BodyPageElement shunt =
        new BodyPageElement() {
          public void addToBody(PageElement element) {
            loadingElement.addToTemplate(element);
          }
        };

    bodyPageElementStack.push(shunt);

    for (TemplateToken token : template.getTokens()) {
      switch (token.getTokenType()) {
        case TEXT:
          text((TextToken) token);
          break;

        case EXPANSION:
          expansion((ExpansionToken) token);
          break;

        case BODY:
          body();
          break;

        case START_ELEMENT:
          startElement((StartElementToken) token);
          break;

        case START_COMPONENT:
          startComponent((StartComponentToken) token);
          break;

        case ATTRIBUTE:
          attribute((AttributeToken) token);
          break;

        case END_ELEMENT:
          endElement();
          break;

        case COMMENT:
          comment((CommentToken) token);
          break;

        case BLOCK:
          block((BlockToken) token);
          break;

        case PARAMETER:
          parameter((ParameterToken) token);
          break;

        case DTD:
          dtd((DTDToken) token);
          break;

        case DEFINE_NAMESPACE_PREFIX:
          defineNamespacePrefix((DefineNamespacePrefixToken) token);
          break;

        case CDATA:
          cdata((CDATAToken) token);
          break;

        default:
          throw new IllegalStateException("Not implemented yet: " + token);
      }
    }

    // For neatness / symmetry:

    bodyPageElementStack.pop(); // the shunt

    // TODO: Check that all stacks are empty. That should never happen, as long
    // as the ComponentTemplate is valid.
  }

  /**
   * Returns a pseudo-set (a case insensitive map where the values are always true) for all the
   * embedded component ids in the component.
   *
   * @param componentModel
   * @return map whose keys are the embedded component ids
   */
  private Map<String, Boolean> collectedEmbeddedComponentIds(ComponentModel componentModel) {
    Map<String, Boolean> result = CollectionFactory.newCaseInsensitiveMap();

    for (String id : componentModel.getEmbeddedComponentIds()) result.put(id, true);

    return result;
  }

  private void cdata(CDATAToken token) {
    final String content = token.getContent();

    PageElement element =
        new PageElement() {
          public void render(MarkupWriter writer, RenderQueue queue) {
            writer.cdata(content);
          }
        };

    addToBody(element);
  }

  private void defineNamespacePrefix(final DefineNamespacePrefixToken token) {
    PageElement element =
        new PageElement() {
          public void render(MarkupWriter writer, RenderQueue queue) {
            writer.defineNamespace(token.getNamespaceURI(), token.getNamespacePrefix());
          }
        };

    addToBody(element);
  }

  private void parameter(ParameterToken token) {
    ComponentPageElement element = activeElementStack.peek();
    String name = token.getName();

    BlockImpl block =
        new BlockImpl(
            token.getLocation(), String.format("Parmeter %s of %s", name, element.getCompleteId()));

    Binding binding = new LiteralBinding("block parameter " + name, block, token.getLocation());

    // TODO: Check that the t:parameter doesn't appear outside of an embedded component.

    element.bindParameter(name, binding);

    setupBlock(block);
  }

  private void setupBlock(BodyPageElement block) {
    bodyPageElementStack.push(block);

    Runnable cleanup =
        new Runnable() {
          public void run() {
            bodyPageElementStack.pop();
          }
        };

    configureEnd(true, cleanup);
  }

  private void block(BlockToken token) {

    String id = token.getId();
    // Don't use the page element factory here becauses we need something that is both Block and
    // BodyPageElement and don't want to use casts.

    String description =
        id == null
            ? String.format("Anonymous within %s", loadingElement.getCompleteId())
            : String.format("%s within %s", id, loadingElement.getCompleteId());

    BlockImpl block = new BlockImpl(token.getLocation(), description);

    if (id != null) loadingElement.addBlock(id, block);

    setupBlock(block);
  }

  private void startComponent(StartComponentToken token) {
    String elementName = token.getElementName();

    // Initial guess: the type from the token (but this may be null in many cases).
    String embeddedType = token.getComponentType();

    // This may be null for an anonymous component.
    String embeddedId = token.getId();

    String embeddedComponentClassName = null;

    final EmbeddedComponentModel embeddedModel =
        embeddedId == null ? null : loadingComponentModel.getEmbeddedComponentModel(embeddedId);

    // We know that if embeddedId is null, embeddedType is not.

    if (embeddedId == null) embeddedId = generateEmbeddedId(embeddedType, idAllocator);

    if (embeddedModel != null) {
      String modelType = embeddedModel.getComponentType();

      if (InternalUtils.isNonBlank(modelType) && embeddedType != null)
        throw new TapestryException(
            ServicesMessages.compTypeConflict(embeddedId, embeddedType, modelType), token, null);

      embeddedType = modelType;
      embeddedComponentClassName = embeddedModel.getComponentClassName();
    }

    // We only have the embeddedModel if the embeddedId was specified.  If embeddedType was ommitted
    // and

    if (InternalUtils.isBlank(embeddedType) && embeddedModel == null)
      throw new TapestryException(
          ServicesMessages.noTypeForEmbeddedComponent(
              embeddedId, loadingComponentModel.getComponentClassName()),
          token,
          null);

    final ComponentPageElement newComponent =
        pageElementFactory.newComponentElement(
            page,
            loadingElement,
            embeddedId,
            embeddedType,
            embeddedComponentClassName,
            elementName,
            token.getLocation());

    addMixinsToComponent(newComponent, embeddedModel, token.getMixins());

    final Map<String, Binding> newComponentBindings = CollectionFactory.newMap();
    componentIdToBindingMap.put(newComponent.getCompleteId(), newComponentBindings);

    if (embeddedModel != null)
      bindParametersFromModel(embeddedModel, loadingElement, newComponent, newComponentBindings);

    addToBody(newComponent);

    // Remember to load the template for this new component
    componentQueue.push(newComponent);

    // Any attribute tokens that immediately follow should be
    // used to bind parameters.

    addAttributesAsComponentBindings = true;

    // Any attributes (including component parameters) that come up belong on this component.

    activeElementStack.push(newComponent);

    // Set things up so that content inside the component is added to the component's body.

    bodyPageElementStack.push(newComponent);

    // And clean that up when the end element is reached.

    final ComponentModel newComponentModel =
        newComponent.getComponentResources().getComponentModel();

    // If the component was from an embedded @Component annotation, and it is inheritting informal
    // parameters,
    // and the component in question supports informal parameters, than get those inheritted
    // informal parameters ...
    // but later (this helps ensure that <t:parameter> elements that may provide informal parameters
    // are
    // visible when the informal parameters are copied to the child component).

    if (embeddedModel != null
        && embeddedModel.getInheritInformalParameters()
        && newComponentModel.getSupportsInformalParameters()) {
      final ComponentPageElement loadingElement = this.loadingElement;

      Runnable finalizer =
          new Runnable() {
            public void run() {
              handleInformalParameters(
                  loadingElement,
                  embeddedModel,
                  newComponent,
                  newComponentModel,
                  newComponentBindings);
            }
          };

      finalization.add(finalizer);
    }

    Runnable cleanup =
        new Runnable() {
          public void run() {
            // May need a separate queue for this, to execute at the very end of page loading.

            activeElementStack.pop();
            bodyPageElementStack.pop();
          }
        };

    // The start tag is not added to the body of the component, so neither should
    // the end tag.
    configureEnd(true, cleanup);
  }

  /**
   * Invoked when a component's end tag is reached, to check and process informal parameters as per
   * the {@link org.apache.tapestry5.model.EmbeddedComponentModel#getInheritInformalParameters()}
   * flag.
   *
   * @param loadingComponent the container component that was loaded
   * @param model
   * @param newComponent
   * @param newComponentBindings
   */
  private void handleInformalParameters(
      ComponentPageElement loadingComponent,
      EmbeddedComponentModel model,
      ComponentPageElement newComponent,
      ComponentModel newComponentModel,
      Map<String, Binding> newComponentBindings) {

    Map<String, Binding> informals = loadingComponent.getInformalParameterBindings();

    for (String name : informals.keySet()) {
      if (newComponentModel.getParameterModel(name) != null) continue;

      Binding binding = informals.get(name);

      newComponent.bindParameter(name, binding);
      newComponentBindings.put(name, binding);
    }
  }

  private void startElement(StartElementToken token) {
    PageElement element = new StartElementPageElement(token.getNamespaceURI(), token.getName());

    addToBody(element);

    // Controls how attributes are interpretted.
    addAttributesAsComponentBindings = false;

    // Index will be matched by end:

    // Do NOT discard the end tag; add it to the body.

    configureEnd(false, NO_OP);
  }

  private void text(TextToken token) {
    PageElement element = new TextPageElement(token.getText());

    addToBody(element);
  }

  private void dtd(DTDToken token) {
    // first DTD encountered wins.
    if (dtdAdded) return;

    PageElement element =
        new DTDPageElement(token.getName(), token.getPublicId(), token.getSystemId());
    // since rendering via the markup writer is to the document tree,
    // we don't really care where this gets placed in the tree; the
    // DTDPageElement will set the dtd of the document directly, rather than
    // writing anything to the markup writer
    page.getRootElement().addToTemplate(element);

    dtdAdded = true;
  }

  /** Works the component queue, until exausted. */
  private void workComponentQueue() {
    while (!componentQueue.isEmpty()) {
      ComponentPageElement componentElement = componentQueue.pop();

      loadTemplateForComponent(componentElement);
    }
  }
}