private boolean isValueNode(TreeNode treeNode) { return treeNode != null && treeNode.type() == TreeNode.Type.VALUE_NODE; } }
@Override public Type type() { return treeNode.type(); }
@Override public String toString() { if (isHidden()) { return "\"" + HIDDEN_PLACEHOLDER + "\""; } else if (children.size() > 0 && children.get(0).type() == Type.VALUE_NODE) { return children.stream().map(item -> "- " + item.toString()).collect(joining("\n")); } else { return children.stream().map(item -> "-\n" + indent(item.toString())).collect(joining("\n")); } }
@Override public String toString() { if (isHidden()) { return "\"" + HIDDEN_PLACEHOLDER + "\""; } else { return children.entrySet().stream().map(entry -> { if (entry.getValue().type() == Type.VALUE_NODE) { return entry.getKey() + ": " + entry.getValue().toString(); } else { return entry.getKey() + ":\n" + indent(entry.getValue().toString()); } }).collect(Collectors.joining("\n")); } }
T map(TreeNode rootNode) { if (rootNode.type() == TreeNode.Type.VALUE_NODE && valueFieldInfo != null) { Optional.ofNullable(coffig.getMapper().map(rootNode, valueFieldInfo.type)) .ifPresent(valueFieldInfo.consumer); } else if (rootNode.type() == TreeNode.Type.MAP_NODE) { fieldInfo.forEach(fieldInfo -> rootNode.get(fieldInfo.alias != null ? fieldInfo.alias : fieldInfo.name) .map(treeNode -> coffig.getMapper().map(treeNode, fieldInfo.type)) .ifPresent(fieldInfo.consumer)); } return holder; }
@Override public void process(MapNode configuration) { Map<MapNode, List<String>> toRemove = new HashMap<>(); configuration.walk() .filter(node -> node.type() == TreeNode.Type.MAP_NODE) .map(MapNode.class::cast) .forEach(mapNode -> mapNode .namedNodes() .filter(namedNode -> namedNode.name().startsWith("-")) .forEach(namedNode -> { List<String> strings = toRemove.get(mapNode); if (strings == null) { toRemove.put(mapNode, strings = new ArrayList<>()); } strings.add(namedNode.name()); strings.add(namedNode.name().substring(1)); })); toRemove.forEach((node, list) -> list.forEach(node::remove)); } }
@Override public void process(MapNode configuration) { configuration.get("env").ifPresent(TreeNode::hide); configuration.get("sys").ifPresent(TreeNode::hide); configuration.walk() .filter(node -> node.type() == TreeNode.Type.MAP_NODE) .forEach(node -> node.namedNodes() .filter(this::isPotentialPassword) .forEach(namedNode -> namedNode.node().hide()) ); }
@Override public Object map(TreeNode treeNode, Type type) { Properties properties = new Properties(); if (treeNode.type() == TreeNode.Type.MAP_NODE) { treeNode.namedNodes() .forEach(namedNode -> properties.setProperty(namedNode.name(), (String) coffig.getMapper().map(namedNode.node(), String.class))); } else { treeNode.nodes().forEach(item -> properties.setProperty(item.value(), "")); } return properties; }
@Override @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST", justification = "Cast is verified in canHandle() method") public Object map(TreeNode treeNode, Type type) { Class<?> rawType = rawClassOf(((ParameterizedType) type).getActualTypeArguments()[0]); if (treeNode.type() == TreeNode.Type.MAP_NODE) { Map<String, String> result = new HashMap<>(); treeNode.namedNodes() .filter(namedNode -> isValueNode(namedNode.node())) .forEach(namedNode -> result.put(namedNode.name(), namedNode.node().value())); return ClassConfiguration.of(rawType, result); } else { throw SeedException.createNew(CoreErrorCode.INVALID_CLASS_CONFIGURATION) .put("nodeType", treeNode.type()) .put("class", rawType.getName()); } }
private TreeNode processArgument(TreeNode tree, String value) throws Exception { if (value.startsWith("'") && value.endsWith("'")) { return new ValueNode(value.substring(1, value.length() - 1)); } CallSiteInfo callSiteInfo = findFunctionCall(value, 0); if (callSiteInfo == null) { TreeNode refNode = tree.get(value).orElse(new ValueNode("")); if (refNode.type() == TreeNode.Type.VALUE_NODE) { // References value nodes can be processed... return new ValueNode(processValue(tree, refNode.value())); } else { // ... whereas other node types are passed directly return refNode; } } else { return new ValueNode(processValue(tree, value)); } }
@Override @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST", justification = "Cast is verified in canHandle() method") public Object map(TreeNode treeNode, Type type) { Type keyType = ((ParameterizedType) type).getActualTypeArguments()[0]; Type valueType = ((ParameterizedType) type).getActualTypeArguments()[1]; if (treeNode.type() == TreeNode.Type.MAP_NODE) { return treeNode.namedNodes() .collect(toMap( namedNode -> coffig.getMapper().map(new ValueNode(namedNode.name()), keyType), namedNode -> Optional.ofNullable(coffig.getMapper().map(namedNode.node(), valueType)) .orElseGet(() -> instantiateDefault((Class<?>) valueType)) )); } else { return treeNode.nodes() .collect(toMap( node -> coffig.getMapper().map(node, keyType), node -> instantiateDefault((Class<?>) valueType)) ); } }
@Override public TreeNode evaluate(TreeNode rootNode, TreeNode valueNode) { if (valueNode.type() == TreeNode.Type.VALUE_NODE && !valueNode.isEmpty()) { try { return new ValueNode(processValue(rootNode, valueNode.value())); } catch (Exception e) { LOGGER.error("Error when evaluating configuration macro: {}", valueNode.value(), e); return new ValueNode(); } } else { return valueNode; } }
@Override public TreeNode evaluate(TreeNode rootNode, TreeNode valueNode) { if (valueNode.type() == TreeNode.Type.VALUE_NODE && !valueNode.isEmpty()) { try { return new ValueNode(processValue(rootNode, valueNode.value())); } catch (Exception e) { LOGGER.error("Error when evaluating configuration function: {}", valueNode.value(), e); return new ValueNode(); } } else { return valueNode; } }
public Object map(TreeNode treeNode, Type type) { if (treeNode == null || (treeNode.type() == TreeNode.Type.VALUE_NODE && treeNode.isEmpty())) { return null; } for (ConfigurationMapper configurationMapper : items) { if (configurationMapper.canHandle(type)) { return configurationMapper.map(treeNode, type); } } ObjectMapper<?> objectMapper = new ObjectMapper<>(rawClassOf(type)); objectMapper.initialize(coffig); return objectMapper.map(treeNode); }