Parse nested child input paths
@param {Build} build
7940
function parseChildInputpaths(build) {
  function parse(build) {
    let inputpaths = [];

    build.forEach(build => {
      inputpaths = inputpaths.concat(build.inputpaths, build.builds ? parse(build.builds) : []);
    });

    return inputpaths;
  }

  build.childInputpaths = parse(build.builds);
}
5768
function tree() {
            var result = {
                name: 'root',
                children: []
            }

            function _parseChildren(parentClientId, children) {
                Util.each(CACHE, function(item) {
                    if (item.parentClientId === parentClientId) {
                        children.push({
                            name: item.moduleId + ',' + item.clientId,
                            module: item,
                            children: _parseChildren(item.clientId, [])
                        })
                    }
                })
                return children
            }

            _parseChildren(Constant.ROOT_CLIENT_ID, result.children)

            return result
        }
1020685
function parseData(options) {
  return readFileTree(options.src.data, options.keys.data, options);
}
630699
function deconstruct(paths) {
    var _paths = []

    paths.forEach(function (path) {
      var currentPath = null
      path.split('.').forEach(function (subpath) {
        currentPath = (currentPath ? (currentPath + '.') : '') + subpath.trim()
        _paths.push(currentPath)
      })
    })

    return _paths
  }
247875
function isPathChild(pathA, pathB) {
  const relPath = relative(normalizePath(pathA), normalizePath(pathB));
  return relPath === '..';
}
953521
def path_regex(self):
        """"""
        if self.locale_build:
            return self.build_list_regex

        return '%s/' % urljoin(self.build_list_regex, self.builds[self.build_index])
162706
function parse(tokens, basePath, iterSuffix) {
  const len = tokens.length;
  const body = [];

  let i = 0;
  while (i < len) {
    const token = tokens[i];
    if (subroutines[token.tokenType]) {
      const rest = tokens.slice(i + 1);
      const [
        branches,
        tokensHandled,
        shouldBreak,
      ] = subroutines[token.tokenType](token, rest, basePath, iterSuffix);

      body.push(...branches);

      i += tokensHandled;

      if (shouldBreak) {
        break;
      }
    } else {
      i += 1;
    }
  }

  return [body, i + 1];
}
1184739
function normalizePath (path, basePath) {
  var joined = nodepath.join(basePath || '/', path || '');
  var normalized = nodepath.normalize(joined);

  return (normalized !== '/' ? normalized : null);
}
570993
function buildPropertyPaths(oObject, sObjectName) {
				Object.keys(oObject).forEach(function (sProperty) {
					var sPropertyPath = _Helper.buildPath(sObjectName, sProperty),
						vPropertyValue = oObject[sProperty];

					if (sProperty === "@$ui5._") {
						return; // ignore private namespace
					}

					if (vPropertyValue !== null && typeof vPropertyValue === "object") {
						buildPropertyPaths(vPropertyValue, sPropertyPath);
					} else {
						aSelect.push(sPropertyPath);
					}
				});
			}
345559
public static List<ChildNumber> parsePath(@Nonnull String path) {
        String[] parsedNodes = path.replace("M", "").split("/");
        List<ChildNumber> nodes = new ArrayList<>();

        for (String n : parsedNodes) {
            n = n.replaceAll(" ", "");
            if (n.length() == 0) continue;
            boolean isHard = n.endsWith("H");
            if (isHard) n = n.substring(0, n.length() - 1);
            int nodeNumber = Integer.parseInt(n);
            nodes.add(new ChildNumber(nodeNumber, isHard));
        }

        return nodes;
    }
