For a single dot-delimited path like 'when.harry.met.sally', returns:

['when', 'when.harry', 'when.harry.met', 'when.harry.met.sally']

@param propertyPath A full dot-delimited path.
@returns {*}
356735
function pathAll(propertyPath) {
  return propertyPath.split('.').reduce((a, v, i) => {
    a[i] = i === 0 ? v : a[i-1] + '.' + v;
    return a;
  }, []);
}
247826
public static Object getProperty(Object bean, List<String> propertyPath) {
		Object current = bean;
		for (String propertyName : propertyPath) {
			if (current == null) {
				return null;
			}
			if (current instanceof Iterable) {
				// follow multi-valued property
				List<Object> result = new ArrayList<>();
				Iterable<?> iterable = (Iterable<?>) current;
				for (Object currentElem : iterable) {
					result.add(getProperty(currentElem, propertyName));
				}
				current = result;
			} else {
				// follow single-valued property
				current = getProperty(current, propertyName);
			}
		}
		return current;
	}
201346
function parseAttributePath(attrPath, context) {
    const parsed = attrPath.split('.');
    parsed.forEach(item => checkIdentifier(item, context));
    return parsed;
}
1318946
@NonNull
    private List<Mapping> getMappings(String httpPath) {
        List<Mapping> returned = new ArrayList<>();
        List<Path.Segment> httpSegments = Path.pathToList(httpPath);
        Map<Mapping, RequestHandler> mappings = getMappingMap();
        for (Mapping mapping : mappings.keySet()) {
            List<Path.Rule> paths = mapping.getPath().getRuleList();
            for (Path.Rule path : paths) {
                List<Path.Segment> segments = path.getSegments();
                if (httpSegments.size() != segments.size()) continue;

                String pathStr = Path.listToPath(segments);
                if (pathStr.equals(httpPath)) {
                    returned.add(mapping);
                    break; // Validate next mapping.
                }

                boolean matches = true;
                for (int i = 0; i < segments.size(); i++) {
                    Path.Segment segment = segments.get(i);
                    if (!segment.equals(httpSegments.get(i)) && !segment.isBlurred()) {
                        matches = false;
                        break;
                    }
                }
                if (matches) returned.add(mapping);
            }
        }
        return returned;
    }
574600
protected String getPropertyPath(Collection<String> parts) {

        StringBuilder propertyPath = new StringBuilder();
        Iterator<String> partsIterator = parts.iterator();
        propertyPath.append(partsIterator.next());
        while (partsIterator.hasNext())
            propertyPath.append(".").append(partsIterator.next());

        return propertyPath.toString();
    }
893111
private String pathToProperty(String path) {
        if (path == null || !path.startsWith("/")) {
            throw new IllegalArgumentException("Path must be prefixed with a \"/\".");
        }
        return path.substring(1);
    }
1237464
def getobjpath(obj, path):
    
    if not path:
        return obj
    if path.startswith("["):
        item = path[1:path.index("]")]
        return getobjpath(obj[item], path[len(item) + 2:])
    if path.startswith("."):
        path = path[1:]
    if "." in path or "[" in path:
        dot_idx = path.find(".")
        bracket_idx = path.find("[")
        if dot_idx == -1 or bracket_idx < dot_idx:
            idx = bracket_idx
            next_idx = idx
        else:
            idx = dot_idx
            next_idx = idx + 1
        attr = path[:idx]
        return getobjpath(getattr(obj, attr), path[next_idx:])
    return getattr(obj, path)
149868
protected int getLastPropertySeparatorIndex(String propertyPath) {
		boolean inKey = false;
		for (int i = propertyPath.length() - 1; i >= 0; i--) {
			switch (propertyPath.charAt(i)) {
			case PropertyAccessor.PROPERTY_KEY_SUFFIX_CHAR:
				inKey = true;
				break;
			case PropertyAccessor.PROPERTY_KEY_PREFIX_CHAR:
				return i;
			case PropertyAccessor.NESTED_PROPERTY_SEPARATOR_CHAR:
				if (!inKey) {
					return i;
				}
				break;
			}
		}
		return -1;
	}
35566
public Property getPropertyDefinition(String path)
    {
        final List /*<Property>*/ propertyList = getPropertyList();
        for (int i = 0; i < propertyList.size(); i++) {
            Property property = (Property) propertyList.get(i);
            if (property.getPath().equals(path)) {
                return property;
            }
        }
        return null;
    }
207201
function getFromPath(obj, path){
		path = path.split('.');

		for(var i = 0, l = path.length; i < l; i++){
			if (hasOwnProperty.call(obj, path[i]))
				obj = obj[path[i]];
			
			else
				return undefined;
		}
		
		return obj;
	}
