Java tutorial
/* * Copyright 2013 Bazaarvoice, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.bazaarvoice.jolt.shiftr.spec; import com.bazaarvoice.jolt.exception.SpecException; import com.bazaarvoice.jolt.common.WalkedPath; import com.bazaarvoice.jolt.common.pathelement.AmpPathElement; import com.bazaarvoice.jolt.common.pathelement.ArrayPathElement; import com.bazaarvoice.jolt.common.pathelement.AtPathElement; import com.bazaarvoice.jolt.common.pathelement.DollarPathElement; import com.bazaarvoice.jolt.common.pathelement.LiteralPathElement; import com.bazaarvoice.jolt.common.pathelement.MatchablePathElement; import com.bazaarvoice.jolt.common.pathelement.PathElement; import com.bazaarvoice.jolt.common.pathelement.StarAllPathElement; import com.bazaarvoice.jolt.common.pathelement.StarRegexPathElement; import com.bazaarvoice.jolt.common.pathelement.StarSinglePathElement; import org.apache.commons.lang.StringUtils; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; /** * A Spec Object represents a single line from the JSON Shiftr Spec. * * At a minimum a single Spec has : * Raw LHS spec value * Some kind of PathElement (based off that raw LHS value) * * Additionally there are 2 distinct subclasses of the base Spec * LeafSpec : where the RHS is a String or Array of Strings, that specify an write path for the data from this level in the tree * CompositeSpec : where the RHS is a map of children Specs * * Mapping of Json Shiftr Spec to Spec objects : * { * rating-*" : { // CompositeSpec with one child and a Star PathElement * "&(1)" : { // CompositeSpec with one child and a Reference PathElement * "foo: { // CompositeSpec with one child and a Literal PathElement * "value" : "Rating-&1.value" // OutputtingSpec with a Literal PathElement and one write path * } * } * } * } * * The tree structure of formed by the CompositeSpecs is what is used during Shiftr transforms * to do the parallel tree walk with the input data tree. * * During the parallel tree walk, a Path<Literal PathElements> is maintained, and used when * a tree walk encounters an Outputting spec to evaluate the wildcards in the write DotNotationPath. */ public abstract class ShiftrSpec { // The processed key from the Json config protected final MatchablePathElement pathElement; public ShiftrSpec(String rawJsonKey) { List<PathElement> pathElements = parse(rawJsonKey); if (pathElements.size() != 1) { throw new SpecException("Shiftr invalid LHS:" + rawJsonKey + " can not contain '.'"); } PathElement pe = pathElements.get(0); if (!(pe instanceof MatchablePathElement)) { throw new SpecException("Spec LHS key=" + rawJsonKey + " is not a valid LHS key."); } this.pathElement = (MatchablePathElement) pe; } // once all the shiftr specific logic is extracted. public static List<PathElement> parse(String key) { if (key.contains("@")) { return Arrays.<PathElement>asList(new AtPathElement(key)); } else if (key.contains("$")) { return Arrays.<PathElement>asList(new DollarPathElement(key)); } else if (key.contains("[")) { if (StringUtils.countMatches(key, "[") != 1 || StringUtils.countMatches(key, "]") != 1) { throw new SpecException("Invalid key:" + key + " has too many [] references."); } // is canonical array? if (key.charAt(0) == '[' && key.charAt(key.length() - 1) == ']') { return Arrays.<PathElement>asList(new ArrayPathElement(key)); } // Split syntactic sugar of "photos[]" --> [ "photos", "[]" ] // or "bob-&(3,1)-smith[&0]" --> [ "bob-&(3,1)-smith", "[&(0,0)]" ] String canonicalKey = key.replace("[", ".["); String[] subkeys = canonicalKey.split("\\."); List<PathElement> subElements = parse(subkeys); // at this point each sub key should be a valid key, so just recall parse for (int index = 0; index < subElements.size() - 1; index++) { PathElement v = subElements.get(index); if (v instanceof ArrayPathElement) { throw new SpecException("Array [..] must be the last thing in the key, was:" + key); } } return subElements; } else if (key.contains("&")) { if (key.contains("*")) { throw new SpecException("Can't mix * with & ) "); } return Arrays.<PathElement>asList(new AmpPathElement(key)); } else if ("*".equals(key)) { return Arrays.<PathElement>asList(new StarAllPathElement(key)); } else if (StringUtils.countMatches(key, "*") == 1) { return Arrays.<PathElement>asList(new StarSinglePathElement(key)); } else if (key.contains("*")) { return Arrays.<PathElement>asList(new StarRegexPathElement(key)); } else { return Arrays.<PathElement>asList(new LiteralPathElement(key)); } } public static List<PathElement> parse(String[] keys) { ArrayList<PathElement> paths = new ArrayList<PathElement>(); for (String key : keys) { List<PathElement> subPaths = parse(key); for (PathElement path : subPaths) { paths.add(path); } } return paths; } /** * This is the main recursive method of the Shiftr parallel "spec" and "input" tree walk. * * It should return true if this Spec object was able to successfully apply itself given the * inputKey and input object. * * In the context of the Shiftr parallel treewalk, if this method returns true, the assumption * is that no other sibling Shiftr specs need to look at this particular input key. * * @return true if this this spec "handles" the inputkey such that no sibling specs need to see it */ public abstract boolean apply(String inputKey, Object input, WalkedPath walkedPath, Map<String, Object> output); }