Exemplo n.º 1
0
  /**
   * React to change of a settable contained in the entity and update the entity's appearance.
   *
   * @param entity The entity that contains the settable.
   * @param settable The settable whose value is changed.
   * @see ptolemy.kernel.util.ValueListener#valueChanged(Settable)
   */
  public static void valueChanged(GTEntity entity, Settable settable) {
    GTIngredientsAttribute criteria = entity.getCriteriaAttribute();

    if (settable == criteria) {
      if (GTTools.isInPattern((NamedObj) entity)) {
        // criteria attribute is used to set the matching criteria for
        // this actor. It is used only for actors in the pattern of
        // a transformation rule. If the actor is in the
        // replacement, this attribute is ignored.
        entity.updateAppearance(criteria);

        // Update the appearance of corresponding entities in the
        // replacement.
        Pattern pattern = (Pattern) GTTools.getContainingPatternOrReplacement((NamedObj) entity);
        NamedObj container = pattern.getContainer();
        if (container instanceof TransformationRule) {
          Replacement replacement = ((TransformationRule) container).getReplacement();
          replacement.updateEntitiesAppearance(criteria);
        }
      }
    }
  }
Exemplo n.º 2
0
 /**
  * Copies single file from <code>src</code> to <code>dest</code>. If the file is source file,
  * variable references will be escaped, so they'll survive Velocity template merging.
  */
 private void copyFile(File src, File dest, Replacement replaceFn) throws IOException {
   if (replaceFn != null && isSourceFile(src)) {
     String original = FileUtils.readFileToString(src);
     String escapeDollarSquiggly = original;
     if (original.contains("${")) {
       String replaced = original.replaceAll(Pattern.quote("${"), "\\${D}{");
       // add Velocity expression at the beginning of the result file.
       // Velocity is used by mvn archetype:generate
       escapeDollarSquiggly = "#set( $D = '$' )\n" + replaced;
     }
     // do additional replacement
     String text = replaceFn.replace(escapeDollarSquiggly);
     FileUtils.write(dest, text);
   } else {
     if (LOG.isDebugEnabled()) {
       LOG.warn(
           "Not a source dir as the extension is {}", FilenameUtils.getExtension(src.getName()));
     }
     FileUtils.copyFile(src, dest);
   }
 }
