@ohos-ports/graphviz 0.0.9-beta.0

package/lib/deps/graph.js

@@ -0,0 +1,402 @@
+/**
+ * Module dependencies
+ */
+var Hash = require( './core_ext/hash' ).Hash,
+  Node = require( './node' ).Node,
+  Edge = require( './edge' ).Edge,
+  gvattrs = require( './attributs' ),
+  Attributs = gvattrs.Attributs,
+  util = require('util'),
+  path = require('path'),
+  spawn  = require('child_process').spawn;
+
+/**
+ * Create a new graph
+ * @constructor
+ * @param {Graph} graph Parent Graph
+ * @param {String} id The graphID
+ * @return {Graph}
+ * @api public
+ */
+var Graph = exports.Graph = function(graph, id) {
+  this.relativeGraph = graph;
+  this.id = id;
+  this.type = 'graph';
+  this.gvPath = '';
+  this.nodes = new Hash();
+  this.edges = new Array();
+  this.clusters = new Hash();
+  if( this.relativeGraph == null ) {
+    this.graphAttributs = new Attributs("G");
+  } else {
+    this.graphAttributs = new Attributs("C");
+  }
+  this.nodesAttributs = new Attributs("N");
+  this.edgesAttributs = new Attributs("E");
+  this.use = 'dot';
+};
+
+/**
+ * Create a new node
+ *
+ * @param {String} id The node ID
+ * @param {Object} attrs Node attributs
+ * @return {Node}
+ * @api public
+ */
+Graph.prototype.addNode = function(id, attrs) {
+  this.nodes.setItem(id, new Node(this, id));
+  if( attrs ) {
+    for( k in attrs ) {
+      this.nodes.items[id].set( k, attrs[k] );
+    }
+  }
+
+  return this.nodes.items[id];
+}
+
+/**
+ * Return a node for a given ID
+ *
+ * @param {String} id The node ID
+ * @return {Node}
+ * @api public
+ */
+Graph.prototype.getNode = function(id) {
+  return this.nodes.items[id];
+}
+
+Graph.prototype.from = function(id) {
+	if( this.nodes.items[id] == undefined ) {
+		this.addNode(id);
+	}
+	return this.nodes.items[id];
+}
+
+/**
+ * Return the number of nodes in the current graph
+ *
+ * @return {Integer}
+ * @api public
+ */
+Graph.prototype.nodeCount = function() {
+  return this.nodes.length;
+}
+
+/**
+ * Create a new edge
+ *
+ * @param {String|Node} nodeOne
+ * @param {String|Node} nodeTwo
+ * @param {Object} attrs Node attributs
+ * @return {Edge}
+ * @api public
+ */
+Graph.prototype.addEdge = function(nodeOne, nodeTwo, attrs) {
+  var _nodeOne = nodeOne;
+  var _nodeTwo = nodeTwo;
+  if( typeof(nodeOne) == 'string' ) {
+    _nodeOne = this.nodes.items[nodeOne];
+    if( _nodeOne == null ) {
+      _nodeOne = this.addNode( nodeOne );
+    }
+  }
+  if( typeof(nodeTwo) == 'string' ) {
+    _nodeTwo = this.nodes.items[nodeTwo];
+    if( _nodeTwo == null ) {
+      _nodeTwo = this.addNode( nodeTwo );
+    }
+  }
+  
+  var edge = new Edge(this, _nodeOne, _nodeTwo);
+  if( attrs ) {
+    for( k in attrs ) {
+      edge.set( k, attrs[k] );
+    }
+  }
+  this.edges.push( edge );
+  
+  return edge;
+}
+
+/**
+ * Return the number of edges in the current graph
+ *
+ * @return {Integer}
+ * @api public
+ */
+Graph.prototype.edgeCount = function() {
+  return this.edges.length;
+};
+
+/**
+ * Create a new subgraph
+ *
+ * @param {String} id The subgraph ID
+ * @return {Graph}
+ * @api public
+ */
+Graph.prototype.addCluster = function(id) {
+  var cluster = new Graph(this, id);
+  cluster.type = this.type;
+  this.clusters.setItem(id, cluster);
+  return cluster;
+}
+
+/**
+ * Return a subgraph for a given ID
+ *
+ * @param {String} id The subgraph ID
+ * @return {Graph}
+ * @api public
+ */
+Graph.prototype.getCluster = function(id) {
+  return this.clusters.items[id];
+}
+
+/**
+ * Return the number of subgraphs in the current graph
+ *
+ * @return {Integer}
+ * @api public
+ */
+Graph.prototype.clusterCount = function() {
+  return this.clusters.length;
+}
+
+/**
+ * Set a graph attribut
+ *
+ * @param {String} name The attribut name
+ * @param {Void} value The attribut value
+ * @api public
+ */
+Graph.prototype.set = function(name, value) {
+  this.graphAttributs.set(name, value);
+}
+
+/**
+ * Get a graph attribut
+ *
+ * @param {String} name The attribut name
+ * @return {Void}
+ * @api public
+ */
+Graph.prototype.get = function(name) {
+  return this.graphAttributs.get(name);
+}
+
+/**
+ * Set a global node attribut
+ *
+ * @param {String} name The attribut name
+ * @param {Void} value The attribut value
+ * @api public
+ */
+Graph.prototype.setNodeAttribut = function(name, value) {
+  this.nodesAttributs.set(name, value);
+}
+
+/**
+ * Get a global node attribut
+ *
+ * @param {String} name The attribut name
+ * @return {Void}
+ * @api public
+ */
+Graph.prototype.getNodeAttribut = function(name) {
+  return this.nodesAttributs.get(name);
+}
+
+/**
+ * Set a global edge attribut
+ *
+ * @param {String} name The attribut name
+ * @param {Void} value The attribut value
+ * @api public
+ */
+Graph.prototype.setEdgeAttribut = function(name, value) {
+  this.edgesAttributs.set(name, value);
+}
+
+/**
+ * Get a global edge attribut
+ *
+ * @param {String} name The attribut name
+ * @return {Void}
+ * @api public
+ */
+Graph.prototype.getEdgeAttribut = function(name) {
+  return this.edgesAttributs.get(name);
+}
+
+/**
+ * Generate the GraphViz script
+ *
+ * @return {String}
+ * @api public
+ */
+Graph.prototype.to_dot = function() {
+  var dotScript = '';
+  if( this.relativeGraph == null ) {
+    dotScript = this.type + ' ' + this.id + ' {\n'
+  } else {
+    dotScript = 'subgraph ' + this.id + ' {\n'
+  }
+  
+  // Graph attributs
+  if( this.graphAttributs.length() > 0 ) {
+    dotScript = dotScript + "  graph" + this.graphAttributs.to_dot() + ";\n";
+  }
+  
+  // Nodes attributs
+  if( this.nodesAttributs.length() > 0 ) {
+    dotScript = dotScript + "  node" + this.nodesAttributs.to_dot() + ";\n";
+  }
+  
+  // Edges attributs
+  if( this.edgesAttributs.length() > 0 ) {
+    dotScript = dotScript + "  edge" + this.edgesAttributs.to_dot() + ";\n";
+  }
+  
+  // Each clusters
+  for( var id in this.clusters.items ) {
+    if (this.clusters.items.hasOwnProperty(id)) {
+      dotScript = dotScript + this.clusters.items[id].to_dot() + '\n';
+    }
+  }
+  
+  // Each nodes
+  for( var id in this.nodes.items ) {
+    if (this.nodes.items.hasOwnProperty(id)) {
+      dotScript = dotScript + '  ' + this.nodes.items[id].to_dot() + ';\n'
+    }
+  }
+  
+  // Each edges
+  for( var i in this.edges ) {
+    if (this.edges.hasOwnProperty(i)) {
+      dotScript = dotScript + '  ' + this.edges[i].to_dot() + ';\n'
+    }
+  }
+  
+  dotScript = dotScript + '}\n'
+  
+  return dotScript;
+}
+
+/**
+ * Generate an output in file or memory
+ *
+ * @param {String|Object} type The output file type (png, jpeg, ps, ...) or options
+ * @param {String|Function} name_or_callback The output file name or callback
+ * @param {Function} errback Error callback
+ * @api public
+ *
+ * Options :
+ *   - type : output file type (png, jpeg, ps, ...)
+ *   - use : Graphviz command to use (dot, neato, ...)
+ *   - path : GraphViz path
+ *   - G : 
+ *   - N :
+ *   - E :
+ */
+Graph.prototype.render = function(type_or_options, name_or_callback, errback) {
+	var parameters = [];
+	
+	// Get output type
+	var type = type_or_options;
+	if( typeof(type_or_options) == 'object' ) {
+		type = type_or_options.type;
+
+		// Get use
+		if( type_or_options.use != undefined ) { this.use = type_or_options.use; }
+		
+		// Get path
+		if( type_or_options.path != undefined ) { this.gvPath = type_or_options.path; }
+		
+		// Get extra Graph Options
+		if( type_or_options.G != undefined ) {
+			for( attr in type_or_options.G ) {
+				if( gvattrs.isValid( attr, "G" ) == false ) {
+					util.debug( "Warning : Invalid attribut `"+attr+"' for a graph" );
+				}
+	      parameters.push( "-G"+attr+"="+type_or_options.G[attr] )
+	    }
+		}
+		// Get extra Node Options
+		if( type_or_options.N != undefined ) {
+			for( attr in type_or_options.N ) {
+				if( gvattrs.isValid( attr, "N" ) == false ) {
+					util.debug( "Warning : Invalid attribut `"+attr+"' for a node" );
+				}
+	      parameters.push( "-N"+attr+"="+type_or_options.N[attr] )
+	    }			
+		}
+		// Get extra Edge Options
+		if( type_or_options.E != undefined ) {
+			for( attr in type_or_options.E ) {
+				if( gvattrs.isValid( attr, "E" ) == false ) {
+					util.debug( "Warning : Invalid attribut `"+attr+"' for an edge" );
+				}
+	      parameters.push( "-E"+attr+"="+type_or_options.E[attr] )
+	    }			
+		}
+	}
+	parameters.push( '-T' + type );
+	
+  var dotScript = this.to_dot();
+  
+  var cmd = this.use;
+  if( this.gvPath != '' ) {
+    cmd = path.join( this.gvPath, this.use )
+  }
+  
+  var rendered = null;
+  var out = ''
+  var err = ''
+  var outcallback = function(data) { 
+    if( rendered == null ) {
+      rendered = data; 
+    } else {
+      __b = new Buffer( rendered.length + data.length )
+      rendered.copy(__b, 0, 0)
+      data.copy(__b, rendered.length, 0)
+      rendered = __b
+    }
+  };
+  
+  if( typeof(name_or_callback) == 'string' ) {
+    parameters.push( '-o' + name_or_callback )
+    outcallback = function(data) { out += data; }
+  }
+  
+  graphviz = spawn(cmd, parameters);
+  graphviz.stdout.on('data', outcallback);
+  graphviz.stderr.on('data', function(data) {
+    err += data;
+  });
+  graphviz.on('exit', function(code) {
+    if(code !== 0) {
+      if(errback) { errback(code, out, err) }
+    } else {
+      if( typeof(name_or_callback) == 'function' ) name_or_callback(rendered);
+    }
+  });
+  graphviz.stdin.write(this.to_dot());
+  graphviz.stdin.end();
+}
+// Compatibility
+Graph.prototype.output = function(type, name_or_callback, errback) {
+  this.render(type, name_or_callback, errback);
+}
+
+/**
+ * Set the GraphViz path
+ *
+ * @param {String} path The GraphViz path
+ * @api public
+ */
+Graph.prototype.setGraphVizPath = function(path) {
+  this.gvPath = path;
+}

