occam-directed-graphs 3.0.37 → 3.0.41

package/src/directedAcyclicGraph.js

@@ -1,422 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import Edge from "./edge";
-import Vertex from "./vertex";
-
-import { vertexNamesFromVertices, orderVertices } from "./utilities/vertex";
-
-const { last } = arrayUtilities;
-
-export default class DirectedAcyclicGraph {
-  constructor(vertexMap) {
-    this.vertexMap = vertexMap;
-  }
-
-  isEmpty() {
-    const vertices = this.getVertices(),
-          verticesLength = vertices.length,
-          empty = (verticesLength === 0);
-
-    return empty;
-  }
-
-  getVertices() {
-    const vertexMapValues = Object.values(this.vertexMap),
-          vertices = vertexMapValues; ///
-
-    return vertices;
-  }
-
-  getVertexNames() {
-    const vertexMapKeys = Object.keys(this.vertexMap),
-          vertexNames = vertexMapKeys;  ///
-
-    return vertexNames;
-  }
-
-  getVertexByVertexName(vertexName) {
-    const vertexPresent = this.isVertexPresentByVertexName(vertexName),
-          vertex = vertexPresent ?
-                     this.vertexMap[vertexName] :
-                       null;
-
-    return vertex;
-  }
-
-  getImmediatePredecessorVertexNamesByVertexName(vertexName) {
-    const vertex = this.getVertexByVertexName(vertexName),
-          immediatePredecessorVertexNames = vertex.getImmediatePredecessorVertexNames();
-
-    return immediatePredecessorVertexNames;
-  }
-
-  getImmediateSuccessorVertexNamesByVertexName(vertexName) {
-    const vertex = this.getVertexByVertexName(vertexName),
-          immediateSuccessorVertexNames = vertex.getImmediateSuccessorVertexNames();
-
-    return immediateSuccessorVertexNames;
-  }
-
-  getPredecessorVertexNamesByVertexName(vertexName) {
-    const vertex = this.getVertexByVertexName(vertexName),
-          predecessorVertexNames = vertex.getPredecessorVertexNames();
-
-    return predecessorVertexNames;
-  }
-
-  getSuccessorVertexNamesByVertexName(vertexName) {
-    const vertex = this.getVertexByVertexName(vertexName),
-          successorVertexNames = vertex.getSuccessorVertexNames();
-
-    return successorVertexNames;
-  }
-
-  getEdgesByTargetVertexName(targetVertexName) {
-    const edges = [],
-          targetVertex = this.getVertexByVertexName(targetVertexName);
-
-    if (targetVertex !== null) {
-      const immediatePredecessorVertexNames = targetVertex.getImmediatePredecessorVertexNames(),
-            sourceVertexNames = immediatePredecessorVertexNames;  ///
-
-      sourceVertexNames.forEach((sourceVertexName) => {
-        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
-
-        edges.push(edge);
-      });
-    }
-
-    return edges;
-  }
-
-  getEdgesBySourceVertexName(sourceVertexName) {
-    const edges = [],
-          sourceVertex = this.getVertexByVertexName(sourceVertexName);
-
-    if (sourceVertex !== null) {
-      const immediateSuccessorVertexNames = sourceVertex.getImmediateSuccessorVertexNames(),
-            targetVertexNames = immediateSuccessorVertexNames;  ///
-
-      targetVertexNames.forEach((targetVertexName) => {
-        const edge = Edge.fromSourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
-
-        edges.push(edge);
-      });
-    }
-
-    return edges;
-  }
-
-  setVertexByVertexName(vertexName, vertex) {
-    this.vertexMap[vertexName] = vertex;
-  }
-
-  deleteVertexByVertexName(vertexName) {
-    delete this.vertexMap[vertexName];
-  }
-
-  isEdgePresent(edge) {
-    const sourceVertexName = edge.getSourceVertexName(),
-          targetVertexName = edge.getTargetVertexName(),
-          edgePresent = this.isEdgePresentByVertexNames(sourceVertexName, targetVertexName);
-    
-    return edgePresent;
-  }
-
-  isEdgePresentByVertexNames(sourceVertexName, targetVertexName) {
-    let edgePresent = false;
-
-    const sourceVertex = this.getVertexByVertexName(sourceVertexName),
-          targetVertex = this.getVertexByVertexName(targetVertexName),
-          sourceVertexAndTargetVertexPresent = (sourceVertex !== null) && (targetVertex !== null);
-
-    if (sourceVertexAndTargetVertexPresent) {
-      edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
-    }
-
-    return edgePresent;
-  }
-
-  isVertexPresentByVertexName(vertexName) {
-    const vertexNames = this.getVertexNames(),
-          vertexNamesIncludesVertexName = vertexNames.includes(vertexName),
-          vertexPresent = vertexNamesIncludesVertexName;  ///
-
-    return vertexPresent;
-  }
-
-  getOrderedVertexNames() {
-    const vertices = this.getVertices();
-
-    orderVertices(vertices);
-
-    const orderedVertices = vertices, ///
-          orderedVertexNames = vertexNamesFromVertices(orderedVertices);
-
-    return orderedVertexNames;
-  }
-
-  addEdge(edge) {
-    const sourceVertexName = edge.getSourceVertexName(),
-          targetVertexName = edge.getTargetVertexName(),
-          success = this.addEdgeByVertexNames(sourceVertexName, targetVertexName);
-
-    return success;
-  }
-
-  removeEdge(edge) {
-    const sourceVertexName = edge.getSourceVertexName(),
-          targetVertexName = edge.getTargetVertexName();
-
-    this.removeEdgeByVertexNames(sourceVertexName, targetVertexName);
-  }
-
-  addEdgeByVertexNames(sourceVertexName, targetVertexName) {
-    let success = false;
-
-    if (sourceVertexName !== targetVertexName) {
-      const sourceVertex = this.addVertexByVertexName(sourceVertexName),
-            targetVertex = this.addVertexByVertexName(targetVertexName),
-            edgePresent = sourceVertex.isEdgePresentByTargetVertex(targetVertex);
-      
-      if (edgePresent) {
-        success = true;
-      } else {
-        const sourceVertexIndex = sourceVertex.getIndex(),
-              targetVertexIndex = targetVertex.getIndex(),
-              invalidatingEdge = (sourceVertexIndex > targetVertexIndex);
-
-        success = invalidatingEdge ?
-                    addInvalidatingEdgeByVertices(sourceVertex, targetVertex) :
-                      true;
-
-        if (success) {
-          const immediatePredecessorVertex = sourceVertex, ///
-                immediateSuccessorVertex = targetVertex; ///
-
-          immediatePredecessorVertex.addImmediateSuccessorVertex(immediateSuccessorVertex);
-
-          immediateSuccessorVertex.addImmediatePredecessorVertex(immediatePredecessorVertex);
-        }
-      }
-    }
-    
-    return success;
-  }
-
-  removeEdgeByVertexNames(sourceVertexName, targetVertexName) {
-    const edgePresent = this.isEdgePresentByVertexNames(sourceVertexName, targetVertexName);
-
-    if (edgePresent) {
-      const sourceVertex = this.getVertexByVertexName(sourceVertexName),
-            targetVertex = this.getVertexByVertexName(targetVertexName);
-
-      sourceVertex.removeImmediateSuccessorVertex(targetVertex);
-      targetVertex.removeImmediatePredecessorVertex(sourceVertex);
-    }
-  }
-
-  removeEdgesBySourceVertexName(sourceVertexName) {
-    const sourceVertexPresent = this.isVertexPresentByVertexName(sourceVertexName);
-
-    if (sourceVertexPresent) {
-      const sourceVertex = this.getVertexByVertexName(sourceVertexName);
-
-      sourceVertex.removeOutgoingEdges();
-    }
-  }
-
-  removeEdgesByTargetVertexName(targetVertexName) {
-    const targetVertexPresent = this.isVertexPresentByVertexName(targetVertexName);
-
-    if (targetVertexPresent) {
-      const targetVertex = this.getVertexByVertexName(targetVertexName);
-
-      targetVertex.removeIncomingEdges();
-    }
-  }
-
-  addVertexByVertexName(vertexName) {
-    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
-
-    if (!vertexPresent) {
-      const vertexNames = this.getVertexNames(),
-            vertexNamesLength = vertexNames.length,
-            name = vertexName,  ///
-            index = vertexNamesLength, ///
-            vertex = Vertex.fromNameAndIndex(name, index);
-
-      this.setVertexByVertexName(vertexName, vertex);
-    }
-
-    const vertex = this.getVertexByVertexName(vertexName);
-
-    return vertex;
-  }
-
-  removeVertexByVertexName(vertexName) {
-    let removedEdges = null;
-
-    const vertexPresent = this.isVertexPresentByVertexName(vertexName);
-
-    if (vertexPresent) {
-      removedEdges = [];
-
-      const vertex = this.getVertexByVertexName(vertexName);
-
-      vertex.forEachImmediateSuccessorVertex((immediateSuccessVertex) => {
-        const immediatePredecessorVertex = vertex,  ///
-              immediatePredecessorVertexName = immediatePredecessorVertex.getName(),
-              immediateSuccessVertexName = immediateSuccessVertex.getName(),
-              removedEdgeSourceVertexName = immediatePredecessorVertexName, ///
-              removedEdgeTargetVertexName = immediateSuccessVertexName, ///
-              removedEdge = new Edge(removedEdgeSourceVertexName, removedEdgeTargetVertexName);
-
-        removedEdges.push(removedEdge);
-
-        immediateSuccessVertex.removeImmediatePredecessorVertex(immediatePredecessorVertex);
-      });
-
-      vertex.forEachImmediatePredecessorVertex((immediatePredecessorVertex) => {
-        const immediateSuccessVertex = vertex,  ///
-              immediatePredecessorVertexName = immediatePredecessorVertex.getName(),
-              immediateSuccessVertexName = immediateSuccessVertex.getName(),  ///
-              removedEdgeSourceVertexName = immediatePredecessorVertexName, ///
-              removedEdgeTargetVertexName = immediateSuccessVertexName, ///
-              removedEdge = new Edge(removedEdgeSourceVertexName, removedEdgeTargetVertexName);
-
-        removedEdges.push(removedEdge);
-
-        immediatePredecessorVertex.removeImmediateSuccessorVertex(immediateSuccessVertex);
-      });
-
-      this.deleteVertexByVertexName(vertexName);
-
-      const deletedVertex = vertex, ///
-            deletedVertexIndex = deletedVertex.getIndex(),
-            vertices = this.getVertices(),
-            affectedVertices = vertices.reduce((affectedVertices, vertex) => {
-              const vertexIndex = vertex.getIndex(),
-                    vertexAffected = (vertexIndex > deletedVertexIndex);
-
-              if (vertexAffected) {
-                const affectedVertex = vertex;  ///
-
-                affectedVertices.push(affectedVertex);
-              }
-
-              return affectedVertices;
-            }, []);
-
-      affectedVertices.forEach((affectedVertex) => affectedVertex.decrementIndex());
-    }
-
-    return removedEdges;
-  }
-
-  static fromNothing() {
-    const vertexMap = {},
-          directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
-
-    return directedAcyclicGraph;
-  }
-  
-  static fromVertexNames(vertexNames) {
-    const vertexMap = vertexMapFromVertexNames(vertexNames);
-
-    const directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
-
-    return directedAcyclicGraph;
-  }
-
-  static fromOrderedVertices(orderedVertices) {
-    const vertexMap = vertexMapFromOrderedVertices(orderedVertices);
-    
-    addEdgesToVertices(orderedVertices, vertexMap);
-    
-    const directedAcyclicGraph = new DirectedAcyclicGraph(vertexMap);
-    
-    return directedAcyclicGraph;
-  }
-}
-
-function addInvalidatingEdgeByVertices(sourceVertex, targetVertex) {
-  let success = false;
-
-  const forwardsAffectedVertices = targetVertex.retrieveForwardsAffectedVertices(sourceVertex),
-        lastForwardsAffectedVertex = last(forwardsAffectedVertices),
-        resultsInCycle = (lastForwardsAffectedVertex === sourceVertex);
-
-  if (!resultsInCycle) {
-    const backwardsAffectedVertices = sourceVertex.retrieveBackwardsAffectedVertices();
-
-    orderVertices(backwardsAffectedVertices);
-
-    orderVertices(forwardsAffectedVertices);
-
-    const affectedVertices = [].concat(backwardsAffectedVertices).concat(forwardsAffectedVertices),
-          affectedVertexIndices = affectedVertices.map((affectedVertex) => {
-            const affectedVertexIndex = affectedVertex.getIndex();
-
-            return affectedVertexIndex;
-          });
-
-    affectedVertexIndices.sort((indexA, indexB) => (indexA - indexB));
-
-    affectedVertices.forEach((affectedVertex, index) => {
-      const affectedVertexIndex = affectedVertexIndices[index];
-
-      affectedVertex.setIndex(affectedVertexIndex);
-    });
-
-    success = true;
-  }
-
-  return success;
-}
-
-function vertexMapFromVertexNames(vertexNames) {
-  const vertexMap = {};
-  
-  vertexNames.forEach((vertexName, index) => {
-    const name = vertexName,  ///
-          vertex = Vertex.fromNameAndIndex(name, index);
-
-    vertexMap[vertexName] = vertex;
-  });
-  
-  return vertexMap;
-}
-
-function vertexMapFromOrderedVertices(orderedVertices) {
-  const vertexMap = {};
-  
-  orderedVertices.forEach((orderedVertex, index) => {
-    const name = orderedVertex.getName(),
-          vertex = Vertex.fromNameAndIndex(name, index),
-          vertexName = name;  ///
-
-    vertexMap[vertexName] = vertex;
-  });
-
-  return vertexMap;
-}
-
-function addEdgesToVertices(orderedVertices, vertexMap) {
-  orderedVertices.forEach((orderedVertex) => {
-    orderedVertex.forEachOutgoingEdge((outgoingEdge) => {
-      const sourceVertexName = outgoingEdge.getSourceVertexName(),
-            targetVertexName = outgoingEdge.getTargetVertexName(),
-            immediatePredecessorVertexName = sourceVertexName,  ///
-            immediateSuccessorVertexName = targetVertexName,
-            immediatePredecessorVertex = vertexMap[immediatePredecessorVertexName], ///
-            immediateSuccessorVertex = vertexMap[immediateSuccessorVertexName]; ///
-
-      immediatePredecessorVertex.addImmediateSuccessorVertex(immediateSuccessorVertex);
-
-      immediateSuccessorVertex.addImmediatePredecessorVertex(immediatePredecessorVertex);
-    });
-  });
-}