1329255
function getBuildFactory(build) {
  return function createBuild(inputpath, outputname) {
    const input = path.relative(process.cwd(), inputpath);
    let parent = build;

    if (!parent.builds.some(build => build.input == input)) {
      const outputpath = path.join(path.dirname(parent.outputpaths[0]), outputname);
      const buildConfig = {
        batch: parent.batch,
        boilerplate: false,
        bootstrap: false,
        browser: parent.browser,
        bundle: parent.bundle,
        fileCache: parent.fileCache,
        index: ++numBuilds,
        input,
        inputpaths: [inputpath],
        isAppServer: false,
        isDynamicBuild: true,
        label: '',
        level: parent.level + 1,
        output: path.relative(process.cwd(), path.dirname(outputpath)),
        outputpaths: [outputpath],
        parent,
        resolverCache: parent.resolverCache,
        runtimeOptions: parent.runtimeOptions,
        type: parent.type,
        watchOnly: parent.watchOnly
      };
      const build = buildFactory(buildConfig);

      build.fileFactoryOptions = getFileFactoryOptions(
        build,
        parent,
        null,
        null,
        Object.assign({}, parent.fileFactoryOptions)
      );
      build.fileFactory = build.fileFactoryOptions.fileFactory;
      parent.builds.push(build);
      parent.childInputpaths.push(inputpath);
    }

    // Find root build
    while (parent.parent)
      parent = parent.parent;
    parent.processFilesOptions.importBoilerplate = true;
  };
}
781902
function buildFlatSourcesObjectFromTreeObject(treeObject) {
  const currentOutputObject = Object.assign({});
  currentOutputObject[treeObject.path] = treeObject.source;

  Object.keys(treeObject.dependencies).forEach(dependantTreeObjectFileName => {
    Object.assign(currentOutputObject, buildFlatSourcesObjectFromTreeObject(treeObject.dependencies[dependantTreeObjectFileName]));
  });

  return currentOutputObject;
}
155994
function parsePlatformFilePath(
  filePath: string,
  platforms: Set<string>,
): PlatformFilePathParts {
  const dirPath = path.dirname(filePath);
  const fileName = path.basename(filePath);
  const match = fileName.match(PATH_RE);
  if (!match) {
    return {dirPath, baseName: fileName, platform: null, extension: null};
  }
  const extension = match[4] || null;
  const platform = match[3] || null;
  if (platform == null || platforms.has(platform)) {
    return {dirPath, baseName: match[1], platform, extension};
  }
  const baseName = `${match[1]}.${platform}`;
  return {dirPath, baseName, platform: null, extension};
}
86257
function childNodesFromPaths (files, parent, renderLabelFn, originalFiles, baseDir) {
  // Group by first path element
  var groups = _.groupBy(files, file => file.match(/^[^/]*\/?/))
  return Object.keys(groups).map(function (groupKey) {
    const group = groups[groupKey]
    // Is this group explicitly part of the result, or
    // just implicit through its children
    const explicit = group.indexOf(groupKey) >= 0
    let index = -1
    if (explicit) {
      index = originalFiles.indexOf(parent.replace(baseDir, '') + groupKey)
    }

    return {
      label: renderLabelFn(parent, groupKey, explicit, explicit ? index : -1),
      nodes: childNodesFromPaths(
        // Remove parent directory from file paths
        group
          .map(node => node.substr(groupKey.length))
          // Skip the empty path
          .filter(node => node),
        // New parent..., normalize to one trailing slash
        parent + groupKey,
        renderLabelFn,
        originalFiles,
        baseDir
      )
    }
  })
}
204591
function parseObject(obj, { name, path, subPaths, type, recursive = true, ...args }) {
    let property = get(obj, path);
    if (property === null || !validatePropertyType(property, type, recursive)) {
        return [];
    }
    if (type === 'uuidList' && isUuidList(property)) {
        return [{ [name]: property.split(',') }];
    }
    if (recursive && typeof property === 'object') {
        const propertyName = isNil(name) ? '' : name;
        const nextPaths = subPaths || Object.keys(property);
        return flatten(nextPaths
            .map(subPath => parseObject(obj, {
                name: `${propertyName}${subPath}`,
                path: `${path}.${subPath}`,
                recursive: false,
                type,
                ...args,
            })));
    }
    if (args.filterPattern) {
        property = typeof property === 'string' ? get(property.match(args.filterPattern), '[1]') : null;
    }
    if (args.hideUUID) {
        property = typeof property === 'string' ? property.replace(
            RegExp('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}', 'g'),
            '{uuid}',
        ) : null;
    }
    return property === null ? [] : [{ [name]: property }];
}
414527
function(path, definitions) {
    path = path.replace(/^#\/definitions\//, '').split('/');

    var find = function(path, root) {
      var key = path.shift();
      if (!root[key]) {
        return {};
      } else if (!path.length) {
        return root[key];
      } else {
        return find(path, root[key]);
      }
    };

    var result = find(path, definitions);

    if (!isObject(result)) {
      return result;
    }
    return cloneJSON(result);
  }
1239726
function parseObject (baseDbStructure, path, obj, parsed) {
  for (const [propertyId, property] of Object.entries(obj)) {
    const newPath = path ? path + '.' + propertyId : propertyId
    const meta = (newPath)

    if (meta.hasOwnProperty('type')) {
      parsed[meta.type + '.' + meta.id] = {
        base: dottie.get(baseDbStructure, newPath),
        target: property
      }
    }

    if (isObject(property) && !Array.isArray(property)) {
      parseObject(baseDbStructure, newPath, property, parsed)
    }
  }
}