return
	}
	if len(o.ParentPath) > 0 {
		o.ParentPath = append(o.ParentPath, ".")
	}
	o.ParentPath = append(o.ParentPath, key)
}

// AppendIndex adds an index to the most recent field of
// the current parent path, if TrackUnknownFieldPaths is true.
func (o *UnknownFieldPathOptions) AppendIndex(index int) {
	if !o.TrackUnknownFieldPaths {
		return
	}

				opts.ParentPath = opts.ParentPath[:origPathLen]
			} else if s.AdditionalProperties != nil {
				opts.AppendKey(k)
				prune(v, s.AdditionalProperties.Structural, opts)
				opts.ParentPath = opts.ParentPath[:origPathLen]
			}
		}
	case []interface{}:
		for i, v := range x {
			opts.AppendIndex(i)
			skipPrune(v, s.Items, opts)
			opts.ParentPath = opts.ParentPath[:origPathLen]
		}
	default:
		// scalars, do nothing

     * @param path Path of the file
     * @param parentPath RelativePath of the parent
     * @param attrs attributes of the path, null if not available
     * @param stopFlag transient flag to stop visiting
     * @param fileSystem for Chmod and Stat
     * @return FileVisitDetails
     */
    public static FileVisitDetails getFileVisitDetails(
        Path path,
        RelativePath parentPath,
        @Nullable BasicFileAttributes attrs,

					return err
				}
				opts.ParentPath = opts.ParentPath[:origPathLen]
			} else if s.AdditionalProperties != nil {
				opts.AppendKey(k)
				if err := c.coerce(pth.Key(k), v, s.AdditionalProperties.Structural, opts); err != nil {
					return err
				}
				opts.ParentPath = opts.ParentPath[:origPathLen]
			}
		}
	case []interface{}:
		for i, v := range x {

	cleanedPath := filepath.Clean(path)
	parentPath, _ := filepath.Split(cleanedPath)

	ws, workerExists := fw.workers[parentPath]
	if !workerExists {
		wk, err := newWorker(parentPath, fw.funcs)
		if err != nil {
			return nil, "", "", err
		}

		ws = &workerState{
			worker: wk,
		}

		fw.workers[parentPath] = ws
	}

	return ws, cleanedPath, parentPath, nil
}

    }

    private void ensureParentDirectoryExists(ChannelSftp channel, URI uri) {
        String parentPath = FilenameUtils.getFullPathNoEndSeparator(uri.getPath());
        if (parentPath.equals("/")) {
            return;
        }
        URI parent = uri.resolve(parentPath);

        try {
            channel.lstat(parentPath);
            return;
        } catch (com.jcraft.jsch.SftpException e) {

        childPaths.findAll { it.contains('/') } collectMany { childPath ->
            parentPaths(childPath).collect { parentPath ->
                new VirtualFileSystemTestSpec(childPaths, parentPath, findPathWithParent(childPaths, parentPath))
            }
        }
    }

    /**
     * The queried/updated path is one of the initial children of the node under test.
     *

        int nextIndex = 0;
        if (parentPath != null) {
            System.arraycopy(parentPath.segments, 0, newSegments, 0, parentPath.segments.length);
            nextIndex = parentPath.segments.length;
        }
        for (String segment : childSegments) {
            if (segment.equals(".")) {
                continue;
            }
            if (segment.equals("..")) {

		return
	}

	pathLen := len(c.parentPath)
	c.pushKey(field)
	errPath := strings.Join(c.parentPath, "")
	c.parentPath = c.parentPath[:pathLen]
	c.unknownFieldErrors = append(c.unknownFieldErrors, fmt.Errorf(`unknown field "%s"`, errPath))
}

func (c *fromUnstructuredContext) pushIndex(index int) {
	if !c.returnUnknownFields {
		return
	}

	c.parentPath = append(c.parentPath, "[", strconv.Itoa(index), "]")

        def project = projects.find {it.name == name}
        assert project != null :  "No project with name $name found"
        assertProject(project, rootDir, path, name, parentPath, childPaths)
     }

    private static void assertProject(def project, File rootDir, String path, String name, String parentPath, List<String> childPaths) {