コード例 #1
0
  private String compare(Node actual, Node expected) {
    List<Node> actualChildren =
        CorePlugin.getInstance()
            .getNodeService()
            .getChildren(actual, new ServiceContext<>(CorePlugin.getInstance().getNodeService()));
    List<Node> expectedChildren =
        CorePlugin.getInstance()
            .getNodeService()
            .getChildren(expected, new ServiceContext<>(CorePlugin.getInstance().getNodeService()));

    // check number of children
    if (actualChildren.size() != expectedChildren.size()) {
      return ResourcesPlugin.getInstance()
          .getMessage(
              "regex.test.compare.result.error.childrenCount", actual.getPropertyValue(NAME));
    }

    for (int i = 0; i < actualChildren.size(); i++) {
      Node actualChild = actualChildren.get(i);
      Node expectedChild = expectedChildren.get(i);
      // compare child properties
      String propertiesCompare = compareProperties(actualChild, expectedChild);
      if (propertiesCompare != null) {
        return propertiesCompare;
      }
      // recurse
      String childrenCompare = compare(actualChild, expectedChild);
      if (childrenCompare != null) {
        return childrenCompare;
      }
    }
    return null;
  }
コード例 #2
0
  private Node createResourceRoot(Node technology, String resourceName, String testResourceUri) {
    NodeService nodeService = CorePlugin.getInstance().getNodeService();

    // create resource file
    ServiceContext<NodeService> context = new ServiceContext<NodeService>(nodeService);
    context.getContext().put(NAME, resourceName);
    context.getContext().put(CoreConstants.FILE_IS_DIRECTORY, false);
    context.getContext().put(CoreConstants.OVERWRITE_IF_NECESSARY, true);
    Node resourceNode = new Node(null, CoreConstants.FILE_NODE_TYPE);
    nodeService.addChild(technology, resourceNode, context);

    // subscribe to resource
    String matchUri = resourceNode.getNodeUri().replaceFirst(FILE_SCHEME, "fpp");
    new ResourceServiceRemote().subscribeToParentResource(matchUri);

    CorePlugin.getInstance()
        .getResourceSetService()
        .reload(matchUri, new ServiceContext<ResourceSetService>());
    Node root = CorePlugin.getInstance().getResourceService().getNode(matchUri);
    nodeService.setProperty(
        root, RESOURCE_URI, testResourceUri, new ServiceContext<NodeService>(nodeService));
    nodeService.setProperty(
        root, SHOW_GROUPED_BY_REGEX, false, new ServiceContext<NodeService>(nodeService));
    return root;
  }
コード例 #3
0
  /**
   * @param nodeUri
   * @throws Exception
   * @author Elena Posea
   * @author Mariana Gheorghe
   */
  public void generateMatches(String nodeUri, boolean all) throws Exception {
    IFileAccessController fileController = FileControllerUtils.getFileAccessController();

    // get repo and technology from node
    VirtualNodeResourceHandler virtualNodeHandler =
        CorePlugin.getInstance().getVirtualNodeResourceHandler();
    String repo = Utils.getRepo(nodeUri);
    String[] typeSpecificPart =
        virtualNodeHandler.getTypeSpecificPartFromNodeUri(nodeUri).split("\\$");
    String technology = typeSpecificPart[0];
    String regexUri =
        FileControllerUtils.createFileNodeUri(
            repo, REGEX_CONFIGS_FOLDER + "/" + technology + "/" + REGEX_CONFIG_FILE);
    regexUri = regexUri.replaceFirst(CoreConstants.FILE_SCHEME, "fpp");

    // get regex configuration file
    new ResourceServiceRemote().subscribeToParentResource(regexUri);
    Node regex = CorePlugin.getInstance().getResourceService().getResourceNode(regexUri);

    // create regEx configuration
    RegexConfiguration regexConfig = new RegexConfiguration();
    new ConfigProcessor().processConfigHierarchy(regex, regexConfig);

    regexConfig.compile(Pattern.DOTALL);

    String technologyPath = REGEX_CONFIGS_FOLDER + "/" + technology;
    Node technologyNode =
        CorePlugin.getInstance()
            .getResourceService()
            .getNode(FileControllerUtils.createFileNodeUri(repo, technologyPath));
    if (all) {
      // parse files contained in the test files directory
      Object file = fileController.getFile(FileControllerUtils.getFilePathWithRepo(regex));
      Object parentFile = fileController.getParentFile(file);
      Object testFilesFolder = fileController.getFile(parentFile, REGEX_TEST_FILES_FOLDER);
      List<Object> testFiles = getTestFiles(testFilesFolder);
      for (Object testFile : testFiles) {
        String relativePath = fileController.getPathRelativeToFile(testFile, testFilesFolder);
        parseFile(technologyNode, testFile, relativePath, regex, regexConfig);
      }
    } else {
      // parse only selected file
      String relativePath = typeSpecificPart[1];
      Object testFile =
          fileController.getFile(
              repo + "/" + technologyPath + "/" + REGEX_TEST_FILES_FOLDER + "/" + relativePath);
      parseFile(technologyNode, testFile, relativePath, regex, regexConfig);
    }
  }