package/lib/deps/node.js

@@ -0,0 +1,58 @@
+/**
+ * Module dependencies
+ */
+var Hash = require('./core_ext/hash').Hash,
+  Attributs = require('./attributs').Attributs;
+
+/**
+ * Create a new node
+ * @constructor
+ * @param {Graph} graph Parent Graph
+ * @param {String} id The node ID
+ * @return {Node}
+ * @api public
+ */
+var Node = exports.Node = function(graph, id) {
+  this.relativeGraph = graph;
+  this.id = id;
+  this.attributs = new Attributs("N");
+};
+
+/**
+ *
+ */
+Node.prototype.to = function(id, attrs) {
+	this.relativeGraph.addEdge(this, id, attrs);
+	return this.relativeGraph.from(id);
+};
+
+/**
+ * Set a node attribut
+ *
+ * @param {String} name The attribut name
+ * @param {Void} value The attribut value
+ * @api public
+ */
+Node.prototype.set = function(name, value) {
+  this.attributs.set(name, value);
+  return this;
+};
+
+/**
+ * Get a node attribut
+ *
+ * @param {String} name The attribut name
+ * @return {Void}
+ * @api public
+ */
+Node.prototype.get = function(name) {
+  return this.attributs.get(name);
+};
+
+/**
+ * @api private
+ */
+Node.prototype.to_dot = function() {
+  var nodeOutput = '"' + this.id + '"' + this.attributs.to_dot();
+  return nodeOutput;
+};