package/src/example.js

@@ -1,22 +0,0 @@
-"use strict";
-
-import { DirectedGraph } from "./index";  ///
-
-const directedGraph = DirectedGraph.fromNothing();
-
-directedGraph.addVerticesByVertexNames([
-  "./easy-layout",
-  "./easy-with-style",
-  "./occam-lexers",
-  "./with-style"
-]);
-
-directedGraph.addEdgeByVertexNames("./easy-with-style", "./easy-layout");
-directedGraph.addEdgeByVertexNames("./with-style", "./easy-with-style");
-directedGraph.addEdgeByVertexNames("./easy-layout", "./occam-lexers");
-directedGraph.addEdgeByVertexNames("./easy-with-style", "./easy-layout");
-directedGraph.addEdgeByVertexNames("./occam-lexers", "./with-style");
-
-directedGraph.removeVertexByVertexName("./occam-lexers");
-
-debugger

package/src/partialCycle.js

@@ -1,69 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { first } = arrayUtilities;
-
-export default class PartialCycle {
-  constructor(predecessorVertices, cyclicEdge) {
-    this.predecessorVertices = predecessorVertices;
-    this.cyclicEdge = cyclicEdge;
-  }
-  
-  getPredecessorVertices() {
-    return this.predecessorVertices;
-  }
-
-  getCyclicEdge() {
-    return this.cyclicEdge;
-  }
-
-  getTargetVertexName() {
-    const cyclicEdgeTargetVertexName = this.cyclicEdge.getTargetVertexName(),
-          targetVertexName = cyclicEdgeTargetVertexName;  ///
-    
-    return targetVertexName;
-  }
-  
-  getPredecessorVertexNames() {
-    const predecessorVertexNames = this.predecessorVertices.map((predecessorVertex) => {
-      const predecessorVertexName = predecessorVertex.getName();
-
-      return predecessorVertexName;
-    });
-    
-    return predecessorVertexNames;
-  }
-  
-  getCyclicEdgeSourceVertexName() {
-    const cyclicEdgeSourceVertexName = this.cyclicEdge.getSourceVertexName();
-    
-    return cyclicEdgeSourceVertexName;
-  }
-  
-  getCyclicEdgeTargetVertexName() {
-    const cyclicEdgeTargetVertexName = this.cyclicEdge.getTargetVertexName();
-    
-    return cyclicEdgeTargetVertexName;
-  }
-  
-  static fromCyclicEdgeAndPredecessorVertices(cyclicEdge, predecessorVertices) {
-    predecessorVertices = predecessorVertices.slice();  ///
-    
-    const predecessorVerticesLength = predecessorVertices.length;
-
-    if (predecessorVerticesLength > 0) {
-      const firstPredecessorVertex = first(predecessorVertices),
-            firstPredecessorVertexName = firstPredecessorVertex.getName(),
-            cyclicEdgeTargetVertexName = cyclicEdge.getTargetVertexName();
-
-      if (firstPredecessorVertexName === cyclicEdgeTargetVertexName) {
-        predecessorVertices.shift();
-      }
-    }
-
-    const partialCycle = new PartialCycle(predecessorVertices, cyclicEdge);
-    
-    return partialCycle;
-  }
-}

