@@ -1,5 +1,6 @@ | |||
<?xml version="1.0" encoding="UTF-8"?> | |||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> | |||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" | |||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> | |||
<modelVersion>4.0.0</modelVersion> | |||
<groupId>org.codehaus.sonar</groupId> | |||
@@ -88,7 +89,7 @@ | |||
<skipSanityChecks>false</skipSanityChecks> | |||
<!-- default GWT configuration. It's overridden by the profile 'dev' to speed up compilation in dev environments--> | |||
<gwt.permutationSuffix /> | |||
<gwt.permutationSuffix/> | |||
<gwt.extraJvmArgs>-Xmx512m -Xss1024k</gwt.extraJvmArgs> | |||
<sonar.snapshotRepository.url>dav:https://dav.codehaus.org/snapshots.repository/sonar</sonar.snapshotRepository.url> | |||
</properties> | |||
@@ -643,12 +644,31 @@ | |||
<dependency> | |||
<groupId>com.tinkerpop.blueprints</groupId> | |||
<artifactId>blueprints-core</artifactId> | |||
<version>2.2.0</version> | |||
<!-- | |||
Do not upgrade because of compatibility with Java 5. | |||
See https://github.com/tinkerpop/blueprints/pull/352 | |||
--> | |||
<version>2.0.0</version> | |||
<exclusions> | |||
<!-- we use our own GraphSON implementation based on json-simple --> | |||
<exclusion> | |||
<groupId>org.codehaus.jettison</groupId> | |||
<artifactId>jettison</artifactId> | |||
</exclusion> | |||
<exclusion> | |||
<groupId>org.codehaus.jackson</groupId> | |||
<artifactId>jackson-jaxrs</artifactId> | |||
</exclusion> | |||
</exclusions> | |||
</dependency> | |||
<dependency> | |||
<!-- | |||
Do not upgrade because of compatibility with Java 5. | |||
See https://github.com/tinkerpop/pipes/pull/74 | |||
--> | |||
<groupId>com.tinkerpop.gremlin</groupId> | |||
<artifactId>gremlin-java</artifactId> | |||
<version>2.2.0</version> | |||
<version>2.0.0</version> | |||
</dependency> | |||
<dependency> | |||
<groupId>org.codehaus.plexus</groupId> | |||
@@ -1122,13 +1142,6 @@ | |||
<organization>SonarSource</organization> | |||
<timezone>+1</timezone> | |||
</developer> | |||
<developer> | |||
<id>david.gageot</id> | |||
<name>David Gageot</name> | |||
<email>david.gageot@sonarsource.com</email> | |||
<organization>SonarSource</organization> | |||
<timezone>+1</timezone> | |||
</developer> | |||
</developers> | |||
<profiles> | |||
@@ -1226,7 +1239,7 @@ | |||
</goals> | |||
</pluginExecutionFilter> | |||
<action> | |||
<ignore /> | |||
<ignore/> | |||
</action> | |||
</pluginExecution> | |||
<pluginExecution> | |||
@@ -1239,7 +1252,7 @@ | |||
</goals> | |||
</pluginExecutionFilter> | |||
<action> | |||
<ignore /> | |||
<ignore/> | |||
</action> | |||
</pluginExecution> | |||
<pluginExecution> | |||
@@ -1252,7 +1265,7 @@ | |||
</goals> | |||
</pluginExecutionFilter> | |||
<action> | |||
<ignore /> | |||
<ignore/> | |||
</action> | |||
</pluginExecution> | |||
<pluginExecution> | |||
@@ -1266,7 +1279,7 @@ | |||
</goals> | |||
</pluginExecutionFilter> | |||
<action> | |||
<ignore /> | |||
<ignore/> | |||
</action> | |||
</pluginExecution> | |||
<pluginExecution> | |||
@@ -1279,7 +1292,7 @@ | |||
</goals> | |||
</pluginExecutionFilter> | |||
<action> | |||
<ignore /> | |||
<ignore/> | |||
</action> | |||
</pluginExecution> | |||
</pluginExecutions> |
@@ -21,11 +21,9 @@ package org.sonar.core.component; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.impls.tg.TinkerGraph; | |||
import org.json.simple.parser.ParseException; | |||
import org.sonar.core.graph.GraphSONReader; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONReader; | |||
import java.io.ByteArrayInputStream; | |||
import java.io.IOException; | |||
public class GraphReader { | |||
@@ -36,9 +34,7 @@ public class GraphReader { | |||
GraphSONReader.inputGraph(graph, input); | |||
Vertex root = graph.getVertex(rootVertexId); | |||
return new ComponentGraph(graph, root); | |||
} catch (IOException e) { | |||
throw new IllegalStateException(e); | |||
} catch (ParseException e) { | |||
} catch (Exception e) { | |||
throw new IllegalStateException(e); | |||
} | |||
} |
@@ -1,135 +0,0 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.util.io.graphson.ElementFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphElementFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import com.tinkerpop.blueprints.util.wrappers.batch.BatchGraph; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import org.json.simple.parser.JSONParser; | |||
import org.json.simple.parser.ParseException; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.io.InputStreamReader; | |||
import java.util.Set; | |||
/** | |||
* GraphSONReader reads the data from a TinkerPop JSON stream to a graph. | |||
* | |||
* @author Stephen Mallette (http://stephen.genoprime.com) | |||
*/ | |||
public class GraphSONReader { | |||
private final Graph graph; | |||
/** | |||
* @param graph the graph to populate with the JSON data | |||
*/ | |||
public GraphSONReader(final Graph graph) { | |||
this.graph = graph; | |||
} | |||
/** | |||
* Input the JSON stream data into the graph. | |||
* In practice, usually the provided graph is empty. | |||
* | |||
* @param graph the graph to populate with the JSON data | |||
* @param jsonInputStream an InputStream of JSON data | |||
* @throws java.io.IOException thrown when the JSON data is not correctly formatted | |||
*/ | |||
public static void inputGraph(final Graph graph, final InputStream jsonInputStream) throws IOException, ParseException { | |||
inputGraph(graph, jsonInputStream, 1000); | |||
} | |||
public static void inputGraph(final Graph inputGraph, final InputStream jsonInputStream, int bufferSize) throws IOException, ParseException { | |||
inputGraph(inputGraph, jsonInputStream, bufferSize, null, null); | |||
} | |||
/** | |||
* Input the JSON stream data into the graph. | |||
* More control over how data is streamed is provided by this method. | |||
* | |||
* @param inputGraph the graph to populate with the JSON data | |||
* @param jsonInputStream an InputStream of JSON data | |||
* @param bufferSize the amount of elements to hold in memory before committing a transactions (only valid for TransactionalGraphs) | |||
* @throws java.io.IOException thrown when the JSON data is not correctly formatted | |||
*/ | |||
public static void inputGraph(final Graph inputGraph, final InputStream jsonInputStream, int bufferSize, | |||
final Set<String> edgePropertyKeys, final Set<String> vertexPropertyKeys) throws ParseException, IOException { | |||
JSONParser parser = new JSONParser(); | |||
JSONObject json = (JSONObject) parser.parse(new InputStreamReader(jsonInputStream)); | |||
// if this is a transactional graph then we're buffering | |||
final BatchGraph graph = BatchGraph.wrap(inputGraph, bufferSize); | |||
final ElementFactory elementFactory = new GraphElementFactory(graph); | |||
final GraphSONMode mode = GraphSONMode.valueOf(json.get(GraphSONTokens.MODE).toString()); | |||
GraphSONUtility graphson = new GraphSONUtility(mode, elementFactory, vertexPropertyKeys, edgePropertyKeys); | |||
JSONArray vertices = (JSONArray) json.get(GraphSONTokens.VERTICES); | |||
for (Object vertice : vertices) { | |||
graphson.vertexFromJson((JSONObject) vertice); | |||
} | |||
JSONArray edges = (JSONArray) json.get(GraphSONTokens.EDGES); | |||
for (Object edgeObject : edges) { | |||
JSONObject edge = (JSONObject) edgeObject; | |||
final Vertex inV = graph.getVertex(edge.get(GraphSONTokens._IN_V)); | |||
final Vertex outV = graph.getVertex(edge.get(GraphSONTokens._OUT_V)); | |||
graphson.edgeFromJson(edge, outV, inV); | |||
} | |||
graph.shutdown(); | |||
} | |||
/** | |||
* Input the JSON stream data into the graph. | |||
* In practice, usually the provided graph is empty. | |||
* | |||
* @param jsonInputStream an InputStream of JSON data | |||
* @throws java.io.IOException thrown when the JSON data is not correctly formatted | |||
*/ | |||
public void inputGraph(final InputStream jsonInputStream) throws IOException, ParseException { | |||
GraphSONReader.inputGraph(this.graph, jsonInputStream, 1000); | |||
} | |||
/** | |||
* Input the JSON stream data into the graph. | |||
* In practice, usually the provided graph is empty. | |||
* | |||
* @param jsonInputStream an InputStream of JSON data | |||
* @param bufferSize the amount of elements to hold in memory before committing a transactions (only valid for TransactionalGraphs) | |||
* @throws java.io.IOException thrown when the JSON data is not correctly formatted | |||
*/ | |||
public void inputGraph(final InputStream jsonInputStream, int bufferSize) throws IOException, ParseException { | |||
GraphSONReader.inputGraph(this.graph, jsonInputStream, bufferSize); | |||
} | |||
} |
@@ -1,129 +0,0 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import java.util.Set; | |||
/** | |||
* GraphSONWriter writes a Graph to a TinkerPop JSON OutputStream. | |||
* | |||
* @author Stephen Mallette | |||
*/ | |||
public class GraphSONWriter { | |||
private final Graph graph; | |||
/** | |||
* @param graph the Graph to pull the data from | |||
*/ | |||
public GraphSONWriter(final Graph graph) { | |||
this.graph = graph; | |||
} | |||
/** | |||
* Write the data in a Graph to a JSON OutputStream. All keys are written to JSON. Utilizing | |||
* GraphSONMode.NORMAL. | |||
* | |||
* @param graph the graph to serialize to JSON | |||
* @param jsonOutputStream the JSON OutputStream to write the Graph data to | |||
* @throws java.io.IOException thrown if there is an error generating the JSON data | |||
*/ | |||
public static void outputGraph(final Graph graph, final OutputStream jsonOutputStream) throws IOException { | |||
final GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(jsonOutputStream, null, null, GraphSONMode.NORMAL); | |||
} | |||
/** | |||
* Write the data in a Graph to a JSON OutputStream. All keys are written to JSON. | |||
* | |||
* @param graph the graph to serialize to JSON | |||
* @param jsonOutputStream the JSON OutputStream to write the Graph data to | |||
* @param mode determines the format of the GraphSON | |||
* @throws java.io.IOException thrown if there is an error generating the JSON data | |||
*/ | |||
public static void outputGraph(final Graph graph, final OutputStream jsonOutputStream, | |||
final GraphSONMode mode) throws IOException { | |||
final GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(jsonOutputStream, null, null, mode); | |||
} | |||
/** | |||
* Write the data in a Graph to a JSON OutputStream. | |||
* | |||
* @param graph the graph to serialize to JSON | |||
* @param jsonOutputStream the JSON OutputStream to write the Graph data to | |||
* @param vertexPropertyKeys the keys of the vertex elements to write to JSON | |||
* @param edgePropertyKeys the keys of the edge elements to write to JSON | |||
* @param mode determines the format of the GraphSON | |||
* @throws java.io.IOException thrown if there is an error generating the JSON data | |||
*/ | |||
public static void outputGraph(final Graph graph, final OutputStream jsonOutputStream, | |||
final Set<String> vertexPropertyKeys, final Set<String> edgePropertyKeys, | |||
final GraphSONMode mode) throws IOException { | |||
final GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(jsonOutputStream, vertexPropertyKeys, edgePropertyKeys, mode); | |||
} | |||
/** | |||
* Write the data in a Graph to a JSON OutputStream. | |||
* | |||
* @param jsonOutputStream the JSON OutputStream to write the Graph data to | |||
* @param vertexPropertyKeys the keys of the vertex elements to write to JSON | |||
* @param edgePropertyKeys the keys of the edge elements to write to JSON | |||
* @param mode determines the format of the GraphSON | |||
* @throws java.io.IOException thrown if there is an error generating the JSON data | |||
*/ | |||
public void outputGraph(final OutputStream jsonOutputStream, final Set<String> vertexPropertyKeys, | |||
final Set<String> edgePropertyKeys, final GraphSONMode mode) throws IOException { | |||
JSONObject root = new JSONObject(); | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, null, vertexPropertyKeys, edgePropertyKeys); | |||
root.put(GraphSONTokens.MODE, mode.toString()); | |||
JSONArray verticesArray = new JSONArray(); | |||
for (Vertex v : this.graph.getVertices()) { | |||
verticesArray.add(graphson.objectNodeFromElement(v)); | |||
} | |||
root.put(GraphSONTokens.VERTICES, verticesArray); | |||
JSONArray edgesArray = new JSONArray(); | |||
for (Edge e : this.graph.getEdges()) { | |||
edgesArray.add(graphson.objectNodeFromElement(e)); | |||
} | |||
root.put(GraphSONTokens.EDGES, edgesArray); | |||
jsonOutputStream.write(root.toString().getBytes()); | |||
} | |||
} |
@@ -20,8 +20,9 @@ | |||
package org.sonar.core.graph; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import org.apache.commons.io.IOUtils; | |||
import org.sonar.core.graph.graphson.GraphSONMode; | |||
import org.sonar.core.graph.graphson.GraphSONWriter; | |||
import java.io.ByteArrayOutputStream; | |||
import java.io.IOException; | |||
@@ -31,7 +32,7 @@ public class GraphWriter { | |||
public String write(Graph graph) { | |||
ByteArrayOutputStream output = new ByteArrayOutputStream(); | |||
try { | |||
GraphSONWriter.outputGraph(graph, output, GraphSONMode.COMPACT); | |||
new GraphSONWriter().write(graph, output, GraphSONMode.COMPACT); | |||
output.flush(); | |||
output.close(); | |||
return new String(output.toByteArray()); |
@@ -0,0 +1,47 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
/** | |||
* The standard factory used for most graph element creation. It uses an actual | |||
* Graph implementation to construct vertices and edges | |||
* | |||
* @author Stephen Mallette (http://stephen.genoprime.com) | |||
*/ | |||
class ElementFactory { | |||
private final Graph graph; | |||
ElementFactory(Graph g) { | |||
this.graph = g; | |||
} | |||
Edge createEdge(Object id, Vertex out, Vertex in, String label) { | |||
return this.graph.addEdge(id, out, in, label); | |||
} | |||
Vertex createVertex(Object id) { | |||
return this.graph.addVertex(id); | |||
} | |||
} |
@@ -0,0 +1,87 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
import java.util.Set; | |||
/** | |||
* Configure how the GraphSON utility treats edge and vertex properties. | |||
* | |||
* @author Stephen Mallette (http://stephen.genoprime.com) | |||
*/ | |||
class ElementPropertyConfig { | |||
static enum ElementPropertiesRule { | |||
INCLUDE, EXCLUDE | |||
} | |||
private final Set<String> vertexPropertyKeys; | |||
private final Set<String> edgePropertyKeys; | |||
private final ElementPropertiesRule vertexPropertiesRule; | |||
private final ElementPropertiesRule edgePropertiesRule; | |||
/** | |||
* A configuration that includes all properties of vertices and edges. | |||
*/ | |||
static ElementPropertyConfig AllProperties = new ElementPropertyConfig(null, null, | |||
ElementPropertiesRule.INCLUDE, ElementPropertiesRule.INCLUDE); | |||
ElementPropertyConfig(Set<String> vertexPropertyKeys, Set<String> edgePropertyKeys, | |||
ElementPropertiesRule vertexPropertiesRule, ElementPropertiesRule edgePropertiesRule) { | |||
this.vertexPropertiesRule = vertexPropertiesRule; | |||
this.vertexPropertyKeys = vertexPropertyKeys; | |||
this.edgePropertiesRule = edgePropertiesRule; | |||
this.edgePropertyKeys = edgePropertyKeys; | |||
} | |||
/** | |||
* Construct a configuration that includes the specified properties from both vertices and edges. | |||
*/ | |||
static ElementPropertyConfig includeProperties(Set<String> vertexPropertyKeys, | |||
Set<String> edgePropertyKeys) { | |||
return new ElementPropertyConfig(vertexPropertyKeys, edgePropertyKeys, ElementPropertiesRule.INCLUDE, | |||
ElementPropertiesRule.INCLUDE); | |||
} | |||
/** | |||
* Construct a configuration that excludes the specified properties from both vertices and edges. | |||
*/ | |||
static ElementPropertyConfig excludeProperties(Set<String> vertexPropertyKeys, | |||
Set<String> edgePropertyKeys) { | |||
return new ElementPropertyConfig(vertexPropertyKeys, edgePropertyKeys, ElementPropertiesRule.EXCLUDE, | |||
ElementPropertiesRule.EXCLUDE); | |||
} | |||
Set<String> getVertexPropertyKeys() { | |||
return vertexPropertyKeys; | |||
} | |||
Set<String> getEdgePropertyKeys() { | |||
return edgePropertyKeys; | |||
} | |||
ElementPropertiesRule getVertexPropertiesRule() { | |||
return vertexPropertiesRule; | |||
} | |||
ElementPropertiesRule getEdgePropertiesRule() { | |||
return edgePropertiesRule; | |||
} | |||
} |
@@ -0,0 +1,45 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
/** | |||
* Modes of operation of the GraphSONUtility. | |||
* | |||
* @author Stephen Mallette | |||
*/ | |||
public enum GraphSONMode { | |||
/** | |||
* COMPACT constructs GraphSON on the assumption that all property keys | |||
* are fair game for exclusion including _type, _inV, _outV, _label and _id. | |||
* It is possible to write GraphSON that cannot be read back into Graph, | |||
* if some or all of these keys are excluded. | |||
*/ | |||
COMPACT, | |||
/** | |||
* NORMAL includes the _type field and JSON data typing. | |||
*/ | |||
NORMAL, | |||
/** | |||
* EXTENDED includes the _type field and explicit data typing. | |||
*/ | |||
EXTENDED | |||
} |
@@ -0,0 +1,81 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.util.wrappers.batch.BatchGraph; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import org.json.simple.parser.JSONParser; | |||
import java.io.InputStream; | |||
import java.io.InputStreamReader; | |||
import java.util.Set; | |||
/** | |||
* Greatly inspired by the Blueprints implementation based on Jettison/Jackson | |||
*/ | |||
public class GraphSONReader { | |||
public Graph read(InputStream jsonInput, Graph toGraph) { | |||
return read(jsonInput, toGraph, 1000, null, null); | |||
} | |||
/** | |||
* Input the JSON stream data into the graph. | |||
* More control over how data is streamed is provided by this method. | |||
* | |||
* @param toGraph the graph to populate with the JSON data | |||
* @param jsonInput an InputStream of JSON data | |||
* @param bufferSize the amount of elements to hold in memory before committing a transactions (only valid for TransactionalGraphs) | |||
*/ | |||
public Graph read(InputStream jsonInput, Graph toGraph, int bufferSize, Set<String> edgePropertyKeys, Set<String> vertexPropertyKeys) { | |||
try { | |||
JSONParser parser = new JSONParser(); | |||
JSONObject json = (JSONObject) parser.parse(new InputStreamReader(jsonInput)); | |||
// if this is a transactional graph then we're buffering | |||
final BatchGraph batchGraph = BatchGraph.wrap(toGraph, bufferSize); | |||
ElementFactory elementFactory = new ElementFactory(batchGraph); | |||
final GraphSONMode mode = GraphSONMode.valueOf(json.get(GraphSONTokens.MODE).toString()); | |||
GraphsonUtil graphson = new GraphsonUtil(mode, elementFactory, vertexPropertyKeys, edgePropertyKeys); | |||
JSONArray vertices = (JSONArray) json.get(GraphSONTokens.VERTICES); | |||
for (Object vertice : vertices) { | |||
graphson.vertexFromJson((JSONObject) vertice); | |||
} | |||
JSONArray edges = (JSONArray) json.get(GraphSONTokens.EDGES); | |||
for (Object edgeObject : edges) { | |||
JSONObject edge = (JSONObject) edgeObject; | |||
final Vertex inV = batchGraph.getVertex(edge.get(GraphSONTokens._IN_V)); | |||
final Vertex outV = batchGraph.getVertex(edge.get(GraphSONTokens._OUT_V)); | |||
graphson.edgeFromJson(edge, outV, inV); | |||
} | |||
batchGraph.shutdown(); | |||
return toGraph; | |||
} catch (Exception e) { | |||
throw new GraphSonException("Unable to parse GraphSON", e); | |||
} | |||
} | |||
} |
@@ -0,0 +1,49 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
/** | |||
* @author Marko A. Rodriguez (http://markorodriguez.com) | |||
* @author Stephen Mallette | |||
*/ | |||
class GraphSONTokens { | |||
public static final String VERTEX = "vertex"; | |||
public static final String EDGE = "edge"; | |||
public static final String _ID = "_id"; | |||
public static final String _LABEL = "_label"; | |||
public static final String _TYPE = "_type"; | |||
public static final String _OUT_V = "_outV"; | |||
public static final String _IN_V = "_inV"; | |||
public static final String VALUE = "value"; | |||
public static final String TYPE = "type"; | |||
public static final String TYPE_LIST = "list"; | |||
public static final String TYPE_STRING = "string"; | |||
public static final String TYPE_DOUBLE = "double"; | |||
public static final String TYPE_INTEGER = "integer"; | |||
public static final String TYPE_FLOAT = "float"; | |||
public static final String TYPE_MAP = "map"; | |||
public static final String TYPE_BOOLEAN = "boolean"; | |||
public static final String TYPE_LONG = "long"; | |||
public static final String TYPE_UNKNOWN = "unknown"; | |||
public static final String VERTICES = "vertices"; | |||
public static final String EDGES = "edges"; | |||
public static final String MODE = "mode"; | |||
} |
@@ -0,0 +1,79 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
import com.google.common.base.Charsets; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import javax.annotation.Nullable; | |||
import java.io.OutputStream; | |||
import java.util.Set; | |||
/** | |||
* GraphSONWriter writes a Graph to a TinkerPop JSON OutputStream. | |||
* | |||
* @author Stephen Mallette | |||
*/ | |||
public class GraphSONWriter { | |||
public void write(Graph graph, OutputStream jsonOutputStream, GraphSONMode mode) { | |||
write(graph, jsonOutputStream, mode, null, null); | |||
} | |||
/** | |||
* Write the data in a Graph to a JSON OutputStream. | |||
* | |||
* @param jsonOutputStream the JSON OutputStream to write the Graph data to | |||
* @param vertexPropertyKeys the keys of the vertex elements to write to JSON | |||
* @param edgePropertyKeys the keys of the edge elements to write to JSON | |||
* @param mode determines the format of the GraphSON | |||
* @throws java.io.IOException thrown if there is an error generating the JSON data | |||
*/ | |||
public void write(Graph graph, OutputStream jsonOutputStream, GraphSONMode mode, @Nullable Set<String> vertexPropertyKeys, @Nullable Set<String> edgePropertyKeys) { | |||
try { | |||
JSONObject root = new JSONObject(); | |||
GraphsonUtil graphson = new GraphsonUtil(mode, null, vertexPropertyKeys, edgePropertyKeys); | |||
root.put(GraphSONTokens.MODE, mode.toString()); | |||
JSONArray verticesArray = new JSONArray(); | |||
for (Vertex v : graph.getVertices()) { | |||
verticesArray.add(graphson.objectNodeFromElement(v)); | |||
} | |||
root.put(GraphSONTokens.VERTICES, verticesArray); | |||
JSONArray edgesArray = new JSONArray(); | |||
for (Edge e : graph.getEdges()) { | |||
edgesArray.add(graphson.objectNodeFromElement(e)); | |||
} | |||
root.put(GraphSONTokens.EDGES, edgesArray); | |||
jsonOutputStream.write(root.toString().getBytes("UTF-8")); | |||
} catch (Exception e) { | |||
throw new GraphSonException("Fail to generate GraphSON", e); | |||
} | |||
} | |||
} |
@@ -0,0 +1,30 @@ | |||
/* | |||
* Sonar, open source software quality management tool. | |||
* Copyright (C) 2008-2012 SonarSource | |||
* mailto:contact AT sonarsource DOT com | |||
* | |||
* Sonar is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph.graphson; | |||
public class GraphSonException extends RuntimeException { | |||
public GraphSonException(String message) { | |||
super(message); | |||
} | |||
public GraphSonException(String message, Throwable cause) { | |||
super(message, cause); | |||
} | |||
} |
@@ -11,28 +11,25 @@ | |||
* Sonar is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* Lesser General License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Direction; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Element; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.util.io.graphson.ElementFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.ElementPropertyConfig; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import org.json.simple.parser.JSONParser; | |||
import org.json.simple.parser.ParseException; | |||
import javax.annotation.Nullable; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.io.InputStreamReader; | |||
@@ -44,14 +41,14 @@ import java.util.List; | |||
import java.util.Map; | |||
import java.util.Set; | |||
import static com.tinkerpop.blueprints.util.io.graphson.ElementPropertyConfig.ElementPropertiesRule; | |||
import static org.sonar.core.graph.graphson.ElementPropertyConfig.ElementPropertiesRule; | |||
/** | |||
* Helps write individual graph elements to TinkerPop JSON format known as GraphSON. | |||
* | |||
* @author Stephen Mallette (http://stephen.genoprime.com) | |||
*/ | |||
public final class GraphSONUtility { | |||
class GraphsonUtil { | |||
private final GraphSONMode mode; | |||
private final Set<String> vertexPropertyKeys; | |||
@@ -72,20 +69,20 @@ public final class GraphSONUtility { | |||
/** | |||
* A GraphSONUtiltiy that includes all properties of vertices and edges. | |||
*/ | |||
public GraphSONUtility(final GraphSONMode mode, final ElementFactory factory) { | |||
GraphsonUtil(GraphSONMode mode, ElementFactory factory) { | |||
this(mode, factory, ElementPropertyConfig.AllProperties); | |||
} | |||
/** | |||
* A GraphSONUtility that includes the specified properties. | |||
*/ | |||
public GraphSONUtility(final GraphSONMode mode, final ElementFactory factory, | |||
final Set<String> vertexPropertyKeys, final Set<String> edgePropertyKeys) { | |||
this(mode, factory, ElementPropertyConfig.IncludeProperties(vertexPropertyKeys, edgePropertyKeys)); | |||
GraphsonUtil(GraphSONMode mode, ElementFactory factory, | |||
Set<String> vertexPropertyKeys, Set<String> edgePropertyKeys) { | |||
this(mode, factory, ElementPropertyConfig.includeProperties(vertexPropertyKeys, edgePropertyKeys)); | |||
} | |||
public GraphSONUtility(final GraphSONMode mode, final ElementFactory factory, | |||
final ElementPropertyConfig config) { | |||
GraphsonUtil(GraphSONMode mode, ElementFactory factory, | |||
ElementPropertyConfig config) { | |||
this.vertexPropertyKeys = config.getVertexPropertyKeys(); | |||
this.edgePropertyKeys = config.getEdgePropertyKeys(); | |||
this.vertexPropertiesRule = config.getVertexPropertiesRule(); | |||
@@ -111,10 +108,9 @@ public final class GraphSONUtility { | |||
* @param propertyKeys The property keys at the root of the element to serialize. If null, then all keys are serialized. | |||
* @param mode the type of GraphSON to be generated. | |||
*/ | |||
public static JSONObject jsonFromElement(final Element element, final Set<String> propertyKeys, | |||
final GraphSONMode mode) { | |||
final GraphSONUtility graphson = element instanceof Edge ? new GraphSONUtility(mode, null, null, propertyKeys) | |||
: new GraphSONUtility(mode, null, propertyKeys, null); | |||
static JSONObject jsonFromElement(Element element, @Nullable Set<String> propertyKeys, GraphSONMode mode) { | |||
GraphsonUtil graphson = element instanceof Edge ? new GraphsonUtil(mode, null, null, propertyKeys) | |||
: new GraphsonUtil(mode, null, propertyKeys, null); | |||
return graphson.jsonFromElement(element); | |||
} | |||
@@ -125,9 +121,9 @@ public final class GraphSONUtility { | |||
* @param propertyKeys The property keys at the root of the element to serialize. If null, then all keys are serialized. | |||
* @param mode The type of GraphSON to generate. | |||
*/ | |||
public static JSONObject objectNodeFromElement(final Element element, final Set<String> propertyKeys, final GraphSONMode mode) { | |||
final GraphSONUtility graphson = element instanceof Edge ? new GraphSONUtility(mode, null, null, propertyKeys) | |||
: new GraphSONUtility(mode, null, propertyKeys, null); | |||
static JSONObject objectNodeFromElement(Element element, Set<String> propertyKeys, GraphSONMode mode) { | |||
GraphsonUtil graphson = element instanceof Edge ? new GraphsonUtil(mode, null, null, propertyKeys) | |||
: new GraphsonUtil(mode, null, propertyKeys, null); | |||
return graphson.objectNodeFromElement(element); | |||
} | |||
@@ -139,9 +135,9 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include on reading of element properties | |||
*/ | |||
public static Vertex vertexFromJson(final JSONObject json, final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws IOException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, propertyKeys, null); | |||
static Vertex vertexFromJson(JSONObject json, ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws IOException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, propertyKeys, null); | |||
return graphson.vertexFromJson(json); | |||
} | |||
@@ -153,9 +149,9 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include on reading of element properties | |||
*/ | |||
public static Vertex vertexFromJson(final String json, final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws ParseException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, propertyKeys, null); | |||
static Vertex vertexFromJson(String json, ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws ParseException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, propertyKeys, null); | |||
return graphson.vertexFromJson(json); | |||
} | |||
@@ -167,22 +163,22 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include on reading of element properties | |||
*/ | |||
public static Vertex vertexFromJson(final InputStream json, final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws IOException, ParseException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, propertyKeys, null); | |||
static Vertex vertexFromJson(InputStream json, ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws IOException, ParseException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, propertyKeys, null); | |||
return graphson.vertexFromJson(json); | |||
} | |||
private static boolean includeReservedKey(final GraphSONMode mode, final String key, | |||
final Set<String> propertyKeys, | |||
final ElementPropertiesRule rule) { | |||
private static boolean includeReservedKey(GraphSONMode mode, String key, | |||
Set<String> propertyKeys, | |||
ElementPropertiesRule rule) { | |||
// the key is always included in modes other than compact. if it is compact, then validate that the | |||
// key is in the property key list | |||
return mode != GraphSONMode.COMPACT || includeKey(key, propertyKeys, rule); | |||
} | |||
private static boolean includeKey(final String key, final Set<String> propertyKeys, | |||
final ElementPropertiesRule rule) { | |||
private static boolean includeKey(String key, Set<String> propertyKeys, | |||
ElementPropertiesRule rule) { | |||
if (propertyKeys == null) { | |||
// when null always include the key and shortcut this piece | |||
return true; | |||
@@ -212,10 +208,10 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include when reading of element properties | |||
*/ | |||
public static Edge edgeFromJson(final String json, final Vertex out, final Vertex in, | |||
final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws IOException, ParseException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, null, propertyKeys); | |||
static Edge edgeFromJson(String json, Vertex out, Vertex in, | |||
ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws IOException, ParseException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, null, propertyKeys); | |||
return graphson.edgeFromJson(json, out, in); | |||
} | |||
@@ -227,10 +223,10 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include when reading of element properties | |||
*/ | |||
public static Edge edgeFromJson(final InputStream json, final Vertex out, final Vertex in, | |||
final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws IOException, ParseException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, null, propertyKeys); | |||
static Edge edgeFromJson(InputStream json, Vertex out, Vertex in, | |||
ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws IOException, ParseException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, null, propertyKeys); | |||
return graphson.edgeFromJson(json, out, in); | |||
} | |||
@@ -242,15 +238,15 @@ public final class GraphSONUtility { | |||
* @param mode the mode of the GraphSON | |||
* @param propertyKeys a list of keys to include when reading of element properties | |||
*/ | |||
public static Edge edgeFromJson(final JSONObject json, final Vertex out, final Vertex in, | |||
final ElementFactory factory, final GraphSONMode mode, | |||
final Set<String> propertyKeys) throws IOException { | |||
final GraphSONUtility graphson = new GraphSONUtility(mode, factory, null, propertyKeys); | |||
static Edge edgeFromJson(JSONObject json, Vertex out, Vertex in, | |||
ElementFactory factory, GraphSONMode mode, | |||
Set<String> propertyKeys) throws IOException { | |||
GraphsonUtil graphson = new GraphsonUtil(mode, factory, null, propertyKeys); | |||
return graphson.edgeFromJson(json, out, in); | |||
} | |||
static Map<String, Object> readProperties(final JSONObject node, final boolean ignoreReservedKeys, final boolean hasEmbeddedTypes) { | |||
final Map<String, Object> map = new HashMap<String, Object>(); | |||
static Map<String, Object> readProperties(JSONObject node, boolean ignoreReservedKeys, boolean hasEmbeddedTypes) { | |||
Map<String, Object> map = new HashMap<String, Object>(); | |||
for (Object objKey : node.keySet()) { | |||
String key = (String) objKey; | |||
@@ -264,17 +260,17 @@ public final class GraphSONUtility { | |||
return map; | |||
} | |||
private static boolean isReservedKey(final String key) { | |||
private static boolean isReservedKey(String key) { | |||
return key.equals(GraphSONTokens._ID) || key.equals(GraphSONTokens._TYPE) || key.equals(GraphSONTokens._LABEL) | |||
|| key.equals(GraphSONTokens._OUT_V) || key.equals(GraphSONTokens._IN_V); | |||
|| key.equals(GraphSONTokens._OUT_V) || key.equals(GraphSONTokens._IN_V); | |||
} | |||
private static JSONArray createJSONList(final List list, final Set<String> propertyKeys, final boolean showTypes) { | |||
private static JSONArray createJSONList(List list, Set<String> propertyKeys, boolean showTypes) { | |||
JSONArray jsonList = new JSONArray(); | |||
for (Object item : list) { | |||
if (item instanceof Element) { | |||
jsonList.add(objectNodeFromElement((Element) item, propertyKeys, | |||
showTypes ? GraphSONMode.EXTENDED : GraphSONMode.NORMAL)); | |||
showTypes ? GraphSONMode.EXTENDED : GraphSONMode.NORMAL)); | |||
} else if (item instanceof List) { | |||
jsonList.add(createJSONList((List) item, propertyKeys, showTypes)); | |||
} else if (item instanceof Map) { | |||
@@ -289,8 +285,8 @@ public final class GraphSONUtility { | |||
} | |||
// | |||
private static JSONObject createJSONMap(final Map map, final Set<String> propertyKeys, final boolean showTypes) { | |||
final JSONObject jsonMap = new JSONObject(); | |||
private static JSONObject createJSONMap(Map map, Set<String> propertyKeys, boolean showTypes) { | |||
JSONObject jsonMap = new JSONObject(); | |||
for (Object key : map.keySet()) { | |||
Object value = map.get(key); | |||
if (value != null) { | |||
@@ -300,7 +296,7 @@ public final class GraphSONUtility { | |||
value = createJSONMap((Map) value, propertyKeys, showTypes); | |||
} else if (value instanceof Element) { | |||
value = objectNodeFromElement((Element) value, propertyKeys, | |||
showTypes ? GraphSONMode.EXTENDED : GraphSONMode.NORMAL); | |||
showTypes ? GraphSONMode.EXTENDED : GraphSONMode.NORMAL); | |||
} else if (value.getClass().isArray()) { | |||
value = createJSONList(convertArrayToList(value), propertyKeys, showTypes); | |||
} | |||
@@ -312,7 +308,7 @@ public final class GraphSONUtility { | |||
} | |||
private static Object readProperty(final Object node, final boolean hasEmbeddedTypes) { | |||
private static Object readProperty(Object node, boolean hasEmbeddedTypes) { | |||
Object propertyValue; | |||
if (hasEmbeddedTypes) { | |||
@@ -363,7 +359,7 @@ public final class GraphSONUtility { | |||
return propertyValue; | |||
} | |||
private static void putObject(final JSONObject jsonMap, final String key, final Object value) { | |||
private static void putObject(JSONObject jsonMap, String key, Object value) { | |||
if (value == null) { | |||
jsonMap.put(key, null); | |||
} else if (value instanceof Boolean) { | |||
@@ -387,8 +383,8 @@ public final class GraphSONUtility { | |||
} | |||
} | |||
private static List readProperties(final Iterator<JSONObject> listOfNodes, final boolean hasEmbeddedTypes) { | |||
final List array = new ArrayList(); | |||
private static List readProperties(Iterator<JSONObject> listOfNodes, boolean hasEmbeddedTypes) { | |||
List array = new ArrayList(); | |||
while (listOfNodes.hasNext()) { | |||
array.add(readProperty(listOfNodes.next(), hasEmbeddedTypes)); | |||
@@ -397,7 +393,7 @@ public final class GraphSONUtility { | |||
return array; | |||
} | |||
private static void addObject(final JSONArray jsonList, final Object value) { | |||
private static void addObject(JSONArray jsonList, Object value) { | |||
if (value == null) { | |||
jsonList.add(null); | |||
} else if (value instanceof Boolean) { | |||
@@ -421,8 +417,8 @@ public final class GraphSONUtility { | |||
} | |||
} | |||
private static Map createPropertyMap(final Element element, final Set<String> propertyKeys, final ElementPropertiesRule rule) { | |||
final Map map = new HashMap<String, Object>(); | |||
private static Map createPropertyMap(Element element, Set<String> propertyKeys, ElementPropertiesRule rule) { | |||
Map map = new HashMap<String, Object>(); | |||
if (propertyKeys == null) { | |||
for (String key : element.getPropertyKeys()) { | |||
@@ -448,7 +444,7 @@ public final class GraphSONUtility { | |||
return map; | |||
} | |||
private static Object getValue(Object value, final boolean includeType) { | |||
private static Object getValue(Object value, boolean includeType) { | |||
Object returnValue = value; | |||
@@ -509,7 +505,7 @@ public final class GraphSONUtility { | |||
return returnValue; | |||
} | |||
private static List convertArrayToList(final Object value) { | |||
private static List convertArrayToList(Object value) { | |||
// is there seriously no better way to do this...bah! | |||
List list = new ArrayList(); | |||
@@ -545,7 +541,7 @@ public final class GraphSONUtility { | |||
return list; | |||
} | |||
private static String determineType(final Object value) { | |||
private static String determineType(Object value) { | |||
String type = GraphSONTokens.TYPE_STRING; | |||
if (value == null) { | |||
type = "unknown"; | |||
@@ -571,37 +567,37 @@ public final class GraphSONUtility { | |||
/** | |||
* Creates a vertex from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Vertex vertexFromJson(final InputStream json) throws ParseException, IOException { | |||
Vertex vertexFromJson(InputStream json) throws ParseException, IOException { | |||
return this.vertexFromJson((JSONObject) parser.parse(new InputStreamReader(json))); | |||
} | |||
/** | |||
* Creates an edge from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Edge edgeFromJson(final String json, final Vertex out, final Vertex in) throws IOException, ParseException { | |||
Edge edgeFromJson(String json, Vertex out, Vertex in) throws IOException, ParseException { | |||
return this.edgeFromJson((JSONObject) parser.parse(json), out, in); | |||
} | |||
/** | |||
* Creates an edge from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Edge edgeFromJson(final InputStream json, final Vertex out, final Vertex in) throws IOException, ParseException { | |||
Edge edgeFromJson(InputStream json, Vertex out, Vertex in) throws IOException, ParseException { | |||
return this.edgeFromJson((JSONObject) parser.parse(new InputStreamReader(json)), out, in); | |||
} | |||
/** | |||
* Creates an edge from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Edge edgeFromJson(final JSONObject json, final Vertex out, final Vertex in) throws IOException { | |||
final Map<String, Object> props = GraphSONUtility.readProperties(json, true, this.hasEmbeddedTypes); | |||
Edge edgeFromJson(JSONObject json, Vertex out, Vertex in) throws IOException { | |||
Map<String, Object> props = GraphsonUtil.readProperties(json, true, this.hasEmbeddedTypes); | |||
// final Object edgeId = getTypedValueFromJsonNode(json.get(GraphSONTokens._ID)); | |||
final Object edgeId = json.get(GraphSONTokens._ID); | |||
// Object edgeId = getTypedValueFromJsonNode(json.get(GraphSONTokens._ID)); | |||
Object edgeId = json.get(GraphSONTokens._ID); | |||
final Object nodeLabel = json.get(GraphSONTokens._LABEL); | |||
final String label = nodeLabel == null ? null : nodeLabel.toString(); | |||
Object nodeLabel = json.get(GraphSONTokens._LABEL); | |||
String label = nodeLabel == null ? null : nodeLabel.toString(); | |||
final Edge e = factory.createEdge(edgeId, out, in, label); | |||
Edge e = factory.createEdge(edgeId, out, in, label); | |||
for (Map.Entry<String, Object> entry : props.entrySet()) { | |||
// if (this.edgePropertyKeys == null || this.edgePropertyKeys.contains(entry.getKey())) { | |||
@@ -616,19 +612,19 @@ public final class GraphSONUtility { | |||
/** | |||
* Creates a vertex from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Vertex vertexFromJson(final String json) throws ParseException { | |||
Vertex vertexFromJson(String json) throws ParseException { | |||
return this.vertexFromJson((JSONObject) parser.parse(json)); | |||
} | |||
/** | |||
* Creates a vertex from GraphSON using settings supplied in the constructor. | |||
*/ | |||
public Vertex vertexFromJson(final JSONObject json) { | |||
final Map<String, Object> props = readProperties(json, true, this.hasEmbeddedTypes); | |||
Vertex vertexFromJson(JSONObject json) { | |||
Map<String, Object> props = readProperties(json, true, this.hasEmbeddedTypes); | |||
//final Object vertexId = getTypedValueFromJsonNode((JSONObject)json.get(GraphSONTokens._ID)); | |||
final Object vertexId = json.get(GraphSONTokens._ID); | |||
final Vertex v = factory.createVertex(vertexId); | |||
//Object vertexId = getTypedValueFromJsonNode((JSONObject)json.get(GraphSONTokens._ID)); | |||
Object vertexId = json.get(GraphSONTokens._ID); | |||
Vertex v = factory.createVertex(vertexId); | |||
for (Map.Entry<String, Object> entry : props.entrySet()) { | |||
//if (this.vertexPropertyKeys == null || vertexPropertyKeys.contains(entry.getKey())) { | |||
@@ -643,21 +639,21 @@ public final class GraphSONUtility { | |||
/** | |||
* Creates GraphSON for a single graph element. | |||
*/ | |||
public JSONObject jsonFromElement(final Element element) { | |||
final JSONObject objectNode = this.objectNodeFromElement(element); | |||
JSONObject jsonFromElement(Element element) { | |||
JSONObject objectNode = this.objectNodeFromElement(element); | |||
return objectNode; | |||
} | |||
/** | |||
* Creates GraphSON for a single graph element. | |||
*/ | |||
public org.json.simple.JSONObject objectNodeFromElement(final Element element) { | |||
final boolean isEdge = element instanceof Edge; | |||
final boolean showTypes = mode == GraphSONMode.EXTENDED; | |||
final Set<String> propertyKeys = isEdge ? this.edgePropertyKeys : this.vertexPropertyKeys; | |||
final ElementPropertiesRule elementPropertyConfig = isEdge ? this.edgePropertiesRule : this.vertexPropertiesRule; | |||
org.json.simple.JSONObject objectNodeFromElement(Element element) { | |||
boolean isEdge = element instanceof Edge; | |||
boolean showTypes = mode == GraphSONMode.EXTENDED; | |||
Set<String> propertyKeys = isEdge ? this.edgePropertyKeys : this.vertexPropertyKeys; | |||
ElementPropertiesRule elementPropertyConfig = isEdge ? this.edgePropertiesRule : this.vertexPropertiesRule; | |||
final org.json.simple.JSONObject jsonElement = createJSONMap(createPropertyMap(element, propertyKeys, elementPropertyConfig), propertyKeys, showTypes); | |||
org.json.simple.JSONObject jsonElement = createJSONMap(createPropertyMap(element, propertyKeys, elementPropertyConfig), propertyKeys, showTypes); | |||
if ((isEdge && this.includeReservedEdgeId) || (!isEdge && this.includeReservedVertexId)) { | |||
putObject(jsonElement, GraphSONTokens._ID, element.getId()); | |||
@@ -666,7 +662,7 @@ public final class GraphSONUtility { | |||
// it's important to keep the order of these straight. check Edge first and then Vertex because there | |||
// are graph implementations that have Edge extend from Vertex | |||
if (element instanceof Edge) { | |||
final Edge edge = (Edge) element; | |||
Edge edge = (Edge) element; | |||
if (this.includeReservedEdgeId) { | |||
putObject(jsonElement, GraphSONTokens._ID, element.getId()); |
@@ -17,17 +17,13 @@ | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Direction; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.impls.tg.TinkerGraph; | |||
import com.tinkerpop.blueprints.impls.tg.TinkerGraphFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import org.junit.Assert; | |||
import org.junit.Test; | |||
@@ -40,7 +36,7 @@ import java.util.List; | |||
import java.util.Map; | |||
import java.util.Set; | |||
public class GraphSONReaderTest { | |||
public class GraphsonReaderTest { | |||
@Test | |||
public void inputGraphModeExtended() throws Exception { | |||
@@ -51,7 +47,7 @@ public class GraphSONReaderTest { | |||
byte[] bytes = json.getBytes(); | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
GraphSONReader.inputGraph(graph, inputStream); | |||
new GraphSONReader().read(inputStream, graph); | |||
Assert.assertEquals(2, getIterableCount(graph.getVertices())); | |||
Assert.assertEquals(1, getIterableCount(graph.getEdges())); | |||
@@ -102,7 +98,7 @@ public class GraphSONReaderTest { | |||
byte[] bytes = json.getBytes(); | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
GraphSONReader.inputGraph(graph, inputStream); | |||
new GraphSONReader().read(inputStream, graph); | |||
Assert.assertEquals(2, getIterableCount(graph.getVertices())); | |||
Assert.assertEquals(1, getIterableCount(graph.getEdges())); | |||
@@ -153,7 +149,7 @@ public class GraphSONReaderTest { | |||
byte[] bytes = json.getBytes(); | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
GraphSONReader.inputGraph(graph, inputStream); | |||
new GraphSONReader().read(inputStream, graph); | |||
Assert.assertEquals(2, getIterableCount(graph.getVertices())); | |||
Assert.assertEquals(1, getIterableCount(graph.getEdges())); | |||
@@ -172,8 +168,8 @@ public class GraphSONReaderTest { | |||
Assert.assertEquals(4, list.size()); | |||
boolean foundNull = false; | |||
for (int ix = 0; ix < list.size(); ix++) { | |||
if (list.get(ix) == null) { | |||
for (Object aList : list) { | |||
if (aList == null) { | |||
foundNull = true; | |||
break; | |||
} | |||
@@ -201,8 +197,8 @@ public class GraphSONReaderTest { | |||
ByteArrayOutputStream stream = new ByteArrayOutputStream(); | |||
GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(stream, null, null, GraphSONMode.EXTENDED); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(graph, stream, GraphSONMode.EXTENDED); | |||
stream.flush(); | |||
stream.close(); | |||
@@ -213,7 +209,7 @@ public class GraphSONReaderTest { | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
TinkerGraph emptyGraph = new TinkerGraph(); | |||
GraphSONReader.inputGraph(emptyGraph, inputStream); | |||
new GraphSONReader().read(inputStream, emptyGraph); | |||
Assert.assertEquals(6, getIterableCount(emptyGraph.getVertices())); | |||
Assert.assertEquals(6, getIterableCount(emptyGraph.getEdges())); | |||
@@ -255,8 +251,8 @@ public class GraphSONReaderTest { | |||
Set<String> vertexKeys = new HashSet<String>(); | |||
vertexKeys.add(GraphSONTokens._ID); | |||
GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(stream, vertexKeys, edgeKeys, GraphSONMode.COMPACT); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(graph, stream, GraphSONMode.EXTENDED, vertexKeys, edgeKeys); | |||
stream.flush(); | |||
stream.close(); | |||
@@ -267,7 +263,7 @@ public class GraphSONReaderTest { | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
TinkerGraph emptyGraph = new TinkerGraph(); | |||
GraphSONReader.inputGraph(emptyGraph, inputStream); | |||
new GraphSONReader().read(inputStream, emptyGraph); | |||
Assert.assertEquals(6, getIterableCount(emptyGraph.getVertices())); | |||
Assert.assertEquals(6, getIterableCount(emptyGraph.getEdges())); | |||
@@ -300,7 +296,7 @@ public class GraphSONReaderTest { | |||
} | |||
@Test(expected = IllegalArgumentException.class) | |||
@Test(expected = GraphSonException.class) | |||
public void inputGraphCompactFullCycleBroken() throws Exception { | |||
TinkerGraph graph = TinkerGraphFactory.createTinkerGraph(); | |||
@@ -313,8 +309,8 @@ public class GraphSONReaderTest { | |||
Set<String> vertexKeys = new HashSet<String>(); | |||
GraphSONWriter writer = new GraphSONWriter(graph); | |||
writer.outputGraph(stream, vertexKeys, edgeKeys, GraphSONMode.COMPACT); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(graph, stream, GraphSONMode.COMPACT, vertexKeys, edgeKeys); | |||
stream.flush(); | |||
stream.close(); | |||
@@ -325,7 +321,7 @@ public class GraphSONReaderTest { | |||
InputStream inputStream = new ByteArrayInputStream(bytes); | |||
TinkerGraph emptyGraph = new TinkerGraph(); | |||
GraphSONReader.inputGraph(emptyGraph, inputStream); | |||
new GraphSONReader().read(inputStream, emptyGraph); | |||
} | |||
@@ -17,18 +17,13 @@ | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Direction; | |||
import com.tinkerpop.blueprints.Edge; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.Vertex; | |||
import com.tinkerpop.blueprints.impls.tg.TinkerGraph; | |||
import com.tinkerpop.blueprints.util.io.graphson.ElementFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.ElementPropertyConfig; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphElementFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
@@ -48,7 +43,7 @@ import java.util.Set; | |||
import static org.fest.assertions.Assertions.assertThat; | |||
public class GraphSONUtilityTest { | |||
public class GraphsonUtilTest { | |||
private final String vertexJson1 = "{\"name\":\"marko\",\"age\":29,\"_id\":1,\"_type\":\"vertex\"}"; | |||
private final String vertexJson2 = "{\"name\":\"vadas\",\"age\":27,\"_id\":2,\"_type\":\"vertex\"}"; | |||
private final String edgeJsonLight = "{\"weight\":0.5,\"_outV\":1,\"_inV\":2}"; | |||
@@ -73,7 +68,7 @@ public class GraphSONUtilityTest { | |||
Edge e = this.graph.addEdge(3, v1, v2, "test"); | |||
e.setProperty("weight", 0.5f); | |||
JSONObject json = GraphSONUtility.jsonFromElement(e, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(e, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._ID)).isTrue(); | |||
@@ -102,7 +97,7 @@ public class GraphSONUtilityTest { | |||
add(GraphSONTokens._ID); | |||
}}; | |||
JSONObject json = GraphSONUtility.jsonFromElement(e, propertiesToInclude, GraphSONMode.COMPACT); | |||
JSONObject json = GraphsonUtil.jsonFromElement(e, propertiesToInclude, GraphSONMode.COMPACT); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._TYPE)).isFalse(); | |||
@@ -115,7 +110,7 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void jsonFromElementEdgeCompactIdOnlyAsExclude() { | |||
ElementFactory factory = new GraphElementFactory(this.graph); | |||
ElementFactory factory = new ElementFactory(this.graph); | |||
Vertex v1 = this.graph.addVertex(1); | |||
Vertex v2 = this.graph.addVertex(2); | |||
@@ -134,7 +129,7 @@ public class GraphSONUtilityTest { | |||
ElementPropertyConfig config = new ElementPropertyConfig(null, propertiesToExclude, | |||
ElementPropertyConfig.ElementPropertiesRule.INCLUDE, | |||
ElementPropertyConfig.ElementPropertiesRule.EXCLUDE); | |||
GraphSONUtility utility = new GraphSONUtility(GraphSONMode.COMPACT, factory, config); | |||
GraphsonUtil utility = new GraphsonUtil(GraphSONMode.COMPACT, factory, config); | |||
JSONObject json = utility.jsonFromElement(e); | |||
assertThat(json).isNotNull(); | |||
@@ -156,7 +151,7 @@ public class GraphSONUtilityTest { | |||
Edge e = this.graph.addEdge(3, v1, v2, "test"); | |||
e.setProperty("weight", 0.5f); | |||
JSONObject json = GraphSONUtility.jsonFromElement(e, null, GraphSONMode.COMPACT); | |||
JSONObject json = GraphsonUtil.jsonFromElement(e, null, GraphSONMode.COMPACT); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._ID)).isTrue(); | |||
@@ -172,7 +167,7 @@ public class GraphSONUtilityTest { | |||
Vertex v = this.graph.addVertex(1); | |||
v.setProperty("name", "marko"); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._ID)).isTrue(); | |||
@@ -191,7 +186,7 @@ public class GraphSONUtilityTest { | |||
add(GraphSONTokens._ID); | |||
}}; | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, propertiesToInclude, GraphSONMode.COMPACT); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, propertiesToInclude, GraphSONMode.COMPACT); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._TYPE)).isFalse(); | |||
@@ -201,7 +196,7 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void jsonFromElementVertexCompactIdNameOnlyAsExclude() { | |||
GraphElementFactory factory = new GraphElementFactory(this.graph); | |||
ElementFactory factory = new ElementFactory(this.graph); | |||
Vertex v = this.graph.addVertex(1); | |||
v.setProperty("name", "marko"); | |||
@@ -213,7 +208,7 @@ public class GraphSONUtilityTest { | |||
ElementPropertyConfig.ElementPropertiesRule.EXCLUDE, | |||
ElementPropertyConfig.ElementPropertiesRule.EXCLUDE); | |||
GraphSONUtility utility = new GraphSONUtility(GraphSONMode.COMPACT, factory, config); | |||
GraphsonUtil utility = new GraphsonUtil(GraphSONMode.COMPACT, factory, config); | |||
JSONObject json = utility.jsonFromElement(v); | |||
assertThat(json).isNotNull(); | |||
@@ -227,7 +222,7 @@ public class GraphSONUtilityTest { | |||
Vertex v = this.graph.addVertex(1); | |||
v.setProperty("name", "marko"); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.COMPACT); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.COMPACT); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._TYPE)).isTrue(); | |||
@@ -246,7 +241,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyDouble", 4.4); | |||
v.setProperty("keyBoolean", true); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.containsKey(GraphSONTokens._ID)).isTrue(); | |||
@@ -276,7 +271,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyMap", map); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -301,7 +296,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -319,7 +314,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyStringArray", stringArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -337,7 +332,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyDoubleArray", doubleArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -355,7 +350,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyIntArray", intArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -373,7 +368,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyLongArray", longArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -391,7 +386,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyFloatArray", floatArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -409,7 +404,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyBooleanArray", booleanArray); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -425,7 +420,7 @@ public class GraphSONUtilityTest { | |||
Vertex v = this.graph.addVertex(1); | |||
v.setProperty("mycat", new Cat("smithers")); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -438,7 +433,7 @@ public class GraphSONUtilityTest { | |||
Vertex v = this.graph.addVertex(1); | |||
v.setProperty("mycat", new Cat("smithers")); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -458,7 +453,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("cats", cats); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -494,7 +489,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("crazy-map", map); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -528,7 +523,7 @@ public class GraphSONUtilityTest { | |||
Set<String> propertiesToInclude = new HashSet<String>(); | |||
propertiesToInclude.add("y"); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, propertiesToInclude, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, propertiesToInclude, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -556,7 +551,7 @@ public class GraphSONUtilityTest { | |||
propertiesToInclude.add("y"); | |||
propertiesToInclude.add("v"); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, propertiesToInclude, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, propertiesToInclude, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -583,7 +578,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyDouble", 4.4); | |||
v.setProperty("keyBoolean", true); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -636,7 +631,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -671,7 +666,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -706,7 +701,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -741,7 +736,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -779,7 +774,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyList", listList); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -816,7 +811,7 @@ public class GraphSONUtilityTest { | |||
v.setProperty("keyMap", map); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get(GraphSONTokens._ID)).isEqualTo("1"); | |||
@@ -866,7 +861,7 @@ public class GraphSONUtilityTest { | |||
list.add("string"); | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.NORMAL); | |||
assertThat(json).isNotNull(); | |||
assertThat(json.get("key")).isNull(); | |||
@@ -908,7 +903,7 @@ public class GraphSONUtilityTest { | |||
list.add("string"); | |||
v.setProperty("keyList", list); | |||
JSONObject json = GraphSONUtility.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
JSONObject json = GraphsonUtil.jsonFromElement(v, null, GraphSONMode.EXTENDED); | |||
assertThat(json).isNotNull(); | |||
@@ -941,9 +936,9 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void vertexFromJsonValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
assertThat(v).isSameAs(g.getVertex(1)); | |||
@@ -956,9 +951,9 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void vertexFromJsonStringValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v = GraphSONUtility.vertexFromJson(vertexJson1, factory, GraphSONMode.NORMAL, null); | |||
Vertex v = GraphsonUtil.vertexFromJson(vertexJson1, factory, GraphSONMode.NORMAL, null); | |||
assertThat(v).isSameAs(g.getVertex(1)); | |||
@@ -971,10 +966,10 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void vertexFromJsonStringValidExtended() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
String vertexJson = "{\"person\":{\"value\":\"marko\",\"type\":\"string\"},\"_id\":1,\"_type\":\"vertex\"}"; | |||
Vertex v = GraphSONUtility.vertexFromJson(vertexJson, factory, GraphSONMode.EXTENDED, null); | |||
Vertex v = GraphsonUtil.vertexFromJson(vertexJson, factory, GraphSONMode.EXTENDED, null); | |||
Assert.assertSame(v, g.getVertex(1)); | |||
@@ -986,9 +981,9 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void vertexFromJsonInputStreamValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v = GraphSONUtility.vertexFromJson(inputStreamVertexJson1, factory, GraphSONMode.NORMAL, null); | |||
Vertex v = GraphsonUtil.vertexFromJson(inputStreamVertexJson1, factory, GraphSONMode.NORMAL, null); | |||
Assert.assertSame(v, g.getVertex(1)); | |||
@@ -1001,12 +996,12 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void vertexFromJsonIgnoreKeyValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Set<String> ignoreAge = new HashSet<String>(); | |||
ignoreAge.add("age"); | |||
ElementPropertyConfig config = ElementPropertyConfig.ExcludeProperties(ignoreAge, null); | |||
GraphSONUtility utility = new GraphSONUtility(GraphSONMode.NORMAL, factory, config); | |||
ElementPropertyConfig config = ElementPropertyConfig.excludeProperties(ignoreAge, null); | |||
GraphsonUtil utility = new GraphsonUtil(GraphSONMode.NORMAL, factory, config); | |||
Vertex v = utility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1)); | |||
Assert.assertSame(v, g.getVertex(1)); | |||
@@ -1020,11 +1015,11 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v1 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphSONUtility.edgeFromJson((JSONObject) JSONValue.parse(edgeJson), v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Vertex v1 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphsonUtil.edgeFromJson((JSONObject) JSONValue.parse(edgeJson), v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Assert.assertSame(v1, g.getVertex(1)); | |||
Assert.assertSame(v2, g.getVertex(2)); | |||
@@ -1041,11 +1036,11 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonStringValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v1 = GraphSONUtility.vertexFromJson(vertexJson1, factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphSONUtility.vertexFromJson(vertexJson2, factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphSONUtility.edgeFromJson(edgeJson, v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Vertex v1 = GraphsonUtil.vertexFromJson(vertexJson1, factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphsonUtil.vertexFromJson(vertexJson2, factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphsonUtil.edgeFromJson(edgeJson, v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Assert.assertSame(v1, g.getVertex(1)); | |||
Assert.assertSame(v2, g.getVertex(2)); | |||
@@ -1062,15 +1057,15 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonIgnoreWeightValid() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v1 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Vertex v1 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Set<String> ignoreWeight = new HashSet<String>(); | |||
ignoreWeight.add("weight"); | |||
ElementPropertyConfig config = ElementPropertyConfig.ExcludeProperties(null, ignoreWeight); | |||
GraphSONUtility utility = new GraphSONUtility(GraphSONMode.NORMAL, factory, config); | |||
ElementPropertyConfig config = ElementPropertyConfig.excludeProperties(null, ignoreWeight); | |||
GraphsonUtil utility = new GraphsonUtil(GraphSONMode.NORMAL, factory, config); | |||
Edge e = utility.edgeFromJson((JSONObject) JSONValue.parse(edgeJson), v1, v2); | |||
Assert.assertSame(v1, g.getVertex(1)); | |||
@@ -1088,11 +1083,11 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonNormalLabelOrIdOnEdge() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v1 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphSONUtility.edgeFromJson((JSONObject) JSONValue.parse(edgeJsonLight), v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Vertex v1 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.NORMAL, null); | |||
Vertex v2 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.NORMAL, null); | |||
Edge e = GraphsonUtil.edgeFromJson((JSONObject) JSONValue.parse(edgeJsonLight), v1, v2, factory, GraphSONMode.NORMAL, null); | |||
Assert.assertSame(v1, g.getVertex(1)); | |||
Assert.assertSame(v2, g.getVertex(2)); | |||
@@ -1102,11 +1097,11 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonInputStreamCompactLabelOrIdOnEdge() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Vertex v1 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.COMPACT, null); | |||
Vertex v2 = GraphSONUtility.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.COMPACT, null); | |||
Edge e = GraphSONUtility.edgeFromJson(inputStreamEdgeJsonLight, v1, v2, factory, GraphSONMode.COMPACT, null); | |||
Vertex v1 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1), factory, GraphSONMode.COMPACT, null); | |||
Vertex v2 = GraphsonUtil.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2), factory, GraphSONMode.COMPACT, null); | |||
Edge e = GraphsonUtil.edgeFromJson(inputStreamEdgeJsonLight, v1, v2, factory, GraphSONMode.COMPACT, null); | |||
Assert.assertSame(v1, g.getVertex(1)); | |||
Assert.assertSame(v2, g.getVertex(2)); | |||
@@ -1116,7 +1111,7 @@ public class GraphSONUtilityTest { | |||
@Test | |||
public void edgeFromJsonInputStreamCompactNoIdOnEdge() throws Exception { | |||
Graph g = new TinkerGraph(); | |||
ElementFactory factory = new GraphElementFactory(g); | |||
ElementFactory factory = new ElementFactory(g); | |||
Set<String> vertexKeys = new HashSet<String>() {{ | |||
add(GraphSONTokens._ID); | |||
@@ -1126,7 +1121,7 @@ public class GraphSONUtilityTest { | |||
add(GraphSONTokens._IN_V); | |||
}}; | |||
GraphSONUtility graphson = new GraphSONUtility(GraphSONMode.COMPACT, factory, vertexKeys, edgeKeys); | |||
GraphsonUtil graphson = new GraphsonUtil(GraphSONMode.COMPACT, factory, vertexKeys, edgeKeys); | |||
Vertex v1 = graphson.vertexFromJson((JSONObject) JSONValue.parse(vertexJson1)); | |||
Vertex v2 = graphson.vertexFromJson((JSONObject) JSONValue.parse(vertexJson2)); |
@@ -17,13 +17,10 @@ | |||
* License along with Sonar; if not, write to the Free Software | |||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02 | |||
*/ | |||
package org.sonar.core.graph; | |||
package org.sonar.core.graph.graphson; | |||
import com.tinkerpop.blueprints.Graph; | |||
import com.tinkerpop.blueprints.impls.tg.TinkerGraphFactory; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONMode; | |||
import com.tinkerpop.blueprints.util.io.graphson.GraphSONTokens; | |||
import org.json.simple.JSONArray; | |||
import org.json.simple.JSONObject; | |||
import org.json.simple.JSONValue; | |||
@@ -33,7 +30,7 @@ import java.io.ByteArrayOutputStream; | |||
import static org.fest.assertions.Assertions.assertThat; | |||
public class GraphSONWriterTest { | |||
public class GraphsonWriterTest { | |||
@Test | |||
public void outputGraphNoEmbeddedTypes() throws Exception { | |||
@@ -41,8 +38,8 @@ public class GraphSONWriterTest { | |||
ByteArrayOutputStream stream = new ByteArrayOutputStream(); | |||
GraphSONWriter writer = new GraphSONWriter(g); | |||
writer.outputGraph(stream, null, null, GraphSONMode.NORMAL); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(g, stream, GraphSONMode.NORMAL); | |||
stream.flush(); | |||
stream.close(); | |||
@@ -74,8 +71,8 @@ public class GraphSONWriterTest { | |||
ByteArrayOutputStream stream = new ByteArrayOutputStream(); | |||
GraphSONWriter writer = new GraphSONWriter(g); | |||
writer.outputGraph(stream, null, null, GraphSONMode.EXTENDED); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(g, stream, GraphSONMode.EXTENDED); | |||
stream.flush(); | |||
stream.close(); | |||
@@ -107,8 +104,8 @@ public class GraphSONWriterTest { | |||
ByteArrayOutputStream stream = new ByteArrayOutputStream(); | |||
GraphSONWriter writer = new GraphSONWriter(g); | |||
writer.outputGraph(stream, null, null, GraphSONMode.COMPACT); | |||
GraphSONWriter writer = new GraphSONWriter(); | |||
writer.write(g, stream, GraphSONMode.COMPACT); | |||
stream.flush(); | |||
stream.close(); |