package/lib/ext/gvpr/dot2js.g

@@ -0,0 +1,157 @@
+// Copyright (c) 2010 Gregoire Lejeune <gregoire.lejeune@free.fr>
+// 
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+//
+// Usage :
+//   gvpr -f dot2js.g [-a <output type>] <dot script>
+
+BEGIN {
+  int g_strict; int g_direct;
+  graph_t cluster;
+  node_t cnode;
+  edge_t cedge;
+  string attr; string attrv;
+  graph_t subgraph; graph_t pgraph;
+  graph_t ofgraph;
+
+	string xOut;
+	if( ARGC == 0 ) {
+		xOut = "_";
+	} else {
+		xOut = tolower(ARGV[0]);
+	}
+  
+  printf( "// This code was generated by dot2js.g\n\n" );
+
+  string rubyfy( string s ) {
+    string out;
+    out = tolower( s );
+    out = gsub( out, " ", "__" ); 
+    out = gsub( out, "'", "" ); 
+    out = gsub( out, "-", "_" ); 
+    out = gsub( out, ".", "" ); 
+		out = gsub( out, "%", "u" ); 
+		out = gsub( out, "+", "" ); 
+		out = gsub( out, "/", "_" ); 
+    return( out );
+  }
+}
+
+BEG_G {
+  printf( "var util = require('util'),\n  graphviz = require('graphviz');\n\n");
+  // Directed 
+  g_direct = isDirect($);
+  if( g_direct == 0 ) {
+    printf( "var graph_%s = graphviz.graph( \"%s\" );\n", rubyfy($.name), rubyfy($.name) );
+  } else {
+    printf( "var graph_%s = graphviz.digraph( \"%s\" );\n", rubyfy($.name), rubyfy($.name) );
+  }
+  // Strict
+  g_strict = isStrict($);
+  if( g_strict != 0 ) {
+    // printf( ", :strict => true" ); ///////////////////////// TODO
+  }
+  
+  // Attributs of G
+  attr = fstAttr($, "G");
+  while( attr != "" ) {
+    attrv = aget( $, attr );
+    if( attrv != "" ) {
+      printf( "graph_%s.set( \"%s\", \"%s\" );\n", rubyfy($.name), attr, attrv );
+    }
+    attr = nxtAttr( $, "G", attr );
+  }
+  
+  // Subgraph
+  subgraph = fstsubg( $ );
+  while( subgraph != NULL ) {
+    pgraph = subgraph.parent;
+    printf ( "var graph_%s = graph_%s.addCluster( \"%s\" )\n", rubyfy(subgraph.name), rubyfy(pgraph.name), rubyfy(subgraph.name) );
+    
+    // ATTRS
+    attr = fstAttr(subgraph, "G");
+    while( attr != "" ) {
+      attrv = aget( subgraph, attr );
+      if( attrv != "" ) {
+        printf( "graph_%s.set( \"%s\", \"%s\" );\n", rubyfy(subgraph.name), attr, attrv );
+      }
+      attr = nxtAttr( subgraph, "G", attr );
+    }
+    
+    subgraph = nxtsubg( subgraph );
+  }
+}
+
+N {
+  pgraph = $.root;
+  ofgraph = pgraph;
+
+  subgraph = fstsubg( pgraph );
+  while( subgraph != NULL ) {
+    if( isSubnode( subgraph, $ ) != 0 ) {
+      ofgraph = subgraph;
+    }
+    subgraph = nxtsubg( subgraph );
+  }
+  
+  printf( "var node_%s = graph_%s.addNode( \"%s\", {", rubyfy($.name), rubyfy(ofgraph.name), $.name );
+
+  // Attributs of N
+  attr = fstAttr($G, "N");
+  while( attr != "" ) {
+    attrv = aget( $, attr );
+    if( attrv != "" ) {
+      printf( "\"%s\" : \"%s\", ", attr, gsub( attrv, "'", "\\'" ) );
+//    } else {
+//      printf( "\"%s\" : \"\", ", attr );
+    }
+    attr = nxtAttr( $G, "N", attr );
+  }
+
+  printf( "} );\n" );
+}
+
+E {
+  pgraph = $.root;
+  ofgraph = pgraph;
+
+  subgraph = fstsubg( pgraph );
+  while( subgraph != NULL ) {
+    if( isSubedge( subgraph, $ ) != 0 ) {
+      ofgraph = subgraph;
+    }
+    subgraph = nxtsubg( subgraph );
+  }
+
+  printf( "graph_%s.addEdge( \"%s\", \"%s\", {", rubyfy(ofgraph.name), $.tail.name, $.head.name );
+  
+  // Attributs of E
+  attr = fstAttr($G, "E");
+  while( attr != "" ) {
+    attrv = aget( $, attr );
+    if( attrv != "" ) {
+      printf( "\"%s\" : \"%s\", ", attr, gsub( attrv, "'", "\\'" ) );
+//    } else {
+//      printf( "\"%s\" : \"\", ", attr );
+    }
+    attr = nxtAttr( $G, "E", attr );
+  }
+  
+  printf( "} );\n" );
+}
+
+END_G {
+	printf( "__graph_eval = graph_%s;\n", rubyfy($.name) );
+}

