nv-graph-parser v1.0.3

nv-graph-parser

• nv-graph-parser
• simple util to parse a-kind-of graph-description

install

• npm install nv-graph-parser

usage

   const {
       parse,
       unparse_from_iedges,
       unparse_from_oedges,
  } = require("nv-graph-parser");

  grammar:

     A -> B
          means  A depends-on B(outbound-edge);
     B -> A  
          means  B depends-on A(inbound-edge);
     A <--> B
         means  A->B  and  B->A

     {...} means OR

     []  is used as quote,such as [A A]  
     
     not support escape 
  
     whitespace:
        , AND ; AND \n AND \r AND \t AND <white-space>
        whitespace is optional

  such as:
      
      {A,B}->{C,D} means:
          A->C and A->D and B->C and B->D
      A->{B,C}->D means:
          A->B and A->C and 
          B->D and C->D
      A->{B,C}<-D means:
          A->B and A->C and
          D->B and D->C

example

parse

    var g0 = `
        D<-{
            E, [F F], G
        } <-C<-B<-[A]
    `

    var {iedges,oedges} = parse(g0);

    /*
    > oedges
    Map(7) {
      'D' => Set(0) {},
      'E' => Set(1) { 'D' },
      'F F' => Set(1) { 'D' },
      'G' => Set(1) { 'D' },
      'C' => Set(3) { 'E', 'F F', 'G' },
      'B' => Set(1) { 'C' },
      'A' => Set(1) { 'B' }
    }
    >
    > iedges
    Map(7) {
      'D' => Set(3) { 'E', 'F F', 'G' },
      'E' => Set(1) { 'C' },
      'F F' => Set(1) { 'C' },
      'G' => Set(1) { 'C' },
      'C' => Set(1) { 'B' },
      'B' => Set(1) { 'A' },
      'A' => Set(0) {}
    }
    >
    */



    var g1 = `
        A->B->C->{
            E,F,G
        }->D
        B->G
    `

    var {iedges,oedges} = parse(g1)


    > oedges
    Map(7) {
      'A' => Set(1) { 'B' },
      'B' => Set(2) { 'C', 'G' },
      'C' => Set(3) { 'E', 'F', 'G' },
      'E' => Set(1) { 'D' },
      'F' => Set(1) { 'D' },
      'G' => Set(1) { 'D' },
      'D' => Set(0) {}
    }
    > iedges
    Map(7) {
      'A' => Set(0) {},
      'B' => Set(1) { 'A' },
      'C' => Set(1) { 'B' },
      'E' => Set(1) { 'C' },
      'F' => Set(1) { 'C' },
      'G' => Set(2) { 'C', 'B' },
      'D' => Set(3) { 'E', 'F', 'G' }
    }
    >



    var g2 =`{J,K}<-->{L,M,N}`


    var {iedges,oedges} = parse(g2)

    /*
    > oedges
    Map(5) {
      'J' => Set(3) { 'L', 'M', 'N' },
      'K' => Set(3) { 'L', 'M', 'N' },
      'L' => Set(2) { 'J', 'K' },
      'M' => Set(2) { 'J', 'K' },
      'N' => Set(2) { 'J', 'K' }
    }
    > iedges
    Map(5) {
      'J' => Set(3) { 'L', 'M', 'N' },
      'K' => Set(3) { 'L', 'M', 'N' },
      'L' => Set(2) { 'J', 'K' },
      'M' => Set(2) { 'J', 'K' },
      'N' => Set(2) { 'J', 'K' }
    }
    >

    */


    var g3 = `
        A->B;
        A<-->C;
        C->{
            D, E->{
                F, G, [long name include space]
            }->H
        }->I;
        I->{J,K}<-->{L,M,N}
    `



    var {iedges,oedges} = parse(g3)


    /*
    > oedges
    Map(15) {
      'A' => Set(2) { 'B', 'C' },
      'B' => Set(0) {},
      'C' => Set(4) { 'A', 'D', 'E', 'H' },
      'D' => Set(1) { 'I' },
      'E' => Set(4) { 'I', 'F', 'G', 'long name include space' },
      'F' => Set(1) { 'H' },
      'G' => Set(1) { 'H' },
      'long name include space' => Set(1) { 'H' },
      'H' => Set(1) { 'I' },
      'I' => Set(2) { 'J', 'K' },
      'J' => Set(3) { 'L', 'M', 'N' },
      'K' => Set(3) { 'L', 'M', 'N' },
      'L' => Set(2) { 'J', 'K' },
      'M' => Set(2) { 'J', 'K' },
      'N' => Set(2) { 'J', 'K' }
    }
    >
    > iedges
    Map(15) {
      'A' => Set(1) { 'C' },
      'B' => Set(1) { 'A' },
      'C' => Set(1) { 'A' },
      'D' => Set(1) { 'C' },
      'E' => Set(1) { 'C' },
      'F' => Set(1) { 'E' },
      'G' => Set(1) { 'E' },
      'long name include space' => Set(1) { 'E' },
      'H' => Set(4) { 'C', 'F', 'G', 'long name include space' },
      'I' => Set(3) { 'D', 'E', 'H' },
      'J' => Set(4) { 'I', 'L', 'M', 'N' },
      'K' => Set(4) { 'I', 'L', 'M', 'N' },
      'L' => Set(2) { 'J', 'K' },
      'M' => Set(2) { 'J', 'K' },
      'N' => Set(2) { 'J', 'K' }
    }
    >

    */

strigify

    > console.log(unparse_from_oedges(oedges))
    [A]->[C]
    [B]->[A]
    [C]->[A]
    [D]->[C]
    [E]->[C]
    [F]->[E]
    [G]->[E]
    [long name include space]->[E]
    [H]->[C]
    [H]->[F]
    [H]->[G]
    [H]->[long name include space]
    [I]->[D]
    [I]->[E]
    [I]->[H]
    [J]->[I]
    [J]->[L]
    [J]->[M]
    [J]->[N]
    [K]->[I]
    [K]->[L]
    [K]->[M]
    [K]->[N]
    [L]->[J]
    [L]->[K]
    [M]->[J]
    [M]->[K]
    [N]->[J]
    [N]->[K]

API

• parse(src:String)
• unparse_from_oedges(oedges:Map)
• unparse_from_iedges(oedges:Map)

LICENSE

• ISC