107288
function extractNormalizedKeys(path) {
    const props = path.node.properties;
    const keys = [];
    let allLiteral = true;

    for (const prop of props) {
      if (t.isIdentifier(prop.key) && !prop.computed) {
        // since a key {a: 3} is equivalent to {"a": 3}, use the latter
        keys.push(t.stringLiteral(prop.key.name));
      } else if (t.isTemplateLiteral(prop.key)) {
        keys.push(t.cloneNode(prop.key));
      } else if (t.isLiteral(prop.key)) {
        keys.push(t.stringLiteral(String(prop.key.value)));
      } else {
        keys.push(t.cloneNode(prop.key));
        allLiteral = false;
      }
    }

    return { keys, allLiteral };
  }
465204
function isObjectMemberProperty(path) {
  return (
    t.isMemberExpression(path.parent) &&
    path.parentPath.get('property') === path
  );
}
996964
function getPropertyOfPath(obj, path) {
    const [child, last] = getLeafOfPath(obj, path, false);
    return child && last ? child[last] : undefined;
}
249469
@SuppressWarnings("unchecked")
    public static <X, Y> PropertyPathExpression<X, Y> getExpression(
            Class<X> source, String propertyPath, Class<Y> valueClass) {
        final PropertyPathExpressionKey key = new PropertyPathExpressionKey(
                source, propertyPath);
        PropertyPathExpression<Object, Object> expression = cache.get(key);

        if (expression == null) {
            expression = new PropertyPathExpression<Object, Object>(
                    (Class<Object>) source, propertyPath);
            final PropertyPathExpression<Object, Object> oldExpression = cache
                    .putIfAbsent(key, expression);

            if (oldExpression != null) {
                expression = oldExpression;
            }
        }

        return (PropertyPathExpression<X, Y>) expression;
    }
745450
private function decodePropertyPaths($propertyPathString)
    {
        $paths = array();
        foreach (explode('/', trim($propertyPathString, '/')) as $path) {
            $path = $this->decodePath($path);
            if (is_string($path) && '' !== $path) {
                $paths[] = $path;
            }
        }

        return $paths;
    }
89431
private static String[] toRealPath(Config config, String dotPath) throws ExpressionException {
	dotPath = dotPath.trim();

	while (dotPath.indexOf('.') == 0) {
	    dotPath = dotPath.substring(1);
	}
	int len = -1;
	while ((len = dotPath.length()) > 0 && dotPath.lastIndexOf('.') == len - 1) {
	    dotPath = dotPath.substring(0, len - 2);
	}
	return CustomTagUtil.getFileNames(config, dotPath.replace('.', '/'));
    }
65696
function getNameForPath(path: Path): string {
  const {node, parent, parentPath} = path;
  if (t.isProgram(node)) {
    return '<global>';
  }
  let {id} = path;
  // has an `id` so we don't need to infer one
  if (node.id) {
    return node.id.name;
  }
  let propertyPath;
  let kind = '';
  if (t.isObjectMethod(node) || t.isClassMethod(node)) {
    id = node.key;
    if (node.kind !== 'method') {
      kind = node.kind;
    }
    propertyPath = path;
  } else if (t.isObjectProperty(parent) || t.isClassProperty(parent)) {
    // { foo() {} };
    id = parent.key;
    propertyPath = parentPath;
  } else if (t.isVariableDeclarator(parent)) {
    // let foo = function () {};
    id = parent.id;
  } else if (t.isAssignmentExpression(parent)) {
    // foo = function () {};
    id = parent.left;
  } else if (t.isJSXExpressionContainer(parent)) {
    if (t.isJSXElement(parentPath.parentPath.node)) {
      // <foo>{function () {}}</foo>
      const openingElement = parentPath.parentPath.node.openingElement;
      id = t.JSXMemberExpression(
        t.JSXMemberExpression(openingElement.name, t.JSXIdentifier('props')),
        t.JSXIdentifier('children'),
      );
    } else if (t.isJSXAttribute(parentPath.parentPath.node)) {
      // <foo bar={function () {}} />
      const openingElement = parentPath.parentPath.parentPath.node;
      const prop = parentPath.parentPath.node;
      id = t.JSXMemberExpression(
        t.JSXMemberExpression(openingElement.name, t.JSXIdentifier('props')),
        prop.name,
      );
    }
  }

  let name = getNameFromId(id);

  if (name == null) {
    if (t.isCallExpression(parent)) {
      // foo(function () {})
      const argIndex = parent.arguments.indexOf(node);
      if (argIndex !== -1) {
        const calleeName = getNameFromId(parent.callee);
        if (calleeName) {
          return `${calleeName}$argument_${argIndex}`;
        }
      }
    }
    return ANONYMOUS_NAME;
  }

  if (kind) {
    name = kind + '__' + name;
  }

  if (propertyPath) {
    if (t.isClassBody(propertyPath.parent)) {
      const className = getNameForPath(propertyPath.parentPath.parentPath);
      if (className !== ANONYMOUS_NAME) {
        const separator = propertyPath.node.static ? '.' : '#';
        name = className + separator + name;
      }
    } else if (t.isObjectExpression(propertyPath.parent)) {
      const objectName = getNameForPath(propertyPath.parentPath);
      if (objectName !== ANONYMOUS_NAME) {
        name = objectName + '.' + name;
      }
    }
  }

  return name;
}