Exemplo n.º 3
0
  /**
   * This method:
   *
   * <ul>
   *   <li>Copies POM from original project to archetype-resources
   *   <li>Generates <code></code>archetype-descriptor.xml</code>
   *   <li>Generates Archetype's <code>pom.xml</code> if not present in target directory.
   * </ul>
   *
   * @param projectPom POM file of original project
   * @param archetypeDir target directory of created Maven Archetype project
   * @param archetypePom created POM file for Maven Archetype project
   * @param metadataXmlOutFile generated archetype-metadata.xml file
   * @param replaceFn replace function
   * @throws IOException
   */
  private void createArchetypeDescriptors(
      File projectPom,
      File archetypeDir,
      File archetypePom,
      File metadataXmlOutFile,
      Replacement replaceFn)
      throws IOException {
    LOG.debug("Parsing " + projectPom);
    String text = replaceFn.replace(FileUtils.readFileToString(projectPom));

    // lets update the XML
    Document doc = archetypeUtils.parseXml(new InputSource(new StringReader(text)));
    Element root = doc.getDocumentElement();

    // let's get some values from the original project
    String originalArtifactId, originalName, originalDescription;
    Element artifactIdEl = (Element) findChild(root, "artifactId");

    Element nameEl = (Element) findChild(root, "name");
    Element descriptionEl = (Element) findChild(root, "description");
    if (artifactIdEl != null
        && artifactIdEl.getTextContent() != null
        && artifactIdEl.getTextContent().trim().length() > 0) {
      originalArtifactId = artifactIdEl.getTextContent().trim();
    } else {
      originalArtifactId = archetypeDir.getName();
    }
    if (nameEl != null
        && nameEl.getTextContent() != null
        && nameEl.getTextContent().trim().length() > 0) {
      originalName = nameEl.getTextContent().trim();
    } else {
      originalName = originalArtifactId;
    }
    if (descriptionEl != null
        && descriptionEl.getTextContent() != null
        && descriptionEl.getTextContent().trim().length() > 0) {
      originalDescription = descriptionEl.getTextContent().trim();
    } else {
      originalDescription = originalName;
    }

    Map<String, String> propertyNameSet = new LinkedHashMap<>();

    if (root != null) {
      // remove the parent element and the following text Node
      NodeList parents = root.getElementsByTagName("parent");
      if (parents.getLength() > 0) {
        if (parents.item(0).getNextSibling().getNodeType() == Node.TEXT_NODE) {
          root.removeChild(parents.item(0).getNextSibling());
        }
        root.removeChild(parents.item(0));
      }

      // lets load all the properties defined in the <properties> element in the pom.
      Map<String, String> pomProperties = new LinkedHashMap<>();

      NodeList propertyElements = root.getElementsByTagName("properties");
      if (propertyElements.getLength() > 0) {
        Element propertyElement = (Element) propertyElements.item(0);
        NodeList children = propertyElement.getChildNodes();
        for (int cn = 0; cn < children.getLength(); cn++) {
          Node e = children.item(cn);
          if (e instanceof Element) {
            pomProperties.put(e.getNodeName(), e.getTextContent());
          }
        }
      }
      if (LOG.isDebugEnabled()) {
        for (Map.Entry<String, String> entry : pomProperties.entrySet()) {
          LOG.debug("pom property: {}={}", entry.getKey(), entry.getValue());
        }
      }

      // lets find all the property names
      NodeList children = root.getElementsByTagName("*");
      for (int cn = 0; cn < children.getLength(); cn++) {
        Node e = children.item(cn);
        if (e instanceof Element) {
          // val text = e.childrenText
          String cText = e.getTextContent();
          String prefix = "${";
          if (cText.startsWith(prefix)) {
            int offset = prefix.length();
            int idx = cText.indexOf("}", offset + 1);
            if (idx > 0) {
              String name = cText.substring(offset, idx);
              if (!pomProperties.containsKey(name) && isValidRequiredPropertyName(name)) {
                // use default value if we have one, but favor value from this pom over the bom pom
                String value = pomProperties.get(name);
                if (value == null) {
                  value = versionProperties.get(name);
                }
                propertyNameSet.put(name, value);
              }
            }
          }
        }
      }

      String profile = replaceNodeValue(doc, root, "fabric8.profile", "${fabric8-profile}");
      if (profile != null) {
        // we do not want a default name for the profile as the end user should be able to set that
        // value
        // and use fabric8-profile as key as there is a problem when using fabric8.profile
        propertyNameSet.put("fabric8-profile", null);
      }

      // now lets replace the contents of some elements (adding new elements if they are not
      // present)
      List<String> beforeNames =
          Arrays.asList(
              "artifactId", "version", "packaging", "name", "properties", "fabric8-profile");
      replaceOrAddElementText(doc, root, "version", "${version}", beforeNames);
      replaceOrAddElementText(doc, root, "artifactId", "${artifactId}", beforeNames);
      replaceOrAddElementText(doc, root, "groupId", "${groupId}", beforeNames);
    }
    archetypePom.getParentFile().mkdirs();

    // remove copyright header which is the first comment, as we do not want that in the archetypes
    removeCommentNodes(doc);

    archetypeUtils.writeXmlDocument(doc, archetypePom);

    // lets update the archetype-metadata.xml file
    String archetypeXmlText = defaultArchetypeXmlText();

    Document archDoc = archetypeUtils.parseXml(new InputSource(new StringReader(archetypeXmlText)));
    Element archRoot = archDoc.getDocumentElement();

    // replace @name attribute on root element
    archRoot.setAttribute("name", archetypeDir.getName());

    LOG.debug(("Found property names: {}"), propertyNameSet);
    // lets add all the properties
    Element requiredProperties =
        replaceOrAddElement(archDoc, archRoot, "requiredProperties", Arrays.asList("fileSets"));

    // lets add the various properties in
    for (Map.Entry<String, String> entry : propertyNameSet.entrySet()) {
      requiredProperties.appendChild(archDoc.createTextNode("\n" + indent + indent));
      Element requiredProperty = archDoc.createElement("requiredProperty");
      requiredProperties.appendChild(requiredProperty);
      requiredProperty.setAttribute("key", entry.getKey());
      if (entry.getValue() != null) {
        requiredProperty.appendChild(archDoc.createTextNode("\n" + indent + indent + indent));
        Element defaultValue = archDoc.createElement("defaultValue");
        requiredProperty.appendChild(defaultValue);
        defaultValue.appendChild(archDoc.createTextNode(entry.getValue()));
      }
      requiredProperty.appendChild(archDoc.createTextNode("\n" + indent + indent));
    }
    requiredProperties.appendChild(archDoc.createTextNode("\n" + indent));

    metadataXmlOutFile.getParentFile().mkdirs();
    archetypeUtils.writeXmlDocument(archDoc, metadataXmlOutFile);

    File archetypeProjectPom = new File(archetypeDir, "pom.xml");
    // now generate Archetype's pom
    if (!archetypeProjectPom.exists()) {
      StringWriter sw = new StringWriter();
      IOUtils.copy(getClass().getResourceAsStream("default-archetype-pom.xml"), sw, "UTF-8");
      Document pomDocument =
          archetypeUtils.parseXml(new InputSource(new StringReader(sw.toString())));

      List<String> emptyList = Collections.emptyList();

      // artifactId = original artifactId with "-archetype"
      Element artifactId =
          replaceOrAddElement(
              pomDocument, pomDocument.getDocumentElement(), "artifactId", emptyList);
      artifactId.setTextContent(archetypeDir.getName());

      // name = "Fabric8 :: Qickstarts :: xxx" -> "Fabric8 :: Archetypes :: xxx"
      Element name =
          replaceOrAddElement(pomDocument, pomDocument.getDocumentElement(), "name", emptyList);
      if (originalName.contains(" :: ")) {
        String[] originalNameTab = originalName.split(" :: ");
        if (originalNameTab.length > 2) {
          StringBuilder sb = new StringBuilder();
          sb.append("Fabric8 :: Archetypes");
          for (int idx = 2; idx < originalNameTab.length; idx++) {
            sb.append(" :: ").append(originalNameTab[idx]);
          }
          name.setTextContent(sb.toString());
        } else {
          name.setTextContent("Fabric8 :: Archetypes :: " + originalNameTab[1]);
        }
      } else {
        name.setTextContent("Fabric8 :: Archetypes :: " + originalName);
      }

      // description = "Creates a new " + originalDescription
      Element description =
          replaceOrAddElement(
              pomDocument, pomDocument.getDocumentElement(), "description", emptyList);
      description.setTextContent("Creates a new " + originalDescription);

      archetypeUtils.writeXmlDocument(pomDocument, archetypeProjectPom);
    }
  }
Exemplo n.º 4
0
 public static void main(String[] args) {
   Replacement test = new Replacement("Hello, World!", "keyword");
   System.out.println(test.getWord());
   System.out.println(test.decrypt());
   System.out.println(test.getKey());
 }