コード例 #4
0
  private String compareForTestFile(String testFileUri, String actual, String expected) {
    String actualNodeUri = testFileUri.replaceFirst(REGEX_TEST_FILE_NODE_TYPE, actual);
    String expectedNodeUri = testFileUri.replaceFirst(REGEX_TEST_FILE_NODE_TYPE, expected);

    ResourceServiceRemote rsr = new ResourceServiceRemote();
    rsr.subscribeToParentResource(actualNodeUri);
    rsr.subscribeToParentResource(expectedNodeUri);

    Node actualNode = CorePlugin.getInstance().getResourceService().getNode(actualNodeUri);
    Node expectedNode = CorePlugin.getInstance().getResourceService().getNode(expectedNodeUri);
    String result = compare(actualNode, expectedNode);
    return result != null
        ? result
        : ResourcesPlugin.getInstance().getMessage("regex.test.compare.result.ok");
  }
コード例 #5
0
  /**
   * @param nodeUri
   * @return compare results
   * @throws Exception
   * @author Elena Posea
   */
  public String testMatchesForAll(String nodeUri) {
    VirtualNodeResourceHandler virtualNodeHandler =
        CorePlugin.getInstance().getVirtualNodeResourceHandler();
    String technology = virtualNodeHandler.getTypeSpecificPartFromNodeUri(nodeUri);
    String repo = CoreUtils.getRepoFromNodeUri(nodeUri);
    String compareResult = "";

    String testFilesNodeUri =
        virtualNodeHandler.createVirtualNodeUri(repo, REGEX_TEST_FILES_NODE_TYPE, technology);
    Node testFilesNode = CorePlugin.getInstance().getResourceService().getNode(testFilesNodeUri);
    List<Node> testFilesNodeChildren =
        CorePlugin.getInstance()
            .getNodeService()
            .getChildren(
                testFilesNode, new ServiceContext<>(CorePlugin.getInstance().getNodeService()));

    for (Node testFileNode : testFilesNodeChildren) {
      compareResult += compareForTestFile(testFileNode);
    }
    return compareResult;
  }
