Implementing a simple graph api

README.md

@@ -5,42 +5,23 @@
 This is a Haskell Library for parsing graph formats such as [GraphML](http://graphml.graphdrawing.org/) and the XML files produced by [Workcraft](https://www.workcraft.org/).
 The library currently implements parsing only the nodes and edges of undirected graphs.  
 See the User Guide for how to use this, with examples below.
-Also information on current graph support below that.
+Information on current graph support can be found below that.
 
-## Getting Started  
-The library `Pangraph` exports the following types:
+## How to use Pangraph
 
+Pangraph offers an api in the module `Pangraph` for accessing of graphs including constructors and getters.  
+You can construct entire graph or edit the results of parser.
+These are imported independently form their own modules:  
 ```
-data Att = Att (String, String) deriving (Show, Eq)
-data Node = Node [Att] deriving (Show, Eq)
-data Edge = Edge [Att] deriving (Show, Eq)
-data ShortGraph = ShortGraph [Node] [Edge] deriving (Show, Eq)
-data ShortFile = ShortFile [ShortGraph] deriving (Show, Eq)
+import Pangraph.GraphML.Parser
 ```
 
-The first five types above define a graph. When parsed one ShortFile will be produced containing one ShortGraph containing zero or more edges and arcs. The library does not check the graphs for correctness however.
-
-To parse graphs you must import them directly.
+All parsers currently export the following:
 ```
-import Pangraph.GraphML.Writer
-import Pangraph.Workcraft.Parser
+formatToPangraph :: format -> Pangraph
 ```
 
-All parsers export the following:
-```
-module Pangraph.Example.Parser
-( parseFile
-, parseString
-)where
-```
-To use these functions,
-And writers export:
-```
-module Pangraph.GraphML.Writer
-( writeGraph
-) where
-...
-```
+An example of reading this code can be found in `Examples` below
 
 ## Binary generation
 
@@ -56,44 +37,32 @@ cabal install
 
 ## Examples  
 
-### Parsing a Graph file  
-```
-module Reading where
+### Parsing a Graph file
+Repeated here the code from `src/Pangraph/Examples`:
+```haskell
+module Pangraph.Examples.Reading where
+
+import Prelude hiding (readFile)
+
+import Data.ByteString (readFile)
 
-import System.IO
 import Pangraph
-import qualified Pangraph.GraphML.Parser as G
+import qualified Pangraph.GraphML.Parser as GraphML_P
 
-main::IO()
-main=do
+main :: IO ()
+main = do
   fileName <- getLine
   file <- readFile fileName
-  let graph = G.parseAsString file
-  putStr $ show graph
-```
-
-### Parsing a graph and then writing to a file
+  print (GraphML_P.parse file)
 ```
-module Writing where
 
-import System.IO
-import Pangraph
-import qualified Pangraph.GraphML.Writer as G
-
-main::IO()
-main=do
-  filePath <- getLine
-  G.writeGraph filePath graph
-  where
-    graph = ShortFile [ShortGraph [Node [Att ("id","n0")],Node [Att ("id","n1")],Node [Att ("id","n2")]] [Edge [Att ("source","n0"),Att ("target","n2")]]]
-```
 ## Graph support  
 ### [GraphML](http://graphml.graphdrawing.org/)
 GraphML files are currently:  
 - Parsing: Ok  
-- Writing: Ok
+- Writing: **Unimplemented**
 
 ### [Workcraft](https://www.workcraft.org/)
 Workcraft files are currently:  
-- Parsing: need to be unzipped manually and given a path to the `model.xml` file that was unzipped.  
+- Parsing: **Unimplemented**  
 - Writing: **Unimplemented**

Test.hs

@@ -2,16 +2,15 @@
 
 module Main where
 
+import Data.Maybe
+
 import Data.ByteString.Char8 (pack)
 import qualified Data.ByteString                  as BS
 import qualified Pangraph                         as P
 import qualified Pangraph.GraphML.Parser          as GraphML_P
 import qualified Pangraph.VHDL.EnvironmentWriter  as VHDL_E
 import qualified Pangraph.VHDL.GraphWriter        as VHDL_G
 
-
-type Parser = GraphML_P.Template -> BS.ByteString -> Either BS.ByteString P.Pangraph
-
 main :: IO ()
 main = do
   putStrLn "\n------Testing begins------"
@@ -22,72 +21,71 @@ main = do
   putStrLn "VHDL:"
   testVHDL
   putStrLn "\n------All Tests Passed------"
-  where
 
 testShowInstance :: IO ()
-testShowInstance = case a == (show b) of
-  True -> putStrLn "-Pangraph show instance passed."
-  False -> error $ "!Show instance failed test: " ++ show b ++ "!=" ++ a
-  where
-    a = fst showInstanceTestCase
-    b = snd showInstanceTestCase
-    showInstanceTestCase :: (String, P.Pangraph)
-    showInstanceTestCase = ("Pangraph [Node [Attribute (\"id\",\"0\")],Node [Attribute (\"id\",\"1\")]] [Edge [Attribute (\"source\",\"0\"),Attribute (\"target\",\"1\")]]",
-     P.makePangraph [P.makeNode [P.makeAttribute ("id","0")],P.makeNode [P.makeAttribute ("id","1")]] [P.makeEdge [P.makeAttribute ("source","0"),P.makeAttribute ("target","1")]])
+testShowInstance = do
+  literal <-fmap (head . lines) $ readFile "test/show-string.txt"
+  let graph = fromMaybe
+                (error "Sample graph failed to build") $
+                P.makePangraph
+                  sampleVertices [
+                  P.makeEdge
+                    [("source","0"), ("target","1")]
+                    (head sampleVertices, sampleVertices !! 1)
+                  ]
+      sampleVertices = [P.makeVertex "0" [("id","0")]
+                       ,P.makeVertex "1" [ ("id","1")]]
+  if literal == show (graph :: P.Pangraph)
+    then putStrLn "-Instance passed"
+    else error
+      $ "!Show instance failed test: \""
+      ++ literal
+      ++ "\"\nSample(above) != Graph(below)\n\""
+      ++ show graph
+        ++ "\""
+
     -- Without escapes:
-    -- Pangraph [Node [Attribute ("id","0")],Node [Attribute ("id","1")]] [Edge [Attribute ("source","0"),Attribute ("target","1")]]
+    -- makePangraph [makeVertex "0" [("id","0")],makeVertex "1" [("id","1")]] [makeEdge [("source","0"),("target","1")] (makeVertex "0" [("id","0")],makeVertex "1" [("id","1")])]
 
 testGraphML :: IO ()
 testGraphML = do
-  file <- fmap pack $ readFile path
-  case (parser (head GraphML_P.template) file) of
-    Left x -> error (show x)
-    Right y -> if y == graphs
-      then putStrLn "-Parse Passed"
-      else error $ "!Test failed\n" ++ show y
-  where
-    path :: FilePath
-    path = "examples/graphs/small.graphml"
-    parser :: Parser
-    parser = GraphML_P.parseTemplateToPangraph
-    graphs :: P.Pangraph
-    graphs =
-      P.makePangraph
-        [P.makeNode [P.makeAttribute ("id","n0")],
-        P.makeNode [P.makeAttribute ("id","n1")],
-        P.makeNode [P.makeAttribute ("id","n2")]]
-        [P.makeEdge
-          [P.makeAttribute ("source","n0"),
-          P.makeAttribute ("target","n2")]]
+  file <- BS.readFile "examples/graphs/small.graphml"
+  let graph  = fromMaybe (error "Sample graph failed to build") graph'
+      graph' = P.makePangraph sampleVertices
+                [P.makeEdge
+                  [("source","n0"),("target","n2")]
+                  (head sampleVertices, sampleVertices !! 2)]
+      sampleVertices = [
+               P.makeVertex "n0" [ ("id","n0")],
+               P.makeVertex "n1" [ ("id","n1")],
+               P.makeVertex "n2" [ ("id","n2")]]
+
+  if graph == GraphML_P.unsafeParse file
+    then putStrLn "-Parse Passed"
+    else error $ "!Test failed\n"
+      ++ show graph
+      ++ "\n!=\n"
+      ++ show (GraphML_P.unsafeParse file)
 
 testVHDL :: IO ()
 testVHDL = do
-  files <- mapM BS.readFile graphPaths
-  vhdlEnvironment <- mapM readFile enviromentPaths
-  vhdlGraph <- mapM readFile networkPaths
+  files <- mapM BS.readFile ["examples/graphs/n1/n1.graphml",
+    "examples/graphs/n2/n2.graphml"]
+  vhdlEnvironment <- mapM readFile ["examples/graphs/n1/n1-sim-environment.vhdl",
+    "examples/graphs/n2/n2-sim-environment.vhdl"]
+  vhdlGraph <- mapM readFile ["examples/graphs/n1/n1-graph.vhdl",
+    "examples/graphs/n2/n2-graph.vhdl"]
   let test1 = zip files vhdlEnvironment
   let test2 = zip files vhdlGraph
-  putStrLn $ concatMap (\a -> applyTest a VHDL_E.writeEnvironmentVhdl) test1
-  putStrLn $ concatMap (\a -> applyTest a VHDL_G.writeGraphVhdl) test2
-
+  putStrLn $ concatMap (`applyTest` VHDL_E.writeEnvironmentVhdl) test1
+  putStrLn $ concatMap (`applyTest` VHDL_G.writeGraphVhdl) test2
   where
     -- args: A graphML file, the string which should result, the function which maps the file to result
     applyTest :: (BS.ByteString, String) -> (P.Pangraph -> String) -> String
-    applyTest (g, example) f = case (parser (head GraphML_P.template) g ) of
-        Left x -> error (show x)
-        Right p -> case example == f p of
-            True -> "-VHDL passed test\n"
-            False -> error $ "!VHDL failed test : " ++ show example ++ "\n!=\n" ++ (show $ f p)
-
-
-    graphPaths :: [FilePath]
-    graphPaths = ["examples/graphs/n1/n1.graphml",
-      "examples/graphs/n2/n2.graphml"]
-    enviromentPaths :: [FilePath]
-    enviromentPaths = ["examples/graphs/n1/n1-sim-environment.vhdl",
-      "examples/graphs/n2/n2-sim-environment.vhdl"]
-    networkPaths :: [FilePath]
-    networkPaths = ["examples/graphs/n1/n1-graph.vhdl",
-      "examples/graphs/n2/n2-graph.vhdl"]
-    parser :: Parser
-    parser = GraphML_P.parseTemplateToPangraph
+    applyTest (raw, sample) f =
+      if show (GraphML_P.unsafeParse raw) == sample
+        then error $ "!VHDL failed test : "
+                   ++ show sample
+                   ++ "\n!=\n"
+                   ++ show (GraphML_P.unsafeParse raw)
+        else "-VHDL passed test\n"

fantasi/Tuura/Fantasi/Main.hs

@@ -18,13 +18,11 @@ main = do
         simulationEnvVhdlPath = optSimName options
 
     -- parse graph
-    case P.parseTemplateToPangraph (head P.template) (pack graphMLPath) of
-      Left l -> error $ show l
-      Right graphParsed -> do
-            let graphVHDL   = W2.writeGraphVhdl graphParsed
-            let simEnvVHDL  = W1.writeEnvironmentVhdl graphParsed
+    let pangraph = P.unsafeParse (pack graphMLPath)
+    let graphVHDL   = W2.writeGraphVhdl pangraph
+    let simEnvVHDL  = W1.writeEnvironmentVhdl pangraph
 
-            -- output vhdl graph
-            writeFile graphVHDLPath graphVHDL
-            -- output vhdl simulation environment
-            writeFile simulationEnvVhdlPath simEnvVHDL
+    -- output vhdl graph
+    writeFile graphVHDLPath graphVHDL
+    -- output vhdl simulation environment
+    writeFile simulationEnvVhdlPath simEnvVHDL

pangraph.cabal

@@ -19,11 +19,13 @@ library
                    ,  Pangraph.GraphML.Parser
                    ,  Pangraph.VHDL.GraphWriter
                    ,  Pangraph.VHDL.EnvironmentWriter
-  other-modules:      Pangraph.XMLTemplate
+                   ,  Pangraph.XMLTemplate
+  other-modules:      Pangraph.Examples.Reading
   build-depends:      base >= 4.8 && < 5
                    ,  bytestring
                    ,  hexml
                    ,  algebraic-graphs
+                   ,  containers
   default-language:   Haskell2010
   GHC-options:        -Wall -fwarn-tabs -O2