import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
public Collection<DynamicProperty> map(String source) {
    //Default value is equal to the input json value (in case empty jolt specs)
    String jsonProperties = source;

    ArrayList transformed = (ArrayList) chainr.transform(JsonUtils.jsonToMap(source));
    jsonProperties = JsonUtils.toJsonString(transformed);

    //Now ensure current json properties is well formatted.
//    if (validateJson(jsonProperties)) {

    List<Object> items = JsonUtils.jsonToList(jsonProperties);
    Object collect = items.stream()
            .map(item -> {
                Map<String, String> mapItem = (Map<String, String>) item;
                Object key = mapItem.get("key");
                if (key instanceof Number) {
                    return new DynamicProperty(key.toString(), mapItem.get("value"));
                } else {
                    return new DynamicProperty((String) key, mapItem.get("value"));
                }
            })
            .collect(Collectors.toList());

    return (Collection<DynamicProperty>) collect;
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@DataProvider
public Iterator<Object[]> getCases() throws IOException {

    String testPath = "/json/chainr/guice_spec_with_context.json";
    Map<String, Object> testSuite = JsonUtils.classpathToMap( testPath );

    Object spec = testSuite.get( "spec" );
    List<Map> tests = (List<Map>) testSuite.get( "tests" );

    List<Object[]> accum = Lists.newLinkedList();

    for ( Map testCase : tests ) {

        String testCaseName = (String) testCase.get( "testCaseName" );
        Object input = testCase.get( "input" );
        Map<String,Object> context = (Map<String,Object>) testCase.get( "context" );
        Object expected = testCase.get( "expected" );

        accum.add( new Object[] { testCaseName, spec, input, context, expected } );
    }

    return accum.iterator();
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void itBlowsUpForMissingProviderStockTransform() throws IOException
{
    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object spec = testUnit.get( "spec" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceSpecDrivenTransform.GuiceConfig getConfigD() {
            return new GuiceSpecDrivenTransform.GuiceConfig( "dd" );
        }
    };

    Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void itBlowsUpForMissingProviderSpecTransform() throws IOException
{
    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object spec = testUnit.get( "spec" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceTransform.GuiceConfig getConfigC() {
            return new GuiceTransform.GuiceConfig( "c", "cc" );
        }
    };

    Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test
public void testAutoArray() throws IOException
{
    SimpleTraversal<String> traversal = SimpleTraversal.newTraversal( "a.[].b" );

    Object expected = JsonUtils.jsonToMap( "{ \"a\" : [ { \"b\" : \"one\" }, { \"b\" : \"two\" } ] }" );

    Object actual = new HashMap();

    Assert.assertFalse( traversal.get( actual ).isPresent() );
    Assert.assertEquals( 0, ((HashMap) actual).size() ); // get didn't add anything

    // Add two things and validate the Auto Expand array
    Assert.assertEquals( "one", traversal.set( actual, "one" ).get() );
    Assert.assertEquals( "two", traversal.set( actual, "two" ).get() );

    JoltTestUtil.runDiffy( expected, actual );
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test
public void testOverwrite() throws IOException
{
    SimpleTraversal<String> traversal = SimpleTraversal.newTraversal( "a.b" );

    Object actual = JsonUtils.jsonToMap( "{ \"a\" : { \"b\" : \"tuna\" } }" );
    Object expectedOne = JsonUtils.jsonToMap( "{ \"a\" : { \"b\" : \"one\" } }" );
    Object expectedTwo = JsonUtils.jsonToMap( "{ \"a\" : { \"b\" : \"two\" } }" );

    Assert.assertEquals( "tuna", traversal.get( actual ).get() );

    // Set twice and verify that the sets did in fact overwrite
    Assert.assertEquals( "one", traversal.set( actual, "one" ).get() );
    JoltTestUtil.runDiffy( expectedOne, actual );

    Assert.assertEquals( "two", traversal.set( actual, "two" ).get() );
    JoltTestUtil.runDiffy( expectedTwo, actual );
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@DataProvider
public Object[][] shiftrKeyOrderingTestCases() throws IOException {
    return new Object[][] {
        {
            "Simple * and &",
            JsonUtils.jsonToMap( "{ \"*\" : { \"a\" : \"b\" }, \"&\" : { \"a\" : \"b\" } }" ),
            Arrays.asList( "&(0,0)", "*" )
        },
        {
            "2* and 2&",
            JsonUtils.jsonToMap( "{ \"rating-*\" : { \"a\" : \"b\" }, \"rating-range-*\" : { \"a\" : \"b\" }, \"&\" : { \"a\" : \"b\" }, \"tuna-&(0)\" : { \"a\" : \"b\" } }" ),
            Arrays.asList( "tuna-&(0,0)", "&(0,0)", "rating-range-*", "rating-*" )
        },
        {
            "2& alpha-number based fallback",
            JsonUtils.jsonToMap( "{ \"&\" : { \"a\" : \"b\" }, \"&(0,1)\" : { \"a\" : \"b\" } }" ),
            Arrays.asList( "&(0,0)", "&(0,1)" )
        },
        {
            "2* and 2& alpha fallback",
            JsonUtils.jsonToMap( "{ \"aaaa-*\" : { \"a\" : \"b\" }, \"bbbb-*\" : { \"a\" : \"b\" }, \"aaaa-&\" : { \"a\" : \"b\" }, \"bbbb-&(0)\" : { \"a\" : \"b\" } }" ),
            Arrays.asList( "aaaa-&(0,0)", "bbbb-&(0,0)", "aaaa-*", "bbbb-*" )
        }
    };
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test
public void runFixtureTests() throws IOException {

    String testFixture = "/json/utils/joltUtils-removeRecursive.json";
    @SuppressWarnings("unchecked")
    List<Map<String, Object>> tests = (List<Map<String, Object>>) JsonUtils.classpathToObject( testFixture );

    for ( Map<String,Object> testUnit : tests ) {

        Object data = testUnit.get( "input" );
        String toRemove = (String) testUnit.get( "remove" );
        Object expected = testUnit.get( "expected" );

        JoltUtils.removeRecursive( data, toRemove );

        Diffy.Result result = diffy.diff( expected, data );
        if (!result.isEmpty()) {
            Assert.fail( "Failed.\nhere is a diff:\nexpected: " + JsonUtils.toJsonString(result.expected) + "\n  actual: " + JsonUtils.toJsonString(result.actual));
        }
    }
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@DataProvider
public Iterator<Object[]> storeTestCases() {

    String testFixture = "/json/utils/joltUtils-store-remove-compact.json";
    @SuppressWarnings("unchecked")
    List<Map<String, Object>> tests = (List<Map<String, Object>>) JsonUtils.classpathToObject( testFixture );

    List<Object[]> testCases = new LinkedList<>();

    for(Map<String, Object> testCase: tests) {
        testCases.add(new Object[] {
                testCase.get("description"),
                testCase.get("source"),
                ((List)testCase.get("path")).toArray(),
                testCase.get("value"),
                testCase.get("output")
        });
    }

    return testCases.iterator();
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test
public void deepCopyTest() throws Exception {

    Object input = JsonUtils.classpathToObject( "/json/deepcopy/original.json" );

    Map<String, Object> fiddle = (Map<String, Object>) DeepCopy.simpleDeepCopy( input );

    JoltTestUtil.runDiffy( "Verify that the DeepCopy did in fact make a copy.", input, fiddle );

    // The test is to make a deep copy, then manipulate the copy, and verify that the original did not change  ;)
    // copy and fiddle
    List array = (List) fiddle.get( "array" );
    array.add( "c" );
    array.set( 1, 3 );
    Map<String,Object> subMap = (Map<String,Object>) fiddle.get( "map" );
    subMap.put("c", "c");
    subMap.put("b", 3 );

    // Verify that the input to the copy was unmodified
    Object unmodified = JsonUtils.classpathToObject( "/json/deepcopy/original.json" );
    JoltTestUtil.runDiffy( "Verify that the deepcopy was actually deep / input is unmodified", unmodified, input );

    // Verify we made the modifications we wanted to.
    Object expectedModified = JsonUtils.classpathToObject( "/json/deepcopy/modifed.json" );
    JoltTestUtil.runDiffy( "Verify fiddled post deepcopy object looks correct / was modifed.", expectedModified, fiddle );
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
/**
 * Load the JSON template data and convert it.
 */
private static void convertJmhJsonData(InputStream specIn, InputStream jmhIn, OutputStream out) throws IOException {
  List<?> chainrConfig = JsonUtils.jsonToList(specIn);
  Chainr chainr = Chainr.fromSpec(chainrConfig);
  List<Object> input = JsonUtils.jsonToList(jmhIn);
  Object jsonOutput = chainr.transform(input);
  out.write(JsonUtils.toJsonString(jsonOutput).getBytes(StandardCharsets.UTF_8));
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
private synchronized Transform getTransform() throws Exception {
    if (transform == null) {
        if (log.isDebugEnabled()) {
            String path = getResourceUri();
            log.debug("Jolt content read from resource {} with resourceUri: {} for endpoint {}", new Object[]{getResourceUri(), path, getEndpointUri()});
        }

        // Sortr does not require a spec
        if (this.transformDsl == JoltTransformType.Sortr) {
            this.transform = new Sortr();
        } else {
            // getResourceAsInputStream also considers the content cache
            Object spec = JsonUtils.jsonToObject(getResourceAsInputStream());
            switch(this.transformDsl) {
            case Shiftr:
                this.transform = new Shiftr(spec);
                break;
            case Defaultr:
                this.transform = new Defaultr(spec);
                break;
            case Removr:
                this.transform = new Removr(spec);
                break;
            case Chainr:
            default:
                this.transform = Chainr.fromSpec(spec);
                break;
            }
        }
        
    }
    return transform;
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Override
protected void onExchange(Exchange exchange) throws Exception {
    String path = getResourceUri();
    ObjectHelper.notNull(path, "resourceUri");

    String newResourceUri = exchange.getIn().getHeader(JoltConstants.JOLT_RESOURCE_URI, String.class);
    if (newResourceUri != null) {
        exchange.getIn().removeHeader(JoltConstants.JOLT_RESOURCE_URI);

        log.debug("{} set to {} creating new endpoint to handle exchange", JoltConstants.JOLT_RESOURCE_URI, newResourceUri);
        JoltEndpoint newEndpoint = findOrCreateEndpoint(getEndpointUri(), newResourceUri);
        newEndpoint.onExchange(exchange);
        return;
    }
    Object input;
    if (getInputType() == JoltInputOutputType.JsonString) {
        input = JsonUtils.jsonToObject(exchange.getIn().getBody(InputStream.class));
    } else {
        input = exchange.getIn().getBody();
    }
    Object output = getTransform().transform(input);
            
    // now lets output the results to the exchange
    Message out = exchange.getOut();
    if (getOutputType() == JoltInputOutputType.JsonString) {
        out.setBody(JsonUtils.toJsonString(output));
    } else {
        out.setBody(output);
    }
    out.setHeaders(exchange.getIn().getHeaders());
    out.setAttachments(exchange.getIn().getAttachments());
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@NotNull
private InputStream transform(@NotNull InputStream content, @NotNull RequestConfiguration configuration) {
    if (StringUtil.isNotEmpty(configuration.getTransform())) {
        List chainrSpecJSON = JsonUtils.jsonToList(configuration.getTransform());
        Chainr chainr = Chainr.fromSpec(chainrSpecJSON);
        Object inputJSON = JsonUtils.jsonToObject(content);
        Object transformedOutput = chainr.transform(inputJSON);

        return new ByteArrayInputStream(JsonUtils.toJsonString(transformedOutput).getBytes(StandardCharsets.UTF_8));
    } else {
        return content;
    }
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
public String migrate(String oldJSON, int targetVersion) {
    LOGGER.debug("Migrating to version {}: {}", targetVersion, oldJSON);

    Chainr transform = getTransformerFor(targetVersion);
    Object transformedObject = transform.transform(JsonUtils.jsonToMap(oldJSON));
    String transformedJSON = JsonUtils.toJsonString(transformedObject);

    LOGGER.debug("After migration to version {}: {}", targetVersion, transformedJSON);
    return transformedJSON;
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
private Chainr getTransformerFor(int targetVersion) {
    try {
        String targetVersionFile = String.format("/config-repo/migrations/%s.json", targetVersion);
        String transformJSON = IOUtils.toString(this.getClass().getResourceAsStream(targetVersionFile), "UTF-8");
        return Chainr.fromSpec(JsonUtils.jsonToList(transformJSON));
    } catch (Exception e) {
        throw new RuntimeException("Failed to migrate to version " + targetVersion, e);
    }
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
public String versionOneComprehensiveWithNoLocking() {
    Map<String, Object> map = getJSONFor("/v1_comprehensive.json");
    store(map, "1", "target_version");
    remove(map, "pipelines", 0, "enable_pipeline_locking");
    remove(map, "pipelines", 1, "enable_pipeline_locking");
    return JsonUtils.toJsonString(map);
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
private Map<String, Object> getJSONFor(String fileName) {
    try {
        String transformJSON = IOUtils.toString(this.getClass().getResourceAsStream(fileName), "UTF-8");
        return JsonUtils.jsonToMap(transformJSON);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
public static void runDiffy( String failureMessage, Object expected, Object actual ) {

        Diffy.Result result = diffy.diff( expected, actual );
        if (!result.isEmpty()) {
            Assert.fail( failureMessage + ".\nhere is a diff:\nexpected: " + JsonUtils.toJsonString(result.expected) + "\n  actual: " + JsonUtils.toJsonString(result.actual));
        }
    }
 

import com.bazaarvoice.jolt.JsonUtils; //导入依赖的package包/类
@Test
public void successTestCase() throws IOException {

    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object input = testUnit.get( "input" );
    Object spec = testUnit.get( "spec" );
    Object expected = testUnit.get( "expected" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceTransform.GuiceConfig getConfigC() {
            return new GuiceTransform.GuiceConfig( "c", "cc" );
        }

        @Provides
        public GuiceSpecDrivenTransform.GuiceConfig getConfigD() {
            return new GuiceSpecDrivenTransform.GuiceConfig( "dd" );
        }
    };

    Chainr unit = Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );

    Assert.assertFalse( unit.hasContextualTransforms() );
    Assert.assertEquals( unit.getContextualTransforms().size(), 0 );

    Object actual = unit.transform( input, null );

    JoltTestUtil.runDiffy( "failed case " + testPath, expected, actual );
}