package/lib/graphviz.js

@@ -0,0 +1,109 @@
+/**
+ * Module dependencies.
+ */
+var path = require('path'),
+  spawn  = require('child_process').spawn,
+  temp = require('temp'),
+  fs = require('fs'),
+  fsExt = require('./deps/core_ext/fs-ext'),
+  Graph = require('./deps/graph').Graph;
+
+/*
+ * OpenHarmony/HarmonyOS port: make the bundled openharmony-arm64
+ * GraphViz binaries (dot, gvpr) available even when postinstall
+ * scripts are disabled (npm allowScripts policy).  Prepend the
+ * bundled bin dir to PATH at require time if the binaries exist.
+ */
+(function bundledBinPath() {
+  var binDir = path.join(__dirname, '..', 'bin', 'openharmony-arm64');
+  if (!fs.existsSync(path.join(binDir, 'dot'))) return;
+  if (!fs.existsSync(path.join(binDir, 'gvpr'))) return;
+  var entries = (process.env.PATH || '').split(path.delimiter);
+  if (entries.indexOf(binDir) === -1) {
+    process.env.PATH = binDir + path.delimiter + (process.env.PATH || '');
+  }
+})();
+
+/**
+ * Create a new undirected graph
+ * @constructor
+ * @param {String} id The graphID
+ * @return {Graph}
+ * @api public
+ */
+exports.graph = function(id) {
+  var graph = new Graph(null, id);
+  graph.type = 'graph';
+  return graph;
+};
+
+/**
+ * Create a new directed graph
+ * @constructor
+ * @param {String} id The graphID
+ * @return {Graph}
+ * @api public
+ */
+exports.digraph = function(id) {
+  var graph = new Graph(null, id);
+  graph.type = 'digraph';
+  return graph;
+};
+
+function _parse(file, callback, errback) {
+  var gvprScript = path.join(__dirname, "ext", "gvpr", "dot2js.g"),
+    parameters = ["-f" + gvprScript, file],
+    cmd = "gvpr",
+    __graph_eval,
+    err = '',
+    out = '',
+    graphviz = spawn(cmd, parameters);
+
+  graphviz.stdout.on('data', function(data) {
+    out += data;
+    eval(data.toString());
+  });
+  graphviz.stderr.on('data', function(data) {
+    err += data;
+  });
+  graphviz.stdin.end();
+  graphviz.on('exit', function(code) {
+    if(code !== 0 || __graph_eval === undefined) {
+      if(errback) {
+        errback(code, out, err);
+      }
+    } else {
+      callback(__graph_eval);
+    }
+  });
+}
+/**
+ * Create a new graph from a dot script
+ * @constructor
+ * @param {String} file_or_script The DOT script or file
+ * @param {Function} callback
+ * @param {Function} errback
+ * @api public
+ */
+exports.parse = function(file_or_script, callback, errback) {
+  if(fsExt.exist(file_or_script)) {
+    _parse(file_or_script, callback, errback);
+  } else {
+    temp.open('node-graphviz', function(err, info) {
+      if(err) {
+        return errback(err);
+      }
+      fs.write(info.fd, file_or_script, function(err) {
+        if(err) {
+          return errback(err);
+        }
+        fs.close(info.fd, function(err) {
+          if(err) {
+            return errback(err);
+          }
+          _parse(info.path, callback, errback);
+        });
+      });
+    });
+  }
+};