コード例 #6
0
  @SuppressWarnings({"unchecked", "rawtypes"})
  private void parseFile(
      Node technology,
      Object testFile,
      String testFilePath,
      Node regex,
      RegexConfiguration regexConfig)
      throws Exception {
    NodeService nodeService = CorePlugin.getInstance().getNodeService();
    IFileAccessController fileController = FileControllerUtils.getFileAccessController();

    // get test file node and test file resource uri
    Node testNode =
        CorePlugin.getInstance()
            .getResourceService()
            .getNode(
                FileControllerUtils.createFileNodeUri(
                    Utils.getRepo(technology.getNodeUri()), fileController.getPath(testFile)));
    List subscribableResources =
        (List) testNode.getPropertyValue(CoreConstants.SUBSCRIBABLE_RESOURCES);
    String testResourceUri = (String) ((Pair) subscribableResources.get(0)).a;

    // start session
    String testFileContent = IOUtils.toString((InputStream) fileController.getContent(testFile));
    RegexProcessingSession session = regexConfig.startSession(testFileContent);

    // prepare to collect model tree
    Node resultRoot =
        createResourceRoot(
            technology,
            String.format(REGEX_RESULT_FILES_FOLDER + "/%s.result", testFilePath),
            testResourceUri);
    ArrayList<Object> stateStack = new ArrayList<Object>();
    stateStack.add(0, new State(0, resultRoot));
    session.context.put(CodeSyncRegexConstants.STATE_STACK, stateStack);

    // prepare to collect match tree
    Node matchRoot =
        createResourceRoot(
            technology,
            String.format(REGEX_MATCH_FILES_FOLDER + "/%s.regexMatches", testFilePath),
            testResourceUri);
    session.find(new CodeSyncRegexMatcher(nodeService, session, testFileContent, matchRoot));

    // everything worked ok => save matches and result
    CorePlugin.getInstance()
        .getResourceService()
        .save(
            matchRoot.getNodeUri(),
            new ServiceContext<ResourceService>(CorePlugin.getInstance().getResourceService()));
    CorePlugin.getInstance()
        .getResourceService()
        .save(
            resultRoot.getNodeUri(),
            new ServiceContext<ResourceService>(CorePlugin.getInstance().getResourceService()));
  }
コード例 #7
0
  /**
   * @param folder
   * @return a list of all files in that folder
   */
  public List<Object> getTestFiles(Object folder) {
    IFileAccessController controller = CorePlugin.getInstance().getFileAccessController();
    Object[] files = controller.listFiles(folder);
    if (files == null) {
      return Collections.emptyList();
    }

    List<Object> result = new ArrayList<Object>();
    for (Object file : files) {
      if (controller.isDirectory(file)) {
        // recurse for directories
        result.addAll(getTestFiles(file));
      } else {
        // keep child file
        result.add(file);
      }
    }
    return result;
  }
コード例 #8
0
  private String compareProperties(Node actual, Node expected) {
    // check type
    if (!actual.getType().equals(expected.getType())) {
      return ResourcesPlugin.getInstance()
          .getMessage("regex.test.compare.result.eror.type", actual.getPropertyValue(NAME));
    }

    // check properties
    ServiceContext<NodeService> context =
        new ServiceContext<>(CorePlugin.getInstance().getNodeService());
    Map<String, Object> expectedProperties = expected.getOrPopulateProperties(context);
    Map<String, Object> actualProperties = actual.getOrPopulateProperties(context);

    // check properties size
    if (actualProperties.size() != expectedProperties.size()) {
      return ResourcesPlugin.getInstance()
          .getMessage(
              "regex.test.compare.result.error.propertiesCount", actual.getPropertyValue(NAME));
    }

    // iterate properties
    for (Entry<String, Object> entry : expectedProperties.entrySet()) {
      if (!actualProperties.containsKey(entry.getKey())) {
        return ResourcesPlugin.getInstance()
            .getMessage(
                "regex.test.compare.result.propertyNotFound",
                entry.getKey(),
                actual.getPropertyValue(NAME));
      }
      Object expectedPropertyValue = entry.getValue();
      Object actualPropertyValue = actualProperties.get(entry.getKey());
      if (!Utils.safeEquals(actualPropertyValue, expectedPropertyValue)) {
        return ResourcesPlugin.getInstance()
            .getMessage(
                "regex.test.compare.result.error.propertyValue",
                entry.getKey(),
                actual.getPropertyValue(NAME),
                expectedPropertyValue,
                actualPropertyValue);
      }
    }
    return null;
  }
コード例 #9
0
 /**
  * @param nodeUri
  * @return compare results
  * @throws Exception
  * @author Elena Posea
  */
 public String testMatchesForSelection(String testFileUri) {
   return compareForTestFile(CorePlugin.getInstance().getResourceService().getNode(testFileUri));
 }