Exemplo n.º 1
0
  /**
   * @param project
   * @param attInfo
   * @param counter
   */
  public static String createDefaultName(IProject project, ISchemaAttribute attInfo, int counter) {
    if (attInfo.getType().getName().equals("boolean")) // $NON-NLS-1$
    return "true"; //$NON-NLS-1$

    String tag = attInfo.getParent().getName();
    return project.getName() + "." + tag + counter; // $NON-NLS-1$
  }
  private void validateExtensionAttribute(Element element, Attr attr, ISchemaAttribute attInfo) {
    ISchemaSimpleType type = attInfo.getType();

    int kind = attInfo.getKind();
    if (kind == IMetaAttribute.JAVA) {
      validateJavaAttribute(element, attr);
    } else if (kind == IMetaAttribute.RESOURCE) {
      validateResourceAttribute(element, attr);
    } else if (kind == IMetaAttribute.IDENTIFIER) {
      validateIdentifierAttribute(element, attr, attInfo);
    } else if (kind == IMetaAttribute.STRING) {
      ISchemaRestriction restriction = type.getRestriction();
      if (restriction != null) {
        validateRestrictionAttribute(element, attr, restriction);
      }
    } else if (type.getName().equals("boolean")) { // $NON-NLS-1$
      validateBoolean(element, attr);
    }

    validateTranslatableString(element, attr, attInfo.isTranslatable());

    if (attInfo.isDeprecated()) {
      reportDeprecatedAttribute(element, attr);
    }
  }
Exemplo n.º 3
0
 /**
  * Creates a default class name including package prefix. Uses the schema attribute to determine a
  * default name, prepends a default package name based on the project and appends the counter if
  * more than one such class exists.
  *
  * @param project project that the class name is being generated for
  * @param attInfo the schema attribute describing the new class
  * @param counter used to make each generated name unique
  */
 public static String createDefaultClassName(
     IProject project, ISchemaAttribute attInfo, int counter) {
   String tag = attInfo.getParent().getName();
   String expectedType = attInfo.getBasedOn();
   String className = ""; // $NON-NLS-1$
   if (expectedType == null) {
     StringBuffer buf = new StringBuffer(tag);
     buf.setCharAt(0, Character.toUpperCase(tag.charAt(0)));
     className = buf.toString();
   } else {
     className = expectedType;
     int dotLoc = className.lastIndexOf('.');
     if (dotLoc != -1) className = className.substring(dotLoc + 1);
     if (className.length() > 2
         && className.charAt(0) == 'I'
         && Character.isUpperCase(className.charAt(1))) className = className.substring(1);
   }
   String packageName = createDefaultPackageName(project, className);
   className += counter;
   return packageName + "." + className; // $NON-NLS-1$
 }
 private void validateIdentifierAttribute(Element element, Attr attr, ISchemaAttribute attInfo) {
   int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_IDENTIFIER);
   if (severity != CompilerFlags.IGNORE) {
     String value = attr.getValue();
     String basedOn = attInfo.getBasedOn();
     // only validate if we have a valid value and basedOn value
     if (value != null && basedOn != null && value.length() > 0 && basedOn.length() > 0) {
       Map attributes = PDESchemaHelper.getValidAttributes(attInfo);
       if (!attributes.containsKey(value)) { // report error if we are missing something
         report(
             NLS.bind(
                 MDECoreMessages.ExtensionsErrorReporter_unknownIdentifier,
                 (new String[] {attr.getValue(), attr.getName()})),
             getLine(element, attr.getName()),
             severity,
             MDEMarkerFactory.CAT_OTHER);
       }
     }
   }
 }
  private void validateRequiredExtensionAttributes(Element element, ISchemaElement schemaElement) {
    int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_NO_REQUIRED_ATT);
    if (severity == CompilerFlags.IGNORE) return;

    ISchemaAttribute[] attInfos = schemaElement.getAttributes();
    for (int i = 0; i < attInfos.length; i++) {
      ISchemaAttribute attInfo = attInfos[i];
      if (attInfo.getUse() == ISchemaAttribute.REQUIRED) {
        boolean found = element.getAttributeNode(attInfo.getName()) != null;
        if (!found && attInfo.getKind() == IMetaAttribute.JAVA) {
          NodeList children = element.getChildNodes();
          for (int j = 0; j < children.getLength(); j++) {
            if (attInfo.getName().equals(children.item(j).getNodeName())) {
              found = true;
              break;
            }
          }
        }
        if (!found) {
          reportMissingRequiredAttribute(element, attInfo.getName(), severity);
        }
      }
    }
  }
  protected void validateElement(Element element, ISchema schema, boolean isTopLevel) {
    String elementName = element.getNodeName();
    ISchemaElement schemaElement = schema.findElement(elementName);

    // Validate element occurrence violations
    if ((schemaElement != null) && (schemaElement.getType() instanceof ISchemaComplexType)) {
      validateMaxElementMult(element, schemaElement);
      validateMinElementMult(element, schemaElement);
    }

    ISchemaElement parentSchema = null;
    if (!"extension".equals(elementName)) { // $NON-NLS-1$
      Node parent = element.getParentNode();
      parentSchema = schema.findElement(parent.getNodeName());
    } else if (isTopLevel == false) {
      // This is an "extension" element; but, not a top level one.
      // It is nested within another "extension" element somewhere
      // e.g. "extension" element is a child element of another element
      // that is not a "plugin" elment
      // element
      // Report illegal element
      int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ELEMENT);
      reportIllegalElement(element, severity);
      return;
    }

    if (parentSchema != null) {
      int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ELEMENT);
      if (severity != CompilerFlags.IGNORE) {
        HashSet allowedElements = new HashSet();
        computeAllowedElements(parentSchema.getType(), allowedElements);
        if (!allowedElements.contains(elementName)) {
          reportIllegalElement(element, severity);
          return;
        }
      }
    }
    if (schemaElement == null && parentSchema != null) {
      ISchemaAttribute attr = parentSchema.getAttribute(elementName);
      if (attr != null && attr.getKind() == IMetaAttribute.JAVA) {
        if (attr.isDeprecated())
          reportDeprecatedAttribute(element, element.getAttributeNode("class")); // $NON-NLS-1$
        validateJavaAttribute(element, element.getAttributeNode("class")); // $NON-NLS-1$			
      }
    } else {
      if (schemaElement != null) {
        validateRequiredExtensionAttributes(element, schemaElement);
        validateExistingExtensionAttributes(element, element.getAttributes(), schemaElement);
        validateInternalExtensionAttribute(element, schemaElement);
        if (schemaElement.isDeprecated()) {
          if (schemaElement instanceof ISchemaRootElement)
            reportDeprecatedRootElement(
                element, ((ISchemaRootElement) schemaElement).getDeprecatedSuggestion());
          else reportDeprecatedElement(element);
        }
        if (schemaElement.hasTranslatableContent()) validateTranslatableElementContent(element);
        // Bug 213457 - look up elements based on the schema in which the parent is found
        schema = schemaElement.getSchema();
      }
      NodeList children = element.getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        validateElement((Element) children.item(i), schema, false);
      }
    }
  }