package/src/utilities/edge.js

@@ -1,58 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-const { prune } = arrayUtilities;
-
-const remove = prune;  ///
-
-export function checkEdgesIncludesEdge(edge, edges) {
-  const edge1 = edge, ///
-        edgesIncludesEdge = edges.some((edge) => {
-          const edge2 = edge, ///
-                matches = edge1.match(edge2);
-
-          if (matches) {
-            return true;
-          }
-        });
-
-  return edgesIncludesEdge;
-}
-
-export function removeEdgeFromEdges(edge, edges) {
-  const edge1 = edge; ///
-
-  remove(edges, (edge) => {
-    const edge2 = edge, ///
-          matches = edge1.match(edge2);
-
-    if (!matches) { ///
-      return true;
-    }
-  });
-}
-
-export function edgesBySourceVertexName(sourceVertexName, edges) {
-  edges = edges.filter((edge) => {  ///
-    const matches = edge.matchSourceVertexName(sourceVertexName);
-
-    if (matches) {
-      return true;
-    }
-  });
-
-  return edges;
-}
-
-export function edgesByTargetVertexName(targetVertexName, edges) {
-  edges = edges.filter((edge) => {  ///
-    const matches = edge.matchTargetVertexName(targetVertexName);
-
-    if (matches) {
-      return true;
-    }
-  });
-
-  return edges;
-}